public void TestMachinePollStatus()
        {
            var provider = _container.Resolve <IHyperVProvider>();

            provider.Connect();

            IHyperVMachine machine = provider.GetMachineByName(MachineName);

            HyperVStatus status = provider.GetStatus(machine);

            Stopwatch s = new Stopwatch();

            s.Start();

            bool isReset = false;

            while (s.Elapsed.TotalSeconds < 15)
            {
                machine = provider.GetMachineByName(MachineName);
                status  = provider.GetStatus(machine);

                Debug.WriteLine("Machine Status is => " + status);

                if (s.Elapsed.TotalSeconds >= 1 && !isReset)
                {
                    provider.Reset(machine);

                    isReset = true;
                }

                Thread.Sleep(1000);
            }

            s.Stop();
        }
        private uint ChangeState(IHyperVMachine machine, HyperVStatus state)
        {
            var rawMachine = ((HyperVMachine)machine).FetchRawMachine();

            var managementService = new ManagementClass(_scope, new ManagementPath("Msvm_VirtualSystemManagementService"), null)
                                    .GetInstances()
                                    .OfType <ManagementObject>().FirstOrDefault();

            if (managementService != null)
            {
                var inParameters = managementService.GetMethodParameters("RequestStateChange");

                inParameters["RequestedState"] = (object)state;

                var outParameters = rawMachine.InvokeMethod("RequestStateChange", inParameters, null);

                Debug.WriteLine("Changed state with return " + outParameters);

                if (outParameters != null)
                {
                    return((uint)outParameters["ReturnValue"]);
                }
            }
            else
            {
                throw new HyperVException("Could not find machine management service for rstate change");
            }

            return(0);
        }
        public void RestoreLastSnapShot(IHyperVMachine machine)
        {
            var raw = ((HyperVMachine)machine).FetchRawMachine();

            var lastSnapshot = raw.GetRelated(
                "Msvm_VirtualSystemSettingData",
                "Msvm_MostCurrentSnapshotInBranch",
                null,
                null,
                "Dependent",
                "Antecedent",
                false,
                null).OfType <ManagementObject>().FirstOrDefault();

            if (lastSnapshot == null)
            {
                throw new HyperVException("No Snapshot found");
            }

            var managementService = new ManagementClass(_scope, new ManagementPath("Msvm_VirtualSystemSnapshotService"), null)
                                    .GetInstances()
                                    .OfType <ManagementObject>().FirstOrDefault();

            var inParameters = managementService.GetMethodParameters("ApplySnapshot");

            inParameters["Snapshot"] = lastSnapshot.Path.Path;

            var outParameters = managementService.InvokeMethod("ApplySnapshot", inParameters, null);
        }
        public void TestResetMachineByName(string machineName)
        {
            var provider = _container.GetRequiredService <IHyperVProvider>();

            provider.Connect();
            IHyperVMachine machine = provider.GetMachineByName(machineName);

            machine.Reset();
        }
        public void TestFetchMachineByName(string machineName)
        {
            var provider = _container.GetRequiredService <IHyperVProvider>();

            provider.Connect();

            IHyperVMachine machine = provider.GetMachineByName(machineName);

            machine.Should().NotBeNull();
        }
        public void TestFetchMachineByName()
        {
            var provider = _container.Resolve <IHyperVProvider>();

            provider.Connect();

            IHyperVMachine machine = provider.GetMachineByName(MachineName);

            machine.Should().NotBeNull();
        }
        public void TestResetMachineByName()
        {
            var provider = _container.Resolve <IHyperVProvider>();

            provider.Connect();

            IHyperVMachine machine = provider.GetMachineByName(MachineName);

            provider.Reset(machine);
        }
        public HyperVStatus GetStatus(IHyperVMachine machine)
        {
            if (_scope == null)
            {
                throw new HyperVException("No management scope present");
            }

            var rawMachine = ((HyperVMachine)machine).FetchRawMachine();


            return((HyperVStatus)rawMachine["EnabledState"]);
        }
        public void TestCheckpointMachineByName()
        {
            var provider = _container.Resolve <IHyperVProvider>();

            provider.Connect();

            IHyperVMachine machine = provider.GetMachineByName(MachineName);

            provider.Stop(machine);

            provider.RestoreLastSnapShot(machine);

            Thread.Sleep(5000);

            provider.Start(machine);
        }
        public void TestCheckpointMachineByName(string machineName)
        {
            var provider = _container.GetRequiredService <IHyperVProvider>();

            provider.Connect();

            IHyperVMachine machine = provider.GetMachineByName(machineName);

            machine.Stop();

            machine.RestoreLastSnapShot();

            Thread.Sleep(5000);

            machine.Start();
        }
        public void OneTimeTearDown()
        {
            // Ensure we shut down the test image after tests complete.
            var provider = _container.GetRequiredService <IHyperVProvider>();

            Thread.Sleep(5000);
            provider.Connect();

            IHyperVMachine machine = provider.GetMachineByName(TestMachineName);

            HyperVStatus status = machine.GetStatus();

            if (status != HyperVStatus.Off)
            {
                machine.Stop();
            }
        }
        public void TestMachineRestore(string machineName, string snapshotName)
        {
            var provider = _container.GetRequiredService <IHyperVProvider>();

            provider.Connect();

            IHyperVMachine machine = provider.GetMachineByName(machineName);

            machine.Stop();

            Thread.Sleep(2000);

            machine.RestoreSnapShotByName(snapshotName);

            Thread.Sleep(2000);

            machine.Start();
        }
        private uint ChangeState(IHyperVMachine machine, HyperVStatus state)
        {
            var rawMachine = ((HyperVMachine)machine).FetchRawMachine();

            var managementService = new ManagementClass(_scope, new ManagementPath("Msvm_VirtualSystemManagementService"), null)
                .GetInstances()
                .OfType<ManagementObject>().FirstOrDefault();

            if (managementService != null)
            {
                var inParameters = managementService.GetMethodParameters("RequestStateChange");

                inParameters["RequestedState"] = (object)state;

                var outParameters = rawMachine.InvokeMethod("RequestStateChange", inParameters, null);

                Debug.WriteLine("Changed state with return " + outParameters);

                if (outParameters != null) return (uint) outParameters["ReturnValue"];
            }
            else
            {
                throw new HyperVException("Could not find machine management service for rstate change");
            }

            return 0;
        }
 public string GetName(IHyperVMachine machine)
 {
     return(machine.FetchName());
 }
 public void Reset(IHyperVMachine machine)
 {
     ChangeState(machine, HyperVStatus.Reset);
 }
 public void Start(IHyperVMachine machine)
 {
     ChangeState(machine, HyperVStatus.Running);
 }
 public void Stop(IHyperVMachine machine)
 {
     ChangeState(machine, HyperVStatus.Off);
 }
 public void Reset(IHyperVMachine machine)
 {
     ChangeState(machine, HyperVStatus.Reset);
 }
        public HyperVStatus GetStatus(IHyperVMachine machine)
        {
            if (_scope == null)
            {
                throw new HyperVException("No management scope present");
            }

            var rawMachine = ((HyperVMachine) machine).FetchRawMachine();

            return (HyperVStatus)rawMachine["EnabledState"];
        }
 public string GetName(IHyperVMachine machine)
 {
     return machine.FetchName();
 }
        public void RestoreLastSnapShot(IHyperVMachine machine)
        {
            var raw = ((HyperVMachine) machine).FetchRawMachine();

            var lastSnapshot = raw.GetRelated(
                "Msvm_VirtualSystemSettingData",
                "Msvm_MostCurrentSnapshotInBranch",
                null,
                null,
                "Dependent",
                "Antecedent",
                false,
                null).OfType<ManagementObject>().FirstOrDefault();

            if (lastSnapshot == null)
            {
                throw new HyperVException("No Snapshot found");
            }

            var managementService = new ManagementClass(_scope, new ManagementPath("Msvm_VirtualSystemSnapshotService"), null)
                .GetInstances()
                .OfType<ManagementObject>().FirstOrDefault();

            var inParameters = managementService.GetMethodParameters("ApplySnapshot");

            inParameters["Snapshot"] = lastSnapshot.Path.Path;

            var outParameters = managementService.InvokeMethod("ApplySnapshot", inParameters, null);
        }
 public void Stop(IHyperVMachine machine)
 {
     ChangeState(machine, HyperVStatus.Off);
 }
 public void Start(IHyperVMachine machine)
 {
     ChangeState(machine, HyperVStatus.Running);
 }