knife-vcenter 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb5fd4c5ff94dae14a1fa45b1624ead2f0c89b04c130cd82fe59085b84e76b1c
-  data.tar.gz: 9c18082a34dfc47c62f67b8d7aa073a869ec4ee83c19fe0e141dab6e51552768
+  metadata.gz: f5b64c8898d3f062d865d4d8ec26728caca8e5477cd60b4bb94812ddb6631167
+  data.tar.gz: 76f8c566aa4eb7d027490f7d6d70fffd07a45a2944cc7d3d09b357be600e856f
 SHA512:
-  metadata.gz: ff27319d80c4ca3c0fc374c43f9deabfc7516a213ac2b7f6adb7b04a268a185044eb99a4324a36511a36ba8cc2bffc48c54dbd356b014d8b80fb0c67966d6a86
-  data.tar.gz: a5f2845785c5bf531a6a8119f4cda2a512f77d37ad490192c07d3b1907f78487f287ac9f06dc1b0db85b570cd0d00c8dfcbaf6c6a765041bd6ec7d6fe094bc4b
+  metadata.gz: cadd9cf60dab6043f285e45d19042de4e34409e71f904bcfe1791e3ed2a3e9619da7b2df5bf036eb2c1895dbc2de849cf421a40c685fff398c9f3add337072c0
+  data.tar.gz: a742b7f205341ae1f6e3d3fd5702fa83215f5c5e588f2fdf6d660bce5becd5a7fe89972bc82aa4bc13249235fdf42cf92e916102d3bf8b9223ebc39a4f8d2cd2

data/lib/chef/knife/cloud/vcenter_service.rb

@@ -21,19 +21,12 @@ require "chef/knife/cloud/exceptions"
 require "chef/knife/cloud/service"
 require "chef/knife/cloud/helpers"
 require "chef/knife/cloud/vcenter_service_helpers"
-require "net/http"
 require "uri"
 require "json"
 require "ostruct"
-require "lookup_service_helper"
-require "vapi"
-require "com/vmware/cis"
-require "com/vmware/vcenter"
-require "com/vmware/vcenter/vm"
-require "sso"
-require "base"
+require "vsphere-automation-cis"
+require "vsphere-automation-vcenter"
 require "set"
-require "support/clone_vm"
 
 class Chef
   # The main knife class
@@ -44,43 +37,30 @@ class Chef
       class VcenterService < Service
         include VcenterServiceHelpers
 
-        attr_reader :vapi_config, :session_svc, :session_id
+        attr_reader :api_client, :session_api, :session_id
         attr_reader :connection_options, :ipaddress
 
         def initialize(options = {})
           super(options)
 
-          # Using the information supplied, configure the connection to vCentre
-          lookup_service_helper = LookupServiceHelper.new(options[:host])
-
-          vapi_urls = lookup_service_helper.find_vapi_urls
-          vapi_url = vapi_urls.values[0]
-          Base.log.info(format("Vapi URL: %s", vapi_url)) if options[:vcenter_logs]
-
-          # Create the VAPI config object
-          ssl_options = {}
-          ssl_options[:verify] = if options[:verify_ssl]
-                                   :peer
-                                 else
-                                   Base.log.warn("SSL Verification is turned OFF") if options[:vcenter_logs]
-                                   :none
-                                 end
-          @vapi_config = VAPI::Bindings::VapiConfig.new(vapi_url, ssl_options)
-
-          # get the SSO url
-          sso_url = lookup_service_helper.find_sso_url
-          sso = SSO::Connection.new(sso_url).login(options[:username], options[:password])
-          token = sso.request_bearer_token
-          vapi_config.set_security_context(
-            VAPI::Security.create_saml_bearer_security_context(token.to_s)
-          )
-
-          # Login and get the session information
-          @session_svc = Com::Vmware::Cis::Session.new(vapi_config)
-          @session_id = session_svc.create
-          vapi_config.set_security_context(
-            VAPI::Security.create_session_security_context(session_id)
-          )
+          configuration = VSphereAutomation::Configuration.new.tap do |c|
+            c.host = options[:host]
+            c.username = options[:username]
+            c.password = options[:password]
+            c.scheme = "https"
+            c.verify_ssl = options[:verify_ssl]
+            c.verify_ssl_host = options[:verify_ssl]
+          end
+
+          Base.log.warn("SSL Verification is turned OFF") if options[:logs] && !options[:verify_ssl]
+
+          @api_client = VSphereAutomation::ApiClient.new(configuration)
+          api_client.default_headers["Authorization"] = configuration.basic_auth_token
+
+          session_api = VSphereAutomation::CIS::SessionApi.new(api_client)
+          session_id = session_api.create("").value
+
+          api_client.default_headers["vmware-api-session-id"] = session_id
 
           # Set the class properties for the rbvmomi connections
           @connection_options = {
@@ -96,7 +76,7 @@ class Chef
         # @param [Object] options to override anything you need to do
         def create_server(options = {})
           # Create the vm object
-          vmobj = Com::Vmware::Vcenter::VM.new(vapi_config)
+          vm_api = VSphereAutomation::VCenter::VMApi.new(api_client)
 
           # Use the option to determine now a new machine is being created
           case options[:type]
@@ -128,24 +108,24 @@ class Chef
           when "create"
 
             # Create the placement object
-            placementspec = Com::Vmware::Vcenter::VM::PlacementSpec.new
-            placementspec.folder = get_folder(options[:folder])
-            placementspec.host = get_host(options[:targethost])
-            placementspec.datastore = get_datastore(options[:datastore])
-            placementspec.resource_pool = get_resourcepool(options[:resource_pool])
+            placement_spec = VSphereAutomation::VCenter::VcenterVMPlacementSpec.new( ###
+              folder: get_folder(options[:folder]),
+              host: get_host(options[:targethost]).host,
+              datastore: get_datastore(options[:datastore]),
+              resource_pool: get_resourcepool(options[:resource_pool])
+            )
 
             # Create the CreateSpec object
-            createspec = Com::Vmware::Vcenter::VM::CreateSpec.new
-
-            createspec.name = options[:name]
-            puts "seting the OS"
-            createspec.guest_OS = Com::Vmware::Vcenter::Vm::GuestOS::UBUNTU_64
-            puts "setting the placement"
-            createspec.placement = placementspec
+            create_spec = VSphereAutomation::VCenter::VcenterVMCreateSpec.new(
+              name: options[:name],
+              guest_OS: VSphereAutomation::VCenter::VcenterVmGuestOS::OTHER,
+              placement: placement_spec
+            )
 
             # Create the new machine
             begin
-              vm = vmobj.create(createspec)
+              create_model = VSphereAutomation::VCenter::VcenterVMCreate.new(spec: create_spec)
+              vm = vm_api.create(create_model).value
             rescue StandardError => e
               puts e.message
             end
@@ -155,111 +135,112 @@ class Chef
         # Get a list of vms from the API
         #
         def list_servers
-          Com::Vmware::Vcenter::VM.new(vapi_config).list
+          vms = VSphereAutomation::VCenter::VMApi.new(api_client).list.value
+
+          # list_resource_command uses .send(:name) syntax, so convert to OpenStruct to keep it compatible
+          vms.map { |vmsummary| OpenStruct.new(vmsummary.to_hash) }
         end
 
         # Return a list of the hosts in the vCenter
         #
         def list_hosts
-          Com::Vmware::Vcenter::Host.new(vapi_config).list
+          VSphereAutomation::VCenter::HostApi.new(api_client).list.value
         end
 
         # Return a list of the datacenters in the vCenter
         #
         def list_datacenters
-          Com::Vmware::Vcenter::Datacenter.new(vapi_config).list
+          VSphereAutomation::VCenter::DatacenterApi.new(api_client).list.value
         end
 
         # Return a list of the clusters in the vCenter
         #
         def list_clusters
-          Com::Vmware::Vcenter::Cluster.new(vapi_config).list
+          VSphereAutomation::VCenter::ClusterApi.new(api_client).list.value
         end
 
         # Checks to see if the datacenter exists in the vCenter
         #
         # @param [String] name is the name of the datacenter
         def datacenter_exists?(name)
-          filter = Com::Vmware::Vcenter::Datacenter::FilterSpec.new(names: Set.new([name]))
-          dc_obj = Com::Vmware::Vcenter::Datacenter.new(vapi_config)
-          dc = dc_obj.list(filter)
+          dc_api = VSphereAutomation::VCenter::DatacenterApi.new(api_client)
+          dcs = dc_api.list({ filter_names: name }).value
 
-          raise format("Unable to find data center: %s", name) if dc.empty?
+          raise format("Unable to find data center: %s", name) if dcs.empty?
         end
 
         # Gets the folder
         #
         # @param [String] name is the folder of the datacenter
         def get_folder(name)
-          # Create a filter to ensure that only the named folder is returned
-          filter = Com::Vmware::Vcenter::Folder::FilterSpec.new(names: Set.new([name]))
-          # filter.names = name
-          folder_obj = Com::Vmware::Vcenter::Folder.new(vapi_config)
-          folder = folder_obj.list(filter)
+          folder_api = VSphereAutomation::VCenter::FolderApi.new(api_client)
+          folders = folder_api.list({ filter_names: name }).value
+
+          raise format("Unable to find folder: %s", name) if folders.empty?
 
-          folder[0].folder
+          folders.first.folder
         end
 
         # Gets the host
         #
         # @param [String] name is the host of the datacenter
         def get_host(name)
-          host_obj = Com::Vmware::Vcenter::Host.new(vapi_config)
+          # create a host object to work with
+          host_api = VSphereAutomation::VCenter::HostApi.new(api_client)
 
           if name.nil?
-            host = host_obj.list
+            hosts = host_api.list.value
           else
-            filter = Com::Vmware::Vcenter::Host::FilterSpec.new(names: Set.new([name]))
-            host = host_obj.list(filter)
+            hosts = host_api.list({ filter_names: name }).value
           end
 
-          host[0].host
+          raise format("Unable to find target host: %s", name) if hosts.empty?
+
+          hosts.first
         end
 
         # Gets the datastore
         #
         # @param [String] name is the datastore of the datacenter
         def get_datastore(name)
-          datastore_obj = Com::Vmware::Vcenter::Datastore.new(vapi_config)
+          ds_api = VSphereAutomation::VCenter::DatastoreApi.new(api_client)
+          ds = ds_api.list({ filter_names: name }).value
 
-          if name.nil?
-            datastore = datastore_obj.list
-          else
-            filter = Com::Vmware::Vcenter::Datastore::FilterSpec.new(names: Set.new([name]))
-            datastore = datastore_obj.list(filter)
-          end
-
-          datastore[0].datastore
+          raise format("Unable to find data store: %s", name) if ds.empty?
+          ds.first.datastore
         end
 
         # Gets the resource_pool
         #
         # @param [String] name is the resource_pool of the datacenter
-        def get_resource_pool(name)
-          # Create a resource pool object
-          rp_obj = Com::Vmware::Vcenter::ResourcePool.new(vapi_config)
+        def get_resourcepool(name)
+### verify
+          rp_api = VSphereAutomation::VCenter::ResourcePoolApi.new(api_client)
 
-          # If a name has been set then try to find it, otherwise use the first
-          # resource pool that can be found
           if name.nil?
-            resource_pool = rp_obj.list
+            # Remove default pool for first pass (<= 1.2.1 behaviour to pick first user-defined pool found)
+            resource_pools = rp_api.list.value.delete_if { |pool| pool.name == "Resources" }
+            puts "Search of all resource pools found: " + resource_pools.map { |pool| pool.name }.to_s
+
+            # Revert to default pool, if no user-defined pool found (> 1.2.1 behaviour)
+            # (This one might not be found under some circumstances by the statement above)
+            return get_resource_pool("Resources") if resource_pools.empty?
           else
-            # create a filter to find the named resource pool
-            filter = Com::Vmware::Vcenter::ResourcePool::FilterSpec.new(names: Set.new([name]))
-            resource_pool = rp_obj.list(filter)
-            raise format("Unable to find Resource Pool: %s", name) if resource_pool.nil?
+            resource_pools = rp_api.list({ filter_names: name }).value
+            puts "Search for resource pools found: " + resource_pools.map { |pool| pool.name }.to_s
           end
 
-          resource_pool[0].resource_pool
+          raise format("Unable to find Resource Pool: %s", name) if resource_pools.empty?
+
+          resource_pools.first.resource_pool
         end
 
         # Gets the server
         #
         # @param [String] name is the server of the datacenter
         def get_server(name)
-          filter = Com::Vmware::Vcenter::VM::FilterSpec.new(names: Set.new([name]))
-          vm_obj = Com::Vmware::Vcenter::VM.new(vapi_config)
-          vm_obj.list(filter)[0]
+          vm_api = VSphereAutomation::VCenter::VMApi.new(api_client)
+          vm_api.list({ filter_names: name }).value.first
         end
 
         # Deletes the VM
@@ -272,16 +253,16 @@ class Chef
 
           ui.confirm("Do you really want to be delete this virtual machine")
 
-          vm_obj = Com::Vmware::Vcenter::VM.new(vapi_config)
+          vm_api = VSphereAutomation::VCenter::VMApi.new(api_client)
 
           # check the power state of the machine, if it is powered on turn it off
-          if vm.power_state.value == "POWERED_ON"
-            power = Com::Vmware::Vcenter::Vm::Power.new(vapi_config)
+          if vm.power_state == "POWERED_ON"
+            power_api = VSphereAutomation::VCenter::VmPowerApi.new(api_client)
             ui.msg("Shutting down machine")
-            power.stop(vm.vm)
+            power_api.stop(vm.vm)
           end
 
-          vm_obj.delete(vm.vm)
+          vm_api.delete(vm.vm)
         end
 
         # Gets some server information

data/lib/chef/knife/vcenter_host_list.rb

@@ -58,8 +58,7 @@ class Chef
         #
         # @param [Object] status takes the number and formats it how you need it to
         def format_power_status(status)
-          status_check = status.value
-          status_color = case status_check
+          status_color = case status
                          when "POWERED_OFF"
                            :red
                          when "POWERED_ON"
@@ -68,7 +67,7 @@ class Chef
                            :yellow
                           end
 
-          ui.color(status.value, status_color)
+          ui.color(status, status_color)
         end
       end
     end

data/lib/chef/knife/vcenter_vm_list.rb

@@ -53,8 +53,7 @@ class Chef
         # Sets the color for the different status of the machines
         #
         def format_power_status(status)
-          status_check = status.value
-          status_color = case status_check
+          status_color = case status
                          when "POWERED_OFF"
                            :red
                          when "POWERED_ON"
@@ -63,7 +62,7 @@ class Chef
                            :yellow
                           end
 
-          ui.color(status.value, status_color)
+          ui.color(status, status_color)
         end
 
         # Formats the memory value

data/lib/knife-vcenter/version.rb

@@ -20,5 +20,5 @@
 # Provisions machines in vCenter
 module KnifeVcenter
   # The version of this amazing Gem, you should <3 it.
-  VERSION = "2.0.1"
+  VERSION = "2.0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knife-vcenter
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.2
 platform: ruby
 authors:
 - Chef Partner Engineering
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-28 00:00:00.000000000 Z
+date: 2019-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: knife-cloud
@@ -72,30 +72,30 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.6'
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.6'
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: debase
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -109,7 +109,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: ruby-debug-ide
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -123,19 +137,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: ruby-debug-ide
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: '3.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
 description: Knife plugin to VMware vCenter.
 email:
 - partnereng@chef.io
@@ -144,7 +172,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
-- lib/base.rb
 - lib/chef/knife/cloud/vcenter_service.rb
 - lib/chef/knife/cloud/vcenter_service_helpers.rb
 - lib/chef/knife/cloud/vcenter_service_options.rb
@@ -157,8 +184,6 @@ files:
 - lib/chef/knife/vcenter_vm_list.rb
 - lib/chef/knife/vcenter_vm_show.rb
 - lib/knife-vcenter/version.rb
-- lib/lookup_service_helper.rb
-- lib/sso.rb
 - lib/support/clone_vm.rb
 - spec/spec_helper.rb
 - spec/unit/vcenter_vm_list_spec.rb
@@ -174,7 +199,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/base.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-#
-# Author:: Chef Partner Engineering (<partnereng@chef.io>)
-# Copyright:: Copyright (c) 2017-2018 Chef Software, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "logger"
-
-# Base module for vcenter knife commands
-module Base
-  attr_accessor :log
-
-  # Creates the @log variable
-  #
-  def self.log
-    @log ||= init_logger
-  end
-
-  # Set the logger level by default
-  #
-  def self.init_logger
-    log = Logger.new(STDOUT)
-    log.progname = "Knife VCenter"
-    log.level = Logger::INFO
-    log
-  end
-end

data/lib/lookup_service_helper.rb

@@ -1,457 +0,0 @@
-# Copyright 2014-2017 VMware, Inc.  All Rights Reserved.
-# SPDX-License-Identifier: MIT
-
-require "savon"
-require "nokogiri"
-require "base"
-# require 'sample/framework/sample_base'
-
-# Utility class that helps use the lookup service.
-class LookupServiceHelper
-  attr_reader :sample, :wsdl_url, :soap_url
-  attr_reader :serviceRegistration
-
-  # Constructs a new instance.
-  # @param [Object] host the associated sample, which provides access
-  # to the configuration properties of the sample
-  def initialize(host)
-    @soap_url = format("https://%s/lookupservice/sdk", host)
-    @wsdl_url = format("https://%s/lookupservice/wsdl/lookup.wsdl", host)
-  end
-
-  # Connects to the lookup service.
-  def connect
-    rsc = RetrieveServiceContent.new(client).invoke
-    @serviceRegistration = rsc.get_service_registration
-    Base.log.info "service registration = #{serviceRegistration}"
-  end
-
-  # Finds the SSO service URL.
-  # In a MxN setup where there are more than one PSC nodes;
-  # This method returns the first SSO service endpoint URL
-  # as returned by the lookup service.
-  #
-  # @return [String] SSO Service endpoint URL.
-  def find_sso_url
-    result = find_service_url(product = "com.vmware.cis",
-                              service = "cs.identity",
-                              endpoint = "com.vmware.cis.cs.identity.sso",
-                              protocol = "wsTrust")
-    raise "SSO URL not found" unless result && !result.empty?
-
-    result.values[0]
-  end
-
-  # Finds all the vAPI service endpoint URLs.
-  # In a MxN setup where there are more than one management node;
-  # this method returns more than one URL
-  #
-  # @return [Hash] vapi service endpoint URLs in a dictionary
-  #     where the key is the node_id and the value is the service URL.
-  def find_vapi_urls
-    find_service_url(product = "com.vmware.cis",
-                     service = "cs.vapi",
-                     endpoint = "com.vmware.vapi.endpoint",
-                     protocol = "vapi.json.https.public")
-  end
-
-  # Finds the vapi service endpoint URL of a management node.
-  #
-  # @param node_id [String] The UUID of the management node.
-  # @return [String] vapi service endpoint URL of a management node or
-  #     nil if no vapi endpoint is found.
-  def find_vapi_url(node_id)
-    raise "node_id is required" if node_id.nil?
-
-    result = find_vapi_urls
-    raise "VAPI URLs not found" unless result && !result.empty?
-
-    result[node_id]
-  end
-
-  # Finds all the vim service endpoint URLs
-  # In a MxN setup where there are more than one management node;
-  # this method returns more than one URL
-  #
-  # @return [Hash] vim service endpoint URLs in a dictionary where
-  #     the key is the node_id and the value is the service URL.
-  def find_vim_urls
-    find_service_url(product = "com.vmware.cis",
-                     service = "vcenterserver",
-                     endpoint = "com.vmware.vim",
-                     protocol = "vmomi")
-  end
-
-  # Finds the vim service endpoint URL of a management node
-  #
-  # @param node_id [String] The UUID of the management node.
-  # @return [String] vim service endpoint URL of a management node or
-  #     nil if no vim endpoint is found.
-  def find_vim_url(node_id)
-    raise "node_id is required" if node_id.nil?
-
-    result = find_vim_urls
-    raise "VIM URLs not found" unless result && !result.empty?
-
-    result[node_id]
-  end
-
-  # Finds all the spbm service endpoint URLs
-  # In a MxN setup where there are more than one management node;
-  # this method returns more than one URL
-  #
-  # @return [Hash] spbm service endpoint URLs in a dictionary where
-  #     the key is the node_id and the value is the service URL.
-  def find_vim_pbm_urls
-    find_service_url(product = "com.vmware.vim.sms",
-                     service = "sms",
-                     endpoint = "com.vmware.vim.pbm",
-                     protocol = "https")
-  end
-
-  # Finds the spbm service endpoint URL of a management node
-  #
-  # @param node_id [String] The UUID of the management node.
-  # @return [String] spbm service endpoint URL of a management node or
-  #     nil if no spbm endpoint is found.
-  def find_vim_pbm_url(node_id)
-    raise "node_id is required" if node_id.nil?
-
-    result = find_vim_pbm_urls
-    raise "PBM URLs not found" unless result && !result.empty?
-
-    result[node_id]
-  end
-
-  # Get the management node id from the instance name
-  #
-  # @param instance_name [String] The instance name of the management node
-  # @return [String] The UUID of the management node or
-  #     nil is no management node is found by the given instance name
-  def get_mgmt_node_id(instance_name)
-    raise "instance_name is required" if instance_name.nil?
-    result = find_mgmt_nodes()
-    raise "Management nodes not found" unless result && result.size > 0
-    result[instance_name]
-  end
-
-  def get_mgmt_node_instance_name(node_id)
-    raise "node_id is required" if node_id.nil?
-
-    result = find_mgmt_nodes
-    raise "Management nodes not found" unless result && !result.empty?
-
-    result.each { |k, v| return k if v == node_id }
-    nil
-  end
-
-  # Finds the instance name and UUID of the management node for M1xN1 or
-  # when the PSC and management services all reside on a single node.
-  def get_default_mgmt_node
-    result = find_mgmt_nodes
-    raise "Management nodes not found" unless result && !result.empty?
-
-    # WHY: raise MultipleManagementNodeException.new if result.size > 1
-    [result.keys[0], result.values[0]]
-  end
-
-  # Finds all the management nodes
-  #
-  # @return [Hash] management node instance name and node id (UUID) in a dictionary.
-  def find_mgmt_nodes
-    # assert self.serviceRegistration is not None
-    list = List.new(client, "com.vmware.cis", "vcenterserver",
-                    "vmomi", "com.vmware.vim")
-
-    list.invoke
-    list.get_instance_names
-  end
-
-  private
-
-  # Finds a service URL with the given attributes.
-  def find_service_url(product, service, endpoint, protocol)
-    # assert serviceRegistration is not None
-    list = List.new(client, product, service, protocol, endpoint)
-
-    list.invoke
-    list.get_service_endpoints
-  end
-
-  # Gets or creates the Savon client instance.
-  def client
-    @client ||= Savon.client do |globals|
-      # see: http://savonrb.com/version2/globals.html
-      globals.wsdl wsdl_url
-      globals.endpoint soap_url
-
-      globals.strip_namespaces false
-      globals.env_namespace :S
-
-      # set like this so https connection does not fail
-      # TODO: find an acceptable solution for production
-      globals.ssl_verify_mode :none
-
-      # dev/debug settings
-      # globals.pretty_print_xml ENV['DEBUG_SOAP']
-      # globals.log ENV['DEBUG_SOAP']
-    end
-  end
-end
-
-# @abstract Base class for invocable service calls.
-class Invocable
-  attr_reader :operation, :client, :response
-
-  # Constructs a new instance.
-  # @param operation [Symbol] the operation name
-  # @param client [Savon::Client] the client
-  def initialize(operation, client)
-    @operation = operation
-    @client = client
-  end
-
-  # Invokes the service call represented by this type.
-  def invoke
-    request = request_xml.to_s
-    Base.log.debug(request)
-    @response = client.call(operation, xml: request)
-    Base.log.debug(response)
-    self # for chaining with new
-  end
-
-  # Builds the request XML content.
-  def request_xml
-    builder = Builder::XmlMarkup.new
-    builder.instruct!(:xml, encoding: "UTF-8")
-
-    builder.tag!("S:Envelope",
-                 "xmlns:S" => "http://schemas.xmlsoap.org/soap/envelope/") do |envelope|
-      envelope.tag!("S:Body") do |body|
-        body_xml(body)
-      end
-    end
-    builder.target!
-  end
-
-  # Builds the body portion of the request XML content.
-  # Specific service operations must override this method.
-  def body_xml
-    raise "abstract method not implemented!"
-  end
-
-  # Gets the response XML content.
-  def response_xml
-    raise "illegal state: response not set yet" if response.nil?
-
-    @response_xml ||= Nokogiri::XML(response.to_xml)
-  end
-
-  def response_hash
-    @response_hash ||= response.to_hash
-  end
-end
-
-# Encapsulates the list operation of the lookup service.
-class List < Invocable
-  # Constructs a new instance.
-  def initialize(client, product, service, protocol, endpoint)
-    super(:list, client)
-
-    @product = product
-    @service = service
-    @protocol = protocol
-    @endpoint = endpoint
-  end
-
-  #     <S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/">
-  #         <S:Body>
-  #             <List xmlns="urn:lookup">
-  #                 <_this type="LookupServiceRegistration">ServiceRegistration</_this>
-  #                 <filterCriteria>
-  #                     <serviceType>
-  #                         <product>com.vmware.cis</product>
-  #                         <type>cs.identity</type>
-  #                     </serviceType>
-  #                     <endpointType>
-  #                         <protocol>wsTrust</protocol>
-  #                         <type>com.vmware.cis.cs.identity.sso</type>
-  #                     </endpointType>
-  #                 </filterCriteria>
-  #             </List>
-  #         </S:Body>
-  #     </S:Envelope>
-  def body_xml(body)
-    body.tag!("List", "xmlns" => "urn:lookup") do |list|
-      # TODO: use the copy that was retrieved on startup?
-      list.tag!("_this",
-                "type" => "LookupServiceRegistration") do |this|
-        this << "ServiceRegistration"
-      end
-      list.tag!("filterCriteria") do |criteria|
-        criteria.tag!("serviceType") do |stype|
-          stype.tag!("product") do |p|
-            p << @product
-          end
-          stype.tag!("type") do |t|
-            t << @service
-          end
-        end
-        criteria.tag!("endpointType") do |etype|
-          etype.tag!("protocol") do |p|
-            p << @protocol
-          end
-          etype.tag!("type") do |t|
-            t << @endpoint
-          end
-        end
-      end
-    end
-  end
-
-  # Gets the service endpoint information from the response.
-  # Support for MxN.
-  # @return [Hash] a hash where the key is NodeId and the Value is a Service URL
-  def get_service_endpoints
-    result = {}
-    #     <ListResponse xmlns="urn:lookup">
-    #         <returnval>
-    #             <serviceVersion>2.0</serviceVersion>
-    #             <vendorNameResourceKey/>
-    #             <vendorNameDefault/>
-    #             <vendorProductInfoResourceKey/>
-    #             <vendorProductInfoDefault/>
-    #             <serviceEndpoints>
-    #                 <url>https://pa-rdinfra3-vm7-dhcp5583.eng.vmware.com/sts/STSService/vsphere.local</url>
-    #                 <endpointType>
-    #                     <protocol>wsTrust</protocol>
-    #                     <type>com.vmware.cis.cs.identity.sso</type>
-    #                 </endpointType>
-    #                 <sslTrust>
-    #                     ...
-    #                 </sslTrust>
-    #             </serviceEndpoints>
-    #             <serviceNameResourceKey/>
-    #             <serviceNameDefault/>
-    #             <serviceDescriptionResourceKey/>
-    #             <serviceDescriptionDefault/>
-    #             <ownerId>pa-rdinfra3-vm7-dhcp5583.eng.vmware.com@vsphere.local</ownerId>
-    #             <serviceType>
-    #                 <product>com.vmware.cis</product>
-    #                 <type>cs.identity</type>
-    #             </serviceType>
-    #             <nodeId/>
-    #             <serviceId>6a8a5058-5d3d-4d42-bb5e-383b91c8732e</serviceId>
-    #             <siteId>default-first-site</siteId>
-    #         </returnval>
-    #     </ListResponse>
-    Base.log.debug "List: response_hash = #{response_hash}"
-    return_val = response_hash[:list_response][:returnval]
-    return_val = [return_val] if return_val.is_a? Hash
-    return_val.each do |entry|
-      # FYI: the node_id is sometimes null, so use the service_id in this case
-      node_id = entry[:node_id] || entry[:service_id]
-      result[node_id] = entry[:service_endpoints][:url]
-    end
-    Base.log.debug "List: result = #{result}"
-    result
-  end
-
-  def get_instance_names
-    result = {}
-    #         <serviceAttributes>
-    #             <key>com.vmware.cis.cm.GroupInternalId</key>
-    #             <value>com.vmware.vim.vcenter</value>
-    #         </serviceAttributes>
-    #         <serviceAttributes>
-    #             <key>com.vmware.cis.cm.ControlScript</key>
-    #             <value>vmware-vpxd.sh</value>
-    #         </serviceAttributes>
-    #         <serviceAttributes>
-    #             <key>com.vmware.cis.cm.HostId</key>
-    #             <value>906477a1-24c6-4d48-9e99-55ef962878f7</value>
-    #         </serviceAttributes>
-    #         <serviceAttributes>
-    #             <key>com.vmware.vim.vcenter.instanceName</key>
-    #             <value>pa-rdinfra3-vm7-dhcp5583.eng.vmware.com</value>
-    #         </serviceAttributes>
-    Base.log.debug "List: response_hash = #{response_hash}"
-    return_val = response_hash[:list_response][:returnval]
-    return_val = [return_val] if return_val.is_a? Hash
-    return_val.each do |entry|
-      node_id = entry[:node_id]
-      # TODO: is it possible there be 0 or 1 attrs?  if so, deal with it.
-      attrs = entry[:service_attributes]
-      Base.log.debug "List: attrs=#{attrs}"
-      attrs.each do |attr|
-        if attr[:key] == "com.vmware.vim.vcenter.instanceName"
-          result[attr[:value]] = node_id
-        end
-      end
-    end
-    Base.log.debug "List: result = #{result}"
-    result
-  end
-end
-
-# Encapsulates the RetrieveServiceContent operation of the lookup service.
-class RetrieveServiceContent < Invocable
-  # Constructs a new instance.
-  def initialize(client)
-    super(:retrieve_service_content, client)
-  end
-
-  #     <S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/">
-  #         <S:Body>
-  #             <RetrieveServiceContent xmlns="urn:lookup">
-  #                 <_this type="LookupServiceInstance">ServiceInstance</_this>
-  #             </RetrieveServiceContent>
-  #         </S:Body>
-  #     </S:Envelope>
-  def body_xml(body)
-    body.tag!("RetrieveServiceContent", "xmlns" => "urn:lookup") do |rsc|
-      rsc.tag!("_this", "type" => "LookupServiceInstance") do |this|
-        this << "ServiceInstance"
-      end
-    end
-  end
-
-  #     ...
-  #         <RetrieveServiceContentResponse xmlns="urn:lookup">
-  #             <returnval>
-  #                 <lookupService type="LookupLookupService">lookupService</lookupService>
-  #                 <serviceRegistration type="LookupServiceRegistration">ServiceRegistration</serviceRegistration>
-  #                 <deploymentInformationService type="LookupDeploymentInformationService">deploymentInformationService</deploymentInformationService>
-  #                 <l10n type="LookupL10n">l10n</l10n>
-  #             </returnval>
-  #         </RetrieveServiceContentResponse>
-  #     ...
-  def get_service_registration
-    Base.log.debug "RetrieveServiceContent: response_hash = #{response_hash}"
-    return_val = response_hash[:retrieve_service_content_response][:returnval]
-    result = return_val[:service_registration]
-    Base.log.debug "RetrieveServiceContent: result = #{result}"
-    result
-  end
-end
-
-class MultipleManagementNodeException < RuntimeError
-end
-
-# main: quick self tester
-if $PROGRAM_NAME == __FILE__
-  Base.log.level = Logger::DEBUG if ENV["DEBUG"]
-  sample = SelfTestSample.new
-  sample.ls_ip = ARGV[0] || "10.67.245.207"
-  # MXN: sample.ls_ip = '10.160.42.83'
-  # MXN: sample.ls_ip = '10.160.35.191'
-  # MAYBE: sample.main() # for arg parsing
-  ls_helper = LookupServiceHelper.new(sample)
-  ls_helper.connect
-  puts "***************************************"
-  puts "SSO URL: #{ls_helper.find_sso_url}"
-  puts "VAPI URL: #{ls_helper.find_vapi_urls}"
-  puts "VIM URL: #{ls_helper.find_vim_urls}"
-  puts "PBM URL: #{ls_helper.find_vim_pbm_urls}"
-  puts "Mgmt Nodes: #{ls_helper.find_mgmt_nodes}"
-end

data/lib/sso.rb

@@ -1,264 +0,0 @@
-# Copyright 2014-2017 VMware, Inc.  All Rights Reserved.
-# SPDX-License-Identifier: MIT
-
-require "savon"
-require "nokogiri"
-require "date"
-require "securerandom"
-
-# A little utility library for VMware SSO.
-# For now, this is not a general purpose library that covers all
-# the interfaces of the SSO service.
-# Specifically, the support is limited to the following:
-# * request bearer token.
-module SSO
-  # The XML date format.
-  DATE_FORMAT = "%FT%T.%LZ".freeze
-
-  # The XML namespaces that are required: SOAP, WSDL, et al.
-  NAMESPACES = {
-    "xmlns:S" => "http://schemas.xmlsoap.org/soap/envelope/",
-    "xmlns:wst" => "http://docs.oasis-open.org/ws-sx/ws-trust/200512",
-    "xmlns:u" => "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd",
-    "xmlns:x" => "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd",
-  }.freeze
-
-  # Provides the connection details for the SSO service.
-  class Connection
-    attr_accessor :sso_url, :wsdl_url, :username, :password
-
-    # Creates a new instance.
-    def initialize(sso_url, wsdl_url = nil)
-      self.sso_url = sso_url
-      self.wsdl_url = wsdl_url || "#{sso_url}?wsdl"
-    end
-
-    # Login with the given credentials.
-    # Note: this does not invoke a login action, but rather stores the
-    # credentials for use later.
-    def login(username, password)
-      self.username = username
-      self.password = password
-      self # enable builder pattern
-    end
-
-    # Gets (or creates) the Savon client instance.
-    def client
-      # construct and init the client proxy
-      @client ||= Savon.client do |globals|
-        # see: http://savonrb.com/version2/globals.html
-        globals.wsdl wsdl_url
-        globals.endpoint sso_url
-
-        globals.strip_namespaces false
-        globals.env_namespace :S
-
-        # set like this so https connection does not fail
-        # TODO: find an acceptable solution for production
-        globals.ssl_verify_mode :none
-
-        # dev/debug settings
-        # globals.pretty_print_xml ENV['DEBUG_SOAP']
-        # globals.log ENV['DEBUG_SOAP']
-      end
-    end
-
-    # Invokes the request bearer token operation.
-    # @return [SamlToken]
-    def request_bearer_token
-      rst = RequestSecurityToken.new(client, username, password)
-      rst.invoke
-      rst.saml_token
-    end
-  end
-
-  # @abstract Base class for invocable service calls.
-  class SoapInvocable
-    attr_reader :operation, :client, :response
-
-    # Constructs a new instance.
-    # @param operation [Symbol] the SOAP operation name (in Symbol form)
-    # @param client [Savon::Client] the client
-    def initialize(operation, client)
-      @operation = operation
-      @client = client
-    end
-
-    # Invokes the service call represented by this type.
-    def invoke
-      request = request_xml.to_s
-      puts "request = #{request}" if ENV["DEBUG"]
-      @response = client.call(operation, xml: request)
-      puts "response = #{response}" if ENV["DEBUG"]
-      self # for chaining with new
-    end
-
-    # Builds the request XML content.
-    def request_xml
-      builder = Builder::XmlMarkup.new
-      builder.instruct!(:xml, encoding: "UTF-8")
-
-      builder.tag!("S:Envelope", NAMESPACES) do |envelope|
-        if has_header?
-          envelope.tag!("S:Header") do |header|
-            header_xml(header)
-          end
-        end
-        envelope.tag!("S:Body") do |body|
-          body_xml(body)
-        end
-      end
-      builder.target!
-    end
-
-    def has_header?
-      true
-    end
-
-    # Builds the header portion of the SOAP request.
-    # Specific service operations must override this method.
-    def header_xml(_header)
-      raise "abstract method not implemented!"
-    end
-
-    # Builds the body portion of the SOAP request.
-    # Specific service operations must override this method.
-    def body_xml(_body)
-      raise "abstract method not implemented!"
-    end
-
-    # Gets the response XML content.
-    def response_xml
-      raise "illegal state: response not set yet" if response.nil?
-
-      @response_xml ||= Nokogiri::XML(response.to_xml)
-    end
-
-    def response_hash
-      @response_hash ||= response.to_hash
-    end
-  end
-
-  # Encapsulates an issue operation that requests a security token
-  # from the SSO service.
-  class RequestSecurityToken < SoapInvocable
-    attr_accessor :request_type, :delegatable
-
-    # Constructs a new instance.
-    def initialize(client, username, password, hours = 2)
-      super(:issue, client)
-
-      @username = username
-      @password = password
-      @hours = hours
-
-      # TODO: these things should be configurable, so we can get
-      # non-delegatable tokens, HoK tokens, etc.
-      @request_type = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Issue"
-      @delegatable = true
-    end
-
-    def now
-      @now ||= Time.now.utc.to_datetime
-    end
-
-    def created
-      @created ||= now.strftime(DATE_FORMAT)
-    end
-
-    def future
-      @future ||= now + (2 / 24.0) # days (for DateTime math)
-    end
-
-    def expires
-      @expires ||= future.strftime(DATE_FORMAT)
-    end
-
-    # Builds the header XML for the SOAP request.
-    def header_xml(header)
-      id = "uuid-" + SecureRandom.uuid
-
-      # header.tag!("x:Security", "x:mustUnderstand" => "1") do |security|
-      header.tag!("x:Security") do |security|
-        security.tag!("u:Timestamp", "u:Id" => "_0") do |timestamp|
-          timestamp.tag!("u:Created") do |element|
-            element << created
-          end
-          timestamp.tag!("u:Expires") do |element|
-            element << expires
-          end
-        end
-        security.tag!("x:UsernameToken", "u:Id" => id) do |utoken|
-          utoken.tag!("x:Username") do |element|
-            element << @username
-          end
-          utoken.tag!("x:Password") do |element|
-            element << @password
-          end
-        end
-      end
-    end
-
-    # Builds the body XML for the SOAP request.
-    def body_xml(body)
-      body.tag!("wst:RequestSecurityToken") do |rst|
-        rst.tag!("wst:RequestType") do |element|
-          element << request_type
-        end
-        rst.tag!("wst:Delegatable") do |element|
-          element << delegatable.to_s
-        end
-        #                 #TODO: we don't seem to need this, but I'm leaving this
-        #                 #here for now as a reminder.
-        #                 rst.tag!("wst:Lifetime") do |lifetime|
-        #                     lifetime.tag!("u:Created") do |element|
-        #                         element << created
-        #                     end
-        #                     lifetime.tag!("u:Expires") do |element|
-        #                         element << expires
-        #                     end
-        #                 end
-      end
-    end
-
-    # Gets the saml_token from the SOAP response body.
-    # @return [SamlToken] the requested SAML token
-    def saml_token
-      assertion = response_xml.at_xpath("//saml2:Assertion",
-                                        "saml2" => "urn:oasis:names:tc:SAML:2.0:assertion")
-      SamlToken.new(assertion)
-    end
-  end
-
-  # Holds a SAML token.
-  class SamlToken
-    attr_reader :xml
-
-    # Creates a new instance.
-    def initialize(xml)
-      @xml = xml
-    end
-
-    # TODO: add some getters for interesting content
-
-    def to_s
-      esc_token = xml.to_xml(indent: 0, encoding: "UTF-8")
-      esc_token = esc_token.delete("\n")
-      esc_token
-    end
-  end
-end
-
-# main: quick self tester
-if $PROGRAM_NAME == __FILE__
-  cloudvm_ip = ARGV[0]
-  cloudvm_ip ||= "10.20.17.0"
-  # cloudvm_ip ||= "10.67.245.207"
-  sso_url = "https://#{cloudvm_ip}/sts/STSService/vsphere.local"
-  wsdl_url = "#{sso_url}?wsdl"
-  sso = SSO::Connection.new(sso_url, wsdl_url)
-  # sso.login("administrator@vsphere.local", "Admin!23")
-  sso.login("root", "vmware")
-  token = sso.request_bearer_token
-  puts token.to_s
-end