public RunCommandResultInner RunCommandInVMInstance(string groupName, string scaleSetName, string vmId, RunCommandInput inputCommand)
{
return(Extensions.Synchronize(() => RunCommandVMInstanceAsync(groupName, scaleSetName, vmId, inputCommand)));
}
public async Task <Models.RunCommandResultInner> RunCommandAsync(string groupName, string name, RunCommandInput inputCommand, CancellationToken cancellationToken = default(CancellationToken))
{
RunCommandInputInner innerInput = new RunCommandInputInner(inputCommand.CommandId, inputCommand.Script, inputCommand.Parameters);
return(await this.Inner.RunCommandAsync(groupName, name, innerInput, cancellationToken));
}
/// <summary>
/// Run command on the VM.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='vmName'>
/// The name of the virtual machine.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to the Run command operation.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <RunCommandResultInner> BeginRunCommandAsync(this IVirtualMachinesOperations operations, string resourceGroupName, string vmName, RunCommandInput parameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginRunCommandWithHttpMessagesAsync(resourceGroupName, vmName, parameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public void TestVMOperations()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
EnsureClientsInitialized(context);
ImageReference imageRef = GetPlatformVMImage(useWindowsImage: true);
// Create resource group
string rg1Name = ComputeManagementTestUtilities.GenerateName(TestPrefix) + 1;
string as1Name = ComputeManagementTestUtilities.GenerateName("as");
string storageAccountName = ComputeManagementTestUtilities.GenerateName(TestPrefix);
VirtualMachine inputVM1;
try
{
// Create Storage Account, so that both the VMs can share it
var storageAccountOutput = CreateStorageAccount(rg1Name, storageAccountName);
VirtualMachine vm1 = CreateVM(rg1Name, as1Name, storageAccountOutput, imageRef, out inputVM1);
m_CrpClient.VirtualMachines.Start(rg1Name, vm1.Name);
m_CrpClient.VirtualMachines.Redeploy(rg1Name, vm1.Name);
m_CrpClient.VirtualMachines.Restart(rg1Name, vm1.Name);
var runCommandImput = new RunCommandInput()
{
CommandId = "RunPowerShellScript",
Script = new List <string>()
{
"param(",
" [string]$arg1,",
" [string]$arg2",
")",
"echo This is a sample script with parameters $arg1 $arg2"
},
Parameters = new List <RunCommandInputParameter>()
{
new RunCommandInputParameter("arg1", "value1"),
new RunCommandInputParameter("arg2", "value2"),
}
};
RunCommandResult result = m_CrpClient.VirtualMachines.RunCommand(rg1Name, vm1.Name, runCommandImput);
Assert.NotNull(result);
Assert.NotNull(result.Value);
Assert.True(result.Value.Count > 0);
m_CrpClient.VirtualMachines.PowerOff(rg1Name, vm1.Name);
m_CrpClient.VirtualMachines.Deallocate(rg1Name, vm1.Name);
m_CrpClient.VirtualMachines.Generalize(rg1Name, vm1.Name);
VirtualMachine ephemeralVM;
string as2Name = as1Name + "_ephemeral";
CreateVM(rg1Name, as2Name, storageAccountName, imageRef, out ephemeralVM, hasManagedDisks: true, hasDiffDisks: true, vmSize: VirtualMachineSizeTypes.StandardDS5V2,
osDiskStorageAccountType: StorageAccountTypes.StandardLRS, dataDiskStorageAccountType: StorageAccountTypes.StandardLRS);
m_CrpClient.VirtualMachines.Reimage(rg1Name, ephemeralVM.Name, tempDisk: true);
var captureParams = new VirtualMachineCaptureParameters
{
DestinationContainerName = ComputeManagementTestUtilities.GenerateName(TestPrefix),
VhdPrefix = ComputeManagementTestUtilities.GenerateName(TestPrefix),
OverwriteVhds = true
};
var captureResponse = m_CrpClient.VirtualMachines.Capture(rg1Name, vm1.Name, captureParams);
Assert.NotNull(captureResponse);
Assert.True(captureResponse.Resources.Count > 0);
string resource = captureResponse.Resources[0].ToString();
Assert.Contains(captureParams.DestinationContainerName.ToLowerInvariant(), resource.ToLowerInvariant());
Assert.Contains(captureParams.VhdPrefix.ToLowerInvariant(), resource.ToLowerInvariant());
Resource template = JsonConvert.DeserializeObject <Resource>(resource);
string imageUri = template.Properties.StorageProfile.OSDisk.Image.Uri;
Assert.False(string.IsNullOrEmpty(imageUri));
// Create 3rd VM from the captured image
// TODO : Provisioning Time-out Issues
VirtualMachine inputVM2;
string as3Name = as1Name + "b";
VirtualMachine vm3 = CreateVM(rg1Name, as3Name, storageAccountOutput, imageRef, out inputVM2,
vm =>
{
vm.StorageProfile.ImageReference = null;
vm.StorageProfile.OsDisk.Image = new VirtualHardDisk {
Uri = imageUri
};
vm.StorageProfile.OsDisk.Vhd.Uri = vm.StorageProfile.OsDisk.Vhd.Uri.Replace(".vhd", "copy.vhd");
vm.StorageProfile.OsDisk.OsType = OperatingSystemTypes.Windows;
}, false, false);
Assert.True(vm3.StorageProfile.OsDisk.Image.Uri == imageUri);
}
finally
{
// Cleanup the created resources. But don't wait since it takes too long, and it's not the purpose
// of the test to cover deletion. CSM does persistent retrying over all RG resources.
m_ResourcesClient.ResourceGroups.Delete(rg1Name);
}
}
}
public RunCommandResultInner RunCommand(string groupName, string name, RunCommandInput inputCommand)
{
return(Extensions.Synchronize(() => RunCommandAsync(groupName, name, inputCommand)));
}
//EBVMInstanceStatus is the condition in here
private int PerformRunCommandActions(
string[] _UniqueInstanceNames,
EBVMOSType _VMOperationSystemType,
string[] _Commands,
Action _OnCompleted,
Action _OnFailure,
Action <string> _ErrorMessageAction = null)
{
int ProgressStackIx = Interlocked.Increment(ref CurrentActionIndex);
var ProgressStack = new Stack <object>();
if (_UniqueInstanceNames != null && _UniqueInstanceNames.Length > 0)
{
lock (ProgressStacks_Lock)
{
ProgressStacks.Add(ProgressStackIx, ProgressStack);
}
var Request = new ConcurrentQueue <Task>();
foreach (var _InstanceName in _UniqueInstanceNames)
{
var FoundInstance = FindInstanceByUniqueName(_InstanceName, _ErrorMessageAction);
if (FoundInstance != null)
{
if (GetStatusFromString(FoundInstance.PowerState.ToString()) == EBVMInstanceStatus.Running)
{
try
{
var _CommandId = "RunPowerShellScript";
if (_VMOperationSystemType == EBVMOSType.Linux)
{
_CommandId = "RunShellScript";
}
var _RunCommandInput = new RunCommandInput()
{
CommandId = _CommandId,
Script = _Commands.ToList()
};
Task RequestAction = FoundInstance.RunCommandAsync(_RunCommandInput);
Request.Enqueue(RequestAction);
ProgressStack.Push(new object());
}
catch (System.Exception ex)
{
_ErrorMessageAction?.Invoke($"BVMServiceAZ->PerformRunCommandActions->An error occurred when RunCommandInput is casting. Error: { ex.Message } - StackTrace: {ex.StackTrace}");
_OnFailure?.Invoke();
}
}
else
{
_ErrorMessageAction?.Invoke("BVMServiceAZ->PerformRunCommandActions->Virtual Machine is not running.");
_OnFailure?.Invoke();
}
}
}
if (ProgressStack.Count > 0)
{
BTaskWrapper.Run(() =>
{
Thread.CurrentThread.IsBackground = true;
try
{
if (Request.TryDequeue(out Task CreatedTask))
{
using (CreatedTask)
{
CreatedTask.Wait();
lock (ProgressStacks_Lock)
{
if (ProgressStacks.TryGetValue(ProgressStackIx, out Stack <object> FoundStack) && FoundStack.Count > 0)
{
if (CreatedTask.Exception != null)
{
_ErrorMessageAction?.Invoke("BVMServiceAZ->PerformRunCommandActions->Error: " + CreatedTask.Exception.Message);
FoundStack.Clear();
_OnFailure?.Invoke();
}
else
{
FoundStack.Pop();
if (FoundStack.Count == 0)
{
ProgressStacks.Remove(ProgressStackIx);
_OnCompleted?.Invoke();
}
}
}
}
}
}
else
{
_ErrorMessageAction?.Invoke("BVMServiceAZ->PerformRunCommandActions->TryDequeue error occured.");
_OnFailure?.Invoke();
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("BVMServiceAZ->PerformRunCommandActions->Exception: " + e.Message);
_OnFailure?.Invoke();
}
});
}
else
{
lock (ProgressStacks_Lock)
{
ProgressStacks.Remove(ProgressStackIx);
}
}
}
return(ProgressStack.Count);
}
public async Task TestVMOperations()
{
EnsureClientsInitialized(DefaultLocation);
ImageReference imageRef = await GetPlatformVMImage(useWindowsImage : true);
// Create resource group
string rg1Name = Recording.GenerateAssetName(TestPrefix) + 1;
string as1Name = Recording.GenerateAssetName("as");
string storageAccountName = Recording.GenerateAssetName(TestPrefix);
VirtualMachine inputVM1;
// Create Storage Account, so that both the VMs can share it
var storageAccountOutput = await CreateStorageAccount(rg1Name, storageAccountName);
var returnTwovm = await CreateVM(rg1Name, as1Name, storageAccountOutput, imageRef);
var vm1 = returnTwovm.Item1;
inputVM1 = returnTwovm.Item2;
await WaitForCompletionAsync(await VirtualMachinesOperations.StartStartAsync(rg1Name, vm1.Name));
await WaitForCompletionAsync(await VirtualMachinesOperations.StartRedeployAsync(rg1Name, vm1.Name));
await WaitForCompletionAsync(await VirtualMachinesOperations.StartRestartAsync(rg1Name, vm1.Name));
var runCommandImput = new RunCommandInput("RunPowerShellScript")
{
Script =
{
"param(",
" [string]$arg1,",
" [string]$arg2",
")",
"echo This is a sample script with parameters $arg1 $arg2"
},
Parameters =
{
new RunCommandInputParameter("arg1", "value1"),
new RunCommandInputParameter("arg2", "value2"),
}
};
RunCommandResult result = (await WaitForCompletionAsync(await VirtualMachinesOperations.StartRunCommandAsync(rg1Name, vm1.Name, runCommandImput))).Value;
Assert.NotNull(result);
Assert.NotNull(result.Value);
Assert.True(result.Value.Count > 0);
await WaitForCompletionAsync(await VirtualMachinesOperations.StartPowerOffAsync(rg1Name, vm1.Name));
await WaitForCompletionAsync(await VirtualMachinesOperations.StartDeallocateAsync(rg1Name, vm1.Name));
await VirtualMachinesOperations.GeneralizeAsync(rg1Name, vm1.Name);
VirtualMachine ephemeralVM;
string as2Name = as1Name + "_ephemeral";
var returnTwoVM = await CreateVM(rg1Name, as2Name, storageAccountName, imageRef, hasManagedDisks : true, hasDiffDisks : true, vmSize : VirtualMachineSizeTypes.StandardDS5V2.ToString(),
osDiskStorageAccountType : StorageAccountTypes.StandardLRS.ToString(), dataDiskStorageAccountType : StorageAccountTypes.StandardLRS.ToString());
ephemeralVM = returnTwoVM.Item2;
await WaitForCompletionAsync(await VirtualMachinesOperations.StartReimageAsync(rg1Name, ephemeralVM.Name));
var captureParams = new VirtualMachineCaptureParameters(Recording.GenerateAssetName(TestPrefix), Recording.GenerateAssetName(TestPrefix), true);
var captureResponse = await WaitForCompletionAsync(await VirtualMachinesOperations.StartCaptureAsync(rg1Name, vm1.Name, captureParams));
Assert.NotNull(captureResponse);
Assert.True(captureResponse.Value.Resources.Count > 0);
string resource = captureResponse.Value.Resources[0].ToString();
Assert.IsTrue(resource.ToLowerInvariant().Contains(captureParams.DestinationContainerName.ToLowerInvariant()));
Assert.IsTrue(resource.ToLowerInvariant().Contains(captureParams.VhdPrefix.ToLowerInvariant()));
Resource template = JsonSerializer.Deserialize <Resource>(resource);
string imageUri = template.Properties.StorageProfile.OSDisk.Image.Uri;
Assert.False(string.IsNullOrEmpty(imageUri));
// Create 3rd VM from the captured image
// TODO : Provisioning Time-out Issues
VirtualMachine inputVM2;
string as3Name = as1Name + "b";
returnTwovm = await CreateVM(rg1Name, as3Name, storageAccountOutput, imageRef,
vm =>
{
vm.StorageProfile.ImageReference = null;
vm.StorageProfile.OsDisk.Image = new VirtualHardDisk {
Uri = imageUri
};
vm.StorageProfile.OsDisk.Vhd.Uri = vm.StorageProfile.OsDisk.Vhd.Uri.Replace(".vhd", "copy.vhd");
vm.StorageProfile.OsDisk.OsType = OperatingSystemTypes.Windows;
}, false, false);
var vm3 = returnTwovm.Item1;
inputVM2 = returnTwovm.Item2;
Assert.True(vm3.StorageProfile.OsDisk.Image.Uri == imageUri);
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
ExecuteClientAction(() =>
{
if (ShouldProcess(this.VMName, VerbsLifecycle.Invoke))
{
string resourceGroupName;
string vmName;
switch (this.ParameterSetName)
{
case "ResourceIdParameter":
resourceGroupName = GetResourceGroupName(this.ResourceId);
vmName = GetResourceName(this.ResourceId, "Microsoft.Compute/virtualMachines");
break;
case "VMParameter":
resourceGroupName = GetResourceGroupName(this.VM.Id);
vmName = GetResourceName(this.VM.Id, "Microsoft.Compute/virtualMachines");
break;
default:
resourceGroupName = this.ResourceGroupName;
vmName = this.VMName;
break;
}
RunCommandInput parameters = new RunCommandInput();
parameters.CommandId = this.CommandId;
if (this.ScriptPath != null)
{
parameters.Script = new List <string>();
PathIntrinsics currentPath = SessionState.Path;
var filePath = new System.IO.FileInfo(currentPath.GetUnresolvedProviderPathFromPSPath(this.ScriptPath));
string fileContent = Commands.Common.Authentication.Abstractions.FileUtilities.DataStore.ReadFileAsText(filePath.FullName);
parameters.Script = fileContent.Split(new string[] { "\r\n", "\n", "\r" }, StringSplitOptions.RemoveEmptyEntries);
}
else if (this.ScriptString != null)
{
parameters.Script = new List <string>()
{
this.ScriptString
};
}
if (this.Parameter != null)
{
var vParameter = new List <RunCommandInputParameter>();
foreach (var key in this.Parameter.Keys)
{
RunCommandInputParameter p = new RunCommandInputParameter();
p.Name = key.ToString();
p.Value = this.Parameter[key].ToString();
vParameter.Add(p);
}
parameters.Parameters = vParameter;
}
var result = VirtualMachinesClient.RunCommand(resourceGroupName, vmName, parameters);
var psObject = new PSRunCommandResult();
ComputeAutomationAutoMapperProfile.Mapper.Map <RunCommandResult, PSRunCommandResult>(result, psObject);
WriteObject(psObject);
}
});
}
/// <summary>
/// Run commands in a virtual machine asynchronously.
/// </summary>
/// <param name="groupName">The resource group name.</param>
/// <param name="name">The virtual machine name.</param>
/// <param name="inputCommand">Command input.</param>
/// <return>Handle to the asynchronous execution.</return>
async Task <Models.RunCommandResultInner> Microsoft.Azure.Management.Compute.Fluent.IVirtualMachinesBeta.RunCommandAsync(string groupName, string name, RunCommandInput inputCommand, CancellationToken cancellationToken)
{
return(await this.RunCommandAsync(groupName, name, inputCommand, cancellationToken));
}
/// <summary>
/// Run commands in a virtual machine.
/// </summary>
/// <param name="groupName">The resource group name.</param>
/// <param name="name">The virtual machine name.</param>
/// <param name="inputCommand">Command input.</param>
/// <return>Result of execution.</return>
Models.RunCommandResultInner Microsoft.Azure.Management.Compute.Fluent.IVirtualMachinesBeta.RunCommand(string groupName, string name, RunCommandInput inputCommand)
{
return(this.RunCommand(groupName, name, inputCommand));
}
public async Task <Models.RunCommandResultInner> RunCommandVMInstanceAsync(string groupName, string scaleSetName, string vmId, RunCommandInput inputCommand, CancellationToken cancellationToken = default(CancellationToken))
{
RunCommandInput innerInput = new RunCommandInput(inputCommand.CommandId, inputCommand.Script, inputCommand.Parameters);
return(await this.Manager.Inner.VirtualMachineScaleSetVMs.RunCommandAsync(groupName, scaleSetName, vmId, innerInput, cancellationToken));
}
public async Task <Models.RunCommandResultInner> RunCommandAsync(string groupName, string name, RunCommandInput inputCommand, CancellationToken cancellationToken = default(CancellationToken))
{
return(await this.Inner.RunCommandAsync(groupName, name, inputCommand, cancellationToken));
}
