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();
     }
 }

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

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