knife-cloud 1.2.3 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e9f12b223e859ae2666a230a73195fb48221bdf29edc0a3b345c0ddc40b6d3b
-  data.tar.gz: 80e5ff22aa5769a1e671526a6fe9a06436db5b3da5192f24dd02a63d5a961089
+  metadata.gz: 3c8e63c32be098a1c7237ffdc07292bf4abb084e3c56fa7e336788a650307976
+  data.tar.gz: 68f6841384ee72b01b5b990ceeac3cf1582a8ebae9f5d63c58f67ffeb5259aa5
 SHA512:
-  metadata.gz: 5c200c5564f6273a92472f0591bd04173b0e266488bddc3320ccccc5be2c00bdea7ac979f661083f559dd7ee4b92e82d8ca8c83335bebbcda033b81fd610106e
-  data.tar.gz: c79491de45e5a99dc43fdcb9204e425c75f1768d90e9518069a8b8cda69b675584fa9f76ccf64aede16e4fd00f8efa2ab27f438d8b965b5bd56f3123e5b90835
+  metadata.gz: 92aa2998725dc7641bf1961aae50c27416188f5b0970c297398aa3e16b9648bd7a6de8a4e111934594e779f4b6ec54cf777bda4e189665f6948e0bdc9a5eedc9
+  data.tar.gz: 5469dc5b52b492416c8c722ece09379df2b7634db7aac0a4b0c43a1a8a5c107e1b72813c5f624b50c28d46d5f0756ee6926f1d13e596172ef31b18bf19ea1d0b

data/lib/chef/knife/cloud/chefbootstrap/bootstrap_options.rb

@@ -15,7 +15,7 @@
 # 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 "chef/knife/winrm_base"
+
 require "chef/knife/core/bootstrap_context"
 require "net/ssh/multi"
 
@@ -36,191 +36,6 @@ class Chef
               Chef::Knife::Ssh.load_deps
             end
 
-            include Chef::Knife::WinrmBase
-
-            option :ssh_user,
-              short: "-x USERNAME",
-              long: "--ssh-user USERNAME",
-              description: "The ssh username",
-              default: "root"
-
-            option :ssh_password,
-              short: "-P PASSWORD",
-              long: "--ssh-password PASSWORD",
-              description: "The ssh password"
-
-            option :ssh_port,
-              short: "-p PORT",
-              long: "--ssh-port PORT",
-              description: "The ssh port",
-              proc: Proc.new { |key| Chef::Config[:knife][:ssh_port] = key },
-              default: "22"
-
-            option :ssh_gateway,
-              long: "--ssh-gateway GATEWAY",
-              description: "The ssh gateway server. Any proxies configured in your ssh config are automatically used by default.",
-              proc: Proc.new { |key| Chef::Config[:knife][:ssh_gateway] = key }
-
-            option :ssh_gateway_identity,
-              long: "--ssh-gateway-identity IDENTITY_FILE",
-              description: "The private key for ssh gateway server",
-              proc: Proc.new { |key| Chef::Config[:knife][:ssh_gateway_identity] = key }
-
-            option :forward_agent,
-              long: "--forward-agent",
-              description: "Enable SSH agent forwarding",
-              boolean: true
-
-            option :identity_file,
-              short: "-i IDENTITY_FILE",
-              long: "--identity-file IDENTITY_FILE",
-              description: "The SSH identity file used for authentication"
-
-            option :chef_node_name,
-              short: "-N NAME",
-              long: "--node-name NAME",
-              description: "The Chef node name for your new node"
-
-            option :prerelease,
-              long: "--prerelease",
-              description: "Install the pre-release chef gems"
-
-            option :bootstrap_version,
-              long: "--bootstrap-version VERSION",
-              description: "The version of Chef to install",
-              proc: lambda { |v| Chef::Config[:knife][:bootstrap_version] = v }
-
-            option :bootstrap_proxy,
-              long: "--bootstrap-proxy PROXY_URL",
-              description: "The proxy server for the node being bootstrapped",
-              proc: Proc.new { |p| Chef::Config[:knife][:bootstrap_proxy] = p }
-
-            option :bootstrap_no_proxy,
-              long: "--bootstrap-no-proxy [NO_PROXY_URL|NO_PROXY_IP]",
-              description: "Do not proxy locations for the node being bootstrapped; this option is used internally by Chef",
-              proc: Proc.new { |np| Chef::Config[:knife][:bootstrap_no_proxy] = np }
-
-            option :bootstrap_template,
-              short: "-t TEMPLATE",
-              long: "--bootstrap-template TEMPLATE",
-              description: "Bootstrap Chef using a built-in or custom template. Set to the full path of an erb template or use one of the built-in templates."
-
-            option :use_sudo,
-              long: "--sudo",
-              description: "Execute the bootstrap via sudo",
-              boolean: true
-
-            option :use_sudo_password,
-              long: "--use-sudo-password",
-              description: "Execute the bootstrap via sudo with password",
-              boolean: false
-
-            option :run_list,
-              short: "-r RUN_LIST",
-              long: "--run-list RUN_LIST",
-              description: "Comma separated list of roles/recipes to apply",
-              proc: lambda { |o| o.split(/[\s,]+/) },
-              default: []
-
-            option :first_boot_attributes,
-              short: "-j JSON_ATTRIBS",
-              long: "--json-attributes",
-              description: "A JSON string to be added to the first run of chef-client",
-              proc: lambda { |o| JSON.parse(o) },
-              default: {}
-
-            option :host_key_verify,
-              long: "--[no-]host-key-verify",
-              description: "Verify host key, enabled by default.",
-              boolean: true,
-              default: true
-
-            option :hint,
-              long: "--hint HINT_NAME[=HINT_FILE]",
-              description: "Specify Ohai Hint to be set on the bootstrap target.  Use multiple --hint options to specify multiple hints.",
-              proc: Proc.new { |h|
-                Chef::Config[:knife][:hints] ||= Hash.new
-                name, path = h.split("=")
-                Chef::Config[:knife][:hints][name] = path ? JSON.parse(::File.read(path)) : Hash.new }
-
-            option :secret,
-              short: "-s SECRET",
-              long: "--secret ",
-              description: "The secret key to use to encrypt data bag item values"
-
-            option :secret_file,
-              long: "--secret-file SECRET_FILE",
-              description: "A file containing the secret key to use to encrypt data bag item values"
-
-            option :bootstrap_url,
-              long: "--bootstrap-url URL",
-              description: "URL to a custom installation script",
-              proc: Proc.new { |u| Chef::Config[:knife][:bootstrap_url] = u }
-
-            option :bootstrap_curl_options,
-              long: "--bootstrap-curl-options OPTIONS",
-              description: "Add options to curl when install chef-client",
-              proc: Proc.new { |co| Chef::Config[:knife][:bootstrap_curl_options] = co }
-
-            option :auth_timeout,
-              long: "--auth-timeout MINUTES",
-              description: "The maximum time in minutes to wait to for authentication over the transport to the node to succeed. The default value is 25 minutes.",
-              default: 25
-
-            option :node_ssl_verify_mode,
-              long: "--node-ssl-verify-mode [peer|none]",
-              description: "Whether or not to verify the SSL cert for all HTTPS requests.",
-              proc: Proc.new { |v|
-                valid_values = %w{none peer}
-                unless valid_values.include?(v)
-                  raise "Invalid value '#{v}' for --node-ssl-verify-mode. Valid values are: #{valid_values.join(", ")}"
-                end
-              }
-
-            option :node_verify_api_cert,
-              long: "--[no-]node-verify-api-cert",
-              description: "Verify the SSL cert for HTTPS requests to the Chef server API.",
-              boolean: true
-
-            option :bootstrap_install_command,
-              long: "--bootstrap-install-command COMMANDS",
-              description: "Custom command to install chef-client",
-              proc: Proc.new { |ic| Chef::Config[:knife][:bootstrap_install_command] = ic }
-
-            option :bootstrap_wget_options,
-              long: "--bootstrap-wget-options OPTIONS",
-              description: "Add options to wget when installing chef-client",
-              proc: Proc.new { |wo| Chef::Config[:knife][:bootstrap_wget_options] = wo }
-
-            option :bootstrap_vault_file,
-              long: "--bootstrap-vault-file VAULT_FILE",
-              description: "A JSON file with a list of vault(s) and item(s) to be updated"
-
-            option :bootstrap_vault_json,
-              long: "--bootstrap-vault-json VAULT_JSON",
-              description: "A JSON string with the vault(s) and item(s) to be updated"
-
-            option :bootstrap_vault_item,
-              long: "--bootstrap-vault-item VAULT_ITEM",
-              description: 'A single vault and item to update as "vault:item"',
-              proc: Proc.new { |i|
-                (vault, item) = i.split(/:/)
-                Chef::Config[:knife][:bootstrap_vault_item] ||= {}
-                Chef::Config[:knife][:bootstrap_vault_item][vault] ||= []
-                Chef::Config[:knife][:bootstrap_vault_item][vault].push(item)
-                Chef::Config[:knife][:bootstrap_vault_item]
-              }
-            option :msi_url,
-              short: "-u URL",
-              long: "--msi-url URL",
-              description: "Location of the Chef Client MSI. The default templates will prefer to download from this location. The MSI will be downloaded from chef.io if not provided.",
-              default: ""
-
-            option :install_as_service,
-              long: "--install-as-service",
-              description: "Install chef-client as service in windows machine",
-              default: false
-
           end
         end
       end # module ends

data/lib/chef/knife/cloud/chefbootstrap/bootstrap_protocol.rb

@@ -51,7 +51,6 @@ class Chef
           bootstrap.config[:run_list] = locate_config_value(:run_list)
           bootstrap.config[:prerelease] = locate_config_value(:prerelease)
           bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
-          bootstrap.config[:distro] = locate_config_value(:distro)
           bootstrap.config[:bootstrap_proxy] = locate_config_value(:bootstrap_proxy)
           bootstrap.config[:environment] = locate_config_value(:environment)
           # see chef/knife/bootstrap.rb #warn_chef_config_secret_key.
@@ -60,7 +59,6 @@ class Chef
           bootstrap.config[:first_boot_attributes] = locate_config_value(:first_boot_attributes)
           bootstrap.config[:secret] = locate_config_value(:secret)
           bootstrap.config[:secret_file] = locate_config_value(:secret_file)
-          bootstrap.config[:template_file] = locate_config_value(:template_file)
           bootstrap.config[:bootstrap_template] = locate_config_value(:bootstrap_template)
           bootstrap.config[:node_ssl_verify_mode] = locate_config_value(:node_ssl_verify_mode)
           bootstrap.config[:node_verify_api_cert] = locate_config_value(:node_verify_api_cert)
@@ -76,6 +74,7 @@ class Chef
           bootstrap.config[:msi_url] = locate_config_value(:msi_url)
           bootstrap.config[:install_as_service] = locate_config_value(:install_as_service)
           bootstrap.config[:session_timeout] = locate_config_value(:session_timeout)
+          bootstrap.config[:channel] = locate_config_value(:channel)
         end
 
       end

data/lib/chef/knife/cloud/chefbootstrap/bootstrapper.rb

@@ -20,8 +20,7 @@
 require "chef/knife/core/ui"
 require "chef/knife/cloud/chefbootstrap/ssh_bootstrap_protocol"
 require "chef/knife/cloud/chefbootstrap/winrm_bootstrap_protocol"
-require "chef/knife/cloud/chefbootstrap/windows_distribution"
-require "chef/knife/cloud/chefbootstrap/unix_distribution"
+require "chef/knife/cloud/chefbootstrap/bootstrap_distribution"
 require "chef/knife/cloud/exceptions"
 
 class Chef
@@ -47,9 +46,9 @@ class Chef
         end
 
         def create_bootstrap_protocol
-          if @config[:bootstrap_protocol].nil? || @config[:bootstrap_protocol] == "ssh"
+          if @config[:connection_protocol].nil? || @config[:connection_protocol] == "ssh"
             SshBootstrapProtocol.new(@config)
-          elsif @config[:bootstrap_protocol] == "winrm"
+          elsif @config[:connection_protocol] == "winrm"
             WinrmBootstrapProtocol.new(@config)
           else
             # raise an exception, invalid bootstrap protocol.
@@ -60,10 +59,8 @@ class Chef
         end
 
         def create_bootstrap_distribution
-          if @config[:image_os_type] == "windows"
-            Chef::Knife::Cloud::WindowsDistribution.new(@config)
-          elsif @config[:image_os_type] == "linux"
-            Chef::Knife::Cloud::UnixDistribution.new(@config)
+          if @config[:image_os_type] == "windows" || @config[:image_os_type] == "linux"
+            Chef::Knife::Cloud::BootstrapDistribution.new(@config)
           else
             # raise an exception, invalid bootstrap distribution.
             error_message = "Invalid bootstrap distribution. image_os_type should be either windows or linux."

data/lib/chef/knife/cloud/chefbootstrap/ssh_bootstrap_protocol.rb

@@ -27,18 +27,17 @@ class Chef
       class SshBootstrapProtocol < BootstrapProtocol
 
         def initialize(config)
-          @bootstrap = (config[:image_os_type] == "linux") ? Chef::Knife::Bootstrap.new : Chef::Knife::BootstrapWindowsSsh.new
+          @bootstrap = Chef::Knife::Bootstrap.new
           super
         end
 
         def init_bootstrap_options
-          bootstrap.config[:ssh_user] = @config[:ssh_user]
-          bootstrap.config[:ssh_password] = @config[:ssh_password]
-          bootstrap.config[:ssh_port] = locate_config_value(:ssh_port)
-          bootstrap.config[:identity_file] = @config[:identity_file]
-          bootstrap.config[:host_key_verify] = @config[:host_key_verify]
-          bootstrap.config[:use_sudo] = true unless @config[:ssh_user] == "root"
-          bootstrap.config[:template_file] = @config[:template_file]
+          bootstrap.config[:connection_user] = @config[:connection_user]
+          bootstrap.config[:connection_password] = @config[:connection_password]
+          bootstrap.config[:connection_port] = locate_config_value(:connection_port)
+          bootstrap.config[:ssh_identity_file] = @config[:ssh_identity_file]
+          bootstrap.config[:ssh_verify_host_key] = @config[:ssh_verify_host_key]
+          bootstrap.config[:use_sudo] = true unless @config[:connection_user] == "root"
           bootstrap.config[:ssh_gateway] = locate_config_value(:ssh_gateway)
           bootstrap.config[:forward_agent] = locate_config_value(:forward_agent)
           bootstrap.config[:use_sudo_password] = locate_config_value(:use_sudo_password)
@@ -58,7 +57,7 @@ class Chef
               puts("done")
             end
           else
-            print(".") until tcp_test_ssh(@config[:bootstrap_ip_address], locate_config_value(:ssh_port)) do
+            print(".") until tcp_test_ssh(@config[:bootstrap_ip_address], locate_config_value(:connection_port) || Chef::Config[:knife][:ssh_port] ) do
               @initial_sleep_delay = !!locate_config_value(:subnet_id) ? 40 : 10
               sleep @initial_sleep_delay
               puts("done")

data/lib/chef/knife/cloud/chefbootstrap/winrm_bootstrap_protocol.rb

@@ -26,30 +26,29 @@ class Chef
 
         def initialize(config)
           load_winrm_deps
-          @bootstrap = Chef::Knife::BootstrapWindowsWinrm.new
+          @bootstrap = Chef::Knife::Bootstrap.new
           super
         end
 
         def load_winrm_deps
           require "winrm"
-          require "chef/knife/bootstrap_windows_winrm"
           require "chef/knife/core/windows_bootstrap_context"
-          require "chef/knife/winrm"
         end
 
         def init_bootstrap_options
-          bootstrap.config[:winrm_user] = @config[:winrm_user] || "Administrator"
-          bootstrap.config[:winrm_password] = @config[:winrm_password]
-          bootstrap.config[:winrm_transport] = @config[:winrm_transport]
-          bootstrap.config[:winrm_port] = @config[:winrm_port]
+          bootstrap.config[:connection_user] = @config[:connection_user] || "Administrator"
+          bootstrap.config[:connection_password] = @config[:connection_password]
+          bootstrap.config[:winrm_ssl] = @config[:winrm_ssl]
+          bootstrap.config[:connection_port] = @config[:connection_port]
           bootstrap.config[:auth_timeout] = @config[:auth_timeout]
           bootstrap.config[:winrm_ssl_verify_mode] = @config[:winrm_ssl_verify_mode]
+          bootstrap.config[:connection_protocol] = @config[:connection_protocol]
           super
         end
 
         def wait_for_server_ready
           print "\n#{ui.color("Waiting for winrm to host (#{@config[:bootstrap_ip_address]})", :magenta)}"
-          print(".") until tcp_test_winrm(@config[:bootstrap_ip_address], @config[:winrm_port]) do
+          print(".") until tcp_test_winrm(@config[:bootstrap_ip_address], @config[:connection_port]) do
             sleep @initial_sleep_delay ||= 10
             puts("done")
           end

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

@@ -55,43 +55,6 @@ class Chef
           Chef::Log.debug(e.message)
           exit 1
         end
-
-        def create_service_instance
-          raise Chef::Exceptions::Override, "You must override create_service_instance in #{self} to create cloud specific service"
-        end
-
-        def execute_command
-          raise Chef::Exceptions::Override, "You must override execute_command in #{self}"
-        end
-
-        # Derived classes can override before_exec_command and after_exec_command
-        def before_exec_command
-        end
-
-        def after_exec_command
-        end
-
-        def set_default_config
-        end
-
-        def validate!(*keys)
-          # validates necessary options/params to carry out the command.
-          # subclasses to implement this.
-          errors = []
-          keys.each do |k|
-            errors << "You did not provide a valid '#{pretty_key(k)}' value." if locate_config_value(k).nil?
-          end
-          error_message = ""
-          raise CloudExceptions::ValidationError, error_message if errors.each { |e| ui.error(e); error_message = "#{error_message} #{e}." }.any?
-        end
-
-        def validate_params!
-        end
-
-        def pretty_key(key)
-          key.to_s.tr("_", " ").gsub(/\w+/) { |w| (w =~ /(ssh)|(aws)/i) ? w.upcase : w.capitalize }
-        end
-
       end # class Command
     end
   end

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

@@ -0,0 +1,62 @@
+#
+# Author:: Ashwini Nehate (<ashwini.nehate@msystechnologies.com>)
+# Copyright:: Copyright (c) 2013-2016 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 "chef/knife/bootstrap"
+require "chef/knife/cloud/helpers"
+require "chef/knife/cloud/exceptions"
+
+class Chef
+  class Knife
+
+    class Cloud
+      class BootstrapCommand < Chef::Knife::Bootstrap
+        include Cloud::Helpers
+        attr_accessor :service, :custom_arguments
+
+        def run
+            # Set dafult config
+          set_default_config
+
+          # validate compulsory params
+          validate!
+
+          # validate command pre-requisites (cli options)
+          validate_params!
+
+          # setup the service
+          @service = create_service_instance
+
+          service.ui = ui # for interactive user prompts/messages
+
+          # Perform any steps before handling the command
+          before_exec_command
+
+          # exec the actual cmd
+          execute_command
+
+          # Perform any steps after handling the command
+          after_exec_command
+        rescue CloudExceptions::KnifeCloudError => e
+          Chef::Log.debug(e.message)
+          exit 1
+        end
+
+      end # class Command
+    end
+  end
+end

data/lib/chef/knife/cloud/fog/service.rb

@@ -45,18 +45,18 @@ class Chef
         def network
           @network ||= begin
                         Fog::Network.new(@auth_params)
-                      rescue Excon::Error::Unauthorized => e
-                        error_message = "Connection failure, please check your username and password."
-                        ui.fatal(error_message)
-                        raise CloudExceptions::ServiceConnectionError, "#{e.message}. #{error_message}"
-                      rescue Excon::Error::Socket => e
-                        error_message = "Connection failure, please check your authentication URL."
-                        ui.fatal(error_message)
-                        raise CloudExceptions::ServiceConnectionError, "#{e.message}. #{error_message}"
-                      rescue Fog::Errors::NotFound => e
-                        error_message = "No Network service found. This command is unavailable with current cloud."
-                        ui.fatal(error_message)
-                        raise CloudExceptions::NetworkNotFoundError, "#{e.message}. #{error_message}"
+                       rescue Excon::Error::Unauthorized => e
+                         error_message = "Connection failure, please check your username and password."
+                         ui.fatal(error_message)
+                         raise CloudExceptions::ServiceConnectionError, "#{e.message}. #{error_message}"
+                       rescue Excon::Error::Socket => e
+                         error_message = "Connection failure, please check your authentication URL."
+                         ui.fatal(error_message)
+                         raise CloudExceptions::ServiceConnectionError, "#{e.message}. #{error_message}"
+                       rescue Fog::Errors::NotFound => e
+                         error_message = "No Network service found. This command is unavailable with current cloud."
+                         ui.fatal(error_message)
+                         raise CloudExceptions::NetworkNotFoundError, "#{e.message}. #{error_message}"
                       end
         end
 
@@ -68,10 +68,10 @@ class Chef
           rescue Excon::Error::BadRequest => e
             response = Chef::JSONCompat.from_json(e.response.body)
             if response["badRequest"]["code"] == 400
-              message = "Bad request (400): #{response['badRequest']['message']}"
+              message = "Bad request (400): #{response["badRequest"]["message"]}"
               ui.fatal(message)
             else
-              message = "Unknown server error (#{response['badRequest']['code']}): #{response['badRequest']['message']}"
+              message = "Unknown server error (#{response["badRequest"]["code"]}): #{response["badRequest"]["message"]}"
               ui.fatal(message)
             end
             raise CloudExceptions::ServerCreateError, message
@@ -124,7 +124,7 @@ class Chef
         def handle_excon_exception(exception_class, e)
           error_message = if e.response
                             response = Chef::JSONCompat.from_json(e.response.body)
-                            "Unknown server error (#{response[response.keys[0]]['code']}): #{response[response.keys[0]]['message']}"
+                            "Unknown server error (#{response[response.keys[0]]["code"]}): #{response[response.keys[0]]["message"]}"
                           else
                             "Unknown server error : #{e.message}"
                           end
@@ -233,7 +233,7 @@ class Chef
                     else
                       col_info[:value]
                     end
-            if !(value.nil? || value.empty?)
+            unless value.nil? || value.empty?
               list << ui.color(col_info[:label], :bold)
               list << value
             end

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

@@ -32,6 +32,38 @@ class Chef
           config[key] || Chef::Config[:knife][key]
         end
 
+        def create_service_instance
+          raise Chef::Exceptions::Override, "You must override create_service_instance in #{self} to create cloud specific service"
+        end
+
+        def execute_command
+          raise Chef::Exceptions::Override, "You must override execute_command in #{self}"
+        end
+
+        # Derived classes can override before_exec_command and after_exec_command
+        def before_exec_command; end
+
+        def after_exec_command; end
+
+        def set_default_config; end
+
+        def validate!(*keys)
+          # validates necessary options/params to carry out the command.
+          # subclasses to implement this.
+          errors = []
+          keys.each do |k|
+            errors << "You did not provide a valid '#{pretty_key(k)}' value." if locate_config_value(k).nil?
+          end
+          error_message = ""
+          raise CloudExceptions::ValidationError, error_message if errors.each { |e| ui.error(e); error_message = "#{error_message} #{e}." }.any?
+        end
+
+        def validate_params!; end
+
+        def pretty_key(key)
+          key.to_s.tr("_", " ").gsub(/\w+/) { |w| (w =~ /(ssh)|(aws)/i) ? w.upcase : w.capitalize }
+        end
+
       end
     end
   end

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

@@ -46,6 +46,7 @@ class Chef
         def is_resource_filtered?(attribute, value)
           # resource_filters is array of filters in form {:attribute => attribute-name, :regex => 'filter regex value'}
           return false if @resource_filters.nil?
+
           @resource_filters.each do |filter|
             if attribute == filter[:attribute] && value =~ filter[:regex]
               return true
@@ -60,7 +61,7 @@ class Chef
           list = []
           @columns_with_info.each do |col_info|
             value = (col_info[:value_callback].nil? ? resource.send(col_info[:key]).to_s : col_info[:value_callback].call(resource.send(col_info[:key])))
-            if !config[:disable_filter]
+            unless config[:disable_filter]
               resource_filtered = true if is_resource_filtered?(col_info[:key], value)
             end
             list << value

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

@@ -8,10 +8,10 @@ class Chef
           includer.class_eval do
 
             option :disable_filter,
-            long: "--disable-filter",
-            description: "Disable filtering of the current resource listing.",
-            boolean: true,
-            default: false
+              long: "--disable-filter",
+              description: "Disable filtering of the current resource listing.",
+              boolean: true,
+              default: false
           end
         end
 

data/lib/chef/knife/cloud/server/create_command.rb

@@ -14,15 +14,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-require "chef/knife/cloud/command"
+require "chef/knife/cloud/command_bootstrap"
 require "chef/knife/cloud/exceptions"
 require "chef/knife/cloud/chefbootstrap/bootstrapper"
 
 class Chef
   class Knife
     class Cloud
-      class ServerCreateCommand < Command
+      class ServerCreateCommand < BootstrapCommand
         attr_accessor :server, :create_options
+        Chef::Knife::Bootstrap.load_deps
 
         def initialize(argv = [])
           super argv
@@ -34,19 +35,18 @@ class Chef
           # set param vm_name to a random value if the name is not set by the user (plugin)
           config[:chef_node_name] = get_node_name(locate_config_value(:chef_node_name), locate_config_value(:chef_node_name_prefix))
 
-          # validate ssh_user, ssh_password, identity_file for ssh bootstrap protocol and winrm_password for winrm bootstrap protocol
+          # validate ssh_identity_file for connection protocol and connection_user, connection_password for both ssh bootstrap protocol and winrm bootstrap protocol
           errors = []
-
-          if locate_config_value(:bootstrap_protocol) == "ssh"
-            if locate_config_value(:identity_file).nil? && locate_config_value(:ssh_password).nil?
-              errors << "You must provide either Identity file or SSH Password."
+          if locate_config_value(:connection_protocol) == "ssh"
+            if locate_config_value(:ssh_identity_file).nil? && locate_config_value(:connection_password).nil?
+              errors << "You must provide either SSH Identity file or Connection Password."
             end
-          elsif locate_config_value(:bootstrap_protocol) == "winrm"
-            if locate_config_value(:winrm_password).nil?
-              errors << "You must provide Winrm Password."
+          elsif locate_config_value(:connection_protocol) == "winrm"
+            if locate_config_value(:connection_password).nil?
+              errors << "You must provide Connection Password."
             end
           else
-            errors << "You must provide a valid bootstrap protocol. options [ssh/winrm]. For linux type images, options [ssh]"
+            errors << "You must provide a valid connection protocol. options [ssh/winrm]. For linux type images, options [ssh]"
           end
           error_message = ""
           raise CloudExceptions::ValidationError, error_message if errors.each { |e| ui.error(e); error_message = "#{error_message} #{e}." }.any?
@@ -82,7 +82,7 @@ class Chef
           cleanup_on_failure
           raise e
         rescue => e
-          error_message = "Check if --bootstrap-protocol and --image-os-type is correct. #{e.message}"
+          error_message = "Check if --connection-protocol and --image-os-type is correct. #{e.message}"
           ui.fatal(error_message)
           cleanup_on_failure
           raise e, error_message
@@ -100,15 +100,13 @@ class Chef
           before_bootstrap
           @bootstrapper = Bootstrapper.new(config)
           Chef::Log.debug("Bootstrapping the server...")
-          ui.info("Bootstrapping the server by using #{ui.color("bootstrap_protocol", :cyan)}: #{config[:bootstrap_protocol]} and #{ui.color("image_os_type", :cyan)}: #{config[:image_os_type]}")
+          ui.info("Bootstrapping the server by using #{ui.color("connection_protocol", :cyan)}: #{config[:connection_protocol]} and #{ui.color("image_os_type", :cyan)}: #{config[:image_os_type]}")
           @bootstrapper.bootstrap
           after_bootstrap
         end
 
         # any cloud specific initializations/cleanup we want to do around bootstrap.
-        def before_bootstrap
-          ssh_override_winrm if locate_config_value(:bootstrap_protocol) == "ssh"
-        end
+        def before_bootstrap; end
 
         def after_bootstrap
           service.server_summary(@server, @columns_with_info)
@@ -116,44 +114,18 @@ class Chef
 
         # knife-plugin can override set_default_config to set default config by using their own mechanism.
         def set_default_config
-          config[:image_os_type] = "windows" if config[:bootstrap_protocol] == "winrm"
+          config[:image_os_type] = "windows" if config[:connection_protocol] == "winrm"
         end
 
         # generate a random name if chef_node_name is empty
         def get_node_name(chef_node_name, prefix)
           return chef_node_name unless chef_node_name.nil?
+
           # lazy uuids, 15 chars cause windows has limits
           ("#{prefix}-" + rand.to_s.split(".")[1]).slice(0, 14)
         end
 
-        def post_connection_validations
-        end
-
-        private
-
-        # Here, ssh config override winrm config
-        def ssh_override_winrm
-          # unchanged ssh_user and changed winrm_user, override ssh_user
-          if locate_config_value(:ssh_user).eql?(options[:ssh_user][:default]) &&
-              !locate_config_value(:winrm_user).eql?(options[:winrm_user][:default])
-            config[:ssh_user] = locate_config_value(:winrm_user)
-          end
-          # unchanged ssh_port and changed winrm_port, override ssh_port
-          if locate_config_value(:ssh_port).eql?(options[:ssh_port][:default]) &&
-              !locate_config_value(:winrm_port).eql?(options[:winrm_port][:default])
-            config[:ssh_port] = locate_config_value(:winrm_port)
-          end
-          # unset ssh_password and set winrm_password, override ssh_password
-          if locate_config_value(:ssh_password).nil? &&
-              !locate_config_value(:winrm_password).nil?
-            config[:ssh_password] = locate_config_value(:winrm_password)
-          end
-          # unset identity_file and set kerberos_keytab_file, override identity_file
-          if locate_config_value(:identity_file).nil? &&
-              !locate_config_value(:kerberos_keytab_file).nil?
-            config[:identity_file] = locate_config_value(:kerberos_keytab_file)
-          end
-        end
+        def post_connection_validations; end
       end # class ServerCreateCommand
     end
   end

data/lib/chef/knife/cloud/server/create_options.rb

@@ -37,7 +37,6 @@ class Chef
               short: "-T IMAGE_OS_TYPE",
               long: "--image-os-type IMAGE_OS_TYPE",
               description: "The image os type. options [windows/linux]. Only required when cloud does not provide a way to identify image os",
-              default: "linux",
               proc: Proc.new { |i| Chef::Config[:knife][:image_os_type] = i }
 
             option :flavor,
@@ -46,11 +45,9 @@ class Chef
               description: "The flavor name or ID of server",
               proc: Proc.new { |f| Chef::Config[:knife][:flavor] = f }
 
-            option :bootstrap_protocol,
-              long: "--bootstrap-protocol protocol",
-              description: "Protocol to bootstrap servers. options: winrm/ssh. For linux servers always use ssh.",
-              default: "ssh",
-              proc: Proc.new { |b| Chef::Config[:knife][:bootstrap_protocol] = b }
+            deprecated_option :bootstrap_protocol,
+              replacement: :connection_protocol,
+              long: "--bootstrap-protocol PROTOCOL"
 
             option :server_create_timeout,
               long: "--server-create-timeout timeout",
@@ -69,7 +66,6 @@ class Chef
               description: "The prefix for chef node name",
               default: includer.snake_case_name.split("_").first,
               proc: Proc.new { |key| Chef::Config[:knife][:chef_node_name_prefix] = key }
-
           end
         end
 

data/lib/chef/knife/cloud/server/options.rb

@@ -30,7 +30,7 @@ class Chef
             option :custom_attributes,
               long: "--custom-attributes CUSTOM_ATTRIBUTES",
               description: "Custom attributes to be passed to Fog.",
-              proc: Proc.new { |args| Chef::Config[:knife][:custom_attributes] = args.split(";").map { |keys| keys.split("=") }.map { |j| Hash[*j.map { |k| k.strip }] } }
+              proc: Proc.new { |args| Chef::Config[:knife][:custom_attributes] = args.split(";").map { |keys| keys.split("=") }.map { |j| Hash[*j.map(&:strip)] } }
           end
         end
       end

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

@@ -36,16 +36,13 @@ class Chef
         end
 
         # override in cloud specific derived classes
-        def list_resource_allocations
-        end
+        def list_resource_allocations; end
 
         # Do nothing or override in cloud specific derived classes for pre-vm-creation setup steps
-        def create_server_dependencies
-        end
+        def create_server_dependencies; end
 
         # Do nothing or override in cloud specific derived classes for pre-vm-creation setup steps
-        def delete_server_dependencies
-        end
+        def delete_server_dependencies; end
 
         def delete_server_on_failure(server = nil)
           raise Chef::Exceptions::Override, "You must override delete_server_on_failure in #{self} to delete server"

data/lib/knife-cloud/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Cloud
-    VERSION = "1.2.3".freeze
+    VERSION = "2.0.2".freeze
     MAJOR, MINOR, TINY = VERSION.split(".")
   end
 end

data/lib/test/fixtures/knife.rb

@@ -5,5 +5,5 @@ validation_client_name   "validation"
 validation_key           "#{current_dir}/validation.pem"
 chef_server_url          "http://localhost:8889"
 cache_type               "BasicFile"
-cache_options( path: "#{ENV['HOME']}/.chef/checksums" )
+cache_options( path: "#{ENV["HOME"]}/.chef/checksums" )
 cookbook_path ["#{current_dir}/chef-repo/cookbooks"]

data/lib/test/knife-utils/knife_test_utils.rb

@@ -30,7 +30,7 @@ module RSpec
     # Convenience function for grabbing a hash of several important
     # Mixlib::Shellout command configuration parameters.
     def self.command_setting(shellout_command)
-      keys = [:cwd, :user, :group, :umask, :timeout, :valid_exit_codes, :environment]
+      keys = %i{cwd user group umask timeout valid_exit_codes environment}
       keys.inject({}) do |hash, attr|
         hash[attr] = shellout_command.send(attr)
         hash

data/lib/test/knife-utils/matchers.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + "/knife_test_utils")
 
 RSpec::Matchers.define :have_outcome do |outcome_spec|
   match do |executed_shellout_command|
-    valid_keys = [:status, :stdout, :stderr]
+    valid_keys = %i{status stdout stderr}
     if outcome_spec.keys & valid_keys == []
       throw "You did not specify values for any of #{valid_keys}!"
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-cloud
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 2.0.2
 platform: ruby
 authors:
 - Kaustubh Deorukhkar
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-28 00:00:00.000000000 Z
+date: 2019-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: knife-windows
+  name: chef
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '15.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '15.0'
 - !ruby/object:Gem::Dependency
   name: mixlib-shellout
   requirement: !ruby/object:Gem::Requirement
@@ -66,10 +66,9 @@ files:
 - lib/chef/knife/cloud/chefbootstrap/bootstrap_protocol.rb
 - lib/chef/knife/cloud/chefbootstrap/bootstrapper.rb
 - lib/chef/knife/cloud/chefbootstrap/ssh_bootstrap_protocol.rb
-- lib/chef/knife/cloud/chefbootstrap/unix_distribution.rb
-- lib/chef/knife/cloud/chefbootstrap/windows_distribution.rb
 - lib/chef/knife/cloud/chefbootstrap/winrm_bootstrap_protocol.rb
 - lib/chef/knife/cloud/command.rb
+- lib/chef/knife/cloud/command_bootstrap.rb
 - lib/chef/knife/cloud/exceptions.rb
 - lib/chef/knife/cloud/fog/options.rb
 - lib/chef/knife/cloud/fog/service.rb
@@ -103,19 +102,19 @@ post_install_message:
 rdoc_options: []
 require_paths:
 - lib
+- spec
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.2
+      version: 2.2.5
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: knife-cloud plugin

data/lib/chef/knife/cloud/chefbootstrap/unix_distribution.rb

@@ -1,31 +0,0 @@
-#
-# Author:: Prabhu Das (<prabhu.das@clogeny.com>)
-# Copyright:: Copyright (c) 2013-2016 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 "chef/knife/cloud/chefbootstrap/bootstrap_distribution"
-
-class Chef
-  class Knife
-    class Cloud
-      class UnixDistribution < BootstrapDistribution
-
-        def initialize(config)
-          super
-          config[:distro] = config[:distro] || "chef-full"
-        end
-      end
-    end
-  end
-end

data/lib/chef/knife/cloud/chefbootstrap/windows_distribution.rb

@@ -1,32 +0,0 @@
-#
-# Author:: Prabhu Das (<prabhu.das@clogeny.com>)
-# Copyright:: Copyright (c) 2013-2016 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 "chef/knife/cloud/chefbootstrap/bootstrap_distribution"
-require "chef/knife/bootstrap_windows_base"
-
-class Chef
-  class Knife
-    class Cloud
-      class WindowsDistribution < BootstrapDistribution
-        def initialize(config)
-          super
-          config[:distro] ||= "windows-chef-client-msi"
-        end
-      end
-    end
-  end
-end