public async Task <IEnumerable <CreatableMachineDto> > Handle(GetCreatableMachinesForAccountQuery request, CancellationToken cancellationToken)
{
var account = await _context.Set <Account>()
.Include(x => x.LicenseConfig)
.Include(x => x.Sites)
.FirstOrDefaultAsync(x => !x.IsDeleted && !x.IsTemplate && x.Id == request.Id, cancellationToken);
if (account == null)
{
throw new EntityNotFoundException(nameof(Account), request.Id);
}
var machines = await _context.Set <Machine>().Where(x => x.AccountId == account.Id)
.ToListAsync(cancellationToken);
var licenseConfig = account.LicenseConfig;
var sites = account.Sites;
var creatableMachines = new List <CreatableMachineDto>();
var launcherMachine = machines.FirstOrDefault(x => x.IsLauncher);
if (launcherMachine == null)
{
var site = licenseConfig.InstancePolicy == ServerInstancePolicy.AllInOne
? sites.FirstOrDefault()
: null;
creatableMachines.Add(new CreatableMachineDto()
{
IsLauncher = true,
IsSiteMaster = licenseConfig.InstancePolicy == ServerInstancePolicy.AllInOne,
Name = AccountUtils.GenerateMachineName(account.UrlFriendlyName, licenseConfig.InstancePolicy, "Launcher"),
SiteId = site?.Id,
SiteName = site?.UrlFriendlyName
});
}
if (licenseConfig.InstancePolicy == ServerInstancePolicy.InstancePerSiteMaster)
{
foreach (var site in sites)
{
var machine = machines.FirstOrDefault(x => x.SiteName == site.UrlFriendlyName);
if (machine == null)
{
creatableMachines.Add(new CreatableMachineDto()
{
IsLauncher = false,
IsSiteMaster = true,
Name = AccountUtils.GenerateMachineName(account.UrlFriendlyName, licenseConfig.InstancePolicy, site.UrlFriendlyName),
SiteId = site.Id,
SiteName = site.UrlFriendlyName
});
}
}
}
return(creatableMachines);
}
public override async Task <long> Handle(CreateAccountCommand command, CancellationToken cancellationToken)
{
var account = Mapper.Map <Account>(command);
var machineConfig = account.MachineConfig;
account.IsActive = true;
account.CreationTime = DateTimeOffset.Now;
account.Creator = command.User;
var userTokenKeyPair = _keysManager.GenerateUserTokenKeyPair(!command.UseUniqueKey);
var interServerKeyPair = _keysManager.GenerateInterServerKeyPair(!command.UseUniqueKey);
var licenseKeyPair = _keysManager.GenerateLicenseKeyPair(!command.UseUniqueKey);
var apiPassword = StringUtils.GeneratePassword(16);
account.Keys = new Keys()
{
UserTokenPrivate = userTokenKeyPair.PrivateKey,
UserTokenPublic = userTokenKeyPair.PublicKey,
InterServerPrivate = interServerKeyPair.PrivateKey,
InterServerPublic = interServerKeyPair.PublicKey,
LicensePrivate = licenseKeyPair.PrivateKey,
LicensePublic = licenseKeyPair.PublicKey,
ApiPassword = apiPassword,
AccountFile = $"{account.UrlFriendlyName}:{apiPassword}".ToBase64(),
SqlExportPass = StringUtils.GeneratePassword(24)
};
var licenseBytes = LicenseUtils.GenerateLicense(account.LicenseConfig, account.Keys.LicensePrivate);
account.License = Convert.ToBase64String(licenseBytes);
var launcherVersion = _versionResolver.Resolve(Softwares.Launcher, command.LauncherVersionMode, command.LauncherHash);
machineConfig.LauncherHash = launcherVersion?.ToString();
var reportingVersion = _versionResolver.Resolve(Softwares.Reporting, command.ReportingVersionMode, command.ReportingHash);
machineConfig.ReportingHash = reportingVersion?.ToString();
var clientVersion = _versionResolver.Resolve(Softwares.WebClient, command.ClientVersionMode, command.ClientHash);
machineConfig.ClientHash = clientVersion?.ToString();
var siteMasterVersion = _versionResolver.Resolve(Softwares.SiteMaster, command.SiteMasterVersionMode, command.SiteMasterHash);
machineConfig.SiteMasterHash = siteMasterVersion?.ToString();
var mmaClass = await Context.Set <Class>().Include(x => x.MmaInstances).FirstOrDefaultAsync(x => x.Id == command.ClassId, cancellationToken);
var deployerVersion = _versionResolver.Resolve(Softwares.Deployer, command.DeployerVersionMode, command.DeployerHash, mmaClass?.MmaInstance?.DeployerVer);
machineConfig.DeployerHash = deployerVersion?.ToString();
var pdfExportVersion = _versionResolver.Resolve(Softwares.PdfExport, command.PdfExportVersionMode, command.PdfExportHash);
machineConfig.PdfExportHash = pdfExportVersion?.ToString();
var relExportVersion = _versionResolver.Resolve(Softwares.RelationalExport, command.RelExportVersionMode, command.RelExportHash);
machineConfig.RelExportHash = relExportVersion?.ToString();
var populateVersion = _versionResolver.Resolve(Softwares.Populate, command.PopulateVersionMode, command.PopulateHash);
machineConfig.PopulateHash = populateVersion?.ToString();
var linkwareVersion = _versionResolver.Resolve(Softwares.Linkware, command.LinkwareVersionMode, command.LinkwareHash);
machineConfig.LinkwareHash = linkwareVersion?.ToString();
var mainLibraryFiles = _versionResolver.GetLibraryFiles(command.MainLibraryFiles, command.MainLibraryMode, machineConfig.MainLibraryFiles.DeserializeArray <long>());
machineConfig.MainLibraryFiles = mainLibraryFiles.Serialize();
machineConfig.MainLibraryFile = mainLibraryFiles.FirstOrDefault();
machineConfig.MainLibraryMode = machineConfig.MainLibraryFiles.Any()
? LibraryFileModes.Select : LibraryFileModes.None;
var accountLibraryFiles = _versionResolver.GetLibraryFiles(command.AccountLibraryFile.HasValue ?
new[] { command.AccountLibraryFile.Value } : new long[0],
command.AccountLibraryMode,
machineConfig.AccountLibraryFile.HasValue ? new[] { machineConfig.AccountLibraryFile.Value } : new long[0]);
if (accountLibraryFiles.Any())
{
machineConfig.AccountLibraryFile = accountLibraryFiles.First();
machineConfig.AccountLibraryMode = LibraryFileModes.Select;
}
else
{
machineConfig.AccountLibraryFile = null;
machineConfig.AccountLibraryMode = LibraryFileModes.None;
}
var state = new State()
{
Launcher = launcherVersion.IsNone() ? Versions.None : launcherVersion.Hash,
Reporting = reportingVersion.IsNone() ? Versions.None : reportingVersion.Hash,
PdfExport = pdfExportVersion.IsNone() ? Versions.None : pdfExportVersion.Hash,
Client = clientVersion.IsNone() ? Versions.None : clientVersion.Hash,
SiteMaster = siteMasterVersion.IsNone() ? Versions.None : siteMasterVersion.Hash,
Deployer = deployerVersion.IsNone() ? Versions.None : deployerVersion.Hash,
RelExport = relExportVersion.IsNone() ? Versions.None : relExportVersion.Hash,
Populate = populateVersion.IsNone() ? Versions.None : populateVersion.Hash,
Linkware = linkwareVersion.IsNone() ? Versions.None : linkwareVersion.Hash,
LibraryFile = machineConfig.MainLibraryFile ?? 0,
LibraryFiles = machineConfig.MainLibraryFiles,
AccountLibraryFile = machineConfig.AccountLibraryFile ?? 0,
Locked = false,
Desired = true,
SslEnabled = command.EnableSsl,
MonitoringEnabled = command.ShowInGrafana
};
var baseDomainUrl = "";
var machine = new Machine()
{
CloudInstanceTypeId = command.CloudInstanceType,
IsLauncher = true,
CreationMailSent = false,
LauncherUrl = $"{(command.EnableSsl ? "https" : "http")}://{account.UrlFriendlyName}.{baseDomainUrl}",
MailTo = command.ContactEmail,
RdpUsers = JsonConvert.SerializeObject(new {}),
States = new List <State>()
{
state
},
ClassId = command.ClassId,
Managed = command.Managed,
Region = command.Region,
VmImageName = command.VmImageName,
SampleData = command.IncludeSampleData,
Turbo = true
};
account.Machines.Add(machine);
var serverInstancePolicy = command.InstancePolicy;
if (serverInstancePolicy == ServerInstancePolicy.AllInOne)
{
var site = new Site()
{
Name = command.SiteMasterName,
UrlFriendlyName = command.SiteMasterUrlFriendlyName,
CloudInstanceType = command.CloudInstanceType
};
account.Sites.Add(site);
machine.IsSiteMaster = true;
machine.SiteName = site.UrlFriendlyName;
machine.SiteMasterUrl = AccountUtils.GenerateSiteMasterUrl(account.UrlFriendlyName, site.UrlFriendlyName, command.EnableSsl);
machine.Name = AccountUtils.GenerateMachineName(command.UrlFriendlyName, command.InstancePolicy);
site.Machine = machine;
}
else
{
machine.Name = AccountUtils.GenerateMachineName(command.UrlFriendlyName, command.InstancePolicy, "launcher");
state.SiteMaster = Versions.None;
state.Linkware = Versions.None;
state.Client = Versions.None;
state.RelExport = Versions.None;
}
Context.Set <Account>().Add(account);
await Context.SaveChangesAsync(cancellationToken);
await Mediator.Publish(new AccountCreatedEvent()
{
User = command.User,
Account = account,
Command = command
}, cancellationToken);
return(account.Id);
}
public override async Task <Unit> Handle(CreateMachineCommand command, CancellationToken cancellationToken)
{
var account = await Context.Set <Account>()
.Include(x => x.Contact)
.Include(x => x.LicenseConfig)
.Include(x => x.MachineConfig)
.Include(x => x.Sites)
.FirstOrDefaultAsync(x => !x.IsDeleted && !x.IsTemplate && x.Id == command.AccountId, cancellationToken);
if (account == null)
{
throw new EntityNotFoundException(nameof(Account), command.AccountId);
}
var machines = await Context.Set <Machine>().Where(x => x.AccountId == account.Id)
.ToListAsync(cancellationToken);
if (command.IsLauncher)
{
var launcherMachine = machines.FirstOrDefault(x => x.IsLauncher);
if (launcherMachine != null)
{
throw new CommandException();
}
}
Site site = null;
if (command.SiteId.HasValue)
{
site = account.Sites.FirstOrDefault(x => x.Id == command.SiteId);
if (site == null)
{
throw new CommandException();
}
var siteMachine = machines.FirstOrDefault(x => x.SiteName == site.UrlFriendlyName);
if (siteMachine != null)
{
throw new CommandException();
}
}
var machineConfig = account.MachineConfig;
var newState = new State()
{
Launcher = command.IsLauncher ? machineConfig.LauncherHash : Versions.None,
PdfExport = command.IsLauncher ? machineConfig.PdfExportHash : Versions.None,
Reporting = command.IsLauncher ? machineConfig.ReportingHash : Versions.None,
Client = machineConfig.ClientHash,
SiteMaster = machineConfig.SiteMasterHash,
RelExport = machineConfig.RelExportHash,
Deployer = machineConfig.DeployerHash,
Populate = machineConfig.PopulateHash,
LibraryFile = machineConfig.MainLibraryFile ?? 0,
LibraryFiles = machineConfig.MainLibraryFiles,
AccountLibraryFile = machineConfig.AccountLibraryFile ?? 0,
Locked = false,
Desired = true,
SslEnabled = machineConfig.EnableSsl,
};
var machine = new Machine()
{
Name = AccountUtils.GenerateMachineName(account.UrlFriendlyName, account.LicenseConfig.InstancePolicy),
Account = account,
CloudInstanceTypeId = account.LicenseConfig.CloudInstanceType,
IsLauncher = command.IsLauncher,
IsSiteMaster = command.SiteId.HasValue,
CreationMailSent = false,
MailTo = account.Contact.Email,
RdpUsers = JsonConvert.SerializeObject(new { }),
ClassId = account.ClassId,
Managed = account.Managed,
Region = machineConfig.Region,
VmImageName = machineConfig.VmImageName,
SiteName = site?.UrlFriendlyName,
SiteMasterUrl = site == null ? null : AccountUtils.GenerateSiteMasterUrl(account.UrlFriendlyName, site.UrlFriendlyName, account.MachineConfig.EnableSsl),
States = new List <State>()
{
newState
},
SampleData = machineConfig.IncludeSampleData
};
if (site != null)
{
site.Machine = machine;
}
Context.Set <Machine>().Add(machine);
await Context.SaveChangesAsync(cancellationToken);
return(Unit.Value);
}
