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); } }