public JobResult ChangeVirtualMachineState(string vmId, VirtualMachineRequestedState newState)
{
try
{
Log.WriteStart("'{0}' ChangeVirtualMachineState", ProviderSettings.ProviderName);
JobResult result = VirtualizationProvider.ChangeVirtualMachineState(vmId, newState);
Log.WriteEnd("'{0}' ChangeVirtualMachineState", ProviderSettings.ProviderName);
return(result);
}
catch (Exception ex)
{
Log.WriteError(String.Format("'{0}' ChangeVirtualMachineState", ProviderSettings.ProviderName), ex);
throw;
}
}
protected void repButtons_ItemCommand(object source, System.Web.UI.WebControls.RepeaterCommandEventArgs e)
{
try
{
ResultObject res = null;
string command = e.CommandName;
if (command == "Snapshot")
{
res = ES.Services.VPS2012.CreateSnapshot(PanelRequest.ItemID);
}
else
{
// parse command
VirtualMachineRequestedState state = (VirtualMachineRequestedState)Enum.Parse(
typeof(VirtualMachineRequestedState), command, true);
// call services
res = ES.Services.VPS2012.ChangeVirtualMachineState(PanelRequest.ItemID, state);
}
// check results
if (res.IsSuccess)
{
if (command == "Snapshot")
{
// go to snapshots screen
Response.Redirect(EditUrl("ItemID", PanelRequest.ItemID.ToString(), "vps_snapshots",
"SpaceID=" + PanelSecurity.PackageId.ToString()));
}
else
{
// return
BindGeneralDetails();
return;
}
}
else
{
// show error
messageBox.ShowMessage(res, "VPS_ERROR_CHANGE_VM_STATE", "VPS");
}
}
catch (Exception ex)
{
messageBox.ShowErrorMessage("VPS_ERROR_CHANGE_VM_STATE", ex);
}
}
public JobResult ChangeVirtualMachineState(string vmId, VirtualMachineRequestedState newState)
{
try
{
Log.WriteStart("'{0}' ChangeVirtualMachineState", ProviderSettings.ProviderName);
JobResult result = VirtualizationProvider.ChangeVirtualMachineState(vmId, newState);
Log.WriteEnd("'{0}' ChangeVirtualMachineState", ProviderSettings.ProviderName);
return result;
}
catch (Exception ex)
{
Log.WriteError(String.Format("'{0}' ChangeVirtualMachineState", ProviderSettings.ProviderName), ex);
throw;
}
}
/// <remarks/>
public void ChangeVirtualMachineStateAsync(int itemId, VirtualMachineRequestedState state, object userState) {
if ((this.ChangeVirtualMachineStateOperationCompleted == null)) {
this.ChangeVirtualMachineStateOperationCompleted = new System.Threading.SendOrPostCallback(this.OnChangeVirtualMachineStateOperationCompleted);
}
this.InvokeAsync("ChangeVirtualMachineState", new object[] {
itemId,
state}, this.ChangeVirtualMachineStateOperationCompleted, userState);
}
public JobResult ChangeVirtualMachineState(string vmId, VirtualMachineRequestedState newState)
{
// target computer
JobResult ret = new JobResult();
ret.Job = new ConcreteJob();
ret.Job.Id = vmId;
try
{
using (WSPVirtualMachineManagementServiceClient client = GetVMMSClient())
{
VirtualMachineInfo vm = client.GetVirtualMachineByName(vmId);
switch (newState)
{
case VirtualMachineRequestedState.Start:
{
client.StartVirtualMachine(vm.Id);
ret.Job.TargetState = Virtualization.VMComputerSystemStateInfo.Running;
break;
}
case VirtualMachineRequestedState.Resume:
{
client.ResumeVirtualMachine(vm.Id);
ret.Job.TargetState = Virtualization.VMComputerSystemStateInfo.Running;
break;
}
case VirtualMachineRequestedState.Pause:
{
client.PauseVirtualMachine(vm.Id);
ret.Job.TargetState = Virtualization.VMComputerSystemStateInfo.Paused;
break;
}
case VirtualMachineRequestedState.ShutDown:
{
client.ShutdownVirtualMachine(vm.Id);
ret.Job.TargetState = Virtualization.VMComputerSystemStateInfo.Stored;
break;
}
case VirtualMachineRequestedState.TurnOff:
{
client.StopVirtualMachine(vm.Id);
ret.Job.TargetState = Virtualization.VMComputerSystemStateInfo.PowerOff;
break;
}
default:
{
break;
}
}
ret.Job.JobState = ConcreteJobState.Running;
ret.Job.Caption = newState.ToString();
ret.ReturnValue = ReturnCode.JobStarted;
}
}
catch (Exception ex)
{
Log.WriteError("Could not change virtual machine state", ex);
//
ret.Job.JobState = ConcreteJobState.Exception;
ret.Job.Caption = newState.ToString();
ret.ReturnValue = ReturnCode.Failed;
}
return ret;
}
/// <remarks/>
public System.IAsyncResult BeginChangeVirtualMachineState(int itemId, VirtualMachineRequestedState state, System.AsyncCallback callback, object asyncState) {
return this.BeginInvoke("ChangeVirtualMachineState", new object[] {
itemId,
state}, callback, asyncState);
}
/// <remarks/>
public void ChangeVirtualMachineStateAsync(int itemId, VirtualMachineRequestedState state) {
this.ChangeVirtualMachineStateAsync(itemId, state, null);
}
public JobResult ChangeVirtualMachineState(string vmId, VirtualMachineRequestedState newState)
{
HostedSolutionLog.LogStart("ChangeVirtualMachineState");
var jobResult = new JobResult();
var vm = GetVirtualMachine(vmId);
try
{
string cmdTxt;
List<string> paramList = new List<string>();
switch (newState)
{
case VirtualMachineRequestedState.Start:
cmdTxt = "Start-VM";
break;
case VirtualMachineRequestedState.Pause:
cmdTxt = "Suspend-VM";
break;
case VirtualMachineRequestedState.Reset:
cmdTxt = "Restart-VM";
break;
case VirtualMachineRequestedState.Resume:
cmdTxt = "Resume-VM";
break;
case VirtualMachineRequestedState.ShutDown:
cmdTxt = "Stop-VM";
break;
case VirtualMachineRequestedState.TurnOff:
cmdTxt = "Stop-VM";
paramList.Add("TurnOff");
break;
case VirtualMachineRequestedState.Save:
cmdTxt = "Save-VM";
break;
default:
throw new ArgumentOutOfRangeException("newState");
}
Command cmd = new Command(cmdTxt);
cmd.Parameters.Add("Name", vm.Name);
//cmd.Parameters.Add("AsJob");
paramList.ForEach(p => cmd.Parameters.Add(p));
PowerShell.Execute(cmd, true);
jobResult = JobHelper.CreateSuccessResult(ReturnCode.JobStarted);
}
catch (Exception ex)
{
HostedSolutionLog.LogError("ChangeVirtualMachineState", ex);
throw;
}
HostedSolutionLog.LogEnd("ChangeVirtualMachineState");
return jobResult;
}
public ResultObject ChangeVirtualMachineState(int itemId, VirtualMachineRequestedState state) {
object[] results = this.Invoke("ChangeVirtualMachineState", new object[] {
itemId,
state});
return ((ResultObject)(results[0]));
}
private static ResultObject ChangeVirtualMachineState(int itemId, VirtualMachineRequestedState state)
{
// start task
ResultObject res = TaskManager.StartResultTask<ResultObject>("VPS", "CHANGE_STATE");
try
{
// load service item
VirtualMachine machine = (VirtualMachine)PackageController.GetPackageItem(itemId);
if (machine == null)
{
TaskManager.CompleteResultTask(res, VirtualizationErrorCodes.CANNOT_FIND_VIRTUAL_MACHINE_META_ITEM);
return res;
}
BackgroundTask topTask = TaskManager.TopTask;
topTask.ItemId = machine.Id;
topTask.ItemName = machine.Name;
topTask.PackageId = machine.PackageId;
TaskController.UpdateTask(topTask);
TaskManager.WriteParameter("New state", state);
// load proxy
VirtualizationServer2012 vps = GetVirtualizationProxy(machine.ServiceId);
try
{
if (state == VirtualMachineRequestedState.ShutDown)
{
ReturnCode code = vps.ShutDownVirtualMachine(machine.VirtualMachineId, true, SHUTDOWN_REASON);
if (code != ReturnCode.OK)
{
res.ErrorCodes.Add(VirtualizationErrorCodes.JOB_START_ERROR + ":" + code);
TaskManager.CompleteResultTask(res);
return res;
}
// spin until fully stopped
VirtualMachine vm = vps.GetVirtualMachine(machine.VirtualMachineId);
while (vm.State != VirtualMachineState.Off)
{
System.Threading.Thread.Sleep(1000); // sleep 1 second
vm = vps.GetVirtualMachine(machine.VirtualMachineId);
}
}
else if (state == VirtualMachineRequestedState.Reboot)
{
// shutdown first
ResultObject shutdownResult = ChangeVirtualMachineState(itemId,
VirtualMachineRequestedState.ShutDown);
if (!shutdownResult.IsSuccess)
{
TaskManager.CompleteResultTask(res);
return shutdownResult;
}
// start machine
ResultObject startResult = ChangeVirtualMachineState(itemId, VirtualMachineRequestedState.Start);
if (!startResult.IsSuccess)
{
TaskManager.CompleteResultTask(res);
return startResult;
}
}
else
{
if (state == VirtualMachineRequestedState.Resume)
state = VirtualMachineRequestedState.Start;
JobResult result = vps.ChangeVirtualMachineState(machine.VirtualMachineId, state);
if (result.Job.JobState == ConcreteJobState.Completed)
{
LogReturnValueResult(res, result);
TaskManager.CompleteTask();
return res;
}
else
{
// check return
if (result.ReturnValue != ReturnCode.JobStarted)
{
LogReturnValueResult(res, result);
TaskManager.CompleteResultTask(res);
return res;
}
// wait for completion
if (!JobCompleted(vps, result.Job))
{
LogJobResult(res, result.Job);
TaskManager.CompleteResultTask(res);
return res;
}
}
}
}
catch(Exception ex)
{
res.IsSuccess = false;
res.ErrorCodes.Add(VirtualizationErrorCodes.CANNOT_CHANGE_VIRTUAL_SERVER_STATE);
TaskManager.WriteError(ex);
}
}
catch (Exception ex)
{
res.IsSuccess = false;
res.ErrorCodes.Add(VirtualizationErrorCodes.CHANGE_VIRTUAL_MACHINE_STATE_GENERAL_ERROR);
TaskManager.WriteError(ex);
return res;
}
TaskManager.CompleteTask();
return res;
}
public ResultObject ChangeVirtualMachineState(int itemId, VirtualMachineRequestedState state)
{
return(VirtualizationServerController.ChangeVirtualMachineStateExternal(itemId, state));
}
public static ResultObject ChangeVirtualMachineStateExternal(int itemId, VirtualMachineRequestedState state)
{
ResultObject res = new ResultObject();
// load service item
VirtualMachine vm = (VirtualMachine)PackageController.GetPackageItem(itemId);
if (vm == null)
{
res.ErrorCodes.Add(VirtualizationErrorCodes.CANNOT_FIND_VIRTUAL_MACHINE_META_ITEM);
return res;
}
#region Check account and space statuses
// check account
if (!SecurityContext.CheckAccount(res, DemandAccount.NotDemo | DemandAccount.IsActive))
return res;
// check package
if (!SecurityContext.CheckPackage(res, vm.PackageId, DemandPackage.IsActive))
return res;
#endregion
#region Check Quotas
// check quotas
List<string> quotaResults = new List<string>();
if ((state == VirtualMachineRequestedState.Start
|| state == VirtualMachineRequestedState.TurnOff
|| state == VirtualMachineRequestedState.ShutDown)
&& !vm.StartTurnOffAllowed)
quotaResults.Add(VirtualizationErrorCodes.QUOTA_EXCEEDED_START_SHUTDOWN_ALLOWED);
else if ((state == VirtualMachineRequestedState.Pause
|| state == VirtualMachineRequestedState.Resume)
&& !vm.PauseResumeAllowed)
quotaResults.Add(VirtualizationErrorCodes.QUOTA_EXCEEDED_PAUSE_RESUME_ALLOWED);
else if (state == VirtualMachineRequestedState.Reboot
&& !vm.RebootAllowed)
quotaResults.Add(VirtualizationErrorCodes.QUOTA_EXCEEDED_REBOOT_ALLOWED);
else if (state == VirtualMachineRequestedState.Reset
&& !vm.ResetAllowed)
quotaResults.Add(VirtualizationErrorCodes.QUOTA_EXCEEDED_RESET_ALOWED);
if (quotaResults.Count > 0)
{
res.ErrorCodes.AddRange(quotaResults);
res.IsSuccess = false;
TaskManager.CompleteResultTask();
return res;
}
#endregion
return ChangeVirtualMachineState(itemId, state);
}
public ResultObject ChangeVirtualMachineState(int itemId, VirtualMachineRequestedState state)
{
return VirtualizationServerController2012.ChangeVirtualMachineStateExternal(itemId, state);
}
public JobResult ChangeVirtualMachineState(string vmId, VirtualMachineRequestedState newState)
{
// target computer
ManagementObject objVm = GetVirtualMachineObject(vmId);
// get method
ManagementBaseObject inParams = objVm.GetMethodParameters("RequestStateChange");
inParams["RequestedState"] = (Int32)newState;
// invoke method
ManagementBaseObject outParams = objVm.InvokeMethod("RequestStateChange", inParams, null);
return CreateJobResultFromWmiMethodResults(outParams);
}
/// <remarks/>
public void ChangeVirtualMachineStateAsync(string vmId, VirtualMachineRequestedState newState)
{
this.ChangeVirtualMachineStateAsync(vmId, newState, null);
}
public JobResult ChangeVirtualMachineState(string vmId, VirtualMachineRequestedState newState)
{
object[] results = this.Invoke("ChangeVirtualMachineState", new object[] {
vmId,
newState});
return ((JobResult)(results[0]));
}
