import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
private static boolean migrateVM(String targetVMName, String newHostName,
    boolean tryAnotherVM, boolean tryAnotherHost) throws Exception {
  ServiceInstance si = new ServiceInstance(new URL(url), username, password,
      true);

  try {
    Folder rootFolder = si.getRootFolder();
    HostSystem newHost = (HostSystem)new InventoryNavigator(rootFolder)
        .searchManagedEntity("HostSystem", newHostName);
    
    return migrateVM(si, rootFolder, newHost, targetVMName, newHostName,
        tryAnotherVM, tryAnotherHost);
  } finally {
    si.getServerConnection().logout();
  }
}
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
private static synchronized boolean doMigrateVM(String targetVMName,
    String newHostName) throws Exception {
  ServiceInstance si = new ServiceInstance(new URL(url), username, password,
      true);
  try {
    Folder rootFolder = si.getRootFolder();
    InventoryNavigator in = new InventoryNavigator(rootFolder);
    HostSystem newHost = (HostSystem)in.searchManagedEntity("HostSystem",
        newHostName);
    if (newHost == null) {
      throw new TestException("Could not find host " + newHostName + " as a target host for vMotion.");
    }

    return migrateVM(si, rootFolder, newHost, targetVMName, newHostName);

  } finally {
    si.getServerConnection().logout();
  }
}
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
public static void HydraTask_migrateNetDownVM() throws Exception {
  SharedMap sMap = VMotionBB.getBB().getSharedMap();

  Boolean bool = (Boolean)sMap.get("connectionDropped");
  if (bool == null || !bool) {
    return;
  }

  initializeParams();
  if (!validateParams()) {
    return;
  }

  ServiceInstance si = new ServiceInstance(new URL(url), username, password,
      true);

  try {
    Folder rootFolder = si.getRootFolder();
    HostSystem newHost = (HostSystem)new InventoryNavigator(rootFolder)
        .searchManagedEntity("HostSystem", hostNames[0]);
    migrateVM(si, rootFolder, newHost, vmNames[0], hostNames[0], false, false);
  } finally {
    si.getServerConnection().logout();
  }
}
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
private Optional<ResourcePool> tryFindResourcePool(Folder folder, String hostname) {
   Iterable<ResourcePool> resourcePools = ImmutableSet.<ResourcePool>of();
   try {
      ManagedEntity[] resourcePoolEntities = new InventoryNavigator(folder).searchManagedEntities("ResourcePool");
      resourcePools = Iterables.transform(Arrays.asList(resourcePoolEntities), new Function<ManagedEntity, ResourcePool>() {
         public ResourcePool apply(ManagedEntity input) {
            return (ResourcePool) input;
         }
      });
      Optional<ResourcePool> optionalResourcePool = Iterables.tryFind(resourcePools, VSpherePredicate.isResourcePoolOf(hostname));
      return optionalResourcePool;
   } catch (Exception e) {
      logger.error("Problem in finding a valid resource pool", e);
   }
   return Optional.absent();
}
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
private void populateMetrics(Folder rootFolder, List<Map<String, Object>> hostConfigs, Map<Pattern, String> replacers, Integer hostThreads, Integer vmThreads) {

        List<ManagedEntity> hostEntities = getHostMachines(rootFolder, hostConfigs);

        if (logger.isDebugEnabled()) {
            logger.debug("Found " + hostEntities.size() + " hosts");
            StringBuilder sb = new StringBuilder();
            for (ManagedEntity managedEntity : hostEntities) {
                if (sb.length() > 0) {
                    sb.append(",");
                }
                sb.append(managedEntity.getName());
            }
            logger.debug("Host machines [ " + sb.toString() + " ]");
        }

        HostMetricCollector hostMetricCollector = new HostMetricCollector(configuration.getMetricWriter(), configuration.getMetricPrefix(), hostEntities, hostConfigs, replacers, hostThreads, vmThreads);
        hostMetricCollector.execute();
    }
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
private List<ManagedEntity> getHostMachines(Folder rootFolder, List<Map<String, Object>> hostConfigs) {
    List<ManagedEntity> hostEntities = new ArrayList<ManagedEntity>();

    for (Map<String, Object> hostConfig : hostConfigs) {
        String hostName = (String) hostConfig.get("host");
        try {
            if ("*".equals(hostName)) {
                hostEntities = Arrays.asList(new InventoryNavigator(rootFolder).searchManagedEntities("HostSystem"));
            } else {
                ManagedEntity hostSystem = new InventoryNavigator(rootFolder).searchManagedEntity("HostSystem", hostName);
                if (hostSystem != null) {
                    hostEntities.add(hostSystem);
                } else {
                    logger.error("Could not find Host with name " + hostName);
                }
            }
        } catch (InvalidProperty invalidProperty) {
            logger.error("Unable to get the host details", invalidProperty);
        } catch (RuntimeFault runtimeFault) {
            logger.error("Unable to get the host details", runtimeFault);
        } catch (RemoteException e) {
            logger.error("Unable to get the host details", e);
        }
    }
    return hostEntities;
}
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
private static void dummyVMotion(ServiceInstance si, Folder rootFolder,
    HostSystem newHost, String targetVMName, String newHostName) {
  log("Selected host [vm] for vMotion: " + newHostName + " [" + targetVMName
      + "]");
  try {Thread.sleep(120000);} catch(InterruptedException ir) {}
  log("vMotion of " + targetVMName + " to " + newHostName
      + " completed");
}
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
private static boolean migrateVM(ServiceInstance si, Folder rootFolder,
    HostSystem newHost, String targetVMName, String newHostName)
    throws Exception {

  log("Selected host [vm] for vMotion: " + newHostName + " [" + targetVMName
      + "]");
  VirtualMachine vm = (VirtualMachine)new InventoryNavigator(rootFolder)
      .searchManagedEntity("VirtualMachine", targetVMName);
  if (vm == null) {
    log(WARNING, "Could not resolve VM " + targetVMName + ", vMotion of this VM cannot be performed.");
    return false;
  }

  ComputeResource cr = (ComputeResource)newHost.getParent();

  String[] checks = new String[] { "cpu", "software" };
  HostVMotionCompatibility[] vmcs = si.queryVMotionCompatibility(vm,
      new HostSystem[] { newHost }, checks);

  String[] comps = vmcs[0].getCompatibility();
  if (checks.length != comps.length) {
    log(WARNING, "CPU/software NOT compatible, vMotion failed.");
    return false;
  }

  long start = System.currentTimeMillis();
  Task task = vm.migrateVM_Task(cr.getResourcePool(), newHost,
      VirtualMachineMovePriority.highPriority,
      VirtualMachinePowerState.poweredOn);
  if (task.waitForMe() == Task.SUCCESS) {
    long end = System.currentTimeMillis();
    log("vMotion of " + targetVMName + " to " + newHostName
        + " completed in " + (end - start) + "ms. Task result: "
        + task.getTaskInfo().getResult());
    return true;
  } else {
    TaskInfo info = task.getTaskInfo();
    log(WARNING, "vMotion of " + targetVMName + " to " + newHostName
        + " failed. Error details: " + info.getError().getFault());
    return false;
  }
}
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
private static boolean validateVMNotOnHost(ServiceInstance si,
    Folder rootFolder, HostSystem newHost, String vmName, String hostName)
    throws Exception {
  VirtualMachine[] vms = newHost.getVms();
  for (VirtualMachine vmac : vms) {
    if (vmac.getName().equals(vmName)) {
      Log.getLogWriter().info(
          vmName + " is already running on target host " + hostName
              + ". Selecting another pair...");
      return false;
    }
  }
  return true;
}
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
    ServiceInstance si = new ServiceInstance(new URL(
            "https://10.120.30.40/sdk"), "[email protected]",
            "Administrator!23", true);
    // Get the rootFolder
    Folder rootFolder = si.getRootFolder();

    // Get all the hosts in the vCenter server
    ManagedEntity[] hosts = new InventoryNavigator(rootFolder)
            .searchManagedEntities("HostSystem");

    if (hosts == null) {
        System.out.println("Host not found on vCenter");
        si.getServerConnection().logout();
        return;
    }

    // Map to store the datastore name as key and its UUID as the value
    Map< String , String> vmfsdatastoreUUIDs = new HashMap< String , String>();

    // Map to store host as key and all of its datastores as the value
    Map< ManagedEntity , Datastore[]> hostDatastores = new HashMap< ManagedEntity , Datastore[]>();
    for (ManagedEntity hostSystem : hosts) {
        HostDatastoreBrowser hdb = ((HostSystem) hostSystem)
                .getDatastoreBrowser();
        Datastore[] ds = hdb.getDatastores();
        hostDatastores.put(hostSystem, ds);
    }

    System.out.println("Hosts and all of its associated datastores");
    for (Map.Entry < ManagedEntity , Datastore[]> datastores : hostDatastores
            .entrySet()) {
        System.out.println("");
        System.out.print("[" + datastores.getKey().getName() + "::");
        for (Datastore datastore : datastores.getValue()) {
            System.out.print(datastore.getName() + ",");
            DatastoreInfo dsinfo = datastore.getInfo();
            if (dsinfo instanceof VmfsDatastoreInfo) {
                VmfsDatastoreInfo vdinfo = (VmfsDatastoreInfo) dsinfo;
                vmfsdatastoreUUIDs.put(datastore.getName(), vdinfo
                        .getVmfs().getUuid());
            }

        }
        System.out.print("]");
    }
    System.out.println(" ");
    System.out.println("Datastore and its UUID");
    for (Map.Entry< String , String> dsuuid : vmfsdatastoreUUIDs.entrySet()) {
        System.out.println("[" + dsuuid.getKey() + "::" + dsuuid.getValue()
                + "]");
    }
    si.getServerConnection().logout();

}
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
private Iterable<VirtualMachine> listNodes(VSphereServiceInstance instance) {
   Iterable<VirtualMachine> vms = ImmutableSet.of();
   try {
      Folder nodesFolder = instance.getInstance().getRootFolder();
      ManagedEntity[] managedEntities = new InventoryNavigator(nodesFolder).searchManagedEntities("VirtualMachine");
      vms = Iterables.transform(Arrays.asList(managedEntities), new Function<ManagedEntity, VirtualMachine>() {
         public VirtualMachine apply(ManagedEntity input) {
            return (VirtualMachine) input;
         }
      });
   } catch (Throwable e) {
      logger.error("Can't find vm", e);
   }
   return vms;
}
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
@Override
   public Iterable<VirtualMachine> listNodesByIds(Iterable<String> ids) {

      Iterable<VirtualMachine> vms = ImmutableSet.of();
      try (VSphereServiceInstance instance = serviceInstance.get();) {
         Folder nodesFolder = instance.getInstance().getRootFolder();
         List<List<String>> list = new ArrayList<List<String>>();
         Iterator<String> idsIterator = ids.iterator();

         while (idsIterator.hasNext()) {
            list.add(Lists.newArrayList("VirtualMachine", idsIterator.next()));
         }

         String[][] typeInfo = ListsUtils.ListToArray(list);

         ManagedEntity[] managedEntities = new InventoryNavigator(nodesFolder).searchManagedEntities(
                 typeInfo, true);
         vms = Iterables.transform(Arrays.asList(managedEntities), new Function<ManagedEntity, VirtualMachine>() {
            public VirtualMachine apply(ManagedEntity input) {
               return (VirtualMachine) input;
            }
         });
      } catch (Throwable e) {
         logger.error("Can't find vms ", e);
      }
      return vms;


//      Iterable<VirtualMachine> nodes = listNodes();
//      Iterable<VirtualMachine> selectedNodes = Iterables.filter(nodes, VSpherePredicate.isNodeIdInList(ids));
//      return selectedNodes;
   }
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
private VirtualMachine cloneMaster(VirtualMachine master, String tag, String name, VirtualMachineCloneSpec cloneSpec, String folderName) {

      VirtualMachine cloned = null;
      try {
         FolderNameToFolderManagedEntity toFolderManagedEntity = new FolderNameToFolderManagedEntity(serviceInstance, master);
         Folder folder = toFolderManagedEntity.apply(folderName);
         Task task = master.cloneVM_Task(folder, name, cloneSpec);
         String result = task.waitForTask();
         if (result.equals(Task.SUCCESS)) {
            logger.trace("<< after clone search for VM with name: " + name);
            Retryer<VirtualMachine> retryer = RetryerBuilder.<VirtualMachine>newBuilder()
                    .retryIfResult(Predicates.<VirtualMachine>isNull())
                    .withStopStrategy(StopStrategies.stopAfterAttempt(5))
                    .retryIfException().withWaitStrategy(WaitStrategies.fixedWait(1, TimeUnit.SECONDS))
                    .build();
            cloned = retryer.call(new GetVirtualMachineCallable(name, folder, serviceInstance.get().getInstance().getRootFolder()));
         } else {
            String errorMessage = task.getTaskInfo().getError().getLocalizedMessage();
            logger.error(errorMessage);
         }
      } catch (Exception e) {
         if (e instanceof NoPermission){
            NoPermission noPermission = (NoPermission)e;
            logger.error("NoPermission: " + noPermission.getPrivilegeId());
         }
         logger.error("Can't clone vm: " + e.toString(), e);
         propagate(e);
      }
      if (cloned == null)
         logger.error("<< Failed to get cloned VM. " + name);
      return checkNotNull(cloned, "cloned");
   }
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
private VirtualMachine getVMwareTemplate(String imageName, Folder rootFolder) {
   VirtualMachine image = null;
   try {
      VirtualMachine node = getVM(imageName, rootFolder);
      if (VSpherePredicate.isTemplatePredicate.apply(node))
         image = node;
   } catch (Exception e) {
      logger.error("cannot find an image called " + imageName, e);
      propagate(e);
   }
   return checkNotNull(image, "image with name " + imageName + " not found.");
}
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
@Override
public Folder apply(final String folderName) {
   try {
      if (Strings.isNullOrEmpty(folderName))
         return (Folder) master.getParent();
      VSphereServiceInstance instance = serviceInstance.get();
      ManagedEntity entity = new InventoryNavigator(instance.getInstance().getRootFolder()).searchManagedEntity("Folder", folderName);
      return (Folder) entity;
   } catch (Exception e) {
      logger.error("Problem in finding a valid Folder with name " + folderName, e);
   }
   return (Folder) master.getParent();
}
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
@Test
public void vSphereLocationSupplierTest() throws IOException {
   ServerConnection serverConnection = PowerMock.createMock(ServerConnection.class);
   WSClient wsClient = PowerMock.createMock(WSClient.class);
   ManagedObjectReference managedObjectReference = PowerMock.createMock(ManagedObjectReference.class);
   ServiceInstance serviceInstance = PowerMock.createMock(ServiceInstance.class);
   CreateAndConnectVSphereClient supplier = PowerMock.createMock(CreateAndConnectVSphereClient.class);
   VSphereServiceInstance vSphereServiceInstance = PowerMock.createMock(VSphereServiceInstance.class);
   Folder rootFolder = PowerMock.createMock(Folder.class);

   expect(supplier.get()).andReturn(vSphereServiceInstance);

   expect(vSphereServiceInstance.getInstance()).andReturn(serviceInstance);

   expect(serviceInstance.getRootFolder()).andReturn(rootFolder);

   expect(rootFolder.getServerConnection()).andReturn(serverConnection).anyTimes();
   expect(rootFolder.getMOR()).andReturn(managedObjectReference);
   expect(serverConnection.getServiceInstance()).andReturn(serviceInstance).anyTimes();
   expect(serverConnection.getVimService()).andReturn(new VimPortType(wsClient)).anyTimes();
   AboutInfo aboutInfo = new AboutInfo();
   aboutInfo.setApiVersion("5.1");
   expect(serviceInstance.getPropertyCollector()).andReturn(new PropertyCollector(serverConnection, managedObjectReference));
   expect(serviceInstance.getAboutInfo()).andReturn(aboutInfo);
   vSphereServiceInstance.close();
   replay(supplier, vSphereServiceInstance, serviceInstance, rootFolder, serverConnection);


   VSphereLocationSupplier vSphereLocationSupplier = new VSphereLocationSupplier(supplier);
   Set<? extends Location> location = vSphereLocationSupplier.get();

   Assert.assertEquals(1, location.size());
   for (Location l : location) {
      Assert.assertEquals("default", l.getId());
   }


   verify(supplier, vSphereServiceInstance, serviceInstance, rootFolder, serverConnection);
}
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
private <T extends ManagedEntity> T createEntity(Class<T> type, @Nullable ManagedEntity parent, String val, String name){
  final ManagedObjectReference mor = new ManagedObjectReference();
  mor.setType(type.getSimpleName());
  mor.setVal(val);
  if (type==Folder.class){
    return (T)new Folder(null, mor){
      @Override
      public ManagedEntity getParent() {
        return parent;
      }

      @Override
      public String getName() {
        return name;
      }
    };
  }
  if (type==ResourcePool.class){
    return (T)new ResourcePool(null, mor){
      @Override
      public ManagedEntity getParent() {
        return parent;
      }

      @Override
      public String getName() {
        return name;
      }
    };
  }
  throw new IllegalArgumentException("can't create instance of type " + type.getSimpleName());
}
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
public <T extends ManagedEntity> void setParent(final String parentName, Class<T> parentType) {
  if (parentType.isAssignableFrom(FakeDatacenter.class)){
    setParent(FakeModel.instance().getDatacenter(parentName));
  } else if (parentType.isAssignableFrom(Folder.class)){
    setParent(FakeModel.instance().getFolder(parentName));
  }
  if (myParent == null) {
    Assert.fail(String.format("Unable to set parent %s of type %s", parentName, parentType.getSimpleName()));
  }
}
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
protected String selectDatastore(VmwareProcessClient vmwareProcessClient, VmwareInstance vmwareInstance) {
    // データストアフォルダ内のデータストアのうち、アクセス可能で空き容量が最も大きいものを用いる
    Datastore datastore = null;
    long freeSpace = 0L;

    // ComputeResourceごとのフォルダがあれば、その中のデータストアを用いる
    String datastoreFolderName = vmwareInstance.getComputeResource() + "-storage";
    Folder datastoreFolder = vmwareProcessClient.getVmwareClient().search(Folder.class, datastoreFolderName);
    if (datastoreFolder == null) {
        // ComputeResourceごとのフォルダがなければ、"storage"フォルダの中のデータストアを用いる
        datastoreFolder = vmwareProcessClient.getVmwareClient().search(Folder.class, "storage");
    }

    if (datastoreFolder != null) {
        ManagedEntity[] entities = vmwareProcessClient.getVmwareClient().searchByType(datastoreFolder,
                Datastore.class);
        for (ManagedEntity entity : entities) {
            Datastore datastore2 = Datastore.class.cast(entity);
            DatastoreSummary summary2 = datastore2.getSummary();

            if (summary2.isAccessible() && freeSpace < summary2.getFreeSpace()) {
                datastore = datastore2;
                freeSpace = summary2.getFreeSpace();
            }
        }
    }

    if (datastore == null) {
        // 利用可能なデータストアがない場合
        throw new AutoException("EPROCESS-000528", vmwareInstance.getComputeResource());
    }

    return datastore.getName();
}
 

import com.vmware.vim25.mo.Folder; //导入依赖的package包/类
private void findHostsInFolder(Folder hostsFolder, List<HostSystem> hostsList)
        throws IOException, Exception {
    for (ManagedEntity e : hostsFolder.getChildEntity()) {
        if (e instanceof HostSystem) {
            hostsList.add((HostSystem)e);
        }

        // This is a cluster resource. Delve deeper to
        // find more hosts.
        if (e instanceof ComputeResource) {
            ComputeResource cr = (ComputeResource) e;
            if (e instanceof ClusterComputeResource) {
                ClusterComputeResource cluster = (ClusterComputeResource) e;
                if ((contrailClusterName != null) && 
                     (cluster.getName().equals(contrailClusterName) != true)) {
                   continue;
               }
            }
            for(HostSystem host : cr.getHosts()) {
                hostsList.add((HostSystem)host);
            }
        }

        if (e instanceof Folder) {
            findHostsInFolder((Folder)e, hostsList);
        }
    }
}