public List<Models.AssignedVmModel> GenerateVMsForUsers(string serviceNameBase, VMConfigModel vmConfig, List<Models.VMUserModel> users)
{
_logger.Info("Entering GenerateVMsForUsers stub. [serviceNameBase:{0}; sourceVhdName:{1}; users:{2}]",
serviceNameBase, vmConfig.ImageName, users.Count);
List<AssignedVmModel> result = new List<AssignedVmModel>();
foreach (VMUserModel user in users)
{
AssignedVmModel assignedVm = new AssignedVmModel
{
UserId = user.IdentityId,
UserName = user.Username,
Password = user.Password,
VmName = "VM_" + user.Username,
VmRdpPort = 567
};
result.Add(assignedVm);
}
Thread.Sleep(1000);
_logger.Info("Exiting GenerateVMsForUsers stub. [serviceNameBase:{0}; sourceVhdName:{1}; users:{2}]",
serviceNameBase, vmConfig.ImageName, users.Count);
return result;
}
private void GenerateVM(string serviceName, VMConfigModel vmConfig, string virtualMachineName,
int rdpPort, VMUserModel user, bool firstVMInDeployment)
{
var windowsConfigurationSet = new ConfigurationSet
{
//TODO: depends on the OS type??
ConfigurationSetType = ConfigurationSetTypes.WindowsProvisioningConfiguration,
AdminPassword = user.Password,
AdminUserName = user.Username,
ComputerName = virtualMachineName,
HostName = string.Format("{0}.cloudapp.net", serviceName),
};
var endpoints = new ConfigurationSet
{
ConfigurationSetType = "NetworkConfiguration",
InputEndpoints = new List<InputEndpoint>
{
new InputEndpoint
{
Name = "RDP",
Port = rdpPort,
Protocol = "TCP",
LocalPort = InternalRdpPort
}
}
};
string newVhdName = string.Format("{0}.vhd", virtualMachineName);
Uri mediaUri = new Uri(GetVHDStorageUrl(vmConfig.Region) + newVhdName);
var vhd = new OSVirtualHardDisk
{
SourceImageName = vmConfig.ImageName,
HostCaching = VirtualHardDiskHostCaching.ReadWrite,
MediaLink = mediaUri,
};
OperationStatusResponse deploymentResult;
if (firstVMInDeployment)
{
deploymentResult = CreateDeployment(serviceName, virtualMachineName, windowsConfigurationSet, endpoints, vhd, vmConfig);
}
else
{
deploymentResult = AddVm(serviceName, virtualMachineName, windowsConfigurationSet, endpoints, vhd, vmConfig);
}
//TODO: handle the deploymentResult
}
private OperationStatusResponse CreateDeployment(string serviceName, string virtualMachineName, ConfigurationSet windowsConfigurationSet, ConfigurationSet endpoints, OSVirtualHardDisk vhd, VMConfigModel vmConfig)
{
OperationStatusResponse deploymentResult;
var role = new Role
{
RoleName = virtualMachineName,
RoleSize = MapToAzureVmSize(vmConfig.VmSize),
RoleType = VirtualMachineRoleType.PersistentVMRole.ToString(),
OSVirtualHardDisk = vhd,
ProvisionGuestAgent = true,
ConfigurationSets = new List<ConfigurationSet>
{
windowsConfigurationSet,
endpoints,
}
};
if (vmConfig.InsertCaptureScript)
{
role.ResourceExtensionReferences =
CreateCaptureScript(vmConfig.CaptureKey, vmConfig.ChocoPackageList);
}
var createDeploymentParameters = new VirtualMachineCreateDeploymentParameters
{
Name = serviceName,
Label = serviceName,
DeploymentSlot = DeploymentSlot.Production,
Roles = new List<Role> { role },
};
deploymentResult = _compute.VirtualMachines.CreateDeployment(
serviceName,
createDeploymentParameters);
return deploymentResult;
}
private OperationStatusResponse AddVm(string serviceName, string virtualMachineName, ConfigurationSet windowsConfigurationSet, ConfigurationSet endpoints, OSVirtualHardDisk vhd, VMConfigModel vmConfig)
{
OperationStatusResponse deploymentResult;
var createVMParameters = new VirtualMachineCreateParameters
{
RoleName = virtualMachineName,
RoleSize = MapToAzureVmSize(vmConfig.VmSize),
OSVirtualHardDisk = vhd,
ProvisionGuestAgent = true,
ConfigurationSets = new List<ConfigurationSet>
{
windowsConfigurationSet,
endpoints,
},
};
if (vmConfig.InsertCaptureScript)
{
createVMParameters.ResourceExtensionReferences =
CreateCaptureScript(vmConfig.CaptureKey, vmConfig.ChocoPackageList);
}
deploymentResult = _compute.VirtualMachines.Create(serviceName, serviceName, createVMParameters);
return deploymentResult;
}
/// <summary>
/// TODO: Summary in work....
/// </summary>
/// <param name="serviceName">A new service name.</param>
/// <param name="sourceVhdName">The original Azure image
/// name from which the reference VM has been created.</param>
/// <param name="users">The list of users that need VMs.</param>
public List<AssignedVmModel> GenerateVMsForUsers(string serviceName, VMConfigModel vmConfig,
List<VMUserModel> users)
{
_compute.HostedServices.Create(new HostedServiceCreateParameters
{
ServiceName = serviceName,
Location = LocationNames.NorthEurope
});
int vmIndex = 0;
int rdpPortIndex = RdpPortBase;
List<AssignedVmModel> assignedVms = new List<AssignedVmModel>();
List<Task> taskList = new List<Task>();
foreach (VMUserModel user in users)
{
bool isFirstVmInDeployment = !assignedVms.Any();
string virtualMachineName = serviceName + ++vmIndex;
//TODO: use the async version of the method to avoid creating new Tasks
//Task task = Task.Factory.StartNew(() => GenerateVM(serviceName, vmConfig, virtualMachineName,
// rdpPortIndex, user, isFirstVmInDeployment));
GenerateVM(serviceName, vmConfig, virtualMachineName,
rdpPortIndex, user, isFirstVmInDeployment);
//if it's the first VM, then we must wait till the Deployment is set-up so we can
//add to it the rest of the VMs
//if (isFirstVmInDeployment) task.Wait(); else taskList.Add(task);
assignedVms.Add(new AssignedVmModel
{
UserId = user.IdentityId,
UserName = user.Username,
VmName = virtualMachineName,
VmRdpPort = rdpPortIndex,
Password = user.Password
});
rdpPortIndex++;
}
//Task.WaitAll(taskList.ToArray());
return assignedVms;
}
public AssignedVmModel GenerateVm(string serviceBaseName, VMConfigModel vmConfig, VMUserModel user)
{
//TODO: refactor GenerateVMsForUsers to be used instead of this one
if (serviceBaseName.Length > 10) throw new ArgumentOutOfRangeException("serviceBaseName can't have more than 10 characters.");
//find a name that is available
Random r = new Random();
string serviceName = null;
HostedServiceCheckNameAvailabilityResponse availableResponse;
do
{
int randomValue = r.Next(99999);
serviceName = serviceBaseName + randomValue;
availableResponse = _compute.HostedServices.CheckNameAvailability(serviceName);
} while (!availableResponse.IsAvailable);
var createCloudService = _compute.HostedServices.Create(
new HostedServiceCreateParameters
{
ServiceName = serviceName,
Location = vmConfig.Region
});
string virtualMachineName = serviceName;
//TODO: need a status check
GenerateVM(serviceName, vmConfig, virtualMachineName, RdpPortBase, user,
firstVMInDeployment: true);
AssignedVmModel assignedVm = new AssignedVmModel
{
UserId = user.IdentityId,
UserName = user.Username,
VmName = virtualMachineName,
VmRdpPort = RdpPortBase,
Password = user.Password
};
return assignedVm;
}
public void Start(StartSessionRequest request)
{
using (ApplicationDbContext context = new ApplicationDbContext())
{
Session session = context.Sessions.Single(x => x.SessionId == request.SessionId);
//Session session = context.Sessions.Single(x => x.Version == version);
//check if the session is canceled or the request is no longer valid
if (session.Removed ||
(session.Version != request.Version.ToString()))
{
_logger.InfoFormat("StartSessionRequest for Sessionid: {0} was ignored because Removed: {1} and Version: {2}",
request.SessionId, session.Removed, request.Version);
return;
}
_logger.InfoFormat("Spawning VMs for SessionId: {0} ({1} - {2})",
session.SessionId, session.StartDate, session.EndDate);
Subscription subscription = context.Subscriptions
.Single(x => x.SubscriptionId == session.SubscriptionId);
IVMManagement vmManagement = AzureFacadeFactory.VMManagement(subscription.AzureSubscriptionId,
subscription.Certificate, subscription.CertificateKey, subscription.BlobStorageName,
subscription.BlobStorageKey);
//TODO: remove the hardcoding at some point in time
string NorthEurope = "North Europe";
VMConfigModel vmConfig = new VMConfigModel(session.Lab.ImageName, NorthEurope)
{
VmSize = (VmSizeEnum)Enum.Parse(typeof(VmSizeEnum), session.VmSize)
};
var sessionUsers = session.SessionUsers.ToList();
var vmUsers = new List<VMUserModel>();
sessionUsers.ForEach(x =>
{
//TODO: wrong logic.. not all sessions are based on templates
var templateVM = context.TemplateVMs.Where(y => y.IdentityId == x.IdentityId && y.SubscriptionId == subscription.SubscriptionId).FirstOrDefault();
if (templateVM != null)
{
vmUsers.Add(new VMUserModel
{
IdentityId = x.IdentityId,
Username = templateVM.VMAdminUser,
Password = templateVM.VMAdminPass
});
}
});
//figure out a URL friendly name for the vm names
string vmNameBase = "tn" + session.SessionId + "vm";
var assignedVMs = vmManagement.GenerateVMsForUsers(vmNameBase, vmConfig, vmUsers);
foreach (var assignedVM in assignedVMs)
{
VirtualMachine virtualMachine = new VirtualMachine
{
IdentityId = assignedVM.UserId,
VmAdminPass = assignedVM.Password,
VmAdminUser = assignedVM.UserName,
VmName = assignedVM.VmName,
VmRdpPort = assignedVM.VmRdpPort
};
session.VirtualMachines.Add(virtualMachine);
context.SaveChanges();
}
_logger.InfoFormat("Spawned VMs for SessionId: {0} ({1} - {2})",
session.SessionId, session.StartDate, session.EndDate);
_logger.InfoFormat("Sending emails for SessionId: {0} ({1} - {2})",
session.SessionId, session.StartDate, session.EndDate);
//well.. this is a hack
//TODO: send the correct service name, that should be returned from the Azure Facade
Email.BuildSessionEmails(session, vmNameBase).Send();
}
}
public void Start(StartSessionRequest request)
{
using (ApplicationDbContext context = new ApplicationDbContext())
{
Session session = context.Sessions.Single(x => x.SessionId == request.SessionId);
//Session session = context.Sessions.Single(x => x.Version == version);
Identity trainer = session.TrainerId != 0 ?
context.Identities.Where(x => x.IdentityId == session.TrainerId).FirstOrDefault() :
context.Identities.Where(x => x.IdentityId ==
(context.SubscriptionIdentityRoles.Where(y => y.SubscriptionId == session.SubscriptionId && y.Role == "Owner").FirstOrDefault()).IdentityId).FirstOrDefault();
//figure out a URL friendly name for the vm names
string vmNameBase = "tn" + session.SessionId + "vm";
try
{
//check if the session is canceled or the request is no longer valid
if (session.Removed ||
(session.Version != request.Version.ToString()))
{
_logger.InfoFormat("StartSessionRequest for Sessionid: {0} was ignored because Removed: {1} and Version: {2}",
request.SessionId, session.Removed, request.Version);
return;
}
_logger.InfoFormat("Spawning VMs for SessionId: {0} ({1} - {2})", session.SessionId, session.StartDate, session.EndDate);
Subscription subscription = context.Subscriptions.Single(x => x.SubscriptionId == session.SubscriptionId);
IVMManagement vmManagement = AzureFacadeFactory.VMManagement(subscription.AzureSubscriptionId,
subscription.Certificate, subscription.CertificateKey, subscription.BlobStorageName,
subscription.BlobStorageKey);
//TODO: remove the hardcoding at some point in time
string NorthEurope = "North Europe";
VMConfigModel vmConfig = new VMConfigModel(session.Lab.ImageName, NorthEurope)
{
VmSize = (VmSizeEnum)Enum.Parse(typeof(VmSizeEnum), session.VmSize)
};
var sessionUsers = session.SessionUsers.ToList();
var vmUsers = new List<VMUserModel>();
RandomProvider randomProvider = new RandomProvider();
sessionUsers.ForEach(x =>
{
vmUsers.Add(new VMUserModel
{
IdentityId = x.IdentityId,
Username = x.Identity != null ? string.Format("{0}.{1}", x.Identity.FirstName, x.Identity.LastName) : string.Empty,
Password = randomProvider.SecurePassword(8)
});
});
Email.BuildSessionStartVmsEmails(trainer.FirstName, trainer.Email, session, vmNameBase, vmUsers.Count).Send();
var assignedVMs = vmManagement.GenerateVMsForUsers(vmNameBase, vmConfig, vmUsers);
foreach (var assignedVM in assignedVMs)
{
VirtualMachine virtualMachine = new VirtualMachine
{
IdentityId = assignedVM.UserId,
VmAdminPass = assignedVM.Password,
VmAdminUser = assignedVM.UserName,
VmName = assignedVM.VmName,
VmRdpPort = assignedVM.VmRdpPort
};
session.VirtualMachines.Add(virtualMachine);
context.SaveChanges();
}
_logger.InfoFormat("Spawned VMs for SessionId: {0} ({1} - {2})", session.SessionId, session.StartDate, session.EndDate);
_logger.InfoFormat("Sending emails for SessionId: {0} ({1} - {2})", session.SessionId, session.StartDate, session.EndDate);
//well.. this is a hack
//TODO: send the correct service name, that should be returned from the Azure Facade
Email.BuildSessionEndVmsEmails(trainer.FirstName, trainer.Email, session.SessionName, vmNameBase, vmUsers.Count, assignedVMs.Count).Send();
Email.BuildSessionEmails(session, vmNameBase).Send();
}
catch(Exception ex)
{
Email.BuildProblemStartingVmsEmails(trainer.FirstName, trainer.Email, session.SessionName, vmNameBase, ex.InnerException != null ? ex.InnerException.Message : "Error in starting the virtual machine(s).").Send();
throw ex;
}
}
}
//TODO: stub
public AssignedVmModel GenerateVm(string serviceBaseName, VMConfigModel vmConfig, VMUserModel user)
{
throw new NotImplementedException();
}
