public async Task <IActionResult> CreateAsync([FromServices] ClusterService service, [FromBody] ClusterDTO ClusterDto) { try { var retornoNetwork = await service.CreateNetwork(ClusterDto.NomeCluster); var retornoSubnet = await service.CreateSubnet(retornoNetwork.Id, ClusterDto.NomeCluster); var retornoRouter = await service.CreateRouter(ClusterDto.NomeCluster); var retornoInterface = await service.AddRouterInterface(retornoSubnet.Id, retornoRouter.Id); var retorno = await service.CreateServer(ClusterDto.NomeCluster, ClusterDto.IdImage, ClusterDto.IdFlavor, retornoNetwork.Id); ClusterDto.IdServer = retorno.Id; ClusterDto.IdNetwork = retornoNetwork.Id; var interfacePort = await service.GetAllServerInterfaces(retorno.Id); var floatingIp = await service.AssociateFloatingIp("78c9ed54-cca8-4f1b-837d-b15c185cce17", interfacePort[0].PortId); ClusterDto.FloatingIP = floatingIp.FloatingIpAddress; ClusterDto.DataCriacao = DateTime.Now; } catch { return(null); } var mapped = Mapper.Map <Cluster>(ClusterDto); var result = service.Add <ClusterValidator>(mapped); return(new ObjectResult(result)); }
public async Task GetClusterList() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); int readyClusters = 10; int deletingCluster = 4; int newClusters = 2; int removeClusters = 1; IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); using (ITransaction tx = stateManager.CreateTransaction()) { await this.AddClusters(tx, dictionary, readyClusters, ClusterStatus.Ready); await this.AddClusters(tx, dictionary, deletingCluster, ClusterStatus.Deleting); await this.AddClusters(tx, dictionary, newClusters, ClusterStatus.New); await this.AddClusters(tx, dictionary, removeClusters, ClusterStatus.Remove); await tx.CommitAsync(); } IEnumerable<ClusterView> actual = await target.GetClusterListAsync(); Assert.AreEqual(readyClusters, actual.Count()); }
private void Start() { try { var configuredListeners = InstantiateConfiguredListenerObjects(); LifecycleService.Start(configuredListeners); InvocationService.Start(); ClusterService.Start(configuredListeners); ConnectionManager.Start(); ClusterService.WaitInitialMemberListFetched(); ConnectionManager.ConnectToAllClusterMembers(); ListenerService.Start(); ProxyManager.Init(ClientConfig); LoadBalancer.Init(((IHazelcastInstance)this).Cluster, ClientConfig); // Statistics.Start(); AddClientConfigAddedListeners(configuredListeners); } catch (Exception e) { try { LifecycleService.Terminate(); } catch (Exception) { //ignore } throw ExceptionUtil.Rethrow(e); } }
public async Task TestProcessRemoveTimeLimit() { bool calledActual = false; ClusterConfig config = new ClusterConfig() { MaxClusterUptime = TimeSpan.FromHours(2) }; MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { DeleteClusterAsyncFunc = name => { calledActual = true; return(Task.FromResult(true)); } }; ClusterService target = new ClusterService(clusterOperator, stateManager) { Config = config }; Cluster cluster = new Cluster() { Status = ClusterStatus.Ready, CreatedOn = DateTimeOffset.UtcNow - config.MaxClusterUptime }; await target.ProcessClusterStatusAsync(cluster); Assert.IsTrue(calledActual); Assert.AreEqual(ClusterStatus.Deleting, cluster.Status); }
public async Task TestTargetClusterCapacityDecreaseAtMinCount() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, stateManager) { Config = config }; var dictionary = await stateManager.GetOrAddAsync <IReliableDictionary <int, Cluster> >(ClusterService.ClusterDictionaryName); int clusterCount = config.MinimumClusterCount + 1; using (ITransaction tx = stateManager.CreateTransaction()) { await AddClusters(tx, dictionary, clusterCount, () => new Cluster() { Users = new List <ClusterUser>(Enumerable.Repeat(new ClusterUser(), (int)Math.Floor((double)config.MaximumUsersPerCluster *config.UserCapacityLowPercentThreshold))) }); await tx.CommitAsync(); } int expected = config.MinimumClusterCount; int actual = await target.GetTargetClusterCapacityAsync(); Assert.AreEqual(expected, actual); }
public async Task TestBalanceClustersIncreaseBelowMin() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, stateManager) { Config = config }; var dictionary = await stateManager.GetOrAddAsync <IReliableDictionary <int, Cluster> >(ClusterService.ClusterDictionaryName); int readyCount = (int)Math.Floor(config.MinimumClusterCount / 5D); int newCount = readyCount; int creatingCount = readyCount; using (ITransaction tx = stateManager.CreateTransaction()) { await AddClusters(tx, dictionary, readyCount, ClusterStatus.Ready); await AddClusters(tx, dictionary, newCount, ClusterStatus.New); await AddClusters(tx, dictionary, creatingCount, ClusterStatus.Creating); await AddClusters(tx, dictionary, config.MinimumClusterCount, ClusterStatus.Deleting); await tx.CommitAsync(); } await target.BalanceClustersAsync(readyCount * 4); Assert.AreEqual(config.MinimumClusterCount, dictionary.Count(x => x.Value.Status == ClusterStatus.Ready || x.Value.Status == ClusterStatus.New || x.Value.Status == ClusterStatus.Creating)); }
public async Task TestBalanceClustersMaxThreshold() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, stateManager) { Config = config }; int readyClusters = 10; int deletingClusterCount = 20; var dictionary = await stateManager.GetOrAddAsync <IReliableDictionary <int, Cluster> >(ClusterService.ClusterDictionaryName); using (ITransaction tx = stateManager.CreateTransaction()) { await AddClusters(tx, dictionary, readyClusters, ClusterStatus.Ready); await AddClusters(tx, dictionary, deletingClusterCount, ClusterStatus.Deleting); await tx.CommitAsync(); } await target.BalanceClustersAsync(config.MaximumClusterCount + 1); Assert.AreEqual(config.MaximumClusterCount + deletingClusterCount, await dictionary.GetCountAsync()); Assert.AreEqual(config.MaximumClusterCount - readyClusters, dictionary.Count(x => x.Value.Status == ClusterStatus.New)); Assert.AreEqual(readyClusters, dictionary.Count(x => x.Value.Status == ClusterStatus.Ready)); }
public async Task TestBalanceClusterDecreaseAlreadyDeleting() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, stateManager) { Config = config }; var dictionary = await stateManager.GetOrAddAsync <IReliableDictionary <int, Cluster> >(ClusterService.ClusterDictionaryName); int readyCount = 5 + config.MinimumClusterCount; int deletingCount = 10; int targetCount = config.MinimumClusterCount / 2; using (ITransaction tx = stateManager.CreateTransaction()) { await AddClusters(tx, dictionary, readyCount, ClusterStatus.Ready); await AddClusters(tx, dictionary, deletingCount, ClusterStatus.Deleting); await tx.CommitAsync(); } await target.BalanceClustersAsync(targetCount); Assert.AreEqual(readyCount - config.MinimumClusterCount, dictionary.Count(x => x.Value.Status == ClusterStatus.Remove)); Assert.AreEqual(config.MinimumClusterCount, dictionary.Count(x => x.Value.Status == ClusterStatus.Ready)); Assert.AreEqual(deletingCount, dictionary.Count(x => x.Value.Status == ClusterStatus.Deleting)); }
public async Task TestProcessRemove() { bool calledActual = false; string nameActual = null; MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { DeleteClusterAsyncFunc = name => { nameActual = name; calledActual = true; return(Task.FromResult(true)); } }; ClusterService target = new ClusterService(clusterOperator, stateManager); Cluster cluster = new Cluster() { Status = ClusterStatus.Remove }; await target.ProcessClusterStatusAsync(cluster); Assert.IsTrue(calledActual); Assert.AreEqual(ClusterStatus.Deleting, cluster.Status); }
public async Task TestProcessNewCluster() { bool calledActual = false; string nameTemplate = "Test:{0}"; string nameActual = null; MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { CreateClusterAsyncFunc = name => { nameActual = name; calledActual = true; return(Task.FromResult(String.Format(nameTemplate, name))); } }; ClusterService target = new ClusterService(clusterOperator, stateManager); Cluster cluster = new Cluster() { Status = ClusterStatus.New }; await target.ProcessClusterStatusAsync(cluster); Assert.IsTrue(calledActual); Assert.AreEqual(ClusterStatus.Creating, cluster.Status); Assert.AreEqual(String.Format(nameTemplate, nameActual), cluster.Address); }
public void PelletClusterWithType() { PelletServer server = new PelletServer(PelletTestServer); Type svcType = typeof(ClusterService); foreach (KnowledgeBase kb in server.KnowledgeBases) { if (kb.SupportsService(svcType)) { Console.WriteLine(kb.Name + " supports Clustering"); ClusterService svc = (ClusterService)kb.GetService(svcType); Console.WriteLine("Cluster=3 and Type=wine:WineGrape"); List <List <INode> > clusters = svc.Cluster(3, "wine:WineGrape"); Console.WriteLine(clusters.Count + " Clusters returned"); for (int i = 0; i < clusters.Count; i++) { Console.WriteLine("Cluster " + (i + 1) + " contains " + clusters[i].Count + " Items"); } } else { Console.WriteLine(kb.Name + " does not support the Cluster Service"); } Console.WriteLine(); } }
protected async Task DeleteClusterAsync() { if (await ClusterService.DeleteClustersAsync(ClusterId)) { NavigationManager.NavigateTo("/k3s"); } }
public async Task TestGetClusterList() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, stateManager) { Config = config }; int readyClusters = 10; int deletingCluster = 4; int newClusters = 2; int removeClusters = 1; var dictionary = await stateManager.GetOrAddAsync <IReliableDictionary <int, Cluster> >(ClusterService.ClusterDictionaryName); using (ITransaction tx = stateManager.CreateTransaction()) { await AddClusters(tx, dictionary, readyClusters, ClusterStatus.Ready); await AddClusters(tx, dictionary, deletingCluster, ClusterStatus.Deleting); await AddClusters(tx, dictionary, newClusters, ClusterStatus.New); await AddClusters(tx, dictionary, removeClusters, ClusterStatus.Remove); await tx.CommitAsync(); } IEnumerable <ClusterView> actual = await target.GetClusterList(); Assert.AreEqual(readyClusters, actual.Count()); }
public DepositOBController() { _villageService = new VillageService(); _groupService = new GroupService(); _clusterService = new ClusterService(); _interestService = new InterestService(); _accountHeadService = new AccountHeadService(); }
public LeadershipController() { _clusterService = new ClusterService(); _branchService = new BranchService(); _groupService = new GroupService(); _memberService = new MemberService(); _leadershipService = new LeadershipService(); }
public VillageController() { _villageService = new VillageService(); _mandalService = new MandalService(); _stateService = new StateService(); _districtservice = new DistrictService(); _clusterService = new ClusterService(); }
public ClusterController() { _mandalService = new MandalService(); _stateService = new StateService(); _districtService = new DistrictService(); _branchService = new BranchService(); _employeeService = new EmployeeService(); _clusterService = new ClusterService(); }
public FederationLoanApplicationController() { _clusterService = new ClusterService(); _groupService = new GroupService(); _ContraEntryService = new ContraEntryService(); _masterService = new MasterService(); _groupOtherReceiptService = new GroupOtherReceiptService(); _federationLoanApplicationService = new FederationLoanApplicationService(); }
public OrganizationController() { _organizationService = new OrganizationService(); _bankService = new BankService(); _villageService = new VillageService(); _clusterService = new ClusterService(); _interestService = new InterestService(); _panchayatService = new PanchayatService(); _commonService = new CommonService(); }
public GeneralPaymentsController() { _clusterService = new ClusterService(); _groupService = new GroupService(); _accountheadService = new AccountHeadService(); _employeeService = new EmployeeService(); _generalpaymentsService = new FederationGeneralPaymentsService(); _groupReceiptService = new GroupReceiptService(); _bankService = new BankService(); }
public GroupJournalEntryController() { _journalService = new GroupJournalService1(); _groupReceiptService = new GroupReceiptService(); _accountHeadService = new AccountHeadService(); _employeeService = new EmployeeService(); _generalpaymentsService = new FederationGeneralPaymentsService(); _groupService = new GroupService(); _clusterService = new ClusterService(); }
public PanchayatController() { _PanchayatService = new PanchayatService(); _stateservice = new StateService(); _clusterService = new ClusterService(); _mandalService = new MandalService(); _villageService = new VillageService(); _CommonService = new CommonService(); _DistrictService = new DistrictService(); }
public EmployeeController() { _branchService = new BranchService(); _employeeService = new EmployeeService(); _ClusterService = new ClusterService(); _employeeKycService = new EmployeeKycService(); _referenceValueService = new ReferenceValueService(); _commonService = new CommonService(); _masterService = new MasterService(); }
public DefaultStorageService(ClusterService clusterSvce, IOptionsMonitor <GeneralOption> option, IOptionsMonitor <DbOption> dbOption, ILogger <DefaultStorageService> logger, IMimeProvider mimeProvider, IRepositoryAccessor repoAccessor) { _clusterSvce = clusterSvce; _logger = logger; _mimeProvider = mimeProvider; _repoAccessor = repoAccessor; _dbOption = dbOption; _option = option; }
public LoanOBController() { _villageService = new VillageService(); _groupService = new GroupService(); _clusterService = new ClusterService(); _projectService = new ProjectService(); _fundSourceService = new FundSourceService(); _loanpurposeService = new LoanPurposeService(); _interestService = new InterestService(); _accountHeadService = new AccountHeadService(); _groupLoanDisbursementService = new GroupLoanDisbursementService(); }
public async IAsyncEnumerable <Cluster> Get(Datacenter datacenter) { if (datacenter?.Adapter == null) { yield return(null); yield break; } List <Cluster> clusters = new List <Cluster>(); Adapter adapter = await _context.Adapters .Where(x => x.IsOK) .Include(x => x.Credentials) .Include(x => x.Provider) .SingleOrDefaultAsync(y => y.Id == datacenter.Adapter.Id); if (adapter?.Provider == null) { yield return(null); yield break; } switch (adapter.Provider.ProviderType) { case ProviderType.Ovirt: ServicesResponse servicesResponse = await ClusterService.GetClusters(adapter); if (servicesResponse.isSuccess) { OvirtClusters ovirtClusters = (OvirtClusters)servicesResponse.resultObject; foreach (var cluster in ovirtClusters.Cluster) { if (cluster.DataCenter.Id == datacenter.Id) { yield return(cluster); } } } break; case ProviderType.VMware: var response = await EasyAdmin.Services.VMware.ClusterService.GetClustersListAsync(adapter, datacenter); if (response.isSuccess) { foreach (var cluster in response.resultObject) { yield return(cluster); } } break; } }
public GroupController() { _groupService = new GroupService(); _bankService = new BankService(); _villageService = new VillageService(); _clusterService = new ClusterService(); _interestService = new InterestService(); _accountHeadService = new AccountHeadService(); _panchayatService = new PanchayatService(); _memberService = new MemberService(); _commonService = new CommonService(); }
public BaseController() { _groupService = new GroupService(); _bankService = new BankService(); _villageService = new VillageService(); _clusterService = new ClusterService(); _interestService = new InterestService(); _accountHeadService = new AccountHeadService(); _panchayatService = new PanchayatService(); _memberService = new MemberService(); _commonService = new CommonService(); //UserInfo.UserID = SESS_USER_ID; }
public ReceiptController() { _groupService = new GroupService(); _referenceValueService = new ReferenceValueService(); _panchayatService = new PanchayatService(); _bankService = new BankService(); _groupReceiptService = new GroupReceiptService(); _ClusterService = new ClusterService(); _villageService = new VillageService(); _employeeService = new EmployeeService(); _accountheadService = new AccountHeadService(); _repaymentService = new RepaymentService(); }
public IActionResult Update([FromServices] ClusterService service, [FromBody] ClusterDTO ClusterDto, int id) { var ClusterRepo = service.GetById(predicate: x => x.IdCluster == id); var mapped = Mapper.Map(ClusterDto, ClusterRepo); var result = service.Update <ClusterValidator>(mapped); //Retornos vazios são NotFound if (result == null) { return(NotFound()); } return(Ok(result)); }
public async Task CreateClusterAsync_should_create_and_return_cluster() { // Arrange var clusterName = "lexicon-cluster"; var client = new EnvironmentVariables().ContainerServiceClient(); IClusterService classUnderTest = new ClusterService(client); // Act var response = await classUnderTest.CreateClusterAsync(clusterName); // Assert Assert.IsTrue(response.Cluster != null); Assert.IsTrue(response.Cluster.ClusterName.Equals(clusterName)); }
public async Task BalanceClusters() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); await target.BalanceClustersAsync(config.MinimumClusterCount); ConditionalResult<IReliableDictionary<int, Cluster>> result = await stateManager.TryGetAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); Assert.IsTrue(result.HasValue); Assert.AreEqual(config.MinimumClusterCount, await result.Value.GetCountAsync()); Assert.IsTrue(result.Value.All(x => x.Value.Status == ClusterStatus.New)); }
public async Task TestBalanceClusters() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, stateManager) { Config = config }; await target.BalanceClustersAsync(config.MinimumClusterCount); var result = await stateManager.TryGetAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); Assert.IsTrue(result.HasValue); Assert.AreEqual(config.MinimumClusterCount, await result.Value.GetCountAsync()); Assert.IsTrue(result.Value.All(x => x.Value.Status == ClusterStatus.New)); }
/// <summary> /// Creates the cluster service instance /// </summary> /// <param name="bus"/> /// <returns> /// The instance of the service /// </returns> public IBusService Create(IServiceBus bus) { var service = new ClusterService(_settings, bus); return service; }
public async Task BalanceClustersDecreaseAboveMax() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceContext(), config); int aboveMax = 10; int readyClusters = config.MaximumClusterCount + aboveMax; int deletingClusterCount = 20; IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); using (ITransaction tx = stateManager.CreateTransaction()) { await this.AddClusters(tx, dictionary, readyClusters, ClusterStatus.Ready); await this.AddClusters(tx, dictionary, deletingClusterCount, ClusterStatus.Deleting); await tx.CommitAsync(); } await target.BalanceClustersAsync(readyClusters - (aboveMax/2), CancellationToken.None); using (ITransaction tx = stateManager.CreateTransaction()) { Assert.AreEqual( config.MaximumClusterCount, (await dictionary.CreateEnumerableAsync(tx)).ToEnumerable().Count(x => x.Value.Status == ClusterStatus.Ready)); Assert.AreEqual( aboveMax, (await dictionary.CreateEnumerableAsync(tx)).ToEnumerable().Count(x => x.Value.Status == ClusterStatus.Remove)); Assert.AreEqual( deletingClusterCount, (await dictionary.CreateEnumerableAsync(tx)).ToEnumerable().Count(x => x.Value.Status == ClusterStatus.Deleting)); } }
public async Task ProcessNewCluster() { bool calledActual = false; string nameTemplate = "Test:{0}"; string nameActual = null; MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { CreateClusterAsyncFunc = name => { nameActual = name; calledActual = true; return Task.FromResult(String.Format(nameTemplate, name)); } }; ClusterConfig config = new ClusterConfig(); ClusterService target = new ClusterService( clusterOperator, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); Cluster cluster = this.CreateCluster(ClusterStatus.New); Cluster actual = await target.ProcessClusterStatusAsync(cluster); Assert.IsTrue(calledActual); Assert.AreEqual(ClusterStatus.Creating, actual.Status); Assert.AreEqual(String.Format(nameTemplate, nameActual), actual.Address); }
public async Task TestProcessCreatingClusterFailed() { MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { GetClusterStatusAsyncFunc = name => Task.FromResult(ClusterOperationStatus.CreateFailed) }; ClusterService target = new ClusterService(clusterOperator, stateManager); Cluster cluster = new Cluster() { Status = ClusterStatus.Creating }; await target.ProcessClusterStatusAsync(cluster); Assert.AreEqual(ClusterStatus.New, cluster.Status); Assert.AreEqual(0, cluster.Ports.Count()); Assert.AreEqual(0, cluster.Users.Count()); }
public async Task TestProcessDeletingSuccessful() { MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { GetClusterStatusAsyncFunc = domain => Task.FromResult(ClusterOperationStatus.ClusterNotFound) }; ClusterService target = new ClusterService(clusterOperator, stateManager); Cluster cluster = new Cluster() { Status = ClusterStatus.Deleting }; await target.ProcessClusterStatusAsync(cluster); Assert.AreEqual(ClusterStatus.Deleted, cluster.Status); }
public async Task TestProcessRemoveTimeLimit() { bool calledActual = false; ClusterConfig config = new ClusterConfig() { MaxClusterUptime = TimeSpan.FromHours(2) }; MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { DeleteClusterAsyncFunc = name => { calledActual = true; return Task.FromResult(true); } }; ClusterService target = new ClusterService(clusterOperator, stateManager) { Config = config }; Cluster cluster = new Cluster() { Status = ClusterStatus.Ready, CreatedOn = DateTimeOffset.UtcNow - config.MaxClusterUptime }; await target.ProcessClusterStatusAsync(cluster); Assert.IsTrue(calledActual); Assert.AreEqual(ClusterStatus.Deleting, cluster.Status); }
public async Task JoinClusterSuccessful() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService( null, new MockMailer(), new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); int id = 5; string email = "*****@*****.**"; Cluster cluster = new Cluster("test", ClusterStatus.Ready, 0, 0, "", new[] {80}, new ClusterUser[0], DateTimeOffset.UtcNow); IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); using (ITransaction tx = stateManager.CreateTransaction()) { await dictionary.AddAsync(tx, id, cluster); await tx.CommitAsync(); } await target.JoinClusterAsync(id, email); using (ITransaction tx = stateManager.CreateTransaction()) { Cluster actual = (await dictionary.TryGetValueAsync(tx, id)).Value; Assert.AreEqual(1, actual.Users.Count(x => x.Email == email)); } }
public async Task ProcessRemoveTimeLimit() { ClusterConfig config = new ClusterConfig() { MaximumClusterUptime = TimeSpan.FromHours(2) }; MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); Cluster cluster = new Cluster( "test", ClusterStatus.Ready, 0, 0, String.Empty, new int[0], new ClusterUser[0], DateTimeOffset.UtcNow - config.MaximumClusterUptime); Cluster actual = await target.ProcessClusterStatusAsync(cluster); Assert.AreEqual(ClusterStatus.Remove, actual.Status); }
public async Task ProcessDeletingSuccessful() { MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { GetClusterStatusAsyncFunc = domain => Task.FromResult(ClusterOperationStatus.ClusterNotFound) }; ClusterConfig config = new ClusterConfig(); ClusterService target = new ClusterService( clusterOperator, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); Cluster cluster = this.CreateCluster(ClusterStatus.Deleting); Cluster actual = await target.ProcessClusterStatusAsync(cluster); Assert.AreEqual(ClusterStatus.Deleted, actual.Status); }
public async Task ProcessRemove() { bool calledActual = false; string nameActual = null; MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { DeleteClusterAsyncFunc = name => { nameActual = name; calledActual = true; return Task.FromResult(true); } }; ClusterConfig config = new ClusterConfig(); ClusterService target = new ClusterService( clusterOperator, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); Cluster cluster = this.CreateCluster(ClusterStatus.Remove); Cluster actual = await target.ProcessClusterStatusAsync(cluster); Assert.IsTrue(calledActual); Assert.AreEqual(ClusterStatus.Deleting, actual.Status); }
public async Task ProcessCreatingClusterFailed() { MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { GetClusterStatusAsyncFunc = name => Task.FromResult(ClusterOperationStatus.CreateFailed) }; ClusterConfig config = new ClusterConfig(); ClusterService target = new ClusterService( clusterOperator, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); Cluster cluster = this.CreateCluster(ClusterStatus.Creating); Cluster actual = await target.ProcessClusterStatusAsync(cluster); Assert.AreEqual(ClusterStatus.Remove, actual.Status); Assert.AreEqual(0, actual.Ports.Count()); Assert.AreEqual(0, actual.Users.Count()); }
public async Task ProcessCreatingClusterSuccess() { MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { GetClusterStatusAsyncFunc = name => Task.FromResult(ClusterOperationStatus.Ready) }; ClusterConfig config = new ClusterConfig(); ClusterService target = new ClusterService( clusterOperator, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); Cluster cluster = this.CreateCluster(ClusterStatus.Creating); Cluster actual = await target.ProcessClusterStatusAsync(cluster); Assert.AreEqual(ClusterStatus.Ready, actual.Status); Assert.IsTrue(actual.CreatedOn.ToUniversalTime() <= DateTimeOffset.UtcNow); actual.Ports.SequenceEqual(await clusterOperator.GetClusterPortsAsync("")); }
public async Task BalanceClustersMinThreshold() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceContext(), config); IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); using (ITransaction tx = stateManager.CreateTransaction()) { await this.AddClusters(tx, dictionary, config.MinimumClusterCount, ClusterStatus.Ready); await tx.CommitAsync(); } await target.BalanceClustersAsync(config.MinimumClusterCount - 1, CancellationToken.None); using (ITransaction tx = stateManager.CreateTransaction()) { Assert.AreEqual(config.MinimumClusterCount, await dictionary.GetCountAsync(tx)); Assert.IsTrue((await dictionary.CreateEnumerableAsync(tx)).ToEnumerable().All(x => x.Value.Status == ClusterStatus.Ready)); } }
public void JoinClusterSuccessful() { throw new NotImplementedException(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, stateManager); }
public async Task JoinClusterEmailData() { ClusterConfig config = new ClusterConfig(); DateTimeOffset clusterCreated = DateTimeOffset.UtcNow; string expectedEmail = "*****@*****.**"; string expectedClusterAddress = "test.azure.com"; int expectedUserPort = 543; string expectedLinkAddress = "http://domain.com/app"; string expectedLinkText = "title"; string expectedLinkDesc = "desc"; string actualEmail = null; string actualClusterAddress = null; int actualUserPort = 0; HyperlinkView actualExplorerLink = null; HyperlinkView actualAppLink = null; MockMailer mailer = new MockMailer(); MockApplicationDeployService appDeploy = new MockApplicationDeployService() { GetApplicationDeploymentsAsyncFunc = (c, p) => Task.FromResult<IEnumerable<ApplicationView>>(new[] { new ApplicationView(new HyperlinkView(expectedLinkAddress, expectedLinkText, expectedLinkDesc)) }) }; mailer.SendJoinMailFunc = (receipientAddress, clusterAddress, userPort, timeRemaining, clusterExpiration, links) => { actualEmail = receipientAddress; actualClusterAddress = clusterAddress; actualUserPort = userPort; actualExplorerLink = links.ElementAt(0); actualAppLink = links.ElementAt(1); return Task.FromResult(true); }; MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService( null, mailer, appDeploy, stateManager, this.CreateServiceParameters(), config); int id = 5; Cluster cluster = new Cluster("test", ClusterStatus.Ready, 0, 0, expectedClusterAddress, new[] { expectedUserPort }, new ClusterUser[0], DateTimeOffset.UtcNow); IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); using (ITransaction tx = stateManager.CreateTransaction()) { await dictionary.AddAsync(tx, id, cluster); await tx.CommitAsync(); } await target.JoinClusterAsync(id, expectedEmail); Assert.AreEqual(expectedEmail, actualEmail); Assert.AreEqual(expectedClusterAddress + ":19000", actualClusterAddress); Assert.AreEqual(expectedUserPort, actualUserPort); Assert.AreEqual(expectedLinkAddress, actualAppLink.Address); Assert.AreEqual(expectedLinkText, actualAppLink.Text); Assert.AreEqual(expectedLinkDesc, actualAppLink.Description); Assert.AreEqual("http://" + expectedClusterAddress + ":19080/Explorer/index.html", actualExplorerLink.Address); }
public async Task BalanceClustersDecreaseNonEmpty() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); int withUsers = config.MinimumClusterCount + 5; int withoutUsers = 10; int targetCount = (withUsers + withoutUsers) - 11; using (ITransaction tx = stateManager.CreateTransaction()) { await this.AddClusters( tx, dictionary, withUsers, () => this.CreateCluster( ClusterStatus.Ready, new List<ClusterUser>() {new ClusterUser()})); await this.AddClusters(tx, dictionary, withoutUsers, ClusterStatus.Ready); await tx.CommitAsync(); } await target.BalanceClustersAsync(targetCount); Assert.AreEqual(withUsers, dictionary.Select(x => x.Value).Count(x => x.Status == ClusterStatus.Ready)); Assert.AreEqual(withoutUsers, dictionary.Select(x => x.Value).Count(x => x.Status == ClusterStatus.Remove)); }
public async Task ProcessClustersAsyncSaveChanges() { int key = 1; string nameTemplate = "Test:{0}"; MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterConfig config = new ClusterConfig(); MockClusterOperator clusterOperator = new MockClusterOperator() { CreateClusterAsyncFunc = name => { return Task.FromResult(String.Format(nameTemplate, name)); } }; IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); Cluster original = this.CreateCluster(ClusterStatus.New); using (ITransaction tx = stateManager.CreateTransaction()) { await dictionary.SetAsync(tx, key, original); } ClusterService target = new ClusterService( clusterOperator, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); await target.ProcessClustersAsync(); using (ITransaction tx = stateManager.CreateTransaction()) { Cluster actual = (await dictionary.TryGetValueAsync(tx, key)).Value; Assert.AreNotEqual(original, actual); } }
public async Task ProcessNewCluster() { bool calledActual = false; string nameTemplate = "Test:{0}"; string nameActual = null; IEnumerable<int> portsExpected = Enumerable.Empty<int>(); MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { CreateClusterAsyncFunc = (name, ports) => { nameActual = name; portsExpected = ports; calledActual = true; return Task.FromResult(String.Format(nameTemplate, name)); } }; ClusterConfig config = new ClusterConfig(); ClusterService target = new ClusterService( clusterOperator, null, new MockApplicationDeployService(), stateManager, this.CreateServiceContext(), config); Cluster cluster = this.CreateCluster(ClusterStatus.New); Cluster actual = await target.ProcessClusterStatusAsync(cluster); Assert.IsTrue(calledActual); Assert.AreEqual(ClusterStatus.Creating, actual.Status); Assert.AreEqual(String.Format(nameTemplate, nameActual), actual.Address); Assert.AreEqual(5, actual.Ports.Count()); Enumerable.SequenceEqual(portsExpected, actual.Ports); }
public async Task TargetClusterCapacityDecreaseAtMinCount() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); int clusterCount = config.MinimumClusterCount + 1; using (ITransaction tx = stateManager.CreateTransaction()) { await this.AddClusters( tx, dictionary, clusterCount, () => this.CreateCluster( ClusterStatus.Ready, new List<ClusterUser>( Enumerable.Repeat( new ClusterUser(), (int) Math.Floor((double) config.MaximumUsersPerCluster*config.UserCapacityLowPercentThreshold))))); await tx.CommitAsync(); } int expected = config.MinimumClusterCount; int actual = await target.GetTargetClusterCapacityAsync(); Assert.AreEqual(expected, actual); }
public async Task TestProcessRemove() { bool calledActual = false; string nameActual = null; MockReliableStateManager stateManager = new MockReliableStateManager(); MockClusterOperator clusterOperator = new MockClusterOperator() { DeleteClusterAsyncFunc = name => { nameActual = name; calledActual = true; return Task.FromResult(true); } }; ClusterService target = new ClusterService(clusterOperator, stateManager); Cluster cluster = new Cluster() { Status = ClusterStatus.Remove }; await target.ProcessClusterStatusAsync(cluster); Assert.IsTrue(calledActual); Assert.AreEqual(ClusterStatus.Deleting, cluster.Status); }
public async Task BalanceClusterDecreaseAlreadyDeleting() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); int readyCount = 5 + config.MinimumClusterCount; int deletingCount = 10; int targetCount = config.MinimumClusterCount/2; using (ITransaction tx = stateManager.CreateTransaction()) { await this.AddClusters(tx, dictionary, readyCount, ClusterStatus.Ready); await this.AddClusters(tx, dictionary, deletingCount, ClusterStatus.Deleting); await tx.CommitAsync(); } await target.BalanceClustersAsync(targetCount); Assert.AreEqual(readyCount - config.MinimumClusterCount, dictionary.Count(x => x.Value.Status == ClusterStatus.Remove)); Assert.AreEqual(config.MinimumClusterCount, dictionary.Count(x => x.Value.Status == ClusterStatus.Ready)); Assert.AreEqual(deletingCount, dictionary.Count(x => x.Value.Status == ClusterStatus.Deleting)); }
public async Task BalanceClustersIncreaseBelowMin() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); int readyCount = (int) Math.Floor(config.MinimumClusterCount/5D); int newCount = readyCount; int creatingCount = readyCount; using (ITransaction tx = stateManager.CreateTransaction()) { await this.AddClusters(tx, dictionary, readyCount, ClusterStatus.Ready); await this.AddClusters(tx, dictionary, newCount, ClusterStatus.New); await this.AddClusters(tx, dictionary, creatingCount, ClusterStatus.Creating); await this.AddClusters(tx, dictionary, config.MinimumClusterCount, ClusterStatus.Deleting); await tx.CommitAsync(); } await target.BalanceClustersAsync(readyCount*4); Assert.AreEqual( config.MinimumClusterCount, dictionary.Count( x => x.Value.Status == ClusterStatus.Ready || x.Value.Status == ClusterStatus.New || x.Value.Status == ClusterStatus.Creating)); }
public async Task TargetClusterCapacityIncreaseAtMaxCount() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceContext(), config); IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); int clusterCount = config.MaximumClusterCount - 1; using (ITransaction tx = stateManager.CreateTransaction()) { await this.AddClusters( tx, dictionary, clusterCount, () => this.CreateCluster( ClusterStatus.Ready, new List<ClusterUser>( Enumerable.Repeat( new ClusterUser(), (int) Math.Ceiling((double) config.MaximumUsersPerCluster*config.UserCapacityHighPercentThreshold))))); await this.AddClusters( tx, dictionary, 5, () => this.CreateCluster( ClusterStatus.Remove, new List<ClusterUser>(Enumerable.Repeat(new ClusterUser(), config.MaximumUsersPerCluster)))); await tx.CommitAsync(); } int actual = await target.GetTargetClusterCapacityAsync(CancellationToken.None); Assert.AreEqual(config.MaximumClusterCount, actual); }
public async Task JoinClusterNotReady() { ClusterConfig config = new ClusterConfig() {MaximumUsersPerCluster = 2}; MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); int id = 5; Cluster cluster = new Cluster( "test", ClusterStatus.Creating, 0, 0, "", new[] {80}, new ClusterUser[0], DateTimeOffset.UtcNow); IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); using (ITransaction tx = stateManager.CreateTransaction()) { await dictionary.AddAsync(tx, id, cluster); await tx.CommitAsync(); } try { await target.JoinClusterAsync(id, "email"); Assert.Fail("JoinClusterFailedException not thrown."); } catch (JoinClusterFailedException result) { Assert.AreEqual(JoinClusterFailedReason.ClusterNotReady, result.Reason); } }
public async Task JoinClusterUserAlreadyExists() { ClusterConfig config = new ClusterConfig() {MaximumUsersPerCluster = 2}; MockReliableStateManager stateManager = new MockReliableStateManager(); MockMailer mockMailer = new MockMailer(); ClusterService target = new ClusterService( null, mockMailer, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); int idWithUser = 5; string email = "*****@*****.**"; Cluster clusterWithUser = new Cluster( "test", ClusterStatus.Ready, 0, 0, "", new[] {80, 81}, new[] {new ClusterUser(email, 80)}, DateTimeOffset.UtcNow); int idWithoutUser = 6; Cluster clusterWithoutUser = new Cluster( "test2", ClusterStatus.Ready, 0, 0, "", new[] {80, 81}, new ClusterUser[0], DateTimeOffset.UtcNow); IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); using (ITransaction tx = stateManager.CreateTransaction()) { await dictionary.AddAsync(tx, idWithUser, clusterWithUser); await dictionary.AddAsync(tx, idWithoutUser, clusterWithoutUser); await tx.CommitAsync(); } try { await target.JoinClusterAsync(idWithoutUser, email); Assert.Fail("JoinClusterFailedException not thrown."); } catch (JoinClusterFailedException result) { Assert.AreEqual(JoinClusterFailedReason.UserAlreadyJoined, result.Reason); } }
public async Task ProcessClustersAsyncDelete() { int key = 1; MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterConfig config = new ClusterConfig(); MockClusterOperator clusterOperator = new MockClusterOperator() { GetClusterStatusAsyncFunc = (name) => Task.FromResult(ClusterOperationStatus.ClusterNotFound) }; IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); Cluster original = this.CreateCluster(ClusterStatus.Deleting); using (ITransaction tx = stateManager.CreateTransaction()) { await dictionary.SetAsync(tx, key, original); } ClusterService target = new ClusterService( clusterOperator, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); await target.ProcessClustersAsync(); using (ITransaction tx = stateManager.CreateTransaction()) { ConditionalResult<Cluster> actual = await dictionary.TryGetValueAsync(tx, key); Assert.IsFalse(actual.HasValue); } }
public async Task BalanceClustersMaxThreshold() { ClusterConfig config = new ClusterConfig(); MockReliableStateManager stateManager = new MockReliableStateManager(); ClusterService target = new ClusterService(null, null, new MockApplicationDeployService(), stateManager, this.CreateServiceParameters(), config); int readyClusters = 10; int deletingClusterCount = 20; IReliableDictionary<int, Cluster> dictionary = await stateManager.GetOrAddAsync<IReliableDictionary<int, Cluster>>(ClusterService.ClusterDictionaryName); using (ITransaction tx = stateManager.CreateTransaction()) { await this.AddClusters(tx, dictionary, readyClusters, ClusterStatus.Ready); await this.AddClusters(tx, dictionary, deletingClusterCount, ClusterStatus.Deleting); await tx.CommitAsync(); } await target.BalanceClustersAsync(config.MaximumClusterCount + 1); Assert.AreEqual(config.MaximumClusterCount + deletingClusterCount, await dictionary.GetCountAsync()); Assert.AreEqual(config.MaximumClusterCount - readyClusters, dictionary.Count(x => x.Value.Status == ClusterStatus.New)); Assert.AreEqual(readyClusters, dictionary.Count(x => x.Value.Status == ClusterStatus.Ready)); }