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));
}
