public MockDesktop()
{
this.name = "foo";
this.ipAddress = "255.255.255.255";
this.state = VirtualMachineState.Stopped;
this.desktopState = DesktopState.UnknownToXenDesktop;
}
private void update()
{
// todo
// add a check here that determines how long it has been since the last update.
// if below a threshold, simply return.
var request = new RestRequest();
request.Resource = "/applications/" + applicationId + "/vms/" + vmId + ";deployment";
request.Method = Method.GET;
request.RequestFormat = DataFormat.Json;
var response = restClient.Execute(request);
RestSharp.Deserializers.JsonDeserializer deserial = new RestSharp.Deserializers.JsonDeserializer();
RavelloVm vm = deserial.Deserialize <RavelloVm>(response);
switch (vm.state)
{
case "STARTING":
case "STARTED":
vmState = VirtualMachineState.POWERED_ON;
break;
case "STOPPING":
case "STOPPED":
vmState = VirtualMachineState.POWERED_OFF;
break;
default:
vmState = VirtualMachineState.UNKNOWN;
break;
}
}
internal static string ToSerializedValue(this VirtualMachineState value)
{
switch (value)
{
case VirtualMachineState.Stopped:
return("Stopped");
case VirtualMachineState.Starting:
return("Starting");
case VirtualMachineState.Running:
return("Running");
case VirtualMachineState.Stopping:
return("Stopping");
case VirtualMachineState.ResettingPassword:
return("ResettingPassword");
case VirtualMachineState.Reimaging:
return("Reimaging");
case VirtualMachineState.Redeploying:
return("Redeploying");
}
return(null);
}
private void update()
{
// todo
// add a check here that determines how long it has been since the last update.
// if below a threshold, simply return.
var request = new RestRequest();
request.Resource = "/vms/" + vmId;
request.Method = Method.GET;
request.RequestFormat = DataFormat.Json;
var response = restClient.Execute(request);
RestSharp.Deserializers.JsonDeserializer deserial = new RestSharp.Deserializers.JsonDeserializer();
KimchiVm vm = deserial.Deserialize <KimchiVm>(response);
switch (vm.state)
{
case "running":
vmState = VirtualMachineState.POWERED_ON;
break;
case "shutoff":
vmState = VirtualMachineState.POWERED_OFF;
break;
default:
vmState = VirtualMachineState.UNKNOWN;
break;
}
}
public static bool CanStart(VirtualMachineState currState)
{
if (currState == VirtualMachineState.Stopped)
{
return true;
}
return false;
}
public static bool CanDelete(VirtualMachineState currState)
{
if (currState == VirtualMachineState.Destroyed || currState == VirtualMachineState.Expunging)
{
return false;
}
return true;
}
public MachineMetadata(string uuid, string name, VirtualMachineState state, DateTime lastAction, string sessionName)
{
Uuid = uuid;
Name = name;
State = state;
LastAction = lastAction;
SessionName = sessionName;
}
public Desktop(string id, string name, string ipAddress, VirtualMachineState state, DesktopState desktopState)
{
Id = id;
Name = name;
IpAddress = ipAddress;
State = state;
DesktopState = desktopState;
}
public override Task ChangeStateOfVirtualMachine(int virtualDataCenterId, int virtualApplianceId, int virtualMachineId,
VirtualMachineState state, bool waitForCompletion)
{
Contract.Requires(0 < virtualDataCenterId);
Contract.Requires(0 < virtualApplianceId);
Contract.Requires(0 < virtualMachineId);
return(default(Task));
}
public static VirtualMachineState GetCriticalState(VirtualMachineState state)
{
var vmState = state;
switch (state)
{
case VirtualMachineState.Running:
vmState = VirtualMachineState.RunningCritical;
break;
case VirtualMachineState.Off:
vmState = VirtualMachineState.OffCritical;
break;
case VirtualMachineState.Stopping:
vmState = VirtualMachineState.StoppingCritical;
break;
case VirtualMachineState.Saved:
vmState = VirtualMachineState.SavedCritical;
break;
case VirtualMachineState.Paused:
vmState = VirtualMachineState.PausedCritical;
break;
case VirtualMachineState.Starting:
vmState = VirtualMachineState.StartingCritical;
break;
case VirtualMachineState.Reset:
vmState = VirtualMachineState.ResetCritical;
break;
case VirtualMachineState.Saving:
vmState = VirtualMachineState.SavingCritical;
break;
case VirtualMachineState.Pausing:
vmState = VirtualMachineState.PausingCritical;
break;
case VirtualMachineState.Resuming:
vmState = VirtualMachineState.ResumingCritical;
break;
case VirtualMachineState.FastSaved:
vmState = VirtualMachineState.FastSavedCritical;
break;
case VirtualMachineState.FastSaving:
vmState = VirtualMachineState.FastSavingCritical;
break;
}
return(vmState);
}
public static bool CanStop(VirtualMachineState currState)
{
if (currState == VirtualMachineState.Running ||
currState == VirtualMachineState.Stopping ||
currState == VirtualMachineState.Starting)
{
return true;
}
return false;
}
public override Task ChangeStateOfVirtualMachine(int virtualDataCenterId, int virtualApplianceId, int virtualMachineId,
VirtualMachineState state)
{
Contract.Requires(0 < virtualDataCenterId);
Contract.Requires(0 < virtualApplianceId);
Contract.Requires(0 < virtualMachineId);
Contract.Requires(null != state);
return(default(Task));
}
private static Bitmap GetMenuImage(VirtualMachineState state)
{
return(state switch
{
VirtualMachineState.Aborted => Properties.Resources.VirtualMachineError,
VirtualMachineState.PoweredOff => Properties.Resources.VirtualMachineStop,
VirtualMachineState.Saved => Properties.Resources.VirtualMachinePause,
VirtualMachineState.Running => Properties.Resources.VirtualMachineRunning,
VirtualMachineState.Saving => Properties.Resources.VirtualMachineRefresh,
VirtualMachineState.Starting => Properties.Resources.VirtualMachineRefresh,
VirtualMachineState.Restoring => Properties.Resources.VirtualMachineRefresh,
_ => Properties.Resources.VirtualMachine
});
internal static IInstruction GetInstruction(VirtualMachineState vmState, List <long> program, IInputProvider inputProvider, IOutputProvider outputProvider)
{
int instructionPointer = vmState.InstructionPointer;
Opcode opcode = new Opcode(program[instructionPointer]);
_instructionsProcessed += 1;
switch (opcode.NumericOpcode)
{
case 1:
return(new AddInstruction(vmState, program, opcode));
case 2:
return(new MultiplyInstruction(vmState, program, opcode));
case 3:
return(new InputInstruction(vmState, program, opcode, inputProvider));
case 4:
return(new OutputInstruction(vmState, program, opcode, outputProvider));
case 5:
return(new JumpIfTrueInstruction(vmState, program, opcode));
case 6:
return(new JumpIfFalseInstruction(vmState, program, opcode));
case 7:
return(new LessThanInstruction(vmState, program, opcode));
case 8:
return(new EqualsInstruction(vmState, program, opcode));
case 9:
return(new AdjustRelativeBaseInstruction(vmState, program, opcode));
case 99:
return(new StopInstruction(vmState, program, opcode));
default:
System.IO.File.WriteAllText("MemoryDebug.txt", String.Join(',', program));
throw new ArgumentException($"Passed invalid opcode = {opcode.NumericOpcode}, last instructionPointer = {instructionPointer}, instructionsProcessed = {_instructionsProcessed}");
}
}
/// <summary> /// Converts the <see cref="sourceValue" /> parameter to the <see cref="destinationType" /> parameter using <see cref="formatProvider" /// /> and <see cref="ignoreCase" /> /// </summary> /// <param name="sourceValue">the <see cref="System.Object"/> to convert from</param> /// <param name="destinationType">the <see cref="System.Type" /> to convert to</param> /// <param name="formatProvider">not used by this TypeConverter.</param> /// <param name="ignoreCase">when set to <c>true</c>, will ignore the case when converting.</param> /// <returns> /// an instance of <see cref="VirtualMachineState" />, or <c>null</c> if there is no suitable conversion. /// </returns> public override object ConvertFrom(object sourceValue, global::System.Type destinationType, global::System.IFormatProvider formatProvider, bool ignoreCase) => VirtualMachineState.CreateFrom(sourceValue);
private Server WaitForVMState(string serverId, VirtualMachineState[] expectedVMStates, VirtualMachineState[] errorVMStates, int refreshCount = 600, TimeSpan? refreshDelay = null)
{
refreshDelay = refreshDelay ?? TimeSpan.FromMilliseconds(2400);
var os = new OpenStackMember(UserName, Password, TenantName);
Server serverDetails = os.GetServer(serverId);
Func<bool> exitCondition = () => serverDetails.TaskState == null && (expectedVMStates.Contains(serverDetails.VMState) || errorVMStates.Contains(serverDetails.VMState));
int count = 0;
int exitCount = exitCondition() ? 1 : 0;
while (exitCount < 3 && count < refreshCount)
{
System.Threading.Thread.Sleep(refreshDelay ?? TimeSpan.FromMilliseconds(2400));
serverDetails = os.GetServer(serverId);
count++;
if (exitCondition())
exitCount++;
else
exitCount = 0;
}
if (errorVMStates.Contains(serverDetails.VMState))
throw new ServerEnteredErrorStateException(serverDetails.Status);
return serverDetails;
}
public AdjustRelativeBaseInstruction(VirtualMachineState vmState, List <long> program, Opcode opcode) : base(vmState, program, opcode)
{
}
public NodeState(VirtualMachineState st)
{
id = NodeType.VirtualMachines;
vs = st;
}
public override Task ChangeStateOfVirtualMachine(VirtualMachine virtualMachine, VirtualMachineState state)
{
Contract.Requires(null != virtualMachine);
Contract.Requires(null != state);
return(default(Task));
}
public InstructionBase(VirtualMachineState vmState, List <long> program, Opcode opcode)
{
this._vmState = vmState;
this.Program = program;
this.Opcode = opcode;
}
public OutputInstruction(VirtualMachineState vmState, List <long> program, Opcode opcode, IOutputProvider outputProvider) : base(vmState, program, opcode)
{
this._outputProvider = outputProvider;
}
public InputInstruction(VirtualMachineState vmState, List <long> program, Opcode opcode, IInputProvider inputProvider) : base(vmState, program, opcode)
{
this._inputProvider = inputProvider;
}
public StopInstruction(VirtualMachineState vmState, List <long> program, Opcode opcode) : base(vmState, program, opcode)
{
}
public static VmStatus MapVmInfoStatusToVmStatus(VirtualMachineState valueState)
{
switch (valueState)
{
case VirtualMachineState.Other:
return(VmStatus.Stopped);
case VirtualMachineState.Running:
return(VmStatus.Running);
case VirtualMachineState.Off:
return(VmStatus.Stopped);
case VirtualMachineState.Stopping:
return(VmStatus.Stopped);
case VirtualMachineState.Saved:
return(VmStatus.Stopped);
case VirtualMachineState.Paused:
return(VmStatus.Stopped);
case VirtualMachineState.Starting:
return(VmStatus.Stopped);
case VirtualMachineState.Reset:
return(VmStatus.Stopped);
case VirtualMachineState.Saving:
return(VmStatus.Stopped);
case VirtualMachineState.Pausing:
return(VmStatus.Stopped);
case VirtualMachineState.Resuming:
return(VmStatus.Stopped);
case VirtualMachineState.FastSaved:
return(VmStatus.Stopped);
case VirtualMachineState.FastSaving:
return(VmStatus.Stopped);
case VirtualMachineState.ForceShutdown:
return(VmStatus.Stopped);
case VirtualMachineState.ForceReboot:
return(VmStatus.Stopped);
case VirtualMachineState.RunningCritical:
return(VmStatus.Stopped);
case VirtualMachineState.OffCritical:
return(VmStatus.Stopped);
case VirtualMachineState.StoppingCritical:
return(VmStatus.Stopped);
case VirtualMachineState.SavedCritical:
return(VmStatus.Stopped);
case VirtualMachineState.PausedCritical:
return(VmStatus.Stopped);
case VirtualMachineState.StartingCritical:
return(VmStatus.Stopped);
case VirtualMachineState.ResetCritical:
return(VmStatus.Stopped);
case VirtualMachineState.SavingCritical:
return(VmStatus.Stopped);
case VirtualMachineState.PausingCritical:
return(VmStatus.Stopped);
case VirtualMachineState.ResumingCritical:
return(VmStatus.Stopped);
case VirtualMachineState.FastSavedCritical:
return(VmStatus.Stopped);
case VirtualMachineState.FastSavingCritical:
return(VmStatus.Stopped);
default:
throw new ArgumentOutOfRangeException(nameof(valueState), valueState, null);
}
}
