Java ManagedEntity类代码示例

import com.vmware.vim25.mo.ManagedEntity; //导入依赖的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.ManagedEntity; //导入依赖的package包/类
private Set<? extends Location> getClusters() {
   Set<Location> hosts = Sets.newHashSet();
   try (VSphereServiceInstance instance = serviceInstance.get();) {

      ManagedEntity[] clusterEntities = new InventoryNavigator(instance.getInstance().getRootFolder()).searchManagedEntities("ClusterComputeResource");

      for (ManagedEntity cluster : clusterEntities) {
         Location location = new LocationImpl(LocationScope.ZONE, cluster.getName(), cluster.getName(), null, ImmutableSet.of(""), Maps.<String, Object>newHashMap());
         hosts.add(location);
      }

      hosts.add(new LocationImpl(LocationScope.ZONE, "default", "default", null, ImmutableSet.of(""), Maps.<String, Object>newHashMap()));

      return hosts;
   } catch (Exception e) {
      logger.error("Problem in finding a valid cluster", e);
      Throwables.propagateIfPossible(e);
   }
   return hosts;
}
 

import com.vmware.vim25.mo.ManagedEntity; //导入依赖的package包/类
/**
 * TODO: メソッドコメントを記述
 *
 * @param vmwareProcessClient
 * @param networkNo
 * @param instanceNo
 */
public void addNetwork(VmwareProcessClient vmwareProcessClient, Long networkNo, Long instanceNo) {
    VmwareNetwork vmwareNetwork = vmwareNetworkDao.read(networkNo);

    // HostSystemを取得
    VmwareClient vmwareClient = vmwareProcessClient.getVmwareClient();
    ManagedEntity[] hostSystems;
    if (instanceNo == null) {
        hostSystems = vmwareClient.searchByType(HostSystem.class);
    } else {
        VmwareInstance vmwareInstance = vmwareInstanceDao.read(instanceNo);
        ComputeResource computeResource = vmwareClient.search(ComputeResource.class,
                vmwareInstance.getComputeResource());
        hostSystems = vmwareClient.searchByType(computeResource, HostSystem.class);
    }

    // ネットワークを追加
    for (ManagedEntity entity : hostSystems) {
        HostSystem hostSystem = HostSystem.class.cast(entity);
        vmwareProcessClient.addNetwork(hostSystem.getName(), vmwareNetwork.getNetworkName(),
                vmwareNetwork.getVlanId(), vmwareNetwork.getVswitchName());
    }
}
 

import com.vmware.vim25.mo.ManagedEntity; //导入依赖的package包/类
/**
 * TODO: メソッドコメントを記述
 *
 * @param vmwareProcessClient
 * @param networkNo
 * @param instanceNo
 */
public void removeNetwork(VmwareProcessClient vmwareProcessClient, Long networkNo, Long instanceNo) {
    VmwareNetwork vmwareNetwork = vmwareNetworkDao.read(networkNo);

    // HostSystemを取得
    VmwareClient vmwareClient = vmwareProcessClient.getVmwareClient();
    ManagedEntity[] hostSystems;
    if (instanceNo == null) {
        hostSystems = vmwareClient.searchByType(HostSystem.class);
    } else {
        VmwareInstance vmwareInstance = vmwareInstanceDao.read(instanceNo);
        ComputeResource computeResource = vmwareClient.search(ComputeResource.class,
                vmwareInstance.getComputeResource());
        hostSystems = vmwareClient.searchByType(computeResource, HostSystem.class);
    }

    // ネットワークを除去
    for (ManagedEntity entity : hostSystems) {
        HostSystem hostSystem = HostSystem.class.cast(entity);
        vmwareProcessClient.removeNetwork(hostSystem.getName(), vmwareNetwork.getNetworkName());
    }
}
 

import com.vmware.vim25.mo.ManagedEntity; //导入依赖的package包/类
static PerfQuerySpec createPerfQuerySpec(ManagedEntity me, 
      PerfMetricId[] metricIds, int maxSample, int interval)
  {
    PerfQuerySpec qSpec = new PerfQuerySpec();
    qSpec.setEntity(me.getMOR());
    // set the maximum of metrics to be return
    // only appropriate in real-time performance collecting
    qSpec.setMaxSample(new Integer(maxSample));
//    qSpec.setMetricId(metricIds);
    // optionally you can set format as "normal"
    qSpec.setFormat("csv");
    // set the interval to the refresh rate for the entity
    qSpec.setIntervalId(new Integer(interval));
 
    return qSpec;
  }
 

import com.vmware.vim25.mo.ManagedEntity; //导入依赖的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.ManagedEntity; //导入依赖的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.ManagedEntity; //导入依赖的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.ManagedEntity; //导入依赖的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.ManagedEntity; //导入依赖的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.ManagedEntity; //导入依赖的package包/类
private HostSystem getSystemHost() {
   Iterable<HostSystem> hosts = ImmutableSet.<HostSystem>of();
   try {
      VSphereServiceInstance instance = serviceInstance.get();
      ManagedEntity[] hostEntities = new InventoryNavigator(instance.getInstance().getRootFolder()).searchManagedEntities("HostSystem");
      hosts = Iterables.transform(Arrays.asList(hostEntities), new Function<ManagedEntity, HostSystem>() {
         public HostSystem apply(ManagedEntity input) {
            return (HostSystem) input;
         }
      });

      HostSystem curHostSystem = null;
      long maxMemory = Integer.MIN_VALUE;
      for (HostSystem hostSystem : hosts) {
         int currentMemory = hostSystem.getSummary().getQuickStats().getOverallMemoryUsage();
         long currentTotalMemory = hostSystem.getConfig().getSystemResources().getConfig().getMemoryAllocation().getLimit();
         if (currentTotalMemory - currentMemory > maxMemory) {
            curHostSystem = hostSystem;
            maxMemory = currentTotalMemory - currentMemory;
         }
      }

      return curHostSystem;
   } catch (Exception e) {
      logger.error("Problem in finding a valid host: " + e.toString(), e);
   }
   return null;
}
 

import com.vmware.vim25.mo.ManagedEntity; //导入依赖的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.ManagedEntity; //导入依赖的package包/类
@Nullable
   @Override
   public VSphereHost apply(@Nullable String dataCenter) {
      try (VSphereServiceInstance instance = serviceInstance.get();) {

         ManagedEntity[] clusterEntities = new InventoryNavigator(instance.getInstance().getRootFolder()).searchManagedEntities("ClusterComputeResource");
         Iterable<ClusterComputeResource> clusterComputeResources = Iterables.transform(Arrays.asList(clusterEntities), new Function<ManagedEntity, ClusterComputeResource>() {
            public ClusterComputeResource apply(ManagedEntity input) {
               return (ClusterComputeResource) input;
            }
         });

         HostSystem curHostSystem = null;
         for (ClusterComputeResource cluster : clusterComputeResources) {
            if (cluster.getName().equals(dataCenter) || dataCenter.equals("default")) {
               HostSystem[] hostSystems = cluster.getHosts();
               long maxMemory = Integer.MIN_VALUE;
               for (HostSystem hostSystem : hostSystems) {
                  int currentMemory = hostSystem.getSummary().getQuickStats().getOverallMemoryUsage();
                  long currentTotalMemory = hostSystem.getConfig().getSystemResources().getConfig().getMemoryAllocation().getLimit();
                  if (currentTotalMemory - currentMemory > maxMemory) {
                     curHostSystem = hostSystem;
                     maxMemory = currentTotalMemory - currentMemory;
                  }
               }
               break;
            }
         }
         return new VSphereHost(curHostSystem.getName(), serviceInstance.get());
//         return this.systemHostToVSphereHost.apply(curHostSystem);
      } catch (Exception e) {
         logger.error("Problem in finding a valid host: " + e.toString(), e);
      }
      return null;
   }
 

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

import com.vmware.vim25.mo.ManagedEntity; //导入依赖的package包/类
public VSphereHost(String hostName, VSphereServiceInstance serviceInstance) {
   this.serviceInstance = checkNotNull(serviceInstance, "serviceInstance");
   try {
      ManagedEntity hostEntity = new InventoryNavigator(serviceInstance.getInstance().getRootFolder()).searchManagedEntity("HostSystem", hostName);
      this.host = checkNotNull((HostSystem)hostEntity, "host");
   } catch (RemoteException e) {
      e.printStackTrace();
   }
}