Inheritance: IXmlSerializable
 public static SqlToGraphiteConfig SerialiseDeserialise(SqlToGraphiteConfig hh)
 {
     var genericSerializer = new GenericSerializer(Global.GetNameSpace());
     var xml = genericSerializer.Serialize<SqlToGraphiteConfig>(hh);
     var sqlToGraphiteConfig = genericSerializer.Deserialize<SqlToGraphiteConfig>(xml);
     return sqlToGraphiteConfig;
 }
 public void SetUp()
 {
     this.log = MockRepository.GenerateMock<ILog>();
     this.assemblyResolver = new AssemblyResolver(new DirectoryImpl(), log);
     this.config = new SqlToGraphiteConfig(this.assemblyResolver, log);
     this.template = new Template();
 }
 public void SetUp()
 {
     sleepTime = 1000;
     assemblyResolver = MockRepository.GenerateMock<IAssemblyResolver>();
     config = new SqlToGraphiteConfig(assemblyResolver, log);
     reader = MockRepository.GenerateMock<IConfigReader>();
     cache = MockRepository.GenerateMock<ICache>();
     sleep = MockRepository.GenerateMock<ISleep>();
     log = MockRepository.GenerateMock<ILog>();
     configPersister = MockRepository.GenerateMock<IConfigPersister>();
     genericSerializer = MockRepository.GenerateMock<IGenericSerializer>();
     repository = new ConfigRepository(this.reader, this.cache, this.sleep, this.log, this.sleepTime, this.configPersister, this.genericSerializer);
 }
 public ConfigRepository(IConfigReader configReader, ICache cache, ISleep sleep, ILog log,
     int errorReadingConfigSleepTime, IGenericSerializer genericSerializer)
 {
     this.configReader = configReader;
     this.cache = cache;
     this.sleep = sleep;
     ConfigRepository.log = log;
     this.errorReadingConfigSleepTime = errorReadingConfigSleepTime;
     this.genericSerializer = genericSerializer;
     clientList = new GraphiteClients();
     var dir = new DirectoryImpl();
     if (ar == null)
     {
         ar = new AssemblyResolver(dir, log);
     }
     this.masterConfig = new SqlToGraphiteConfig(ar, log);
     this.Hash = "NotSet";
 }
 public void Load()
 {
     if (cache.HasExpired())
     {
         log.Debug("Cache has expired");
         var configXml = this.GetRemoteConfigXml();
         var newHash = configReader.GetHash();
         if (this.IsNewHash(newHash))
         {
             var newRemoteConfig = this.GetRemoteConfigObject();
             log.Debug("remote configuration has changed " + newHash);
             this.masterConfig = newRemoteConfig;
             Init();
             this.Hash = newHash;
             this.IsNewConfig = true;
             newRemoteConfig = null;
         }
         else
         {
             log.Debug("remote configuration has not changed " + Hash);
             this.IsNewConfig = false;
         }
         cache.ResetCache();
     }
 }
 public void Should_throw_exception_trying_delete_role_from_host_where_role_does_not_exsist()
 {
     string hostname = "abc";
     string roleName = "notFound";
     config = new SqlToGraphiteConfig { Hosts = CreateTwoHosts() };
     cache.Expect(x => x.HasExpired()).Return(true).Repeat.Once();
     string configXml = "<xml></xml>";
     genericSerializer.Expect(x => x.Deserialize<SqlToGraphiteConfig>(configXml)).Return(config);
     reader.Expect(x => x.GetXml()).Return(configXml);
     repository.Load();
     //Test
     var ex = Assert.Throws<RoleNotFoundException>(() => repository.DeleteRoleFromHost(roleName, hostname));
     Assert.That(ex.Message, Is.EqualTo(string.Format("Role {0} is not found", roleName)));
     cache.VerifyAllExpectations();
     genericSerializer.VerifyAllExpectations();
 }
        public void Should_throw_exception_if_host_not_found_tring_to_add_role_to_host()
        {
            string hostname = "notFound";
            string roleName = "newRole";
            config = new SqlToGraphiteConfig { Hosts = CreateTwoHosts() };
            cache.Expect(x => x.HasExpired()).Return(true).Repeat.Once();
            string configXml = "<xml></xml>";
            genericSerializer.Expect(x => x.Deserialize<SqlToGraphiteConfig>(configXml)).Return(config);
            reader.Expect(x => x.GetXml()).Return(configXml);
            repository.Load();
            //Test
            var ex = Assert.Throws<HostNotFoundException>(() => repository.AddRoleToHost(roleName, hostname));
            Assert.That(ex.Message, Is.EqualTo(string.Format("Host {0} has not been found", hostname)));

            cache.VerifyAllExpectations();
            genericSerializer.VerifyAllExpectations();
        }
        public void Should_delete_role_from_host()
        {
            string hostname = "abc";
            string roleName = "123";
            config = new SqlToGraphiteConfig { Hosts = CreateTwoHosts() };
            cache.Expect(x => x.HasExpired()).Return(true).Repeat.Once();
            string configXml = "<xml></xml>";
            genericSerializer.Expect(x => x.Deserialize<SqlToGraphiteConfig>(configXml)).Return(config);
            reader.Expect(x => x.GetXml()).Return(configXml);
            repository.Load();
            //Test
            repository.DeleteRoleFromHost(roleName, hostname);
            Assert.That(config.Hosts[0].Roles.Count, Is.EqualTo(0));

            cache.VerifyAllExpectations();
            genericSerializer.VerifyAllExpectations();
        }
        public void Initialise(string path)
        {
            log = LogManager.GetLogger("log");
            log4net.Config.XmlConfigurator.Configure();

            var sleepTime = 0;
            assemblyResolver = new AssemblyResolver(new DirectoryImpl(), log);
            var config = new SqlToGraphiteConfig(assemblyResolver, log);
            encryption = new Encryption();
            var reader = new ConfigHttpReader(path, "", "");
            var cache = new Cache(new TimeSpan(0, 0, 1, 0), log);
            var sleep = new Sleeper();
            var genericSerializer = new GenericSerializer(Global.GetNameSpace());
            var configPersister = new ConfigPersister(new ConfigFileWriter(path), genericSerializer);

            repository = new ConfigRepository(reader, cache, sleep, this.log, sleepTime, configPersister, genericSerializer);
        }
 public void SetUp()
 {
     this.directory = MockRepository.GenerateMock<IDirectory>();
     this.log = MockRepository.GenerateMock<ILog>();
     this.config = new SqlToGraphiteConfig(new AssemblyResolver(new DirectoryImpl(), log), log);
 }
 public void Save(SqlToGraphiteConfig config, string path)
 {
     var data = genericSerializer.Serialize(config);
     configWriter.Save(data, path);
 }
 public void Save(SqlToGraphiteConfig config)
 {
     var data = genericSerializer.Serialize(config);
     configWriter.Save(data);
 }
        public void Should_generate_test_config_file()
        {
            try
            {
                var log = LogManager.GetLogger("log");
                var encryption = new Encryption();
                var simpleCs = encryption.Encrypt("some Cs");

                log4net.Config.XmlConfigurator.Configure();

                var job1 = new WmiClient { ClientName = "GraphiteTcpClient", Name = "GetNumberOfTransactionsASecond", Hostname = simpleCs, Sql = "some sql" };
                var job2 = new WmiClient { ClientName = "GraphiteUdpClient", Name = "GetNumberOfDeliveryies", Hostname = simpleCs, Sql = "some sql1" };
                var client1 = new GraphiteTcpClient { ClientName = "GraphiteTcpClient", Port = 2003, Hostname = "metrics.london.ttldev.local" };
                var client2 = new GraphiteUdpClient { ClientName = "GraphiteUdpClient", Port = 2003, Hostname = "metrics.london.ttldev.local" };

                var config = new SqlToGraphiteConfig(new AssemblyResolver(new DirectoryImpl(), log), log);
                config.Jobs.Add(job1);
                config.Jobs.Add(job2);

                var host1 = new Host { Name = "TTL001121" };
                var host2 = new Host { Name = "Server1" };
                var role1 = new Role { Name = "ProductionTests" };
                var role2 = new Role { Name = "default" };
                var role3 = new Role { Name = "SqlTests" };

                host1.Roles.Add(role1);
                host1.Roles.Add(role2);
                host2.Roles.Add(role2);
                host2.Roles.Add(role3);
                config.Hosts.Add(host1);
                config.Hosts.Add(host2);

                var template = new Template();
                var wi = new WorkItems { RoleName = role1.Name, TaskSet = new List<TaskSet>() };
                var taskSet = new TaskSet { Frequency = 1000 };
                taskSet.Tasks.Add(new Task { JobName = job1.Name });
                wi.TaskSet.Add(taskSet);
                template.WorkItems.Add(wi);

                var wi1 = new WorkItems { RoleName = role2.Name, TaskSet = new List<TaskSet>() };
                var taskSet1 = new TaskSet { Frequency = 2000 };
                taskSet1.Tasks.Add(new Task { JobName = job2.Name });
                wi1.TaskSet.Add(taskSet1);
                template.WorkItems.Add(wi1);

                var wi2 = new WorkItems { RoleName = role3.Name, TaskSet = new List<TaskSet>() };
                var taskSet2 = new TaskSet { Frequency = 3000 };
                wi2.TaskSet.Add(taskSet2);
                template.WorkItems.Add(wi2);

                config.Templates.Add(template);
                config.Clients = new ListOfUniqueType<Client> { client1, client2 };
                //var genericSerializer = new GenericSerializer(Global.GetNameSpace());
                //string xml = genericSerializer.Serialize(config);
                //Console.WriteLine(xml);
                //var sqlToGraphiteConfig = genericSerializer.Deserialize<SqlToGraphiteConfig>(xml);
                //foreach (var job in sqlToGraphiteConfig.Jobs)
                //{
                    //Console.WriteLine(job.Type);
                //}
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }
 public void SetUP()
 {
     log = MockRepository.GenerateMock<ILog>();
     this.assemblyResolver = MockRepository.GenerateMock<IAssemblyResolver>();
     this.config = new SqlToGraphiteConfig(this.assemblyResolver, log);
 }