knife-undev 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b10ee6fac2453b117a90410553a6da337329ab7
-  data.tar.gz: b966038f848f734a1e938a824b8fd4947c3ac759
+  metadata.gz: 2ba84740385210e9d5e64a67a37f43919da6539f
+  data.tar.gz: 527e5ae42dbe266d9903d749c6c4189d214d5b28
 SHA512:
-  metadata.gz: 73b67c4030e75b383c757014b88ca32954dabbc7ded496ecd1cb6e05f455d775c8c209e4949787b0de7b0f58ad2247af612412877f8a1f9ba8d0350f1245a296
-  data.tar.gz: ced24f8cad9ec235a9c97d8d6aa6ea36090c893bfa64cc69598e078730486dfe7d066161da995b8839bdaf97e992f6cb3b24c7d6b93ed75a1d453ed46f57dfd9
+  metadata.gz: 78e2afbe003643a7906208f7d3c8ebe4472cfa5522b1d66a5b090eae68b439903edf34ebc35367ce43c55bd08b8f2f3ad7567e95a55540db3bd8e90790b64dc1
+  data.tar.gz: 44fd9445f1badce11fb05991c3d5747eca43c726bba015a2a88c1eb666df8d8b7fdf5ecbead9a643890325247f9b0f51ec5b9fe7e9439d4ad515794d9f711bab

data/lib/knife/undev.rb

@@ -1,4 +1,4 @@
 require "knife/undev/version"
 require "knife/undev/monkey_patches/object_loader"
 require "knife/undev/monkey_patches/node_presenter"
-require "knife/undev/monkey_patches/ssh"
+require "knife/undev/plugins/cloud_ssh"

data/lib/knife/undev/monkey_patches/node_presenter.rb

@@ -1,17 +1,14 @@
-require 'chef/knife'
 require 'chef/knife/core/node_presenter'
 
-class Chef
-  class Knife
-    module Core
 
-        def summarize(data)
-          if data.kind_of?(Chef::Node)
-            node = data
-            # special case ec2 with their split horizon whatsis.
-            ip = (node[:private_ipaddress]) || node[:ipaddress]
+class Chef::Knife::Core::NodePresenter
 
-            summarized=<<-SUMMARY
+  def summarize(data)
+    if data.kind_of?(Chef::Node)
+      node = data
+      ip = node[:ipaddress]
+
+      summarized=<<-SUMMARY
 #{ui.color('Node Name:', :bold)}   #{ui.color(node.name, :bold)}
 #{key('Environment:')} #{node.chef_environment}
 #{key('FQDN:')}        #{node[:fqdn]}
@@ -23,14 +20,15 @@ class Chef
 #{key('Platform:')}    #{node[:platform]} #{node[:platform_version]}
 #{key('Tags:')}        #{Array(node[:tags]).join(', ')}
 SUMMARY
-            if config[:medium_output] || config[:long_output]
-              summarized +=<<-MORE
+      if config[:medium_output] || config[:long_output]
+        summarized +=<<-MORE
 #{key('Attributes:')}
 #{text_format(node.normal_attrs)}
 MORE
-            end
-            if config[:long_output]
-              summarized +=<<-MOST
+      end
+    
+      if config[:long_output]
+        summarized +=<<-MOST
 #{key('Default Attributes:')}
 #{text_format(node.default_attrs)}
 #{key('Override Attributes:')}
@@ -38,13 +36,12 @@ MORE
 #{key('Automatic Attributes (Ohai Data):')}
 #{text_format(node.automatic_attrs)}
 MOST
-            end
-            summarized
-          else
-            super
-          end
-        end
-
+      end
+  
+    summarized
+    else # not Chef::Node
+      super
     end
   end
+
 end

data/lib/knife/undev/plugins/cloud_ssh.rb

@@ -0,0 +1,325 @@
+require 'chef/knife'
+
+# отличается от ssh:
+# 1. host_key_verify => false
+# 2. concurrency => 50
+# 3. коннектиться по дефолту к private_ip
+# 4. выдает exit status не нулевой если есть сфеленные по коннекту
+# 5. выводит список всех сфейленных машин в самом конце
+
+class Chef
+  class Knife
+    class CloudSsh < Knife
+
+      deps do
+        require 'net/ssh'
+        require 'net/ssh/multi'
+        require 'chef/monkey_patches/net-ssh-multi'
+        require 'readline'
+        require 'chef/exceptions'
+        require 'chef/search/query'
+        require 'chef/mixin/shell_out'
+        require 'mixlib/shellout'
+      end
+
+      include Chef::Mixin::ShellOut
+
+      attr_writer :password
+
+      banner "knife private_ssh QUERY COMMAND (options)"
+
+      option :concurrency,
+        :short => "-C NUM",
+        :long => "--concurrency NUM",
+        :description => "The number of concurrent connections",
+        :default => 50,
+        :proc => lambda { |o| o.to_i }
+
+      option :attribute,
+        :short => "-a ATTR",
+        :long => "--attribute ATTR",
+        :description => "The attribute to use for opening the connection - default depends on the context",
+        :proc => Proc.new { |key| Chef::Config[:knife][:ssh_attribute] = key.strip }
+
+      option :manual,
+        :short => "-m",
+        :long => "--manual-list",
+        :boolean => true,
+        :description => "QUERY is a space separated list of servers",
+        :default => false
+
+      option :ssh_user,
+        :short => "-x USERNAME",
+        :long => "--ssh-user USERNAME",
+        :description => "The ssh username"
+
+      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.strip }
+
+      option :ssh_gateway,
+        :short => "-G GATEWAY",
+        :long => "--ssh-gateway GATEWAY",
+        :description => "The ssh gateway",
+        :proc => Proc.new { |key| Chef::Config[:knife][:ssh_gateway] = key.strip }
+
+      option :forward_agent,
+        :short => "-A",
+        :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 :host_key_verify,
+        :long => "--[no-]host-key-verify",
+        :description => "Verify host key, disabled by default.",
+        :boolean => true,
+        :default => false
+
+      def session
+        config[:on_error] ||= :skip
+        ssh_error_handler = Proc.new do |server|
+          @failed_connect_nodes << { "node" => server.host , "message" => "#{$!.class.name}: #{$!.message}" }
+          if config[:manual]
+            node_name = server.host
+          else
+            @action_nodes.each do |n|
+              node_name = n if format_for_display(n)[config[:attribute]] == server.host
+            end
+          end
+          case config[:on_error]
+          when :skip
+            ui.warn "Failed to connect to #{node_name} -- #{$!.class.name}: #{$!.message}"
+            $!.backtrace.each { |l| Chef::Log.debug(l) }
+          when :raise
+            #Net::SSH::Multi magic to force exception to be re-raised.
+            throw :go, :raise
+          end
+        end
+
+        @session ||= Net::SSH::Multi.start(:concurrent_connections => config[:concurrency], :on_error => ssh_error_handler)
+      end
+
+      def configure_gateway
+        config[:ssh_gateway] ||= Chef::Config[:knife][:ssh_gateway]
+        if config[:ssh_gateway]
+          gw_host, gw_user = config[:ssh_gateway].split('@').reverse
+          gw_host, gw_port = gw_host.split(':')
+          gw_opts = gw_port ? { :port => gw_port } : {}
+
+          session.via(gw_host, gw_user || config[:ssh_user], gw_opts)
+        end
+      rescue Net::SSH::AuthenticationFailed
+        user = gw_user || config[:ssh_user]
+        prompt = "Enter the password for #{user}@#{gw_host}: "
+        gw_opts.merge!(:password => prompt_for_password(prompt))
+        session.via(gw_host, user, gw_opts)
+      end
+
+      def configure_session
+        list = case config[:manual]
+               when true
+                 @name_args[0].split(" ")
+               when false
+                 r = Array.new
+                 q = Chef::Search::Query.new
+                 @action_nodes = q.search(:node, @name_args[0])[0]
+                 @action_nodes.each do |item|
+                   # we should skip the loop to next iteration if the item returned by the search is nil
+                   next if item.nil?
+                   # if a command line attribute was not passed, and we have a cloud public_hostname, use that.
+                   # see #configure_attribute for the source of config[:attribute] and config[:override_attribute]
+                   if !config[:override_attribute] && item[:cloud] and item[:cloud][:public_hostname]
+                     i = item[:cloud][:public_hostname]
+                   elsif config[:override_attribute]
+                     i = extract_nested_value(item, config[:override_attribute])
+                   else
+                     i = extract_nested_value(item, config[:attribute])
+                   end
+                   # next if we couldn't find the specified attribute in the returned node object
+                   next if i.nil?
+                   r.push(i)
+                 end
+                 r
+               end
+        if list.length == 0
+          if @action_nodes.length == 0
+            ui.fatal("No nodes returned from search!")
+          else
+            ui.fatal("#{@action_nodes.length} #{@action_nodes.length > 1 ? "nodes":"node"} found, " +
+                     "but does not have the required attribute to establish the connection. " +
+                     "Try setting another attribute to open the connection using --attribute.")
+          end
+          exit 10
+        end
+        session_from_list(list)
+      end
+
+      def session_from_list(list)
+        list.each do |item|
+          Chef::Log.debug("Adding #{item}")
+          session_opts = {}
+
+          ssh_config = Net::SSH.configuration_for(item)
+
+          # Chef::Config[:knife][:ssh_user] is parsed in #configure_user and written to config[:ssh_user]
+          user = config[:ssh_user] || ssh_config[:user]
+          hostspec = user ? "#{user}@#{item}" : item
+          session_opts[:keys] = File.expand_path(config[:identity_file]) if config[:identity_file]
+          session_opts[:keys_only] = true if config[:identity_file]
+          session_opts[:password] = config[:ssh_password] if config[:ssh_password]
+          session_opts[:forward_agent] = config[:forward_agent]
+          session_opts[:port] = config[:ssh_port] || Chef::Config[:knife][:ssh_port] || ssh_config[:port]
+          session_opts[:logger] = Chef::Log.logger if Chef::Log.level == :debug
+
+          if !config[:host_key_verify]
+            session_opts[:paranoid] = false
+            session_opts[:user_known_hosts_file] = "/dev/null"
+          end
+
+          session.use(hostspec, session_opts)
+
+          @longest = item.length if item.length > @longest
+        end
+
+        session
+      end
+
+      def fixup_sudo(command)
+        command.sub(/^sudo/, 'sudo -p \'knife sudo password: \'')
+      end
+
+      def print_data(host, data)
+        @buffers ||= {}
+        if leftover = @buffers[host]
+          @buffers[host] = nil
+          print_data(host, leftover + data)
+        else
+          if newline_index = data.index("\n")
+            line = data.slice!(0...newline_index)
+            data.slice!(0)
+            print_line(host, line)
+            print_data(host, data)
+          else
+            @buffers[host] = data
+          end
+        end
+      end
+
+      def print_line(host, data)
+        padding = @longest - host.length
+        str = ui.color(host, :cyan) + (" " * (padding + 1)) + data
+        ui.msg(str)
+      end
+
+      def ssh_command(command, subsession=nil)
+        exit_status = 0
+        subsession ||= session
+        command = fixup_sudo(command)
+        command.force_encoding('binary') if command.respond_to?(:force_encoding)
+        subsession.open_channel do |ch|
+          ch.request_pty
+          ch.exec command do |ch, success|
+            raise ArgumentError, "Cannot execute #{command}" unless success
+            ch.on_data do |ichannel, data|
+              print_data(ichannel[:host], data)
+              if data =~ /^knife sudo password: /
+                print_data(ichannel[:host], "\n")
+                ichannel.send_data("#{get_password}\n")
+              end
+            end
+            ch.on_request "exit-status" do |ichannel, data|
+              exit_status = [exit_status, data.read_long].max
+              @not_zerro_nodes << { 'node' => ichannel[:host], "message" => "exit status: #{exit_status}" } if exit_status != 0 
+            end
+          end
+        end
+        session.loop
+        exit_status
+      end
+
+      def get_password
+        @password ||= prompt_for_password
+      end
+
+      def prompt_for_password(prompt = "Enter your password: ")
+        ui.ask(prompt) { |q| q.echo = false }
+      end
+
+      def configure_attribute
+        config[:override_attribute] = config[:attribute] || Chef::Config[:knife][:ssh_attribute]
+        config[:attribute] = (Chef::Config[:knife][:ssh_attribute] ||
+                              config[:attribute] ||
+                              "private_ipaddress").strip
+      end
+
+
+      def get_stripped_unfrozen_value(value)
+        return nil if value.nil?
+        value.strip
+      end
+
+      def configure_user
+        config[:ssh_user] = get_stripped_unfrozen_value(config[:ssh_user] ||
+                             Chef::Config[:knife][:ssh_user])
+      end
+
+      def configure_identity_file
+        config[:identity_file] = get_stripped_unfrozen_value(config[:identity_file] ||
+                             Chef::Config[:knife][:ssh_identity_file])
+      end
+
+      def extract_nested_value(data_structure, path_spec)
+        ui.presenter.extract_nested_value(data_structure, path_spec)
+      end
+
+      def print_failed(arr = [{"node" => "ip", "meesage" => "message"}])
+        return if arr.compact.empty?
+        arr.each do |status|
+          ui.error("#{status['node']}  #{status['message']}")
+        end
+      end
+
+      def run
+        extend Chef::Mixin::Command
+
+        @longest = 0
+
+        @failed_connect_nodes = []
+        @not_zerro_nodes = []
+
+        configure_attribute
+        configure_user
+        configure_identity_file
+        configure_gateway
+        configure_session
+
+        exit_status = ssh_command(@name_args[1..-1].join(" "))
+
+        session.close
+
+        print_failed(@failed_connect_nodes)
+        print_failed(@not_zerro_nodes)
+
+        if (@not_zerro_nodes + @failed_connect_nodes).compact.empty?
+          exit_status
+        else
+          my_status = exit_status == 0 ? 1 : exit_status
+          exit my_status
+        end
+      end
+
+    end
+  end
+end

data/lib/knife/undev/version.rb

@@ -1,5 +1,5 @@
 module Knife
   module Undev
-    VERSION = "0.0.8"
+    VERSION = "0.0.9"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-undev
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Vasiliev Dmitry
@@ -101,7 +101,7 @@ files:
 - lib/knife/undev/converter.rb
 - lib/knife/undev/monkey_patches/node_presenter.rb
 - lib/knife/undev/monkey_patches/object_loader.rb
-- lib/knife/undev/monkey_patches/ssh.rb
+- lib/knife/undev/plugins/cloud_ssh.rb
 - lib/knife/undev/version.rb
 homepage: ''
 licenses:

data/lib/knife/undev/monkey_patches/ssh.rb

@@ -1,17 +0,0 @@
-require 'chef/knife'
-require 'chef/knife/ssh'
-
-class Chef
-  class Knife
-    class Ssh
-      
-      def configure_attribute
-        config[:override_attribute] = config[:attribute] || Chef::Config[:knife][:ssh_attribute]
-        config[:attribute] = (Chef::Config[:knife][:ssh_attribute] ||
-                              config[:attribute] || "private_ipaddress").strip
-      end
-
-    end
-  end
-end
-