import com.vmware.vim25.VimPortType; //导入依赖的package包/类
/**
 * Deletes a managed object and waits for the delete operation to complete
 * 
 * @param vimPort
 * @param serviceContent
 * @param mor
 */
public static boolean deleteManagedEntity(VimPortType vimPort,
        ServiceContent serviceContent, ManagedObjectReference mor) {
    WaitForValues waitForValues = new WaitForValues(vimPort,
            serviceContent);
    System.out.println("Deleting : [" + mor.getValue() + "]");
    try {
        ManagedObjectReference taskmor = vimPort.destroyTask(mor);
        if (waitForValues.getTaskResultAfterDone(taskmor)) {
            System.out.println("Successful delete of Managed Entity - ["
                    + mor.getValue() + "]" + " and Entity Type - ["
                    + mor.getType() + "]");
            return true;
        } else {
            System.out
                    .println("Unable to delete : [" + mor.getValue() + "]");
            return false;
        }
    } catch (Exception e) {
        System.out.println("Unable to delete : [" + mor.getValue() + "]");
        System.out.println("Reason :" + e.getLocalizedMessage());
        return false;
    }
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
public static boolean createSnapshot(VimPortType vimPort,
        ServiceContent serviceContent, ManagedObjectReference vmMor,
        String snapshotname, String description) {
    WaitForValues waitForValues = new WaitForValues(vimPort,
            serviceContent);
    System.out.println("Taking snapshot : [" + snapshotname + "]");
    try {
        ManagedObjectReference taskMor = vimPort.createSnapshotTask(vmMor,
                snapshotname, description, false, false);
        if (waitForValues.getTaskResultAfterDone(taskMor)) {
            System.out.println("Snapshot - [" + snapshotname
                    + "] Creation Successful");
            return true;
        } else {
            System.out.println(
                    "Snapshot - [" + snapshotname + "] Creation Failed");
            return false;
        }
    } catch (Exception e) {
        System.out.println(
                "Snapshot - [" + snapshotname + "] Creation Failed");
        System.out.println("Reason :" + e.getLocalizedMessage());
        return false;
    }
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
/**
 * Sets the timeout for server connections.
 *
 * @param timeout the timeout to be used for connecting
 * @return true, if the operation was successful
 */
public boolean setTimeout(int timeout) {
    if (serviceInstance != null) {
        ServerConnection serverConnection = serviceInstance.getServerConnection();
        if (serverConnection != null) {
            VimPortType vimService = serverConnection.getVimService();
            if (vimService != null) {
                WSClient wsClient = vimService.getWsc();
                if (wsClient != null) {
                    wsClient.setConnectTimeout(timeout);
                    wsClient.setReadTimeout(timeout);
                    return true;
                }
            }
        }
    }
    return false;
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
/**
 * Sets the timeout for server connections.
 *
 * @param timeout the timeout to be used for connecting
 * @return true, if the operation was successful
 */
public boolean setTimeout(int timeout) {
    if (m_serviceInstance != null) {
        ServerConnection serverConnection = m_serviceInstance.getServerConnection();
        if (serverConnection != null) {
            VimPortType vimService = serverConnection.getVimService();
            if (vimService != null) {
                WSClient wsClient = vimService.getWsc();
                if (wsClient != null) {
                    wsClient.setConnectTimeout(timeout);
                    wsClient.setReadTimeout(timeout);
                    return true;
                }
            }
        }
    }
    return false;
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
protected TaskInfo getTaskInfo(VMwareClient vmw,
        VMPropertyHandler paramHandler) throws Exception {

    String instanceId = paramHandler.getInstanceName();
    String taskKey = paramHandler
            .getServiceSetting(VMPropertyHandler.TASK_KEY);
    logger.debug("VM: " + instanceId + " taskId: " + taskKey);
    if (taskKey == null || "".equals(taskKey)) {
        return null;
    }

    VimPortType service = vmw.getConnection().getService();
    ManagedObjectReference taskManager = vmw.getConnection()
            .getServiceContent().getTaskManager();
    ManagedObjectReference taskHistoryCollector = service
            .createCollectorForTasks(taskManager, new TaskFilterSpec());
    try {
        service.resetCollector(taskHistoryCollector);
        service.readNextTasks(taskHistoryCollector, 100);
        List<TaskInfo> taskList = vmw.getConnection().getService()
                .readPreviousTasks(taskHistoryCollector, 100);

        if (taskList != null) {
            for (TaskInfo taskInfo : taskList) {
                if (taskInfo != null && taskKey.equals(taskInfo.getKey())) {
                    logTaskInfo(taskInfo);
                    return taskInfo;
                }
            }
        }

        logger.error("Task not found. VM: " + instanceId + " taskId: "
                + taskKey);
        return null;
    } finally {
        service.destroyCollector(taskHistoryCollector);
    }
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
/**
 * Reconfigures VMware instance. Memory, CPU, disk space and network
 * adapter. The VM has been created and must be stopped to reconfigure the
 * hardware.
 */
public TaskInfo reconfigureVirtualMachine(VMPropertyHandler paramHandler)
        throws Exception {
    LOG.debug("instanceName: " + instanceName);

    VimPortType service = vmw.getConnection().getService();
    VirtualMachineConfigSpec vmConfigSpec = new VirtualMachineConfigSpec();

    vmConfigSpec
            .setMemoryMB(Long.valueOf(paramHandler.getConfigMemoryMB()));
    vmConfigSpec.setNumCPUs(Integer.valueOf(paramHandler.getConfigCPUs()));

    String reqUser = paramHandler
            .getServiceSetting(VMPropertyHandler.REQUESTING_USER);

    String comment = Messages.get(paramHandler.getLocale(), "vm_comment",
            new Object[] { paramHandler.getSettings().getOrganizationName(),
                    paramHandler.getSettings().getSubscriptionId(),
                    reqUser });
    String annotation = vmConfigSpec.getAnnotation();
    comment = updateComment(comment, annotation);
    vmConfigSpec.setAnnotation(comment);

    DiskManager diskManager = new DiskManager(vmw, paramHandler);
    diskManager.reconfigureDisks(vmConfigSpec, vmInstance);

    NetworkManager.configureNetworkAdapter(vmw, vmConfigSpec, paramHandler,
            vmInstance);

    LOG.debug("Call vSphere API: reconfigVMTask()");
    ManagedObjectReference reconfigureTask = service
            .reconfigVMTask(vmInstance, vmConfigSpec);

    return (TaskInfo) vmw.getServiceUtil()
            .getDynamicProperty(reconfigureTask, "info");
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
public TaskInfo updateCommentField(String comment) throws Exception {
    LOG.debug("instanceName: " + instanceName + " comment: " + comment);
    VimPortType service = vmw.getConnection().getService();
    VirtualMachineConfigSpec vmConfigSpec = new VirtualMachineConfigSpec();
    String annotation = vmConfigSpec.getAnnotation();
    comment = updateComment(comment, annotation);
    vmConfigSpec.setAnnotation(comment);
    LOG.debug("Call vSphere API: reconfigVMTask()");
    ManagedObjectReference reconfigureTask = service
            .reconfigVMTask(vmInstance, vmConfigSpec);

    return (TaskInfo) vmw.getServiceUtil()
            .getDynamicProperty(reconfigureTask, "info");
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
/**
 * Power off virtual machine
 */
public static void powerOffVM(final Connection connection, final VimPortType vimPort,
        final ManagedObjectReference vm) throws Exception {
    ManagedObjectReference powerTask = vimPort.powerOffVMTask(vm);
    TaskInfo info = VimUtils.waitTaskEnd(connection, powerTask);
    if (info.getState() == TaskInfoState.ERROR) {
        VimUtils.rethrow(info.getError());
    }
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
/**
 * Power on virtual machine
 */
public static void powerOnVM(final Connection connection, final VimPortType vimPort,
        final ManagedObjectReference vm) throws Exception {
    ManagedObjectReference powerTask = vimPort.powerOnVMTask(vm, null);
    TaskInfo info = VimUtils.waitTaskEnd(connection, powerTask);
    if (info.getState() == TaskInfoState.ERROR) {
        VimUtils.rethrow(info.getError());
    }
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
private static void powerOffVm(Connection connection, VimPortType vimPort,
        ManagedObjectReference vm) {
    try {
        powerOffVM(connection, vimPort, vm);
    } catch (Exception e) {
        // Ignore the error message. Don't log. Attempt with the rest of the flow.
    }
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
/**
 * Get access to the service content
 *
 * @param vimPortType
 * @return {@link ServiceContent}
 * @throws RuntimeFaultFaultMsg
 */
public static ServiceContent getServiceContent(VimPortType vimPortType)
        throws RuntimeFaultFaultMsg {
    // get the service content
    ManagedObjectReference serviceInstance = new ManagedObjectReference();
    serviceInstance.setType("ServiceInstance");
    serviceInstance.setValue("ServiceInstance");
    return vimPortType.retrieveServiceContent(serviceInstance);
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
/**
 * Uses the new RetrievePropertiesEx method to emulate the now deprecated
 * RetrieveProperties method.
 *
 * @param listpfs
 * @return list of object content
 * @throws Exception
 */
public static List<ObjectContent> retrievePropertiesAllObjects(
        VimPortType vimPort, ManagedObjectReference propCollectorRef,
        List<PropertyFilterSpec> listpfs)
        throws InvalidPropertyFaultMsg, RuntimeFaultFaultMsg {
    RetrieveOptions propObjectRetrieveOpts = new RetrieveOptions();
    List<ObjectContent> listobjcontent = new ArrayList<ObjectContent>();

    RetrieveResult rslts = vimPort.retrievePropertiesEx(propCollectorRef,
            listpfs, propObjectRetrieveOpts);
    if (rslts != null && rslts.getObjects() != null
            && !rslts.getObjects().isEmpty()) {
        listobjcontent.addAll(rslts.getObjects());
    }
    String token = null;
    if (rslts != null && rslts.getToken() != null) {
        token = rslts.getToken();
    }
    while (token != null && !token.isEmpty()) {
        rslts = vimPort.continueRetrievePropertiesEx(propCollectorRef,
                token);
        token = null;
        if (rslts != null) {
            token = rslts.getToken();
            if (rslts.getObjects() != null
                    && !rslts.getObjects().isEmpty()) {
                listobjcontent.addAll(rslts.getObjects());
            }
        }
    }

    return listobjcontent;
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
/**
 * Get the required properties of the specified object.
 *
 * @param vimPort
 * @param serviceContent
 * @param moRef
 * @param type
 * @param properties
 * @return
 * @throws RuntimeFaultFaultMsg
 * @throws InvalidPropertyFaultMsg
 */
public static List<DynamicProperty> getProperties(VimPortType vimPort,
        ServiceContent serviceContent, ManagedObjectReference moRef,
        String type, List<String> properties)
        throws RuntimeFaultFaultMsg, InvalidPropertyFaultMsg {
    // Create Property Spec
    PropertySpec propertySpec = new PropertySpec();
    propertySpec.setAll(false);
    propertySpec.setType(type);
    propertySpec.getPathSet().addAll(properties);

    // Now create Object Spec
    ObjectSpec objectSpec = new ObjectSpec();
    objectSpec.setObj(moRef);
    objectSpec.setSkip(false);

    // Create PropertyFilterSpec using the PropertySpec and ObjectPec
    // created above.
    PropertyFilterSpec propertyFilterSpec = new PropertyFilterSpec();
    propertyFilterSpec.getPropSet().add(propertySpec);
    propertyFilterSpec.getObjectSet().add(objectSpec);

    List<PropertyFilterSpec> listpfs = new ArrayList<PropertyFilterSpec>(1);
    listpfs.add(propertyFilterSpec);
    List<ObjectContent> listobjcontent = VimUtil
            .retrievePropertiesAllObjects(vimPort,
                    serviceContent.getPropertyCollector(), listpfs);
    assert listobjcontent != null && listobjcontent.size() > 0;
    ObjectContent contentObj = listobjcontent.get(0);
    List<DynamicProperty> objList = contentObj.getPropSet();
    return objList;
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
/**
 * builds an instance of this object
 * @param vimPort
 * @param serviceInstanceReference
 * @param interval
 */
public KeepAlive(final VimPortType vimPort, final ManagedObjectReference serviceInstanceReference, final Long interval) {
    this.vimPort = vimPort;
    this.serviceInstanceReference = serviceInstanceReference;
    this.interval = interval;
    this.running = Boolean.TRUE;
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
/**
 * given a hostname or IP address, returns the managed object ref for that host using
 * the connection fed to the constructor.
 * <p/>
 *
 * @param hostname
 * @return the matching managed object reference or null
 */
public ManagedObjectReference byName(String hostname) {
    ManagedObjectReference host = null;
    VimPortType vimPort = connection.getVimPort();
    ManagedObjectReference searchIndex = connection.getServiceContent().getSearchIndex();
    try {
        if (isIpAddress(hostname)) {
            final java.net.InetAddress inetAddress = address(hostname);
            final String ipAddress = ipAddress(inetAddress);
            if ("".equals(ipAddress)) {
                throw new GetHostRuntimeFault(String.format(
                        "could not properly verify '%s' as an IP address", hostname
                ));
            }
            // find by IP uses a subtly different method call, assuming you can resolve the IP
            // you could just use this method all the time... but you can't always reach a host
            // from your remote execution context ... and you may have the name.
            host = vimPort.findByIp(searchIndex, null, ipAddress, false);
        } else {
            // a host name could be anything in this scenario since we are talking about
            // a name that could potentially be an alias not actually reachable in our
            // local command-line context, we'll give it a shot and see if we find anything...
            host = vimPort.findByDnsName(searchIndex, null, hostname, false);
        }
    } catch (RuntimeFaultFaultMsg runtimeFaultFaultMsg) {
        throw new GetHostRuntimeFault(runtimeFaultFaultMsg);
    }

    return host;
}
 

import com.vmware.vim25.VimPortType; //导入依赖的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.VimPortType; //导入依赖的package包/类
/**
 * Uses the new RetrievePropertiesEx method to emulate the now deprecated
 * RetrieveProperties method
 *
 * @param propertyFilterSpecList
 * @return list of object content
 * @throws Exception
 */
private static List<ObjectContent> retrievePropertiesAllObjects(ConnectionResources connectionResources,
                                                               List<PropertyFilterSpec> propertyFilterSpecList)
        throws RuntimeFaultFaultMsg, InvalidPropertyFaultMsg {

    VimPortType vimPort = connectionResources.getVimPortType();
    ManagedObjectReference serviceInstance = connectionResources.getServiceInstance();
    ServiceContent serviceContent = vimPort.retrieveServiceContent(serviceInstance);
    ManagedObjectReference propertyCollectorReference = serviceContent.getPropertyCollector();
    RetrieveOptions propertyObjectRetrieveOptions = new RetrieveOptions();
    List<ObjectContent> objectContentList = new ArrayList<>();

    RetrieveResult results = vimPort.retrievePropertiesEx(propertyCollectorReference,
            propertyFilterSpecList,
            propertyObjectRetrieveOptions);

    if (results != null && results.getObjects() != null && !results.getObjects().isEmpty()) {
        objectContentList.addAll(results.getObjects());
    }

    String token = null;
    if (results != null && results.getToken() != null) {
        token = results.getToken();
    }

    while (token != null && !token.isEmpty()) {
        results = vimPort.continueRetrievePropertiesEx(propertyCollectorReference, token);
        token = null;
        if (results != null) {
            token = results.getToken();
            if (results.getObjects() != null && !results.getObjects().isEmpty()) {
                objectContentList.addAll(results.getObjects());
            }
        }
    }

    return objectContentList;
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
public ServiceConnection(VimPortType service, ServiceContent content) {
    this.service = service;
    this.content = content;
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
/**
 * Establish a connection to the vCenter.
 */
public void connect() throws Exception {
    // FIXME what to do?
    HostnameVerifier hv = new HostnameVerifier() {
        @Override
        public boolean verify(String urlHostName, SSLSession session) {
            return true;
        }
    };

    int numFailedLogins = 0;
    boolean repeatLogin = true;

    while (repeatLogin) {
        try {
            HttpsURLConnection.setDefaultHostnameVerifier(hv);

            VimService vimService = new VimService();
            VimPortType vimPort = vimService.getVimPort();
            Map<String, Object> ctxt = ((BindingProvider) vimPort)
                    .getRequestContext();

            ctxt.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, url);
            ctxt.put(BindingProvider.SESSION_MAINTAIN_PROPERTY,
                    Boolean.TRUE);

            ManagedObjectReference morSvcInstance = new ManagedObjectReference();
            morSvcInstance.setType("ServiceInstance");
            morSvcInstance.setValue("ServiceInstance");
            ServiceContent serviceContent = vimPort
                    .retrieveServiceContent(morSvcInstance);
            vimPort.login(serviceContent.getSessionManager(), user,
                    password, null);
            connection = new ServiceConnection(vimPort, serviceContent);
            LOG.debug("Established connection to vSphere. URL: " + url
                    + ", UserId: " + user);

            repeatLogin = false;
        } catch (Exception e) {
            LOG.error("Failed to establish connection to vSphere. URL: "
                    + url + ", UserId: " + user, e);
            if (numFailedLogins > 2) {
                throw e;
            }
            numFailedLogins++;
            repeatLogin = true;
            try {
                Thread.sleep(3000);
            } catch (@SuppressWarnings("unused") InterruptedException ex) {
                Thread.currentThread().interrupt();
            }
        }
    }
}
 

import com.vmware.vim25.VimPortType; //导入依赖的package包/类
public VimPortType getService() {
    return getConnection().getService();
}