public void Start(ConfigurationSection configuration) {
			_tokenDistributor = new System.Timers.Timer();
			_tokenDistributor.Elapsed += new System.Timers.ElapsedEventHandler(TokenDistributor_Elapsed);
			_tokenDistributor.Interval = _interval;
			_tokenDistributor.AutoReset = true;
			_tokenDistributor.Enabled = true;
		}

 public IEnumerable<ConfigurationEntry> Parse(string data)
 {
     ConfigurationSection currentSection = null;
     foreach (var line in data.Split(new[] { "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries))
     {
         var sectionMatch = _configurationSectionRegex.Match(line);
         if (sectionMatch.Success)
         {
             if (currentSection != null)
                 yield return currentSection;
             currentSection = new ConfigurationSection
             {
                 Type = sectionMatch.Groups["type"].Value,
                 Name = sectionMatch.Groups["name"].Success ? sectionMatch.Groups["name"].Value : string.Empty
             };
             continue;
         }
         var lineMatch = _configurationLineRegex.Match(line);
         if (lineMatch.Success)
         {
             var configLine = new ConfigurationLine
             {
                 Name = lineMatch.Groups["name"].Value,
                 Value = lineMatch.Groups["value"].Value
             };
             if (currentSection != null)
                 currentSection.Lines.Add(configLine);
             else
                 yield return configLine;
         }
     }
     if (currentSection != null)
         yield return currentSection;
 }

 public void CanRemoveAddedValue()
 {
     var section = new ConfigurationSection( SectionName );
     section.Set( Key, Value );
     bool success = section.Remove( Key );
     Assert.True( success );
 }

 public void CanReadAddedValue()
 {
     var section = new ConfigurationSection( SectionName );
     section.Set( Key, Value );
     var value = section.Get<string>( "key" );
     Assert.Equal( Value, value );
 }

 protected static ConfigurationSourceBaseImpl GetConfigurationSource()
 {
     var section = new ConfigurationSection( SectionName );
     var source = new ConfigurationSourceBaseImpl {section};
     section.Set( Key, Value );
     return source;
 }

		public static ConfigurationSection GetInstance()
		{
			if (instance == null)
			{
				lock (typeof(ConfigurationSection))
				{
					try
					{	
#pragma warning disable 618
						instance = (ConfigurationSection)ConfigurationSettings.GetConfig("Platform/VirtualFileSystem/Multimedia/Configuration");
#pragma warning restore 618
					}
					catch (Exception e)
					{
						throw e.InnerException;
					}

					if (instance == null)
					{
						instance = new ConfigurationSection();
					}
				}
			}

			return instance;
		}

 public void CanGetAndSetEnumFlagValues()
 {
     const OptionsEnum all = ( OptionsEnum.A | OptionsEnum.B | OptionsEnum.C );
     var section = new ConfigurationSection( SectionName );
     section.Set( Key, all );
     var fromSection = section.Get<OptionsEnum>( Key );
     Assert.AreEqual( all, fromSection );
 }

 public void CanGetAndSetEnumValues()
 {
     const OSEnum value = OSEnum.Win2k;
     var section = new ConfigurationSection( SectionName );
     section.Set( Key, value );
     var fromSection = section.Get<OSEnum>( Key );
     Assert.AreEqual( value, fromSection );
 }

 public void CanReadAddedValueWithTryGet()
 {
     var section = new ConfigurationSection( SectionName );
     section.Set( Key, Value );
     string value;
     bool found = section.TryGet( "key", out value );
     Assert.True( found );
     Assert.Equal( Value, value );
 }

        public void AddingNewSectionOverridesKeys()
        {
            ConfigurationSourceBaseImpl source = GetConfigurationSource();
            var section = new ConfigurationSection( SectionName );
            section.Set( Key, Key );

            Assert.Equal( Value, source.Sections[SectionName].Get<string>( Key ) );
            source.Add( section );
            Assert.Equal( Key, source.Sections[SectionName].Get<string>( Key ) );
        }

 public void MergingWithCollectionOverwritesExistingKeys()
 {
     ConfigurationSourceBaseImpl source = GetConfigurationSource();
     var section = new ConfigurationSection( SectionName );
     section.Set( Key, Key );
     var source2 = new ConfigurationSourceBaseImpl {section};
     Assert.Equal( Value, source.Sections[SectionName].Get<string>( Key ) );
     source.Merge( new[] {source2} );
     Assert.Equal( Key, source.Sections[SectionName].Get<string>( Key ) );
 }

 public void MergingWithCollectionAddsConfigurationSection()
 {
     ConfigurationSourceBaseImpl source = GetConfigurationSource();
     const string sectionName = SectionName + Key;
     var section = new ConfigurationSection( sectionName );
     section.Set( Key, Key );
     var source2 = new ConfigurationSourceBaseImpl {section};
     source.Merge( new[] {source2} );
     Assert.Contains( section, source );
 }

 public static IConfigurationSection GetSingleSection()
 {
     IConfigurationSection section = new ConfigurationSection( "Default" );
     section.Set( "a", "a" );
     section.Set( "b", "b" );
     section.Set( "c", "c" );
     section.Set( "d", "d" );
     section.Set( "e", "e" );
     return section;
 }

 public static IEnumerable<IConfigurationSection> GetTwoSections()
 {
     IConfigurationSection section = new ConfigurationSection( "Default" );
     section.Set( "a", "a" );
     section.Set( "b", "b" );
     IConfigurationSection section2 = new ConfigurationSection( "Default2" );
     section2.Set( "c", "c" );
     section2.Set( "d", "d" );
     section2.Set( "e", "e" );
     return new[] { section, section2 };
 }

 public void EnumeratorGivesKeysAndValues()
 {
     var section = new ConfigurationSection( SectionName );
     section.Set( Key, Value );
     int count = 0;
     foreach ( KeyValuePair<string, string> pair in section )
     {
         Assert.Equal( Key, pair.Key );
         Assert.Equal( Value, pair.Value );
         count++;
     }
     Assert.Equal( 1, count );
 }

        public void Should_be_possible_get_a_valid_configuration_from_a_section_object()
        {
            MockRepository mocks = new MockRepository();

            var fakeView = MockRepository.GenerateStub<IConfigurationView>();
            var fakeController = mocks.DynamicMock<ConfigurationController>(new object[] { fakeView });

            var fakeConfigurationSection = new ConfigurationSection();
            fakeConfigurationSection.server.Address = "http://localhost";
            fakeConfigurationSection.server.Port = "1024";
            fakeConfigurationSection.server.Username = "admin";
            fakeConfigurationSection.server.Password = "PassworD";

            fakeConfigurationSection.target.Address = "10.0.0.1";
            fakeConfigurationSection.target.Username = "administrator";
            fakeConfigurationSection.target.Password = "[email protected]";
            fakeConfigurationSection.target.AdministrativePassword = "qwerty";

            fakeConfigurationSection.file.SaveFolder = "C:\\Temp\\";
            fakeConfigurationSection.file.DefinitionFilename = "C:\\Temp\\definitions.xml";

            using (mocks.Record())
            {
                Expect.Call(fakeController.FileExists(null)).IgnoreArguments().Return(true);
                Expect.Call(fakeController.ReadConfigurationSection(null)).IgnoreArguments().Return(fakeConfigurationSection);
            }

            mocks.ReplayAll();

            fakeController.view_OnReadConfiguration(this, EventArgs.Empty);

            mocks.VerifyAll();

            Assert.IsNotNull(fakeView.Server);
            Assert.AreEqual("http://localhost", fakeView.Server.Address);
            Assert.AreEqual("1024", fakeView.Server.Port);
            Assert.AreEqual("admin", fakeView.Server.Username);
            Assert.AreEqual("PassworD", fakeView.Server.Password);

            Assert.IsNotNull(fakeView.Target);
            Assert.AreEqual("10.0.0.1", fakeView.Target.Address);
            Assert.AreEqual("administrator", fakeView.Target.Username);
            Assert.AreEqual("[email protected]", fakeView.Target.Password);
            Assert.AreEqual("qwerty", fakeView.Target.AdministrativePassword);

            Assert.IsNotNull(fakeView.DestinationFolder);
            Assert.AreEqual("C:\\Temp\\", fakeView.DestinationFolder);
            Assert.IsNotNull(fakeView.DefinitionFilename);
            Assert.AreEqual("C:\\Temp\\definitions.xml", fakeView.DefinitionFilename);
        }

 public static ConfigurationSection GetInstance()
 {
     try
     {
         if (instance == null)
         {
             instance = (ConfigurationSection)ConfigurationManager.GetSection("searchEngineConfiguration");
         }
         return instance;
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }

        public override bool TryGetSubSection(string key, out ConfigurationSection sect)
        {
            if (ParentConfig == null)
            {
                throw new InvalidOperationException();
            }

            string res;
            if (TryGetValue(key, out res))
            {
                sect = ParentConfig[res];
                return true;
            }
            sect = null;
            return false;
        }

        public DiskBackupManager(ConfigurationSection configSection, string partitionId, long keymin, long keymax, string codePackageTempDirectory)
        {
            this.keyMin = keymin;
            this.keyMax = keymax;

            string BackupArchivalPath = configSection.Parameters["BackupArchivalPath"].Value;
            this.backupFrequencyInSeconds = long.Parse(configSection.Parameters["BackupFrequencyInSeconds"].Value);
            this.MaxBackupsToKeep = int.Parse(configSection.Parameters["MaxBackupsToKeep"].Value);

            this.PartitionArchiveFolder = Path.Combine(BackupArchivalPath, "Backups", partitionId);
            this.PartitionTempDirectory = Path.Combine(codePackageTempDirectory, partitionId);

            ServiceEventSource.Current.Message(
                "DiskBackupManager constructed IntervalinSec:{0}, archivePath:{1}, tempPath:{2}, backupsToKeep:{3}",
                this.backupFrequencyInSeconds,
                this.PartitionArchiveFolder,
                this.PartitionTempDirectory,
                this.MaxBackupsToKeep);
        }

        public AzureBlobBackupManager(ConfigurationSection configSection, string partitionId, long keymin, long keymax, string codePackageTempDirectory)
        {
            this.keyMin = keymin;
            this.keyMax = keymax;

            string backupAccountName = configSection.Parameters["BackupAccountName"].Value;
            string backupAccountKey = configSection.Parameters["PrimaryKeyForBackupTestAccount"].Value;
            string blobEndpointAddress = configSection.Parameters["BlobServiceEndpointAddress"].Value;

            this.backupFrequencyInSeconds = long.Parse(configSection.Parameters["BackupFrequencyInSeconds"].Value);
            this.MaxBackupsToKeep = int.Parse(configSection.Parameters["MaxBackupsToKeep"].Value);
            this.partitionId = partitionId;
            this.PartitionTempDirectory = Path.Combine(codePackageTempDirectory, partitionId);

            StorageCredentials storageCredentials = new StorageCredentials(backupAccountName, backupAccountKey);
            this.cloudBlobClient = new CloudBlobClient(new Uri(blobEndpointAddress), storageCredentials);
            this.backupBlobContainer = this.cloudBlobClient.GetContainerReference(this.partitionId);
            this.backupBlobContainer.CreateIfNotExists();
        }