Esempio n. 1
0
        private static VirtualDeviceConfigSpec GetCdrom(ref int key, int controllerkey, string iso)
        {
            VirtualDeviceConfigSpec devicespec = new VirtualDeviceConfigSpec();

            // CD ROM
            VirtualCdrom cdrom = new VirtualCdrom();

            cdrom.key = key--;

            VirtualCdromIsoBackingInfo isobacking = new VirtualCdromIsoBackingInfo();

            isobacking.fileName = iso;
            cdrom.backing       = isobacking;

            cdrom.controllerKey              = controllerkey;
            cdrom.controllerKeySpecified     = true;
            cdrom.connectable                = new VirtualDeviceConnectInfo();
            cdrom.connectable.startConnected = true;

            devicespec                    = new VirtualDeviceConfigSpec();
            devicespec.device             = cdrom;
            devicespec.operation          = VirtualDeviceConfigSpecOperation.add;
            devicespec.operationSpecified = true;

            return(devicespec);
        }
Esempio n. 2
0
        private VirtualDeviceConfigSpec getCDDeviceConfigSpec()
        {
            String ops = cb.get_option("operation");
            VirtualDeviceConfigSpec  cdSpec = new VirtualDeviceConfigSpec();
            VirtualMachineConfigInfo vmConfigInfo
                = (VirtualMachineConfigInfo)cb.getServiceUtil().GetDynamicProperty(
                      _virtualMachine, "config");

            if (ops.Equals("add"))
            {
                cdSpec.operation          = VirtualDeviceConfigSpecOperation.add;
                cdSpec.operationSpecified = true;
                VirtualCdrom cdrom = new VirtualCdrom();

                VirtualCdromIsoBackingInfo cdDeviceBacking
                    = new  VirtualCdromIsoBackingInfo();
                DatastoreSummary dsum = getDataStoreSummary();
                cdDeviceBacking.datastore = dsum.datastore;
                cdDeviceBacking.fileName  = "[" + dsum.name + "] " + cb.get_option("value") + ".iso";

                VirtualDevice vd = getIDEController();
                cdrom.backing                = cdDeviceBacking;
                cdrom.controllerKey          = vd.key;
                cdrom.controllerKeySpecified = true;
                cdrom.unitNumber             = -1;
                cdrom.unitNumberSpecified    = true;
                cdrom.key = -100;

                cdSpec.device = cdrom;

                return(cdSpec);
            }
            else
            {
                VirtualCdrom     cdRemove = null;
                VirtualDevice [] test     = vmConfigInfo.hardware.device;
                cdSpec.operation          = VirtualDeviceConfigSpecOperation.remove;
                cdSpec.operationSpecified = true;
                for (int k = 0; k < test.Length; k++)
                {
                    if (test[k].deviceInfo.label.Equals(
                            cb.get_option("value")))
                    {
                        cdRemove = (VirtualCdrom)test[k];
                    }
                }
                if (cdRemove != null)
                {
                    cdSpec.device = cdRemove;
                }
                else
                {
                    Console.WriteLine("No device available " + cb.get_option("value"));
                    return(null);
                }
            }
            return(cdSpec);
        }
        public void DeployAndConnectIso( string localPath, string remotePath )
        {
            UploadArtifact( localPath, remotePath );

            _vm.UpdateViewData();

            VirtualCdrom cd = _vm.Config.Hardware.Device.FirstOrDefault( d => d is VirtualCdrom ) as VirtualCdrom;

            if ( cd == null )
            {
                throw new ApplicationException( "CD is null" );
            }

            VirtualCdromIsoBackingInfo newBacking = new VirtualCdromIsoBackingInfo
                                                        {
                                                            FileName = string.Format( "[{0}] {1}", _vmWareConfiguration.DataStoreName, remotePath )
                                                        };
            cd.Backing = newBacking;
            cd.Connectable.StartConnected = true;
            cd.Connectable.Connected = true;

            VirtualDeviceConfigSpec deviceSpec = new VirtualDeviceConfigSpec
                                                     {
                                                         Device = cd,
                                                         Operation = VirtualDeviceConfigSpecOperation.edit
                                                     };

            VirtualMachineConfigSpec vmSpec = new VirtualMachineConfigSpec
                                                  {
                                                      DeviceChange = new[] {deviceSpec}
                                                  };

            _vm.ReconfigVM( vmSpec );
        }
        public void ConnectIso( string isoLocation )
        {
            const string remotePath = "/Temp";

            UploadArtifact( isoLocation, remotePath );

            _virtualMachine.UpdateViewData();

            VirtualCdrom cd = _virtualMachine.Config.Hardware.Device.FirstOrDefault( d => d is VirtualCdrom ) as VirtualCdrom;

            if ( cd == null )
            {
                throw new ApplicationException( "CD is null" );
            }

            VirtualCdromIsoBackingInfo newBacking = new VirtualCdromIsoBackingInfo
                                                        {
                                                            FileName = string.Format( "[{0}] {1}", "datastore1", remotePath )
                                                        };
            cd.Backing = newBacking;
            cd.Connectable.StartConnected = true;
            cd.Connectable.Connected = true;

            VirtualDeviceConfigSpec deviceSpec = new VirtualDeviceConfigSpec
                                                     {
                                                         Device = cd,
                                                         Operation = VirtualDeviceConfigSpecOperation.edit
                                                     };

            VirtualMachineConfigSpec vmSpec = new VirtualMachineConfigSpec
                                                  {
                                                      DeviceChange = new[] {deviceSpec}
                                                  };

            _virtualMachine.ReconfigVM( vmSpec );
        }
Esempio n. 5
0
        public VirtualMachineConfigSpec createVmConfigSpec(String vmName,

                                                           String datastoreName,

                                                           int diskSizeMB,

                                                           ManagedObjectReference computeResMor,

                                                           ManagedObjectReference hostMor)

        {
            ConfigTarget configTarget = getConfigTargetForHost(computeResMor, hostMor);

            VirtualDevice[] defaultDevices = getDefaultDevices(computeResMor, hostMor);

            VirtualMachineConfigSpec configSpec = new VirtualMachineConfigSpec();



            String networkName = null;

            if (configTarget.network != null)

            {
                for (int i = 0; i < configTarget.network.Length; i++)

                {
                    VirtualMachineNetworkInfo netInfo = configTarget.network[i];

                    NetworkSummary netSummary = netInfo.network;

                    if (netSummary.accessible)

                    {
                        networkName = netSummary.name;

                        break;
                    }
                }
            }

            ManagedObjectReference datastoreRef = null;

            if (datastoreName != null)

            {
                Boolean flag = false;

                for (int i = 0; i < configTarget.datastore.Length; i++)

                {
                    VirtualMachineDatastoreInfo vdsInfo = configTarget.datastore[i];

                    DatastoreSummary dsSummary = vdsInfo.datastore;

                    if (dsSummary.name.Equals(datastoreName))

                    {
                        flag = true;

                        if (dsSummary.accessible)

                        {
                            datastoreName = dsSummary.name;

                            datastoreRef = dsSummary.datastore;
                        }

                        else

                        {
                            throw new Exception("Specified Datastore is not accessible");
                        }

                        break;
                    }
                }

                if (!flag)

                {
                    throw new Exception("Specified Datastore is not Found");
                }
            }

            else

            {
                Boolean flag = false;

                for (int i = 0; i < configTarget.datastore.Length; i++)

                {
                    VirtualMachineDatastoreInfo vdsInfo = configTarget.datastore[i];

                    DatastoreSummary dsSummary = vdsInfo.datastore;

                    if (dsSummary.accessible)

                    {
                        datastoreName = dsSummary.name;

                        datastoreRef = dsSummary.datastore;

                        flag = true;

                        break;
                    }
                }

                if (!flag)

                {
                    throw new Exception("No Datastore found on host");
                }
            }

            String datastoreVolume = getVolumeName(datastoreName);

            VirtualMachineFileInfo vmfi = new VirtualMachineFileInfo();

            vmfi.vmPathName = datastoreVolume;

            configSpec.files = vmfi;

            // Add a scsi controller

            int diskCtlrKey = 1;

            VirtualDeviceConfigSpec scsiCtrlSpec = new VirtualDeviceConfigSpec();

            scsiCtrlSpec.operation = VirtualDeviceConfigSpecOperation.add;

            scsiCtrlSpec.operationSpecified = true;

            VirtualLsiLogicController scsiCtrl = new VirtualLsiLogicController();

            scsiCtrl.busNumber = 0;

            scsiCtrlSpec.device = scsiCtrl;

            scsiCtrl.key = diskCtlrKey;

            scsiCtrl.sharedBus = VirtualSCSISharing.noSharing;

            String ctlrType = scsiCtrl.GetType().Name;



            // Find the IDE controller

            VirtualDevice ideCtlr = null;

            for (int di = 0; di < defaultDevices.Length; di++)

            {
                if (defaultDevices[di].GetType().Name.Equals("VirtualIDEController"))

                {
                    ideCtlr = defaultDevices[di];

                    break;
                }
            }



            // Add a floppy

            VirtualDeviceConfigSpec floppySpec = new VirtualDeviceConfigSpec();

            floppySpec.operation = VirtualDeviceConfigSpecOperation.add;

            floppySpec.operationSpecified = true;

            VirtualFloppy floppy = new VirtualFloppy();

            VirtualFloppyDeviceBackingInfo flpBacking = new VirtualFloppyDeviceBackingInfo();

            flpBacking.deviceName = "/dev/fd0";

            floppy.backing = flpBacking;

            floppy.key = 3;

            floppySpec.device = floppy;



            // Add a cdrom based on a physical device

            VirtualDeviceConfigSpec cdSpec = null;



            if (ideCtlr != null)

            {
                cdSpec = new VirtualDeviceConfigSpec();

                cdSpec.operation = VirtualDeviceConfigSpecOperation.add;

                cdSpec.operationSpecified = true;

                VirtualCdrom cdrom = new VirtualCdrom();

                VirtualCdromIsoBackingInfo cdDeviceBacking = new VirtualCdromIsoBackingInfo();

                cdDeviceBacking.datastore = datastoreRef;

                cdDeviceBacking.fileName = datastoreVolume + "testcd.iso";

                cdrom.backing = cdDeviceBacking;

                cdrom.key = 20;

                cdrom.controllerKey = ideCtlr.key;

                cdrom.controllerKeySpecified = true;

                cdrom.unitNumberSpecified = true;

                cdrom.unitNumber = 0;

                cdSpec.device = cdrom;
            }



            // Create a new disk - file based - for the vm

            VirtualDeviceConfigSpec diskSpec = null;

            diskSpec = createVirtualDisk(datastoreName, diskCtlrKey, datastoreRef, diskSizeMB);



            // Add a NIC. the network Name must be set as the device name to create the NIC.

            VirtualDeviceConfigSpec nicSpec = new VirtualDeviceConfigSpec();

            if (networkName != null)

            {
                nicSpec.operation = VirtualDeviceConfigSpecOperation.add;

                nicSpec.operationSpecified = true;

                VirtualEthernetCard nic = new VirtualPCNet32();

                VirtualEthernetCardNetworkBackingInfo nicBacking = new VirtualEthernetCardNetworkBackingInfo();

                nicBacking.deviceName = networkName;

                nic.addressType = "generated";

                nic.backing = nicBacking;

                nic.key = 4;

                nicSpec.device = nic;
            }



            var deviceConfigSpec = new List <VirtualDeviceConfigSpec>();

            deviceConfigSpec.Add(scsiCtrlSpec);

            deviceConfigSpec.Add(floppySpec);

            deviceConfigSpec.Add(diskSpec);

            deviceConfigSpec.Add(nicSpec);



            if (ideCtlr != null)

            {
                deviceConfigSpec.Add(cdSpec);
            }



            configSpec.deviceChange = deviceConfigSpec.ToArray();

            return(configSpec);
        }
Esempio n. 6
0
        public VirtualMachineConfigSpec createVmConfigSpec(String vmName,
                                                        String datastoreName,
                                                        int diskSizeMB,
                                                        ManagedObjectReference computeResMor,
                                                        ManagedObjectReference hostMor)
        {

            ConfigTarget configTarget = getConfigTargetForHost(computeResMor, hostMor);
            VirtualDevice[] defaultDevices = getDefaultDevices(computeResMor, hostMor);
            VirtualMachineConfigSpec configSpec = new VirtualMachineConfigSpec();

            String networkName = null;
            if (configTarget.network != null)
            {
                for (int i = 0; i < configTarget.network.Length; i++)
                {
                    VirtualMachineNetworkInfo netInfo = configTarget.network[i];
                    NetworkSummary netSummary = netInfo.network;
                    if (netSummary.accessible)
                    {
                        networkName = netSummary.name;
                        break;
                    }
                }
            }
            ManagedObjectReference datastoreRef = null;
            if (datastoreName != null)
            {
                Boolean flag = false;
                for (int i = 0; i < configTarget.datastore.Length; i++)
                {
                    VirtualMachineDatastoreInfo vdsInfo = configTarget.datastore[i];
                    DatastoreSummary dsSummary = vdsInfo.datastore;
                    if (dsSummary.name.Equals(datastoreName))
                    {
                        flag = true;
                        if (dsSummary.accessible)
                        {
                            datastoreName = dsSummary.name;
                            datastoreRef = dsSummary.datastore;
                        }
                        else
                        {
                            throw new Exception("Specified Datastore is not accessible");
                        }
                        break;
                    }
                }
                if (!flag)
                {
                    throw new Exception("Specified Datastore is not Found");
                }
            }
            else
            {
                Boolean flag = false;
                for (int i = 0; i < configTarget.datastore.Length; i++)
                {
                    VirtualMachineDatastoreInfo vdsInfo = configTarget.datastore[i];
                    DatastoreSummary dsSummary = vdsInfo.datastore;
                    if (dsSummary.accessible)
                    {
                        datastoreName = dsSummary.name;
                        datastoreRef = dsSummary.datastore;
                        flag = true;
                        break;
                    }
                }
                if (!flag)
                {
                    throw new Exception("No Datastore found on host");
                }
            }
            String datastoreVolume = getVolumeName(datastoreName);
            VirtualMachineFileInfo vmfi = new VirtualMachineFileInfo();
            vmfi.vmPathName = datastoreVolume;
            configSpec.files = vmfi;
            // Add a scsi controller
            int diskCtlrKey = 1;
            VirtualDeviceConfigSpec scsiCtrlSpec = new VirtualDeviceConfigSpec();
            scsiCtrlSpec.operation = VirtualDeviceConfigSpecOperation.add;
            scsiCtrlSpec.operationSpecified = true;
            VirtualLsiLogicController scsiCtrl = new VirtualLsiLogicController();
            scsiCtrl.busNumber = 0;
            scsiCtrlSpec.device = scsiCtrl;
            scsiCtrl.key = diskCtlrKey;
            scsiCtrl.sharedBus = VirtualSCSISharing.noSharing;
            String ctlrType = scsiCtrl.GetType().Name;


            // Find the IDE controller
            VirtualDevice ideCtlr = null;
            for (int di = 0; di < defaultDevices.Length; di++)
            {
                if (defaultDevices[di].GetType().Name.Equals("VirtualIDEController"))
                {
                    ideCtlr = defaultDevices[di];
                    break;
                }
            }

            // Add a floppy
            VirtualDeviceConfigSpec floppySpec = new VirtualDeviceConfigSpec();
            floppySpec.operation = VirtualDeviceConfigSpecOperation.add;
            floppySpec.operationSpecified = true;
            VirtualFloppy floppy = new VirtualFloppy();
            VirtualFloppyDeviceBackingInfo flpBacking = new VirtualFloppyDeviceBackingInfo();
            flpBacking.deviceName = "/dev/fd0";
            floppy.backing = flpBacking;
            floppy.key = 3;
            floppySpec.device = floppy;

            // Add a cdrom based on a physical device
            VirtualDeviceConfigSpec cdSpec = null;

            if (ideCtlr != null)
            {
                cdSpec = new VirtualDeviceConfigSpec();
                cdSpec.operation = VirtualDeviceConfigSpecOperation.add;
                cdSpec.operationSpecified = true;
                VirtualCdrom cdrom = new VirtualCdrom();
                VirtualCdromIsoBackingInfo cdDeviceBacking = new VirtualCdromIsoBackingInfo();
                cdDeviceBacking.datastore = datastoreRef;
                cdDeviceBacking.fileName = datastoreVolume + "testcd.iso";
                cdrom.backing = cdDeviceBacking;
                cdrom.key = 20;
                cdrom.controllerKey = ideCtlr.key;
                cdrom.controllerKeySpecified = true;
                cdrom.unitNumberSpecified = true;
                cdrom.unitNumber = 0;
                cdSpec.device = cdrom;
            }

            // Create a new disk - file based - for the vm
            VirtualDeviceConfigSpec diskSpec = null;
            diskSpec = createVirtualDisk(datastoreName, diskCtlrKey, datastoreRef, diskSizeMB);

            // Add a NIC. the network Name must be set as the device name to create the NIC.
            VirtualDeviceConfigSpec nicSpec = new VirtualDeviceConfigSpec();
            if (networkName != null)
            {
                nicSpec.operation = VirtualDeviceConfigSpecOperation.add;
                nicSpec.operationSpecified = true;
                VirtualEthernetCard nic = new VirtualPCNet32();
                VirtualEthernetCardNetworkBackingInfo nicBacking = new VirtualEthernetCardNetworkBackingInfo();
                nicBacking.deviceName = networkName;
                nic.addressType = "generated";
                nic.backing = nicBacking;
                nic.key = 4;
                nicSpec.device = nic;
            }

            var deviceConfigSpec = new List<VirtualDeviceConfigSpec>();
            deviceConfigSpec.Add(scsiCtrlSpec);
            deviceConfigSpec.Add(floppySpec);
            deviceConfigSpec.Add(diskSpec);
            deviceConfigSpec.Add(nicSpec);

            if (ideCtlr != null)
            {
                deviceConfigSpec.Add(cdSpec);
            }

            configSpec.deviceChange = deviceConfigSpec.ToArray();
            return configSpec;
        }
Esempio n. 7
0
 private VirtualDeviceConfigSpec getCDDeviceConfigSpec()  {
    String ops = cb.get_option("operation");
    VirtualDeviceConfigSpec cdSpec = new VirtualDeviceConfigSpec();      
    VirtualMachineConfigInfo vmConfigInfo 
       = (VirtualMachineConfigInfo)cb.getServiceUtil().GetDynamicProperty(
           _virtualMachine,"config");
    
    if(ops.Equals("add")) {                        
       cdSpec.operation = VirtualDeviceConfigSpecOperation.add;
       cdSpec.operationSpecified = true;
       VirtualCdrom cdrom =  new VirtualCdrom();
       
       VirtualCdromIsoBackingInfo cdDeviceBacking 
          = new  VirtualCdromIsoBackingInfo();
       DatastoreSummary dsum = getDataStoreSummary();        
       cdDeviceBacking.datastore= dsum.datastore;
       cdDeviceBacking.fileName="["+dsum.name+"] "+cb.get_option("value")+".iso";
       
       VirtualDevice vd = getIDEController();          
       cdrom.backing =cdDeviceBacking;                    
       cdrom.controllerKey = vd.key;
       cdrom.controllerKeySpecified = true;
       cdrom.unitNumber= -1;
       cdrom.unitNumberSpecified = true;
       cdrom.key= -100;          
       
       cdSpec.device=cdrom;
       
       return cdSpec;          
    }
    else {
       VirtualCdrom cdRemove = null;
       VirtualDevice [] test = vmConfigInfo.hardware.device;
       cdSpec.operation=VirtualDeviceConfigSpecOperation.remove;
       cdSpec.operationSpecified = true;
       for(int k=0;k<test.Length;k++){
          if(test[k].deviceInfo.label.Equals(
             cb.get_option("value"))){                             
             cdRemove = (VirtualCdrom)test[k];
          }
       }
       if(cdRemove != null) {
          cdSpec.device=cdRemove;
       }
       else {
          Console.WriteLine("No device available " + cb.get_option("value"));
          return null;
       }
    }
    return cdSpec;
 }