static void Main(string[] args)
	{
		var ctx = new ServiceContext();
		var service = new AgentService();
		service.Launch(12000);
		ctx.Run();
	}
Example #2
0
        public async Task UpdateAgentAsyncWithPropertyNameIsNullShouldThrowException()
        {
            var service      = new AgentService(Context);
            var itemToUpdate = await service.GetAgentAsync(FirstItem.Id);

            itemToUpdate.Name = null;

            Assert.ThrowsAsync <DbUpdateException>(() => service.UpdateAgentAsync(itemToUpdate));
        }
 public AgentDetailUC(Guid id, AgentService agentService, ItensMonitoringService itensMonitoringService)
 {
     InitializeComponent();
     _id = id;
     _itensMonitoringService = itensMonitoringService;
     _agentsService          = agentService;
     Populate();
     InsertAgentDetail();
 }
Example #4
0
        private void InstanceServices()
        {
            var companyEndPoint = new CompanyEndPoint(_customHttpCliente);

            _agentService           = new AgentService(new AgentEndPoint(_customHttpCliente));
            _itemsMonitoringService = new ItemsMonitoringService(new ItemsEndPoint(_customHttpCliente));
            _userService            = new UserService(new UserEndPoint(_customHttpCliente), companyEndPoint);
            _companyService         = new CompanyService(companyEndPoint);
        }
        public async Task UpdateAgent_ExistingAgent_NoError()
        {
            // Arrange
            DbContextOptions <YellowJacketContext> options = new DbContextOptionsBuilder <YellowJacketContext>()
                                                             .UseInMemoryDatabase("UpdateAgent_ExistingAgent_NoError")
                                                             .Options;

            const string agentName = "MyAgent";

            // Act
            using (YellowJacketContext context = new YellowJacketContext(options))
            {
                context.Agents.Add(new AgentEntity
                {
                    Name         = agentName,
                    LastUpdateOn = DateTime.Now,
                    RegisteredOn = DateTime.Now,
                    Status       = AgentStatus.Idle.ToString()
                });

                context.SaveChanges();
            }

            List <AgentModel> models;

            using (YellowJacketContext context = new YellowJacketContext(options))
            {
                IAgentRepository agentRepository = new AgentRepository(context);

                IAgentService service = new AgentService(agentRepository, GetMapper());

                models = await service.GetAll();
            }

            AgentModel model = models.First();

            string expectedStatus = AgentStatus.Running.ToString();

            // Assert
            using (YellowJacketContext context = new YellowJacketContext(options))
            {
                model.Status = AgentStatus.Running.ToString();

                IAgentRepository agentRepository = new AgentRepository(context);

                IAgentService service = new AgentService(agentRepository, GetMapper());

                model.Status = expectedStatus;

                model = await service.Update(model);

                Assert.That(
                    model.Status,
                    Is.EqualTo(expectedStatus),
                    $"The actual agent status {model.Status} should be equal to the expected value {expectedStatus}");
            }
        }
Example #6
0
        public void should_use_fake_builder(Agent agent, AgentService fakeAgentService, TeamManager teamManager)
        {
            Insert(agent);
            A.CallTo(() => fakeAgentService.CallAgent(agent.Id)).Returns(true);

            teamManager.Contact(agent);

            agent.ContactedByTeam.ShouldBeTrue();
        }
        public async Task TestHandleUpdateAgentProxyRequest()
        {
            using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
            {
                var createContext = new Mock <RequestContext <CreateAgentProxyResult> >();
                var updateContext = new Mock <RequestContext <UpdateAgentProxyResult> >();
                var deleteContext = new Mock <RequestContext <DeleteAgentProxyResult> >();

                var service = new AgentService();
                var proxy   = new AgentProxyInfo()
                {
                    Id             = 10,
                    AccountName    = "Test Proxy 2",
                    CredentialName = "User",
                    Description    = "",
                    IsEnabled      = true
                };

                var connectionResult = await LiveConnectionHelper.InitLiveConnectionInfoAsync("master", queryTempFile.FilePath);

                await service.HandleDeleteAgentProxyRequest(new DeleteAgentProxyParams()
                {
                    OwnerUri = connectionResult.ConnectionInfo.OwnerUri,
                    Proxy    = proxy
                }, deleteContext.Object);

                deleteContext.VerifyAll();

                await service.HandleCreateAgentProxyRequest(new CreateAgentProxyParams
                {
                    OwnerUri = connectionResult.ConnectionInfo.OwnerUri,
                    Proxy    = proxy
                }, createContext.Object);

                createContext.VerifyAll();

                string originalProxyName = proxy.AccountName;
                proxy.AccountName = proxy.AccountName + " Updated";
                await service.HandleUpdateAgentProxyRequest(new UpdateAgentProxyParams()
                {
                    OwnerUri          = connectionResult.ConnectionInfo.OwnerUri,
                    OriginalProxyName = originalProxyName,
                    Proxy             = proxy
                }, updateContext.Object);

                updateContext.VerifyAll();

                await service.HandleDeleteAgentProxyRequest(new DeleteAgentProxyParams()
                {
                    OwnerUri = connectionResult.ConnectionInfo.OwnerUri,
                    Proxy    = proxy
                }, deleteContext.Object);

                deleteContext.VerifyAll();
            }
        }
        public IEnumerable <WeatherForecast> Get()
        {
            //Console.WriteLine($"WeatherForecast调用的服务端口:{ _configuration["port"]}");
            #region Consul
            string       url       = "http://productservice/product/WeatherForecast";
            Uri          uri       = new Uri(url);
            string       groupName = uri.Host;
            ConsulClient client    = new ConsulClient(c =>
            {
                c.Address    = new Uri("http://192.168.19.130:11500/");
                c.Datacenter = "dc1";
            });
            var response = client.Agent.Services().Result.Response;
            ///找到服务名为groupName的所有服务
            var serviceDict = response.Values.Where(m => m.Service.Equals(groupName, StringComparison.OrdinalIgnoreCase)).ToArray();
            #region 负载均衡
            AgentService agentService = null;
            //平均分配法
            {
                agentService = serviceDict[new Random(iSeed++).Next(0, serviceDict.Length)];
            }
            //轮询分配法
            {
                //agentService = serviceDict[iSeed++ % serviceDict.Length];
            }
            //权重分配法
            {
                //List<AgentService> pairsList = new List<AgentService>();
                //foreach (var pair in serviceDict)
                //{
                //    int count = int.Parse(pair.Tags?[0]);
                //    for (int i = 0; i < count; i++)
                //    {
                //        pairsList.Add(pair);
                //    }
                //}
                //agentService = pairsList[new Random(iSeed++).Next(0, pairsList.Count)];
            }
            #endregion

            string baseurl = $"{uri.Scheme}://{agentService.Address}:{agentService.Port}{uri.PathAndQuery}";
            Console.WriteLine(baseurl);
            string content = WebApiHelper.InvokeApi(baseurl);
            Console.WriteLine(content);
            #endregion

            var rng = new Random();
            return(Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = rng.Next(-20, 55),
                Summary = Summaries[rng.Next(Summaries.Length)],
                Port = _configuration["port"]
            })
                   .ToArray());
        }
        public async Task GetAllAgents_ExistingAgents_NoError()
        {
            // Arrange
            DbContextOptions <YellowJacketContext> options = new DbContextOptionsBuilder <YellowJacketContext>()
                                                             .UseInMemoryDatabase("GetAllAgent_ExistingAgents_NoError")
                                                             .Options;

            List <AgentModel> expectedAgents = new List <AgentModel>
            {
                new AgentModel
                {
                    Name         = "AgentA",
                    LastUpdateOn = DateTime.Now,
                    RegisteredOn = DateTime.Now,
                    Status       = AgentStatus.Idle.ToString()
                },
                new AgentModel
                {
                    Name         = "AgentB",
                    LastUpdateOn = DateTime.Now,
                    RegisteredOn = DateTime.Now,
                    Status       = AgentStatus.Idle.ToString()
                }
            };

            using (YellowJacketContext context = new YellowJacketContext(options))
            {
                IAgentRepository agentRepository = new AgentRepository(context);

                IAgentService service = new AgentService(agentRepository, GetMapper());

                foreach (AgentModel model in expectedAgents)
                {
                    await service.Add(model);
                }

                context.SaveChanges();
            }

            List <AgentModel> actualAgents;

            // Act
            using (YellowJacketContext context = new YellowJacketContext(options))
            {
                IAgentRepository agentRepository = new AgentRepository(context);

                IAgentService service = new AgentService(agentRepository, GetMapper());

                actualAgents = await service.GetAll();
            }

            Assert.That(
                actualAgents.Count,
                Is.EqualTo(2),
                $"The actual agent list count {actualAgents.Count} should be equal to the expected one {expectedAgents.Count}");
        }
Example #10
0
        public async Task Catalog_EnableTagOverride()
        {
            var svcID   = KVTest.GenerateTestKeyName();
            var service = new AgentService()
            {
                ID      = svcID,
                Service = svcID,
                Tags    = new[] { "master", "v1" },
                Port    = 8000
            };

            var registration = new CatalogRegistration()
            {
                Datacenter = "dc1",
                Node       = "foobar",
                Address    = "192.168.10.10",
                Service    = service
            };

            using (IConsulClient client = new ConsulClient())
            {
                await client.Catalog.Register(registration);

                var node = await client.Catalog.Node("foobar");

                Assert.Contains(svcID, node.Response.Services.Keys);
                Assert.False(node.Response.Services[svcID].EnableTagOverride);

                var services = await client.Catalog.Service(svcID);

                Assert.NotEmpty(services.Response);
                Assert.Equal(svcID, services.Response[0].ServiceName);

                Assert.False(services.Response[0].ServiceEnableTagOverride);
            }

            // Use a new scope
            using (IConsulClient client = new ConsulClient())
            {
                service.EnableTagOverride = true;

                await client.Catalog.Register(registration);

                var node = await client.Catalog.Node("foobar");

                Assert.Contains(svcID, node.Response.Services.Keys);
                Assert.True(node.Response.Services[svcID].EnableTagOverride);

                var services = await client.Catalog.Service(svcID);

                Assert.NotEmpty(services.Response);
                Assert.Equal(svcID, services.Response[0].ServiceName);

                Assert.True(services.Response[0].ServiceEnableTagOverride);
            }
        }
 public static ServiceDescrption GetServiceDescrption(this AgentService service)
 {
     return(new ServiceDescrption
     {
         Id = service.ID,
         Name = service.Service,
         Address = service.Address,
         Port = service.Port
     });
 }
Example #12
0
        public async Task <IActionResult> CreateAsync([FromBody] AgentCreateRequest request)
        {
            if (request == null)
            {
                return(Fail(WebResource.CreateRequestIsEmpty));
            }
            var id = await AgentService.CreateAsync(request);

            return(Success(id));
        }
Example #13
0
        protected void Page_Load(object sender, EventArgs e)
        {
            var companyId = System.Configuration.ConfigurationManager.AppSettings["CompanyId"];
            var client    = new MoxiWorksClient();
            var service   = new AgentService(client);
            var source    = System.Threading.Tasks.Task.Run(() => service.GetAgentsAsync(companyId, null, DateTime.Now.AddDays(-100))).Result;

            gvAgent.DataSource = source.Item.Agents;
            gvAgent.DataBind();
        }
        private async Task ThenApplicationWithIdAndAddressIsSuccessfullyRegistered(string serviceId, string serviceAddress)
        {
            var client   = new ConsulClient();
            var services = await client.Agent.Services();

            AgentService agentService = services.Response.Values.FirstOrDefault(x => x.ID == serviceId);

            Assert.NotNull(agentService);
            Assert.Equal(serviceAddress, agentService.Address);
        }
Example #15
0
 public static async Task CleanupNotebookJob(TestConnectionResult connectionResult, AgentNotebookInfo notebook)
 {
     var service = new AgentService();
     await AgentNotebookHelper.DeleteNotebook(
         service,
         connectionResult.ConnectionInfo.OwnerUri,
         notebook,
         ManagementUtils.asRunType(0)
         );
 }
Example #16
0
        private void btnAgentsMenu_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            var service         = new AgentService(new AgentEndPoint(_customHttpCliente));
            var monitoringItems = new ItensMonitoringService(new ItemsEndPoint(_customHttpCliente));


            var agentsUserControl = new AgentsUserControl(service, monitoringItems, IncludeUserControl);

            IncludeUserControl(agentsUserControl, new EventArgs());
        }
        public void ShouldReturnAgentWithAlternateOffices()
        {
            var           agentJson = StubDataLoader.LoadJsonFile("Agent.json");
            IAgentService service   = new AgentService(new MoxiWorksClient(new StubContextClient(agentJson)));
            var           response  = service.GetAgentAsync("some_agent_id", "some_company_id").Result;
            var           agent     = response.Item;

            Assert.True(agent.AlternateOffices.Count == 2);
            Assert.Equal(1234, agent.AlternateOffices[0].OfficeId);
        }
Example #18
0
        public ActionResult DeleteAgent(int id)
        {
            var service = new AgentService();

            service.DeleteAgent(id);

            TempData["Save Result"] = "The agent was removed.";

            return(RedirectToAction("Index"));
        }
Example #19
0
        public static async Task <AgentJobInfo> SetupJob(TestConnectionResult connectionResult)
        {
            var service = new AgentService();
            var job     = GetTestJobInfo();

            await DeleteAgentJob(service, connectionResult, job);
            await CreateAgentJob(service, connectionResult, job);

            return(job);
        }
        public void ShouldReturnAnAgent()
        {
            var           agentJson = StubDataLoader.LoadJsonFile("Agent.json");
            IAgentService service   = new AgentService(new MoxiWorksClient(new StubContextClient(agentJson)));
            var           response  = service.GetAgentAsync("some_agent_id", "some_company_id").Result;

            Assert.IsType <Agent>(response.Item);
            Assert.True(response.Item.CreatedTimestamp.HasValue);
            Assert.False(response.Item.DeactivatedTimestamp.HasValue);
        }
Example #21
0
        public async Task DeleteAgentAsyncShouldDeleteAgent()
        {
            var service = new AgentService(Context);

            await service.DeleteAgentAsync(FirstItem.Id);

            var agentsFromService = await service.GetAgentListAsync();

            Assert.That(agentsFromService.All(p => p.Id != FirstItem.Id));
        }
Example #22
0
 ConsulService ConverToConsulService(AgentService service)
 {
     return(new ConsulService
     {
         Address = service.Address,
         Id = service.ID,
         Name = service.ID,
         Tags = service.Tags.ToList(),
         Port = service.Port
     });
 }
Example #23
0
        public async Task GetAgentListAsyncShouldReturnAllAgents()
        {
            var service = new AgentService(Context);

            var agentsFromService = await service.GetAgentListAsync();

            Assert.That(agentsFromService.Any(p => p.Id == FirstItem.Id));
            Assert.That(agentsFromService.Any(p => p.Id == SecondItem.Id));

            Assert.AreEqual(_agents.Count(), agentsFromService.Count());
        }
Example #24
0
 public AgentsUserControl(AgentService agentService,
                          ItensMonitoringService itensMonitoringService,
                          EventHandler onSwitchControl)
 {
     InitializeComponent();
     _agentService           = agentService;
     _onSwitchControl        = onSwitchControl;
     _itensMonitoringService = itensMonitoringService;
     _indexes = new Dictionary <Guid, AgentUC>();
     Populate();
 }
Example #25
0
        /// <summary>
        /// resets the Receipt Mode
        /// </summary>
        private void ResetReceiptModeCampaignIDToZero()
        {
            Agent     objAgent;
            AgentStat objAgentStat;
            Campaign  objCampaign;

            try
            {
                objCampaign  = (Campaign)Session["Campaign"];
                objAgentStat = (AgentStat)Session["AgentStat"];
                objAgent     = (Agent)Session["LoggedAgent"];
                if (objAgentStat != null)
                {
                    objAgentStat.ReceiptModeID = objAgent.ReceiptModeID = 0;
                }
                objAgent.CampaignID = 0;

                AgentService    objAgentService = new AgentService();
                CampaignService objCampService  = new CampaignService();

                XmlDocument xDocAgent     = new XmlDocument();
                XmlDocument xDocCampaign  = new XmlDocument();
                XmlDocument xDocAgentStat = new XmlDocument();
                if (objAgentStat != null)
                {
                    xDocAgentStat.LoadXml(Serialize.SerializeObject(objAgentStat, "AgentStat"));
                }
                xDocCampaign.LoadXml(Serialize.SerializeObject(objCampaign, "Campaign"));


                xDocAgent.LoadXml(Serialize.SerializeObject(objAgent, "Agent"));

                objAgent = (Agent)Serialize.DeserializeObject(
                    objAgentService.AgentActivityInsertUpdate(xDocAgent), "Agent");

                try
                {
                    if (objAgentStat != null)
                    {
                        objAgentStat = (AgentStat)Serialize.DeserializeObject(
                            objCampService.InsertUpdateAgentStat(xDocCampaign, xDocAgentStat), "AgentStat");
                        if (objAgentStat != null)
                        {
                            Session["AgentStat"] = objAgentStat;
                        }
                    }
                }
                catch { }
            }
            catch (Exception ex)
            {
                PageMessage = ex.Message;
            }
        }
 private void UpdateAgentStatus(Agent objAgent)
 {
     objAgent = (Agent)Session["LoggedAgent"];
     if (!objAgent.IsAdministrator)
     {
         AgentService objAgentService = new AgentService();
         XmlDocument  xDocAgent       = new XmlDocument();
         xDocAgent.LoadXml(Serialize.SerializeObject(objAgent, "Agent"));
         objAgentService.UpdateAgentLogOut(xDocAgent); //Sets LogoutTime to now for specific agent
     }
 }
Example #27
0
        /// <summary>
        /// 随机获取
        /// </summary>
        /// <param name="services">服务列表</param>
        /// <returns></returns>
        public AgentService Resolve(List <AgentService> services)
        {
            AgentService consul = null;
            Random       rand   = new Random();

            if (services.Count > 0)
            {
                consul = services[rand.Next(services.Count)];
            }
            return(consul);
        }
 /// <summary>
 /// 修改会员信用
 /// 编写时间: 2010-10-6 14:10
 /// 创建者:Mickey
 /// </summary>
 /// <param name="id"></param>
 /// <param name="credit"></param>
 /// <returns></returns>
 public static bool updateCredit(string id, string credit, string userId, string userCredit, decimal balance)
 {
     if (userService.updateUserCredit(id, credit, balance))
     {
         AgentService agentService = new AgentService();
         return(agentService.updateUserCredit(userId, userCredit));
     }
     else
     {
         return(false);
     }
 }
Example #29
0
 private ServiceInformation MapToServiceInformation(AgentService agentService)
 {
     return(new ServiceInformation
     {
         Address = agentService.Address,
         EnableTagOverride = agentService.EnableTagOverride,
         ID = agentService.ID,
         Port = agentService.Port,
         Service = agentService.Service,
         Tags = agentService.Tags
     });
 }
        public void ShouldReturnAnAgentWithAccessLevel()
        {
            var           agentJson = StubDataLoader.LoadJsonFile("Agent.json");
            IAgentService service   = new AgentService(new MoxiWorksClient(new StubContextClient(agentJson)));
            var           response  = service.GetAgentWithAccessLevelAsync("some_agent_id", "some_company_id", true).Result;
            var           agent     = response.Item;

            Assert.IsType <Agent>(response.Item);
            Assert.Equal("YERP", agent.AccessLevel);
            Assert.Equal(1.25f, agent.BuyerCommissionRate);
            Assert.Equal(1.25f, agent.SellerCommissionRate);
        }
Example #31
0
        public async Task AgentTests_GetAgent_NotNull()
        {
            var mockAgent           = new Agent();
            var mockAgentRepository = await new MockAgentRepository().MockGetById(null);
            var mockUnitOfWork      = new MockUnitOfWork().MockGetAgentRepository(mockAgentRepository.Object);
            var agentService        = new AgentService(mockUnitOfWork.Object);
            var agent = await agentService.GetById(2);

            Assert.Null(agent);
            mockUnitOfWork.VerifyGetAgentRepository(Times.Once());
            mockAgentRepository.VerifyGetById(Times.Once());
        }
Example #32
0
        public void Catalog_RegistrationDeregistration()
        {
            var c = ClientTest.MakeClient();
            var service = new AgentService()
            {
                ID = "redis1",
                Service = "redis",
                Tags = new[] {"master", "v1"},
                Port = 8000
            };

            var check = new AgentCheck()
            {
                Node = "foobar",
                CheckID = "service:redis1",
                Name = "Redis health check",
                Notes = "Script based health check",
                Status = CheckStatus.Passing,
                ServiceID = "redis1"
            };

            var reg = new CatalogRegistration()
            {
                Datacenter = "dc1",
                Node = "foobar",
                Address = "192.168.10.10",
                Service = service,
                Check = check
            };

            c.Catalog.Register(reg);

            var node = c.Catalog.Node("foobar");
            Assert.IsTrue(node.Response.Services.ContainsKey("redis1"));

            var health = c.Health.Node("foobar");
            Assert.AreEqual("service:redis1", health.Response[0].CheckID);

            var dereg = new CatalogDeregistration()
            {
                Datacenter = "dc1",
                Node = "foobar",
                Address = "192.168.10.10",
                CheckID = "service:redis1"
            };

            c.Catalog.Deregister(dereg);

            health = c.Health.Node("foobar");
            Assert.AreEqual(0, health.Response.Length);

            dereg = new CatalogDeregistration()
            {
                Datacenter = "dc1",
                Node = "foobar",
                Address = "192.168.10.10"
            };

            c.Catalog.Deregister(dereg);

            node = c.Catalog.Node("foobar");
            Assert.IsNull(node.Response);
        }
        public void SetUp()
        {
            _deploymentPipelineFake = new Mock<IDeploymentPipeline>();
              _diagnositcMessagesLoggerFake = new Mock<IDiagnosticMessagesLogger>();
              _projectInfoRepositoryFake = new Mock<IProjectInfoRepository>();
              _environmentInfoRepositoryFake = new Mock<IEnvironmentInfoRepository>();
              _teamCityClientFake = new Mock<ITeamCityClient>();
              _deploymentRequestRepositoryFake = new Mock<IDeploymentRequestRepository>();
              _projectMetadataExplorerFake = new Mock<IProjectMetadataExplorer>();
              _dirPathParamsResolver = new Mock<IDirPathParamsResolver>();

              _agentService =
            new AgentService(
            _deploymentPipelineFake.Object,
            _projectInfoRepositoryFake.Object,
            _environmentInfoRepositoryFake.Object,
            _teamCityClientFake.Object,
            _deploymentRequestRepositoryFake.Object,
            _diagnositcMessagesLoggerFake.Object,
            _projectMetadataExplorerFake.Object,
            _dirPathParamsResolver.Object);
        }
Example #34
0
        public async Task Catalog_EnableTagOverride()
        {
            var service = new AgentService()
            {
                ID = "redis1",
                Service = "redis",
                Tags = new[] { "master", "v1" },
                Port = 8000
            };

            var registration = new CatalogRegistration()
            {
                Datacenter = "dc1",
                Node = "foobar",
                Address = "192.168.10.10",
                Service = service
            };

            using (IConsulClient client = new ConsulClient())
            {
                await client.Catalog.Register(registration);

                var node = await client.Catalog.Node("foobar");

                Assert.Contains("redis1", node.Response.Services.Keys);
                Assert.False(node.Response.Services["redis1"].EnableTagOverride);

                var services = await client.Catalog.Service("redis");

                Assert.NotEmpty(services.Response);
                Assert.Equal("redis", services.Response[0].ServiceName);

                Assert.False(services.Response[0].ServiceEnableTagOverride);
            }

            // Use a new scope
            using (IConsulClient client = new ConsulClient())
            {
                service.EnableTagOverride = true;

                await client.Catalog.Register(registration);
                var node = await client.Catalog.Node("foobar");

                Assert.Contains("redis1", node.Response.Services.Keys);
                Assert.True(node.Response.Services["redis1"].EnableTagOverride);

                var services = await client.Catalog.Service("redis");

                Assert.NotEmpty(services.Response);
                Assert.Equal("redis", services.Response[0].ServiceName);

                Assert.True(services.Response[0].ServiceEnableTagOverride);
            }
        }