knife-vcenter 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 98d04aca8b51b9eb519891ee0932d9ab1f51c744
-  data.tar.gz: f1e973fc0d6b65de7a65cabebafd47c7954e81dd
+SHA256:
+  metadata.gz: bb5fd4c5ff94dae14a1fa45b1624ead2f0c89b04c130cd82fe59085b84e76b1c
+  data.tar.gz: 9c18082a34dfc47c62f67b8d7aa073a869ec4ee83c19fe0e141dab6e51552768
 SHA512:
-  metadata.gz: 3d7aa9eaa280b57fb02b04ad5eb009e42554c19a0df9fdb4abd9a4684bdad894e281c7874895dfc4a1798e40e76972e115ddc99eac1babb49c82453283f765ea
-  data.tar.gz: b0e840bd91752be7542b2c13a7bfe5731b479e7cfb77d39c459876cd047de29a91e0c53e30f6f6b6db2a3a8a7d6a3b6df4b4c77a78875ca5c517fb7082a45a23
+  metadata.gz: ff27319d80c4ca3c0fc374c43f9deabfc7516a213ac2b7f6adb7b04a268a185044eb99a4324a36511a36ba8cc2bffc48c54dbd356b014d8b80fb0c67966d6a86
+  data.tar.gz: a5f2845785c5bf531a6a8119f4cda2a512f77d37ad490192c07d3b1907f78487f287ac9f06dc1b0db85b570cd0d00c8dfcbaf6c6a765041bd6ec7d6fe094bc4b

data/lib/base.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 #
 # Author:: Chef Partner Engineering (<partnereng@chef.io>)
-# Copyright:: Copyright (c) 2017 Chef Software, Inc.
+# Copyright:: Copyright (c) 2017-2018 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,18 +17,23 @@
 # limitations under the License.
 #
 
-require 'logger'
+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.progname = "Knife VCenter"
     log.level = Logger::INFO
     log
   end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 #
 # Author:: Chef Partner Engineering (<partnereng@chef.io>)
-# Copyright:: Copyright (c) 2017 Chef Software, Inc.
+# Copyright:: Copyright (c) 2017-2018 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,64 +17,67 @@
 # limitations under the License.
 #
 
-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 'set'
-require 'support/clone_vm'
+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 "set"
+require "support/clone_vm"
 
 class Chef
+  # The main knife class
   class Knife
+    # The main cloud class from knife-cloud
     class Cloud
+      # Extends the Service method, this is the bulk of the integration
       class VcenterService < Service
         include VcenterServiceHelpers
 
         attr_reader :vapi_config, :session_svc, :session_id
         attr_reader :connection_options, :ipaddress
 
-        def initialize(options={})
+        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_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]
+          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]
+                                   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_url = lookup_service_helper.find_sso_url
           sso = SSO::Connection.new(sso_url).login(options[:username], options[:password])
-          token = sso.request_bearer_token()
+          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()
+          @session_id = session_svc.create
           vapi_config.set_security_context(
             VAPI::Security.create_session_security_context(session_id)
           )
@@ -88,8 +91,10 @@ class Chef
           }
         end
 
-        def create_server(options={})
-
+        # Creates the server
+        #
+        # @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)
 
@@ -99,21 +104,23 @@ class Chef
 
             datacenter_exists?(options[:datacenter])
 
-            # Some of ht eoptions need to be the ID of the component in VMWAre
+            # Some of ht eoptions need to be the ID of the component in VMware
             # Update these using the REST API so that they can be passed to the support library
             options[:targethost] = get_host(options[:targethost])
 
             options[:resource_pool] = get_resource_pool(options[:resource_pool])
 
             # Configure the folder option as a has with the name an the id
-            options[:folder] = {
-              name: options[:folder],
-              id: get_folder(options[:folder])
-            } unless options[:folder].nil?
+            unless options[:folder].nil?
+              options[:folder] = {
+                name: options[:folder],
+                id: get_folder(options[:folder]),
+              }
+            end
 
             # Clone the machine using the support library
             clone_obj = Support::CloneVm.new(connection_options, options)
-            @ipaddress = clone_obj.clone()
+            @ipaddress = clone_obj.clone
 
             # return an object from the restapi
             return get_server(options[:name])
@@ -121,16 +128,16 @@ class Chef
           when "create"
 
             # Create the placement object
-            placementspec = Com::Vmware::Vcenter::VM::PlacementSpec.new()
+            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])
 
             # Create the CreateSpec object
-            createspec = Com::Vmware::Vcenter::VM::CreateSpec.new()
+            createspec = Com::Vmware::Vcenter::VM::CreateSpec.new
 
-            createspec.name = options[:name]#
+            createspec.name = options[:name]
             puts "seting the OS"
             createspec.guest_OS = Com::Vmware::Vcenter::Vm::GuestOS::UBUNTU_64
             puts "setting the placement"
@@ -139,41 +146,53 @@ class Chef
             # Create the new machine
             begin
               vm = vmobj.create(createspec)
-            rescue => e
+            rescue StandardError => e
               puts e.message
             end
           end
         end
 
+        # Get a list of vms from the API
+        #
         def list_servers
-          # get a list of vms from the API
-          Com::Vmware::Vcenter::VM.new(vapi_config).list()
+          Com::Vmware::Vcenter::VM.new(vapi_config).list
         end
 
+        # Return a list of the hosts in the vCenter
+        #
         def list_hosts
-          # return a list of the hosts in the vcenter
-          Com::Vmware::Vcenter::Host.new(vapi_config).list()
+          Com::Vmware::Vcenter::Host.new(vapi_config).list
         end
 
+        # Return a list of the datacenters in the vCenter
+        #
         def list_datacenters
-          Com::Vmware::Vcenter::Datacenter.new(vapi_config).list()
+          Com::Vmware::Vcenter::Datacenter.new(vapi_config).list
         end
 
+        # Return a list of the clusters in the vCenter
+        #
         def list_clusters
-          Com::Vmware::Vcenter::Cluster.new(vapi_config).list()
+          Com::Vmware::Vcenter::Cluster.new(vapi_config).list
         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)
-  
-          raise format('Unable to find data center: %s', name) if dc.empty?
+
+          raise format("Unable to find data center: %s", name) if dc.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 = 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)
@@ -181,32 +200,41 @@ class Chef
           folder[0].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)
 
           if name.nil?
             host = host_obj.list
           else
-            filter = Com::Vmware::Vcenter::Host::FilterSpec.new({names: Set.new([name])})
+            filter = Com::Vmware::Vcenter::Host::FilterSpec.new(names: Set.new([name]))
             host = host_obj.list(filter)
           end
 
           host[0].host
         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)
 
           if name.nil?
             datastore = datastore_obj.list
           else
-            filter = Com::Vmware::Vcenter::Datastore::FilterSpec.new({names: Set.new([name])})
+            filter = Com::Vmware::Vcenter::Datastore::FilterSpec.new(names: Set.new([name]))
             datastore = datastore_obj.list(filter)
           end
 
           datastore[0].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)
@@ -219,71 +247,79 @@ class Chef
             # 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?
+            raise format("Unable to find Resource Pool: %s", name) if resource_pool.nil?
           end
 
           resource_pool[0].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])})
+          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]
         end
 
+        # Deletes the VM
+        #
+        # @param [String] name is the server to delete
         def delete_vm(name)
           vm = get_server(name)
           server_summary(vm)
-          ui.msg('')
+          ui.msg("")
 
-          ui.confirm('Do you really want to be delete this virtual machine')
+          ui.confirm("Do you really want to be delete this virtual machine")
 
           vm_obj = Com::Vmware::Vcenter::VM.new(vapi_config)
 
           # 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)
-            ui.msg('Shutting down machine')
+            ui.msg("Shutting down machine")
             power.stop(vm.vm)
           end
 
           vm_obj.delete(vm.vm)
         end
 
-        def server_summary(server, _coloumns_with_inf=nil)
-          msg_pair('ID', server.vm)
-          msg_pair('Name', server.name)
-          msg_pair('Power State', server.power_state)
+        # Gets some server information
+        #
+        # @param [Object] server is the server object
+        def server_summary(server, _coloumns_with_inf = nil)
+          msg_pair("ID", server.vm)
+          msg_pair("Name", server.name)
+          msg_pair("Power State", server.power_state)
         end
 
-=begin
-        def bootstrap_common_params(bootstrap)
-          bootstrap.config[:run_list] = config[:run_list]
-          bootstrap.config[:environment] = get_config(:environment)
-          bootstrap.config[:first_boot_attributes] = get_config(:first_boot_attributes)
-          bootstrap.config[:chef_node_name] = get_config(:chef_node_name)
-          bootstrap.config[:node_ssl_verify_mode] = get_config(:node_ssl_verify_mode)
-          bootstrap
-        end
+        #         def bootstrap_common_params(bootstrap)
+        #           bootstrap.config[:run_list] = config[:run_list]
+        #           bootstrap.config[:environment] = get_config(:environment)
+        #           bootstrap.config[:first_boot_attributes] = get_config(:first_boot_attributes)
+        #           bootstrap.config[:chef_node_name] = get_config(:chef_node_name)
+        #           bootstrap.config[:node_ssl_verify_mode] = get_config(:node_ssl_verify_mode)
+        #           bootstrap
+        #         end
+        #
+        #         def bootstrap_for_node
+        #           Chef::Knife::Bootstrap.load_deps
+        #           bootstrap = Chef::Knife::Bootstrap.new
+        #           bootstrap.name_args = [config[:fqdn]]
+        #           bootstrap.config[:ssh_user] = get_config(:ssh_user)
+        #           bootstrap.config[:ssh_password] = get_config(:ssh_password)
+        #           bootstrap.config[:ssh_port] = get_config(:ssh_port)
+        #           bootstrap.config[:identity_file] = get_config(:identity_file)
+        #           bootstrap.config[:use_sudo] = true unless get_config(:ssh_user) == 'root'
+        #           bootstrap.config[:use_sudo_password] = true unless get_config(:ssh_user) == 'root'
+        #           bootstrap.config[:log_level] = get_config(:log_level)
+        #           bootstrap_common_params(bootstrap)
+        #         end
 
-        def bootstrap_for_node
-          Chef::Knife::Bootstrap.load_deps
-          bootstrap = Chef::Knife::Bootstrap.new
-          bootstrap.name_args = [config[:fqdn]]
-          bootstrap.config[:ssh_user] = get_config(:ssh_user)
-          bootstrap.config[:ssh_password] = get_config(:ssh_password)
-          bootstrap.config[:ssh_port] = get_config(:ssh_port)
-          bootstrap.config[:identity_file] = get_config(:identity_file)
-          bootstrap.config[:use_sudo] = true unless get_config(:ssh_user) == 'root'
-          bootstrap.config[:use_sudo_password] = true unless get_config(:ssh_user) == 'root'
-          bootstrap.config[:log_level] = get_config(:log_level)
-          bootstrap_common_params(bootstrap)
-        end
-=end
         private
 
         def cleanup
-          session_svc.delete() unless session_id.nil?
+          session_svc.delete unless session_id.nil?
         end
       end
     end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 #
 # Author:: Chef Partner Engineering (<partnereng@chef.io>)
-# Copyright:: Copyright (c) 2017 Chef Software, Inc.
+# Copyright:: Copyright (c) 2017-2018 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,14 +17,19 @@
 # limitations under the License.
 #
 
-require 'chef/knife/cloud/helpers'
+require "chef/knife/cloud/helpers"
 
 class Chef
+  # The main knife class
   class Knife
+    # The main cloud class from knife-cloud
     class Cloud
+      # Module that creates the helpers for this gem
       module VcenterServiceHelpers
         include Chef::Knife::Cloud::Helpers
 
+        # Creates the object for vCenterService
+        #
         def create_service_instance
           Chef::Knife::Cloud::VcenterService.new(username: locate_config_value(:vcenter_username),
                                                  password: locate_config_value(:vcenter_password),
@@ -32,20 +37,27 @@ class Chef
                                                  verify_ssl: verify_ssl?)
         end
 
+        # Do we have valid SSL?
+        #
         def verify_ssl?
           !locate_config_value(:vcenter_disable_ssl_verify)
         end
 
+        # Validate the options and fail out if something isn't there
+        #
         def validate!
           check_for_missing_config_values!(:vcenter_username, :vcenter_password, :vcenter_host)
         end
 
         # rubocop:disable Style/GuardClause
+        # Checks for any missing values
+        #
+        # @param [Object] keys makes sure that the values are all not nil
         def check_for_missing_config_values!(*keys)
           missing = keys.select { |x| locate_config_value(x).nil? }
 
           unless missing.empty?
-            ui.error(format("The following required parameters are missing: %s", missing.join(', ')))
+            ui.error(format("The following required parameters are missing: %s", missing.join(", ")))
             exit(1)
           end
         end