public void RunVirtualMachinesUntilTimerInterupt()
{
for (int i = 0; i < VirtualMachines.Count; i++)
{
try
{
if (VirtualMachines[i].IsFinished)
{
continue;
}
TI = Settings.Default.TimerStartValue;
for (; TI > 0; TI--)
{
if (!VirtualMachines[i].IsFinished)
{
ExecuteAction(VirtualMachines[i]);
}
}
}
catch (Exception exception)
{
if (i < VirtualMachines.Count)
{
VirtualMachines[i].ReleaseResources();
VirtualMachines.Remove(VirtualMachines[i]);
MessageBox.Show("Ooops... your program have crased\n" + exception.Message, "Program " + VirtualMachines[i].Name + "(" + VirtualMachines[i].PID + ") have occured error");
}
}
}
}
public async Task MainTest()
{
string rgName = SdkContext.RandomResourceName("rgRSMA", 24);
string vmName = SdkContext.RandomResourceName("rgRSMA", 24);
string ipLabel = SdkContext.RandomResourceName("rgRSMA", 12);
ResourceGroups oResourceGroups = new ResourceGroups(this.credentials, this.subscriptionId);
oResourceGroups.Create(rgName, this.region);
var vm = new VirtualMachines(credentials, subscriptionId);
vm.CreateWindowsVM(vmName, rgName, this.region, "10.0.0.0/28", ipLabel, KnownWindowsVirtualMachineImage.WindowsServer2008R2_SP1, "adminUser", "Password@123", VirtualMachineSizeTypes.StandardA0);
var resources = await oResourceGroups.GetResources(rgName);
Assert.AreEqual(Formatter.CountPageable(resources), 5);
await vm.Del(vmName, rgName, true);
var resourcesAfterDel = await oResourceGroups.GetResources(rgName);
Assert.AreEqual(Formatter.CountPageable(resourcesAfterDel), 0);
oResourceGroups.Del(rgName);
}
//Until program is finished do tasks
public void FullyRunAllPrograms()
{
while (VirtualMachines.Any(x => !x.IsFinished))
{
RunVirtualMachinesUntilTimerInterupt();
}
}
public void Test_GetAllVirtualMachineRoles_Should_Return_AlistOfVirtualMachines()
{
VirtualMachines vms = sutR.GetAllVirtualMachineRoles();
foreach (var vm in testData._VirtualMachines._VirtualMachineRoles)
{
Should.Equals(vms.Contains(vm.VmName), true);
}
}
public void VM_ETL_Tests()
{
var meters = RawData.RateCard.Value.Meters.AsEnumerable();
meters = meters
.FilterData(K.FilterConfigurationBaseFolder)
.KeepLatest()
.ToList()
;
VirtualMachines.MapAndExport(meters, "../../../junk");
}
public static List <VirtualMachine> GetAll()
{
var v = new VirtualMachines();
var returnList = new List <VirtualMachine>();
foreach (DataRow dr in v.GetAll().Rows)
{
returnList.Add(new VirtualMachine(dr));
}
return(returnList);
}
//Executes next action of command in file
public void ExecuteAction(VirtualMachine virtualMachine)
{
try
{
virtualMachine.DoNextInstruction();
}
catch (Exception exception)
{
virtualMachine.ReleaseResources();
VirtualMachines.Remove(virtualMachine);
MessageBox.Show("Ooops... your program have crased\n" + exception.Message, "Program " + virtualMachine.Name + "(" + virtualMachine.PID + ") have occured error");
}
}
public void BindVirtualMachines()
{
// clear list
VirtualMachines.Items.Clear();
// bind
int serviceId = Utils.ParseInt(HyperVServices.SelectedValue, 0);
if (serviceId > 0)
{
VirtualMachines.DataSource = ES.Services.Proxmox.GetVirtualMachinesByServiceId(serviceId);
VirtualMachines.DataBind();
}
// add select value
VirtualMachines.Items.Insert(0, new ListItem(GetLocalizedString("SelectVirtualMachine.Text"), ""));
}
//Fork means to duplicate proccess
public VirtualMachine ForkVirtualMachine(VirtualMachine virtualMachine)
{
VirtualMachine vm;
try
{
vm = new VirtualMachine(virtualMachine);
VirtualMachines.Add(vm);
return(vm);
}
catch (Exception)
{
if (virtualMachine != null)
{
virtualMachine.ReleaseResources();
}
throw new InsufficientMemoryException("No more memmory");
}
}
/// <summary>
/// Performs the execution of the activity.
/// </summary>
/// <param name="context">The execution context under which the activity executes.</param>
protected override void Execute(CodeActivityContext context)
{
var azureSubscription = new AzureSubscription(SettingsPath, SubscriptionId);
var credentials = new CertificateCloudCredentials(
SubscriptionId,
new X509Certificate2(Convert.FromBase64String(azureSubscription.ManagementCertificate)));
var tasks = VirtualMachines.Get(context).Select(
async vm =>
{
using (var client = new ComputeManagementClient(credentials))
{
switch (vm.Size)
{
case VirtualMachineSize.Stop:
await client.DeallocateVmAsync(vm.Name);
break;
case VirtualMachineSize.Small:
case VirtualMachineSize.ExtraSmall:
case VirtualMachineSize.Large:
case VirtualMachineSize.Medium:
case VirtualMachineSize.ExtraLarge:
case VirtualMachineSize.A5:
case VirtualMachineSize.A6:
case VirtualMachineSize.A7:
case VirtualMachineSize.A8:
case VirtualMachineSize.A9:
await client.ResizeVmAsync(vm.Name, vm.Size.GetEnumDescription());
break;
default:
throw new ArgumentOutOfRangeException(
nameof(context),
@"Unknown VM Size, this shouldn't happen, but the enumeration value isn't implemented in the acitivity switch");
}
}
});
Task.WhenAll(tasks);
}
public async Task <IEnumerable <VirtualMachine> > GetNewVirtualMachines()
{
var machines = await VirtualMachines.ToListAsync();
var connections = GetConnectionStatus()?.ToDictionary(target => target.Port) ?? new Dictionary <int, ConnectionStatus>();
foreach (var machine in machines)
{
if (connections.TryGetValue(machine.Port, out ConnectionStatus connection) == true)
{
machine.Operation = OperationStatus.Work;
machine.ConnectedMachine = connection.ConnectedMachine;
}
else
{
machine.Operation = OperationStatus.Stop;
machine.ConnectedMachine = null;
}
}
return(machines);
}
/// <summary>
/// Returns a list of Permanent Virtual Machine roles. Each Virtual Machine object contains some metadata of the actual virtual machine
/// </summary>
/// <returns>A list of Permanent Virtual Machine Roles</returns>
public VirtualMachines GetAllVirtualMachineRoles()
{
ComputeManagementClient client = new ComputeManagementClient(MyCloudCredentials);
try
{
VirtualMachines vms = new VirtualMachines(new List <VirtualMachine>());
var hostedServices = client.HostedServices.List();
foreach (var service in hostedServices)
{
var deployment = GetAzureDeyployment(service.ServiceName, DeploymentSlot.Production);
if (deployment != null)
{
if (deployment.Roles.Count > 0)
{
VirtualMachine vm = null;
foreach (var role in deployment.Roles)
{
if (role.RoleType == VirtualMachineRoleType.PersistentVMRole.ToString())
{
var operatingSystem = string.Format("{0}--{1}", role.OSVirtualHardDisk.OperatingSystem, role.OSVirtualHardDisk.SourceImageName);
var rate = Configuration.GetAzureRates().GetMyRate(role.RoleSize);
vm = new VirtualMachine(role.RoleName, role.RoleSize, role.RoleType, operatingSystem, rate);
vms.Add(vm);
}
}
}
}
}
return(vms);
}
catch (CloudException ce)
{
Logger.Warn(ce, String.Format("Exception during retrieval of Virtual Machine Roles Exception: {0}", ce));
}
return(null);
}
public static string StopAll()
{
var v = new VirtualMachines();
return(v.StopAll());
}
public string Stop()
{
var v = new VirtualMachines();
return(v.Stop(Name));
}
