github.com/emc-advanced-dev/unik@v0.0.0-20190717152701-a58d3e8e33b7/containers/utils/vsphere-client/src/main/java/com/emc/unik/VmAttachDisk.java (about)

     1  package com.emc.unik;
     2  
     3  import java.net.URL;
     4  
     5  import com.vmware.vim25.*;
     6  import com.vmware.vim25.mo.*;
     7  
     8  public class VmAttachDisk {
     9      public static void main(String[] args) throws Exception {
    10          if (args.length < 1) {
    11              System.err.println("Usage: java VmAttachDisk|CopyFile|CopyVirtualDisk [<opts>]");
    12              System.exit(-1);
    13          }
    14  
    15          if (args[0].equals("VmAttachDisk")) {
    16              if (args.length != 8) {
    17                  System.err.println("Usage: java VmAttachDisk <url> " +
    18                          "<username> <password> <vmname> <vmdkPath> <DeviceType: SCSI|IDE> <deviceSlot>");
    19                  System.exit(-1);
    20              }
    21  
    22              String vmname = args[4];
    23              String vmdkPath = args[5];
    24              String deviceType = args[6];
    25              int deviceSlot = Integer.parseInt(args[7]);
    26  
    27              ServiceInstance si = new ServiceInstance(
    28                      new URL(args[1]), args[2], args[3], true);
    29  
    30              Folder rootFolder = si.getRootFolder();
    31              VirtualMachine vm = (VirtualMachine) new InventoryNavigator(
    32                      rootFolder).searchManagedEntity("VirtualMachine", vmname);
    33  
    34              if (vm == null) {
    35                  System.out.println("No VM " + vmname + " found");
    36                  si.getServerConnection().logout();
    37                  System.exit(-1);
    38              }
    39  
    40              int storageDeviceKey = -1;
    41              if (deviceType.contains("SCSI")) {
    42                  storageDeviceKey = getScsiDeviceKey(vm);
    43              } else if (deviceType.contains("IDE")) {
    44                  storageDeviceKey = getIdeDeviceKey(vm);
    45              }
    46  
    47              if (storageDeviceKey == -1) {
    48                  System.out.println("could not find controller device type: "+deviceType);
    49                  System.exit(-1);
    50              }
    51  
    52              VirtualMachineConfigSpec vmConfigSpec = new VirtualMachineConfigSpec();
    53  
    54              // mode: persistent|independent_persistent,independent_nonpersistent
    55              String diskMode = "persistent";
    56              VirtualDeviceConfigSpec vdiskSpec = createExistingDiskSpec(vmdkPath, storageDeviceKey, deviceSlot, diskMode);
    57              VirtualDeviceConfigSpec[] vdiskSpecArray = {vdiskSpec};
    58              vmConfigSpec.setDeviceChange(vdiskSpecArray);
    59  
    60              Task task = vm.reconfigVM_Task(vmConfigSpec);
    61              System.out.println(task.waitForTask());
    62              if (task.getTaskInfo() != null && task.getTaskInfo().getDescription() != null) {
    63                  System.out.println(task.getTaskInfo().getDescription().getMessage());
    64                  if (task.getTaskInfo().getDescription().getMessage().contains("success")) {
    65                      return;
    66                  }
    67                  System.exit(-1);
    68              }
    69          }
    70  
    71          if (args[0].equals("VmDetachDisk")) {
    72              if (args.length != 7) {
    73                  System.err.println("Usage: java VmAttachDisk <url> " +
    74                          "<username> <password> <vmname>  <DeviceType: SCSI|IDE> <deviceSlot>");
    75                  System.exit(-1);
    76              }
    77  
    78              String vmname = args[4];
    79              String deviceType = args[6];
    80              int deviceSlot = Integer.parseInt(args[6]);
    81  
    82              ServiceInstance si = new ServiceInstance(
    83                      new URL(args[1]), args[2], args[3], true);
    84  
    85              Folder rootFolder = si.getRootFolder();
    86              VirtualMachine vm = (VirtualMachine) new InventoryNavigator(
    87                      rootFolder).searchManagedEntity("VirtualMachine", vmname);
    88  
    89              if (vm == null) {
    90                  System.out.println("No VM " + vmname + " found");
    91                  si.getServerConnection().logout();
    92                  System.exit(-1);
    93              }
    94  
    95              int storageDeviceKey = -1;
    96              if (deviceType.contains("SCSI")) {
    97                  storageDeviceKey = getScsiDeviceKey(vm);
    98              } else if (deviceType.contains("IDE")) {
    99                  storageDeviceKey = getIdeDeviceKey(vm);
   100              }
   101  
   102              if (storageDeviceKey == -1) {
   103                  System.out.println("could not find controller device type: "+deviceType);
   104                  System.exit(-1);
   105              }
   106  
   107              VirtualMachineConfigSpec vmConfigSpec = new VirtualMachineConfigSpec();
   108  
   109              VirtualDeviceConfigSpec vdiskSpec = createRemoveDiskSpec(storageDeviceKey, deviceSlot);
   110              VirtualDeviceConfigSpec[] vdiskSpecArray = {vdiskSpec};
   111              vmConfigSpec.setDeviceChange(vdiskSpecArray);
   112  
   113              Task task = vm.reconfigVM_Task(vmConfigSpec);
   114              System.out.println(task.waitForTask());
   115              if (task.getTaskInfo() != null && task.getTaskInfo().getDescription() != null) {
   116                  System.out.println(task.getTaskInfo().getDescription().getMessage());
   117              }
   118              if (task.getTaskInfo().getDescription().getMessage().contains("success")) {
   119                  return;
   120              }
   121              System.exit(-1);
   122          }
   123          if (args[0].equals("CopyFile")) {
   124              if (args.length != 7) {
   125                  System.err.println("Usage: java CopyFile <url> " +
   126                          "<username> <password> <datacenter> <sourcePath> <destinationPath>");
   127                  System.exit(-1);
   128              }
   129  
   130              ServiceInstance si = new ServiceInstance(
   131                      new URL(args[1]), args[2], args[3], true);
   132              String datacenterName = args[4];
   133  
   134              Datacenter datacenter = (Datacenter) new InventoryNavigator(si.getRootFolder()).searchManagedEntity("Datacenter", datacenterName);
   135  
   136              String sourcePath = args[5];
   137              String destinationPath = args[6];
   138  
   139              FileManager fileManager = si.getFileManager();
   140              if (fileManager == null) {
   141                  System.err.println("filemanager not available");
   142                  System.exit(-1);
   143              }
   144              Task copyTask = fileManager.copyDatastoreFile_Task(sourcePath, datacenter, destinationPath, datacenter, true);
   145  
   146              String res = copyTask.waitForTask();
   147              System.out.println(res);
   148              if (res.contains("success")) {
   149                  return;
   150              }
   151              System.exit(-1);
   152          }
   153          if (args[0].equals("CopyVirtualDisk")) {
   154              if (args.length != 7) {
   155                  System.out.println("Usage: java CopyVirtualDisk "
   156                          + "<url> <username> <password> <datacenter> <src> <dest>");
   157                  System.exit(-1);
   158              }
   159  
   160              ServiceInstance si = new ServiceInstance(
   161                      new URL(args[1]), args[2], args[3], true);
   162  
   163              String datacenterName = args[4];
   164  
   165              Datacenter dc = (Datacenter) new InventoryNavigator(
   166                      si.getRootFolder()).searchManagedEntity(
   167                      "Datacenter", datacenterName);
   168  
   169              VirtualDiskManager diskManager = si.getVirtualDiskManager();
   170              if (diskManager == null) {
   171                  System.out.println("DiskManager not available.");
   172                  si.getServerConnection().logout();
   173                  System.exit(-1);
   174              }
   175  
   176              String srcPath = args[5];
   177              String dstPath = args[6];
   178              VirtualDiskSpec copyDiskSpec = new VirtualDiskSpec();
   179              copyDiskSpec.setDiskType(VirtualDiskType.thin.name());
   180              copyDiskSpec.setAdapterType(VirtualDiskAdapterType.ide.name());
   181              Task cTask = null;
   182              try {
   183                  cTask = diskManager.copyVirtualDisk_Task(srcPath, dc, dstPath, dc, copyDiskSpec, new Boolean(true));
   184              } catch (InvalidArgument e){
   185                  e.getInvalidProperty();
   186                  e.printStackTrace();
   187                  System.exit(-1);
   188              }
   189  
   190              if (cTask.waitForTask().equals(Task.SUCCESS)) {
   191                  System.out.println("Disk copied successfully!");
   192              } else {
   193                  System.out.println("Disk copy failed!");
   194                  System.out.println(cTask.getTaskInfo().getError().getLocalizedMessage());
   195                  System.exit(-1);
   196              }
   197              si.getServerConnection().logout();
   198          }
   199      }
   200  
   201      private static VirtualDeviceConfigSpec createExistingDiskSpec(String fileName, int controllerKey, int deviceKey, String diskMode) {
   202          VirtualDeviceConfigSpec diskSpec =
   203                  new VirtualDeviceConfigSpec();
   204          diskSpec.setOperation(VirtualDeviceConfigSpecOperation.add);
   205          // do not set diskSpec.fileOperation!
   206          VirtualDisk vd = new VirtualDisk();
   207          vd.setCapacityInKB(-1);
   208          vd.setKey(deviceKey);
   209          vd.setUnitNumber(new Integer(deviceKey));
   210          vd.setControllerKey(new Integer(controllerKey));
   211          VirtualDiskFlatVer2BackingInfo diskfileBacking =
   212                  new VirtualDiskFlatVer2BackingInfo();
   213          diskfileBacking.setFileName(fileName);
   214          diskfileBacking.setDiskMode(diskMode);
   215          vd.setBacking(diskfileBacking);
   216          diskSpec.setDevice(vd);
   217          return diskSpec;
   218      }
   219  
   220      private static int getScsiDeviceKey(VirtualMachine vm) {
   221          for (VirtualDevice vd : vm.getConfig().getHardware().getDevice()) {
   222              if (vd instanceof VirtualSCSIController) {
   223                  VirtualSCSIController vscsi = (VirtualSCSIController) vd;
   224                  System.out.println("found scsi controller:"+vscsi.getScsiCtlrUnitNumber()+" "+vscsi.getUnitNumber()+" "+vscsi.getKey());
   225                  return vscsi.getKey();
   226              }
   227          }
   228          return -1;
   229      }
   230  
   231      private static int getIdeDeviceKey(VirtualMachine vm) {
   232          for (VirtualDevice vd : vm.getConfig().getHardware().getDevice()) {
   233              if (vd instanceof VirtualIDEController) {
   234                  VirtualIDEController vide = (VirtualIDEController) vd;
   235                  System.out.println("found ide controller:"+" "+vide.getUnitNumber()+" "+vide.getKey());
   236                  return vide.getKey();
   237              }
   238          }
   239          return -1;
   240      }
   241  
   242      private static VirtualDeviceConfigSpec createRemoveDiskSpec(int controllerKey, int deviceKey) {
   243          VirtualDeviceConfigSpec diskSpec =
   244                  new VirtualDeviceConfigSpec();
   245          diskSpec.setOperation(VirtualDeviceConfigSpecOperation.remove);
   246  
   247          VirtualDisk vd = new VirtualDisk();
   248          vd.setCapacityInKB(-1);
   249          vd.setKey(deviceKey);
   250          vd.setUnitNumber(new Integer(deviceKey));
   251          vd.setControllerKey(new Integer(controllerKey));
   252          diskSpec.setDevice(vd);
   253          return diskSpec;
   254      }
   255  }
   256