Esempio n. 1
0
 public long StartProgramInGuest(GuestProgramSpec guestProgramSpec)
 {
     //throw new NotImplementedException();
     return(_vimService.StartProgramInGuest(
                _morProcessManager,          //VimLib.VimServiceReference.ManagedObjectReference _this,
                _morVM,                      //VimLib.VimServiceReference.ManagedObjectReference vm,
                _NamePasswordAuthentication, //VimLib.VimServiceReference.GuestAuthentication auth,
                guestProgramSpec             //VimLib.VimServiceReference.GuestProgramSpec spec
                ));
 }
Esempio n. 2
0
 private void RunProgramInGuest(VimService service, string vmKey, string username, string password, string programPath, string arguments)
 {
     var auth = new NamePasswordAuthentication {
         username = username, password = password, interactiveSession = false
     };
     var vmRef = new ManagedObjectReference {
         type = "VirtualMachine", Value = vmKey
     };
     var progSpec = new GuestProgramSpec {
         programPath = programPath, arguments = arguments
     };
     var processMgr = new ManagedObjectReference {
         type = "GuestProcessManager", Value = "guestOperationsProcessManager"
     };
     var result = service.StartProgramInGuest(processMgr, vmRef, auth, progSpec);
 }
Esempio n. 3
0
        /// <summary>
        /// Runs a guest process in the specified virtual machine.
        /// </summary>
        /// <param name="vmObject">The <see cref="VSphereManagedObject" /> representing the virtual machine.</param>
        /// <param name="fileName">The file name of the application to run.</param>
        /// <param name="arguments">The command-line arguments to pass to the application when the process starts.</param>
        /// <param name="credential">The credential to run the process as.</param>
        /// <param name="waitForExit">if set to <c>true</c> wait for the process to exit before returning.</param>
        /// <returns>The ID of the guest process that was started.</returns>
        /// <exception cref="ArgumentNullException">
        /// <paramref name="vmObject" /> is null.
        /// <para>or</para>
        /// <paramref name="credential" /> is null.
        /// </exception>
        public long RunVirtualMachineGuestProcess(VSphereManagedObject vmObject, string fileName, string arguments, NetworkCredential credential, bool waitForExit)
        {
            if (vmObject == null)
            {
                throw new ArgumentNullException(nameof(vmObject));
            }

            if (credential == null)
            {
                throw new ArgumentNullException(nameof(credential));
            }

            VSpherePropertySpec  spec = new VSpherePropertySpec(VSphereManagedObjectType.GuestOperationsManager, "processManager");
            VSphereManagedObject guestOperationsManager = RetrieveObject(new VSphereManagedObject(_serviceContent.guestOperationsManager), spec);
            var processManager = (ManagedObjectReference)guestOperationsManager.Properties["processManager"];

            NamePasswordAuthentication auth = new NamePasswordAuthentication
            {
                username           = BuildUserName(credential),
                password           = credential.Password,
                interactiveSession = true
            };
            GuestProgramSpec guestProgram = new GuestProgramSpec
            {
                programPath = fileName,
                arguments   = arguments
            };

            long processId = _vimService.StartProgramInGuest(processManager, vmObject.ManagedObjectReference, auth, guestProgram);

            if (waitForExit)
            {
                while (true)
                {
                    var processInfo = _vimService.ListProcessesInGuest(processManager, vmObject.ManagedObjectReference, auth, new[] { processId }).FirstOrDefault();
                    if (processInfo?.exitCodeSpecified == true)
                    {
                        break;
                    }
                    Thread.Sleep(TimeSpan.FromSeconds(1));
                }
            }

            return(processId);
        }
Esempio n. 4
0
        public override IAsyncExecutionResult startExecutableAsync(string toExecute, string args, string workingDir = null)
        {
            string tempDir = String.Format("C:\\users\\{0}\\", _spec.kernelVMUsername);

            if (workingDir == null)
            {
                workingDir = tempDir;
            }

            execFileSet fileSet = prepareForExecution(toExecute, args, tempDir);

            NamePasswordAuthentication auth = new NamePasswordAuthentication
            {
                Username           = _spec.kernelVMUsername,
                Password           = _spec.kernelVMPassword,
                InteractiveSession = true
            };

            VimClientImpl  _vClient      = conn.getConnection();
            VirtualMachine _underlyingVM = conn.getMachine();

            GuestOperationsManager gom = (GuestOperationsManager)_vClient.GetView(_vClient.ServiceContent.GuestOperationsManager, null);
            GuestAuthManager       guestAuthManager = (GuestAuthManager)_vClient.GetView(gom.AuthManager, null);

            guestAuthManager.ValidateCredentialsInGuest(_underlyingVM.MoRef, auth);
            GuestProcessManager guestProcessManager = _vClient.GetView(gom.ProcessManager, null) as GuestProcessManager;
            GuestProgramSpec    progSpec            = new GuestProgramSpec
            {
                ProgramPath      = fileSet.launcherPath,
                Arguments        = "",
                WorkingDirectory = workingDir
            };

            guestProcessManager.StartProgramInGuest(_underlyingVM.MoRef, auth, progSpec);

            return(new asyncExecutionResultViaFile(this, fileSet));
        }
        public int RunProcess( string executable, string args, bool waitForExit = false )
        {
            GuestProcessManager processManager = new GuestProcessManager( _virtualHost, _manager.ProcessManager );

            GuestProgramSpec arguments = new GuestProgramSpec
                                             {
                                                 Arguments = args,
                                                 ProgramPath = executable,
                                                 WorkingDirectory = Path.GetDirectoryName( executable )
                                             };

            long pid = processManager.StartProgramInGuest( _vm.MoRef, _authentication, arguments );
            int exitCode = 0;

            if ( waitForExit )
            {
                while ( true )
                {
                    GuestProcessInfo process = processManager.ListProcessesInGuest( _vm.MoRef, _authentication, new[] {pid} )
                        .FirstOrDefault( p => p.Pid == pid );

                    if ( process == null || process.EndTime != null )
                    {
                        if ( process != null && process.ExitCode.HasValue )
                        {
                            exitCode = process.ExitCode.Value;
                        }
                        break;
                    }

                    Thread.Sleep( 60000 );
                    processManager.UpdateViewData();
                }
            }

            return exitCode;
        }
        public int StartProcessAndWaitForExit( string processLocationInVm, string arguments )
        {
            GuestProcessManager processManager = new GuestProcessManager( _virtualMachine.Client, _manager.ProcessManager );

            GuestProgramSpec args = new GuestProgramSpec
                                        {
                                            Arguments = arguments,
                                            ProgramPath = processLocationInVm,
                                            WorkingDirectory = Path.GetDirectoryName( processLocationInVm )
                                        };

            long pid = processManager.StartProgramInGuest( _virtualMachine.MoRef, _authentication, args );
            int exitCode = 0;

            while ( true )
            {
                GuestProcessInfo process = processManager.ListProcessesInGuest( _virtualMachine.MoRef, _authentication, new[] {pid} )
                    .FirstOrDefault( p => p.Pid == pid );

                if ( process == null || process.EndTime != null )
                {
                    if ( process != null && process.ExitCode.HasValue )
                    {
                        exitCode = process.ExitCode.Value;
                    }
                    break;
                }

                Thread.Sleep( 6000 );
                processManager.UpdateViewData();
            }

            return exitCode;
        }
        public void StartProcess( string processLocationInVm, string arguments )
        {
            GuestProcessManager processManager = new GuestProcessManager( _virtualMachine.Client, _manager.ProcessManager );

            GuestProgramSpec args = new GuestProgramSpec
                                        {
                                            Arguments = arguments,
                                            ProgramPath = processLocationInVm,
                                            WorkingDirectory = Path.GetDirectoryName( processLocationInVm )
                                        };

            processManager.StartProgramInGuest( _virtualMachine.MoRef, _authentication, args );
        }
Esempio n. 8
0
        //WIP for SSO auth

        /*private static byte[] GetSSPIToken(string packageName)
         * {
         *  ClientCurrentCredential clientCred = null;
         *  ClientContext client = null;
         *
         *  ServerCurrentCredential serverCred = null;
         *  ServerContext server = null;
         *
         *  byte[] clientToken;
         *  byte[] serverToken;
         *
         *  SecurityStatus clientStatus;
         *
         *  try
         *  {
         *      clientCred = new ClientCurrentCredential(packageName);
         *      serverCred = new ServerCurrentCredential(packageName);
         *
         *      Console.Out.WriteLine(clientCred.PrincipleName);
         *
         *      client = new ClientContext(
         *          clientCred,
         *          serverCred.PrincipleName, ContextAttrib.Zero
         *      );
         *
         *      server = new ServerContext(
         *          serverCred, ContextAttrib.Zero
         *      );
         *
         *      clientToken = null;
         *      serverToken = null;
         *
         *      clientStatus = client.Init(serverToken, out clientToken);
         *
         *
         *  }
         *  finally
         *  {
         *      if (server != null)
         *      {
         *          server.Dispose();
         *      }
         *
         *      if (client != null)
         *      {
         *          client.Dispose();
         *      }
         *
         *      if (clientCred != null)
         *      {
         *          clientCred.Dispose();
         *      }
         *
         *      if (serverCred != null)
         *      {
         *          serverCred.Dispose();
         *      }
         *  }
         *  return clientToken;
         * }*/
        static void ExecuteCommand(GuestAuthentication creds, string arguments, string programPath, string workingDirectory, bool output)
        {
            try
            {
                ManagedObjectReference processManager = GetProperty <ManagedObjectReference>(serviceContent.guestOperationsManager, "processManager");

                var guestProgramSpec = new GuestProgramSpec()
                {
                    arguments        = arguments,
                    programPath      = programPath,
                    workingDirectory = workingDirectory,
                };

                if (output)
                {
                    //Set file to receive output
                    var outfile = Path.GetRandomFileName();
                    guestProgramSpec.arguments += @" > C:\Users\Public\" + outfile + @" 2>&1";

                    //Start the program and receive the PID back
                    Log("[x] Attempting to run cmd with the following arguments: " + guestProgramSpec.arguments);
                    Log(@"[x] Temporarily saving out to C:\Users\Public\" + outfile);
                    long pid = vim.StartProgramInGuest(processManager, vm, creds, guestProgramSpec);

                    //Display PID
                    Log("[x] Process started with PID " + pid + " waiting for execution to finish");

                    bool finished = false;
                    while (!finished)
                    {
                        //Get status of our process
                        long[]             pids             = { pid };
                        GuestProcessInfo[] guestProcessInfo = vim.ListProcessesInGuest(processManager, vm, creds, pids);
                        if (guestProcessInfo.Length == 0)
                        {
                            Log("Error retrieving status of the process, check for the existance of the output file manually");
                        }
                        if (guestProcessInfo[0].exitCodeSpecified)
                        {
                            Log("[x] Execution finished, attempting to retrieve the results");
                            //Get the results
                            var fileTransferInformation = vim.InitiateFileTransferFromGuest(guestFileManager, vm, creds, @"C:\Users\Public\" + outfile);
                            using (var client = new System.Net.WebClient())
                            {
                                client.CachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
                                var results = client.DownloadString(fileTransferInformation.url);
                                Log("[x] Output: ");
                                Log(results);
                            }

                            //Delete the file
                            vim.DeleteFileInGuest(guestFileManager, vm, creds, @"C:\Users\Public\" + outfile);
                            Log("[x] Output file deleted");

                            finished = true;
                        }
                    }
                }
                else
                {
                    //Start the program and receive the PID back
                    Log("[x] Attempting to execute with cmd /c the following command: " + guestProgramSpec.arguments);
                    long pid = vim.StartProgramInGuest(processManager, vm, creds, guestProgramSpec);

                    //Display PID
                    Log("[x] Process started with PID" + pid);
                }
            }
            catch (Exception fault)
            {
                Error(fault);
            }
        }
Esempio n. 9
0
        public static int MainFindVM(MainSearchVM_In inParam, MainSearchVM_Out outRet)
        {
            VmSummaryInfo vmSummaryInfo = new VmSummaryInfo();

            System.Net.ServicePointManager.Expect100Continue = false;

            MyCertVerify certVerify = new MyCertVerify();

            System.Net.ServicePointManager.ServerCertificateValidationCallback =
                certVerify.RemoteCertificateValidationCallback;

            BasicHttpBinding binding = null;

            if (string.Compare("https", inParam.Protocal, StringComparison.InvariantCultureIgnoreCase) == 0)
            {
                binding = new BasicHttpBinding(BasicHttpSecurityMode.Transport)
                {
                    AllowCookies           = true,
                    OpenTimeout            = TimeSpan.FromHours(1),
                    ReceiveTimeout         = TimeSpan.FromHours(1),
                    SendTimeout            = TimeSpan.FromHours(1),
                    CloseTimeout           = TimeSpan.FromHours(1),
                    MaxBufferPoolSize      = 1024 * 1024 * 2,
                    MaxReceivedMessageSize = 1024 * 512,
                    MaxBufferSize          = 1024 * 512
                };
            }
            else
            {
                binding = new BasicHttpBinding()
                {
                    AllowCookies           = true,
                    OpenTimeout            = TimeSpan.FromHours(1),
                    ReceiveTimeout         = TimeSpan.FromHours(1),
                    SendTimeout            = TimeSpan.FromHours(1),
                    CloseTimeout           = TimeSpan.FromHours(1),
                    MaxBufferPoolSize      = 1024 * 1024 * 2,
                    MaxReceivedMessageSize = 1024 * 512,
                    MaxBufferSize          = 1024 * 512
                };
            }

            string          sdkUrl = string.Format("{0}://{1}{2}/sdk", inParam.Protocal, inParam.ServerName, 0 == inParam.Port ? "" : ":" + inParam.Port.ToString());
            EndpointAddress epa    = new EndpointAddress(sdkUrl);

            vmSummaryInfo.VmHost.ServerName = inParam.ServerName;
            vmSummaryInfo.VmHost.UserName   = inParam.User;
            vmSummaryInfo.VmHost.Password   = inParam.Password;
            vmSummaryInfo.VmHost.Port       = inParam.Port;


            StringBuilder sb = new StringBuilder();
            StringWriter  sw = new StringWriter(sb);

            using (var vimClient = new VimPortTypeClient(binding, epa))
            {
                //var serviceCertificate = vimClient.ClientCredentials.ServiceCertificate;
                //serviceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.Custom;
                //serviceCertificate.Authentication.CustomCertificateValidator = new MyX509CertificateValidator(null);
                //serviceCertificate.Authentication.RevocationMode = X509RevocationMode.NoCheck;

                //var clientCertificate = vimClient.ClientCredentials.ClientCertificate;

                try
                {
                    ManagedObjectReference morServiceInstance = new ManagedObjectReference()
                    {
                        @type = "ServiceInstance",
                        Value = "ServiceInstance"
                    };
                    ServiceContent sc = vimClient.RetrieveServiceContent(morServiceInstance);

                    vmSummaryInfo.VmHost.ThumbPrint = StaticHelpers.FormatThumbPrint(certVerify.Thumbprint);

                    sb.AppendFormat("{0}, {1}, {2}, {3}, {4}", epa.Uri, inParam.User, inParam.Password, vmSummaryInfo.VmHost.ThumbPrint, certVerify.Thumbprint);
                    sb.AppendLine();
                    //StaticHelpers.PrintServerAboutInfo(sb, sc.about);
                    sc.about.Dump(nameof(sc.about), sw, false);

                    Console.WriteLine("{0}", sb.ToString());
                    sb.Clear();


                    using (MyCollectionDisposable collectionDisposal = new MyCollectionDisposable())
                    {
                        UserSession userSession = vimClient.Login(sc.sessionManager, inParam.User, inParam.Password, null);
                        collectionDisposal.Add(() => vimClient.Logout(sc.sessionManager));

                        //bool bListAllVMs = false;
                        //if(bListAllVMs)
                        if (inParam.ToListAllVMs)
                        {
                            CListVMs listVMs = new CListVMs(vimClient, sc.propertyCollector);
                            listVMs.list_all_vms(sc);
                        }


                        VimPropCollector pc = new VimPropCollector(vimClient, sc.propertyCollector);

                        VimFinder vimFinder = new VimFinder(vimClient, sc.propertyCollector, sc.rootFolder);

                        List <ManagedObjectReference> morDatacenters = new List <ManagedObjectReference>();
                        vimFinder.FindDatacenters(morDatacenters);

                        foreach (var datacenter in morDatacenters)
                        {
                            try
                            {
                                ManagedObjectReference morVM = (ManagedObjectReference)vimClient.FindByDatastorePath(sc.searchIndex, datacenter, inParam.VmPath);
                                if (null != morVM)
                                {
                                    vmSummaryInfo.VmHost.VmxSpec = "moref=" + morVM.Value;

                                    VirtualMachineConfigInfo virtualMachineConfigInfo = (VirtualMachineConfigInfo)pc.Get(morVM, "config");
                                    //StaticHelpers.PrintMor(sb, morVM);
                                    morVM.Dump(nameof(morVM), sw, false);
                                    //StaticHelpers.PrintVMCI(sb, virtualMachineConfigInfo);
                                    StaticHelpers.PrintVirtualDisksBriefInfo(sb, virtualMachineConfigInfo, vmSummaryInfo.VmHost.CurrentDiskPath);
                                    virtualMachineConfigInfo.Dump(nameof(virtualMachineConfigInfo), sw, false);
                                    Console.WriteLine("{0}", sb.ToString());
                                    sb.Clear();

                                    VimSnapshotInfo si = new VimSnapshotInfo(vimClient, sc.propertyCollector, morVM, sb, vmSummaryInfo.Snapshots);
                                    si.Traverse();
                                    Console.WriteLine("{0}", sb.ToString());
                                    sb.Clear();

                                    //datastore ManagedObjectReference:Datastore[] datastore-983 (datastore_on_30_1T)
                                    var datastore = (ManagedObjectReference[])pc.Get(morVM, "datastore");
                                    if (null != datastore)
                                    {
                                        var datastoreName = from item in datastore
                                                            select new { Datastore = item, DatastoreName = (string)pc.Get(item, "name") };
                                        foreach (var item in datastoreName)
                                        {
                                            sb.AppendLine();
                                            //StaticHelpers.PrintMor(sb, item.Datastore);
                                            item.Datastore.Dump(nameof(item.Datastore), sw, false);
                                            sb.AppendFormat("{0}\t\"{1}\"", nameof(item.DatastoreName), item.DatastoreName);
                                            sb.AppendLine();
                                        }
                                    }
                                    //guest GuestInfo guest
                                    var guest = (GuestInfo)pc.Get(morVM, "guest");
                                    //StaticHelpers.PrintGuestInfo(sb, guest);
                                    guest.Dump(nameof(guest), sw, false);
                                    //layout VirtualMachineFileLayout layout
                                    var layout = (VirtualMachineFileLayout)pc.Get(morVM, "layout");
                                    //StaticHelpers.PrintVirtualMachineFileLayout(sb, layout);
                                    layout.Dump(nameof(layout), sw, false);
                                    //layoutEx VirtualMachineFileLayoutEx layoutEx
                                    var layoutEx = (VirtualMachineFileLayoutEx)pc.Get(morVM, "layoutEx");
                                    //StaticHelpers.PrintVirtualMachineFileLayoutEx(sb, layoutEx);
                                    layoutEx.Dump(nameof(layoutEx), sw, false);
                                    //name string "shuli02-vc60"
                                    var name = (string)pc.Get(morVM, "name");
                                    sb.AppendFormat("{0}\t\"{1}\"", nameof(name), name);
                                    //network ManagedObjectReference:Network[] network-822(VM Network)
                                    var network = (ManagedObjectReference[])pc.Get(morVM, "network");
                                    if (null != network)
                                    {
                                        foreach (var Network in network)
                                        {
                                            //StaticHelpers.PrintMor(sb, Network);
                                            Network.Dump(nameof(Network), sw, false);
                                        }
                                    }

                                    //parent ManagedObjectReference:Folder group-v3 (vm)
                                    var parent = (ManagedObjectReference)pc.Get(morVM, "parent");
                                    //StaticHelpers.PrintMor(sb, parent);
                                    parent.Dump(nameof(parent), sw, false);

                                    //resourceConfig ResourceConfigSpec resourceConfig
                                    var resourceConfig = (ResourceConfigSpec)pc.Get(morVM, "resourceConfig");
                                    //StaticHelpers.PrintResourceConfigSpec(sb, resourceConfig);
                                    resourceConfig.Dump(nameof(resourceConfig), sw, false);

                                    //resourcePool ManagedObjectReference:ResourcePool resgroup-980 (VC)
                                    var resourcePool = (ManagedObjectReference)pc.Get(morVM, "resourcePool");
                                    //StaticHelpers.PrintMor(sb, resourcePool);
                                    resourcePool.Dump(nameof(resourcePool), sw, false);

                                    //runtime VirtualMachineRuntimeInfo runtime
                                    var runtime = (VirtualMachineRuntimeInfo)pc.Get(morVM, "runtime");
                                    //StaticHelpers.PrintVirtualMachineRuntimeInfo(sb, runtime);
                                    runtime.Dump(nameof(runtime), sw, false);

                                    string runtimeHostName = (string)pc.Get(runtime.host, "name");
                                    ManagedObjectReference morRuntimehostParent = (ManagedObjectReference)pc.Get(runtime.host, "parent");
                                    string runtimeHostParentName = (string)pc.Get(morRuntimehostParent, "name");
                                    //StaticHelpers.PrintMor(sb, runtime.host);
                                    runtime.host.Dump(nameof(runtime.host), sw, false);
                                    sb.AppendFormat("{0}\t\"{1}\"", nameof(runtimeHostName), runtimeHostName); sb.AppendLine();
                                    sb.AppendLine();
                                    //StaticHelpers.PrintMor(sb, morRuntimehostParent);
                                    morRuntimehostParent.Dump(nameof(morRuntimehostParent), sw, false);
                                    sb.AppendFormat("{0}\t\"{1}\"", nameof(runtimeHostParentName), runtimeHostParentName); sb.AppendLine();
                                    sb.AppendLine();

                                    //storage VirtualMachineStorageInfo storage
                                    var storage = (VirtualMachineStorageInfo)pc.Get(morVM, "storage");
                                    //StaticHelpers.PrintVirtualMachineStorageInfo(sb, storage);
                                    storage.Dump(nameof(storage), sw, false);
                                    Console.WriteLine("{0}", sb.ToString());
                                    sb.Clear();

                                    //summary VirtualMachineSummary summary
                                    var summary = (VirtualMachineSummary)pc.Get(morVM, "summary");
                                    //StaticHelpers.PrintVirtualMachineSummary(sb, summary);
                                    summary.Dump(nameof(summary), sw, false);


                                    Console.WriteLine("{0}", sb.ToString());
                                    sb.Clear();

                                    /////////////////////////////////////////////////////////////////////////////////////////////
                                    sb.Append('~', 80); sb.AppendLine();
                                    sb.Append('~', 80); sb.AppendLine();
                                    vmSummaryInfo.Dump(nameof(vmSummaryInfo), sw, false);
                                    sb.Append('~', 80); sb.AppendLine();
                                    sb.Append('~', 80); sb.AppendLine();
                                    Console.WriteLine("{0}", sb.ToString());
                                    sb.Clear();

                                    /////////////////////////////////////////////////////////////////////////////////////////////
                                    bool testVmOperation = false;
                                    if (testVmOperation)
                                    {
                                        try
                                        {
                                            MyVMOperation vmop = new MyVMOperation(vimClient, sc.propertyCollector, morVM);

                                            TaskInfoState state = vmop.ConsolidateVMDisks();

                                            string snapshotid1 = null;
                                            state = vmop.CreateSnapshot("test snapshot name 1", "test snapshot description1 ", false, true, out snapshotid1);
                                            VirtualDisk[] VirtualDisks1 = vmop.QuerySnapshotVirtualDisks(snapshotid1);


                                            string snapshotid2 = null;
                                            state = vmop.CreateSnapshot("test snapshot name 2", "test snapshot description2 ", false, true, out snapshotid2);
                                            VirtualDisk[] VirtualDisks2 = vmop.QuerySnapshotVirtualDisks(snapshotid2);



                                            try
                                            {
                                                foreach (var vdisk in VirtualDisks1)
                                                {
                                                    long startOffset = 0;
                                                    long diskSize    = vdisk.capacityInBytes == 0 ? vdisk.capacityInKB * 1024 : vdisk.capacityInBytes;
                                                    while (startOffset < diskSize)
                                                    {
                                                        DiskChangeInfo diskChangeInfo = vmop.QueryChangedDiskAreas(snapshotid2, vdisk, startOffset);
                                                        if (null != diskChangeInfo.changedArea)
                                                        {
                                                            foreach (var changedArea in diskChangeInfo.changedArea)
                                                            {
                                                                changedArea.Dump(nameof(changedArea), sw, false);
                                                            }
                                                            Console.WriteLine("{0}", sb.ToString());
                                                            sb.Clear();
                                                        }
                                                        startOffset = diskChangeInfo.startOffset + diskChangeInfo.length;
                                                    }
                                                }
                                            }
                                            catch (Exception exQueryChangedDiskAreas)
                                            {
                                                StaticHelpers.PrintException(exQueryChangedDiskAreas, 0);
                                            }

                                            state = vmop.RemoveSnapshot(snapshotid2, false, true);
                                            state = vmop.RemoveSnapshot(snapshotid1, false, true);
                                        }
                                        catch (Exception exTestVmOperation)
                                        {
                                            StaticHelpers.PrintException(exTestVmOperation, 0);
                                        }
                                    }

                                    /////////////////////////////////////////////////////////////////////////////////////////////
                                    bool testGustOp = false;
                                    if (testGustOp)
                                    {
                                        try
                                        {
                                            string            guestUser     = "******";
                                            string            guestPassword = "******";
                                            VimGuestOperation vimGuestOp    = new VimGuestOperation(vimClient, sc.propertyCollector, sc.guestOperationsManager, morVM, guestUser, guestPassword);

                                            string[] vars = vimGuestOp.ReadEnvironmentVariableInGuest(new string[] { "path" });

                                            GuestProgramSpec guestProgramSpec = new GuestProgramSpec()
                                            {
                                                programPath      = @"c:\Windows\notepad.exe",
                                                arguments        = "",
                                                workingDirectory = @"c:\",
                                                envVariables     = null
                                            };
                                            long pid = vimGuestOp.StartProgramInGuest(guestProgramSpec);
                                            GuestProcessInfo[] gpi = vimGuestOp.ListProcessesInGuest(new long[] { pid });
                                            vimGuestOp.TerminateProcessInGuest(pid);


                                            string guestFilePath = @"E:\1.vhdx";
                                            string localFile     = @"E:\~temp\1.vhdx";
                                            vimGuestOp.FileTransferFromGuest(guestFilePath, localFile);
                                            string guestFilePath2 = @"e:\111\1.vhdx";
                                            vimGuestOp.FileTransferToGuest(guestFilePath2, localFile, true);
                                        }
                                        catch (Exception exGust)
                                        {
                                            StaticHelpers.PrintException(exGust, 0);
                                        }
                                    }
                                }
                            }
                            catch (Exception exFind)
                            {
                                StaticHelpers.PrintException(exFind, 0);
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    StaticHelpers.PrintException(ex, 0);
                }
            }

            return(0);
        }