Vmware Vsphere WebService SDK开发（第一讲）-基本知识学习

刚开始这方面开发的时候，不知道如何下手，能够查到的资料特别少，而且看到很多网友和我一样也在找这方面的资料。接下来的一段时间我就结合自己所参与的项目，完成关于Vmware Vsphere WebService SDK开发的一系列教程（java），分享自己在Vmware开发过程中学习到的知识，希望能和大家一起进步。

今天先和大家学习下一些基本知识，我参考官方6.0英文文档，SDK版本：VMware-vSphere-SDK-6.0.0-2561048。

Managed Object: 代表服务端对象，在vSphere server(ESX/ESXi 或 vCenter Server system)上，代表着vSphere的服务和组件，都直接或间接继承自 ManagedEntity 抽象类。

Managed Object refereneces:代表客户端对服务端对象的引用，客户端应用程序通过使用ManagedObjectReference objects来向服务器发送请求操作。

Data objects:包含着关于managed objects的信息，你的客户端通过发送data objects和接收data objects与服务端进行通信(通过键值对的形式)。

图示为三者之间的关系：

接下来贴上认证、连接、断开vcenter server的代码(java)：这个代码在官方的例子中也有，直接拿过来用替换掉里面的url、username、password即可，代码可以直接运行。

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLSession;
import javax.xml.ws.BindingProvider;
import javax.xml.ws.soap.SOAPFaultException;

import com.vmware.vim25.ManagedObjectReference;
import com.vmware.vim25.ObjectContent;
import com.vmware.vim25.PropertyFilterSpec;
import com.vmware.vim25.RetrieveOptions;
import com.vmware.vim25.RetrieveResult;
import com.vmware.vim25.ServiceContent;
import com.vmware.vim25.VimPortType;
import com.vmware.vim25.VimService;

/** 
* @author Di
* @功能描述 服务器的连接、认证、断开
* @date 创建时间：2016年12月8日 下午3:37:18 
* @version 1.0   
*/
public class MoniterWsInterface
{
    private static String url = "";
    private static String userName = "";
    private static String password = "";

    private static final ManagedObjectReference SVC_INST_REF = new ManagedObjectReference();
    public static VimService vimService;
    public static VimPortType vimPort;

    public static ServiceContent serviceContent;
    private static final String SVC_INST_NAME = "ServiceInstance";
    private static Boolean isConnected = false;
    public static ManagedObjectReference perfManager;
    public static ManagedObjectReference propCollectorRef;

    private static class TrustAllTrustManager implements javax.net.ssl.TrustManager, javax.net.ssl.X509TrustManager
    {
        public java.security.cert.X509Certificate[] getAcceptedIssuers()
        {
            return null;
        }

        public boolean isServerTrusted(java.security.cert.X509Certificate[] certs)
        {
            return true;
        }

        public boolean isClientTrusted(java.security.cert.X509Certificate[] certs)
        {
            return true;
        }

        public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType) throws java.security.cert.CertificateException
        {
            return;
        }

        public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType) throws java.security.cert.CertificateException
        {
            return;
        }
    }

    private static void trustAllHttpsCertificates() throws Exception
    {
        javax.net.ssl.TrustManager[] trustAllCerts = new javax.net.ssl.TrustManager[1];
        javax.net.ssl.TrustManager tm = new TrustAllTrustManager();
        trustAllCerts[0] = tm;
        javax.net.ssl.SSLContext sc = javax.net.ssl.SSLContext.getInstance("SSL");
        javax.net.ssl.SSLSessionContext sslsc = sc.getServerSessionContext();
        sslsc.setSessionTimeout(0);
        sc.init(null, trustAllCerts, null);
        javax.net.ssl.HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
    }

    /**
     * @功能描述 连接认证
     */
    public static void connect() throws Exception
    {
        HostnameVerifier hv = new HostnameVerifier()
        {
            public boolean verify(String urlHostName, SSLSession session)
            {
                return true;
            }
        };
        trustAllHttpsCertificates();

        HttpsURLConnection.setDefaultHostnameVerifier(hv);

        SVC_INST_REF.setType(SVC_INST_NAME);
        SVC_INST_REF.setValue(SVC_INST_NAME);

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

        ctxt.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, url);
        ctxt.put(BindingProvider.SESSION_MAINTAIN_PROPERTY, true);

        serviceContent = vimPort.retrieveServiceContent(SVC_INST_REF);
        vimPort.login(serviceContent.getSessionManager(), userName, password, null);
        isConnected = true;

        perfManager = serviceContent.getPerfManager();
        propCollectorRef = serviceContent.getPropertyCollector();
        
        System.out.println(serviceContent.getAbout().getFullName());
        System.out.println("Server type is " + serviceContent.getAbout().getApiType());
    }

    /**
     * @功能描述 断开连接
     * @return
     * @throws Exception
     */
    public static void disconnect() throws Exception
    {
        if (isConnected)
        {
            vimPort.logout(serviceContent.getSessionManager());
        }
        isConnected = false;
    }

    /**
     * @功能描述 打印错误信息
     * @param
     * @param sfe
     */
    public static void printSoapFaultException(SOAPFaultException sfe)
    {
        System.out.println("Soap fault: ");
        if (sfe.getFault().hasDetail())
        {
            System.out.println(sfe.getFault().getDetail().getFirstChild().getLocalName());
        }
        if (sfe.getFault().getFaultString() != null)
        {
            System.out.println("Message: " + sfe.getFault().getFaultString());
        }
    }
        
    /**
     * @功能描述 根据属性检索要查询的对象信息
     * @param listpfs 属性过滤器集合
     * @throws Exception
     */
    public static List<ObjectContent> retrievePropertiesAllObjects(List<PropertyFilterSpec> listpfs) throws Exception
    {
        RetrieveOptions propObjectRetrieveOpts = new RetrieveOptions();
        List<ObjectContent> listobjcontent = new ArrayList<ObjectContent>();
        try
        {
            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());
                    }
                }
            }
        }
        catch (SOAPFaultException sfe)
        {
            printSoapFaultException(sfe);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

        return listobjcontent;
    }
    
    /**
     * @see main测试方法
     * */
    public static void main(String[] args)
    {
        new MoniterWsInterface();
        try
        {
            connect();
        }
        catch (SOAPFaultException sfe)
        {
            printSoapFaultException(sfe);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            try
            {
                disconnect();
            }
            catch (SOAPFaultException sfe)
            {
                printSoapFaultException(sfe);
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }
}

现在我们对Vcenter中涉及的三种数据类型有了一定的认识，接下来学习重要的清单遍历知识。

清单层次和servicetInstance：

Serviceinstance:Serviceinstance是清单根对象，从这里开始访问清单的各个层次，通常一个serviceinstance会绑定一个session，当开启session时，vsphere会创建一个具有rootFolder，和四个不同类型Folder的serviceInstance。

rootFolder：清单遍历根目录。

Datacenter：rootFolder下就是数据中心，数据中心可以创建多个，一个session会自带一个。

hostFolder(左一)：包含ComputeResource(计算资源)的目录，ComputeResource下还有HostSystem(主机)、ResourcePool(资源池)对象，如果想获取计算资源、主机、资源池、集群的对象及其信息，就需要通过此条路径遍历获取。

vmFolder(左二)：包含VirtualMachine(虚拟机)、VirtualApp(虚拟应用)，如果想获取虚拟机对象或虚拟机相关信息，就需要通过此遍历层次遍历获取。

networkFolder(右二)：包含Network(网络)，此条遍历路径便是获取Network的。

datastoreFolder(右一)：包含Datastore(数据存储)，通过此遍历路径获取和数据存储相关的所有信息。

 　　　　　　　　　　　　　　　　　　　　　　　　图一

访问具体清单元素的遍历路径：

从清单的根元素ServiceInstance开始，通过带有(Property collector)属性收集器的TraversalSpec和对象的属性确定对象在清单中的位置。

ServiceInstance具有content的属性：content属性是ServiceContent对象，serviceContent中包含很多重要的属性和服务的引用。

ServiceContent具有rootFolder属性：属性是rootFolder。

rootFolder有childEntity属性：属性指向的对象便是Datacenter(数据中心)。

Datacenter用于四个不同的Folder属性：分别指向四个不同的Folder对象，hostFolder、vmFolder、networkFolder、datastoreFolder(参照图一)。

每一个Folder对应childEntity属性：hostFolder对应ComputeResource等，vmFolder对象VirtualMachine等，networkFolder对应NetWork，datastoreFolder对应DataStore等。(可参考图一)

 前面讲了这么多清单遍历的知识，接下来就和大家演示下如何获取Datacenter对象及其属性，代码可以直接运行。

import java.util.ArrayList;
import java.util.List;

import javax.xml.ws.soap.SOAPFaultException;

import com.vmware.vim25.DynamicProperty;
import com.vmware.vim25.ManagedObjectReference;
import com.vmware.vim25.ObjectContent;
import com.vmware.vim25.ObjectSpec;
import com.vmware.vim25.PropertyFilterSpec;
import com.vmware.vim25.PropertySpec;
import com.vmware.vim25.SelectionSpec;
import com.vmware.vim25.TraversalSpec;

/** 
* @author Di
* @see 获取数据中心对象引用及name属性
* @date 创建时间：2016年12月8日 下午4:01:33 
* @version 1.0   
*/
public class GetDataCenter {
    
    /**
     * @see 获取遍历数据中心的TraversalSpec
     * @explain:清单遍历一定要结合清单遍历结构图。
     * @return TraversalSpec:清单遍历对象，明确属性收集的对象类型，同事提供对象遍历的路径。
     * */
    public static TraversalSpec getDatacenterTraversalSpec()  
    {  
        //SelectionSpec是TraversalSpec的一个引用。
        SelectionSpec sSpec = new SelectionSpec();  
        sSpec.setName("VisitFolders");  
        
        TraversalSpec traversalSpec = new TraversalSpec();  
        //给traversalSpec设置名称
        traversalSpec.setName("VisitFolders");    
        //从rootFolder开始遍历，rootFolder类型是Folder
        traversalSpec.setType("Folder");  
        //rootFolder拥有childEntity属性，清单结构图中指向的便是Datacenter
        traversalSpec.setPath("childEntity");
        //false表示不对其本身进行收集，只对其下对象进行收集
        traversalSpec.setSkip(false);
        //将sSpec添加到SelectionSpec集合中
        traversalSpec.getSelectSet().add(sSpec);  
        return traversalSpec;  
    }
    
    /**
     * @see 获取出所有的数据中心
     * @return retVal:数据中心对象引用list。
     * */
    public static List<ManagedObjectReference> getAllDatacenter()
    {
        List<ManagedObjectReference> retVal = new ArrayList<ManagedObjectReference>();
        //获取根目录对象引用
        ManagedObjectReference rootFolder = MoniterWsInterface.serviceContent.getRootFolder();
        try
        {
            TraversalSpec tSpec = getDatacenterTraversalSpec();
            
            /** 
             * ObjectSpec：定义对象详述，明确清单导航起始点。
             * obj:定义遍历起始对象为根目录rootFolder
             * true:表示只收集Datacenter的数据，不收集containerView的数据。
             * */
            ObjectSpec objectSpec = new ObjectSpec();
            objectSpec.setObj(rootFolder);
            objectSpec.setSkip(Boolean.TRUE);
            
            /** 添加 tSpec到 ObjectSpec.selectSet队列中 */
            objectSpec.getSelectSet().add(tSpec);

            /**
             * PropertySpec：定义一个属性收集器详述，明确收集的具体对象(Datacenter)和属性(Datacenter中的name，可以为多个)
             * Type:具体的对象类型为Datacenter
             * pathset:明确对象Datacenter中的属性，可以为多个。
             * */
            PropertySpec propertySpec = new PropertySpec();
            propertySpec.setAll(Boolean.FALSE);
            propertySpec.getPathSet().add("name");
            propertySpec.setType("Datacenter");
            
            /**
             * PropertyFilterSpec:定义一个属性过滤器详述，添加对象详述和属性收集器详述到过率中
             * */ 
            PropertyFilterSpec propertyFilterSpec = new PropertyFilterSpec();
            propertyFilterSpec.getPropSet().add(propertySpec);
            propertyFilterSpec.getObjectSet().add(objectSpec);

            /** 添加属性过滤器详述到属性过滤器集合中 */
            List<PropertyFilterSpec> listfps = new ArrayList<PropertyFilterSpec>(1);
            listfps.add(propertyFilterSpec);
            
            /** 调用方法获取ObjectContent对象集合 */
            List<ObjectContent> listobcont = MoniterWsInterface.retrievePropertiesAllObjects(listfps);

            if (listobcont != null)
            {
                for (ObjectContent oc : listobcont)
                {
                    //根据object对象获得MOR对象
                    ManagedObjectReference mr = oc.getObj();
                    
                    String dcnm = null;
                    //获取属性集合(此处只有一个name属性)
                    List<DynamicProperty> dps = oc.getPropSet();
                    if (dps != null)
                    {
                        for (DynamicProperty dp : dps)
                        {
                            //获取到具体的数据中心(Datacenter)的名称
                            dcnm = (String) dp.getVal();
                            //System.out.println("数据中心名称"+dcnm);
                            retVal.add(mr);
                        }
                    }
                }
            }
        }
        catch (SOAPFaultException sfe)
        {
            MoniterWsInterface.printSoapFaultException(sfe);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return retVal;
    }

    /**
     * @see 获取出所有的数据中心，和上面方法一样，只是最后返回值取得是Datacenter的属性name的值，而非Datacenter的对象引用。
     * @return retVal:数据中心名称list。
     * */
    public static List<String> getDatacenterName()
    {
        List<String> retVal = new ArrayList<String>();
        ManagedObjectReference rootFolder = MoniterWsInterface.serviceContent.getRootFolder();
        try
        {
            TraversalSpec tSpec = getDatacenterTraversalSpec();
            
            ObjectSpec objectSpec = new ObjectSpec();
            objectSpec.setObj(rootFolder);
            objectSpec.setSkip(Boolean.TRUE);
            objectSpec.getSelectSet().add(tSpec);
            
            PropertySpec propertySpec = new PropertySpec();
            propertySpec.setAll(Boolean.FALSE);
            propertySpec.getPathSet().add("name");
            propertySpec.setType("Datacenter");

            //添加对象和属性声明到 PropertyFilterSpec。 
            PropertyFilterSpec propertyFilterSpec = new PropertyFilterSpec();
            propertyFilterSpec.getPropSet().add(propertySpec);
            propertyFilterSpec.getObjectSet().add(objectSpec);

            List<PropertyFilterSpec> listfps = new ArrayList<PropertyFilterSpec>(1);
            listfps.add(propertyFilterSpec);
            
            List<ObjectContent> listobcont = MoniterWsInterface.retrievePropertiesAllObjects(listfps);

            if (listobcont != null)
            {
                for (ObjectContent oc : listobcont)
                {
                    //根据object对象获得MOR对象
                    ManagedObjectReference mr = oc.getObj();
                    
                    String dcnm = null;
                    List<DynamicProperty> dps = oc.getPropSet();
                    if (dps != null)
                    {
                        for (DynamicProperty dp : dps)
                        {
                            dcnm = (String) dp.getVal();
                            retVal.add(dcnm);
                        }
                    }
                }
            }
        }
        catch (SOAPFaultException sfe)
        {
            MoniterWsInterface.printSoapFaultException(sfe);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return retVal;
    }
    
    /**
     * @see main测试方法
     * */
    public static void main(String[] args) throws Exception {
        MoniterWsInterface moniterWsInterface = new MoniterWsInterface();
        moniterWsInterface.connect();
        
       /* List<ManagedObjectReference> allDatacenter = getAllDatacenter();
        for (ManagedObjectReference dataCenter : allDatacenter) {
            System.out.println(dataCenter.getType());
        }*/
        List<String> datacenterName = getDatacenterName();
        for (String name : datacenterName) {
            System.out.println(name);
        }
        moniterWsInterface.disconnect();
    }
}

今天的入门知识就先讲这么多，新手一定要先学习下文档掌握基本的知识，然后结合代码练手，这样的可以更快的掌握套路。

关于主机、虚拟机、存储、集群等等其他的操作，我会在之后的文章为大家呈现，敬请期待。如果对哪块资源的操作需求特别紧急，可以给我评论留言。