net-ssh-cli 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acbf06cc3c79c68f798c7eaa7ee15a904fe56679d115c6ba9a3de3663d9b9198
-  data.tar.gz: 3e5da2f3f30cb58ea964faf25ff66da3f52221735bb6b4f953ac6def4d5d3dbc
+  metadata.gz: 36080ea8a1e4e289bc73d79d9a665a0848925799db74242e5705814a8c6081c9
+  data.tar.gz: 85cbb73ba6ff4925b39955c7416934a5c9124b8e4e5cbf0eeafc67af1bb2193f
 SHA512:
-  metadata.gz: f27705802860566503cc779c4e34a82270176bcb057d3b01545503673f4b0fb0244e4b2888afe85a09c0fe9f1e2510b7656d4ecfaaead6b751b98485046c1de2
-  data.tar.gz: c9d9f68b922206b848687164c5523682d5d349eed7195772c55b3f1f8e7e25a14adbd5c2201729f5c6effd4cea6a1ea2c8eda3ef71e469c86bd49fa1aecfaba7
+  metadata.gz: 0e3a0db15b0bb3d14e9cc2f7a1bd8c5e3379c8e2829e09fc8e3f63a445514f6b5a467cc3de76be5da34ec33632e8545bf8eea10ea2898eade24496f6fca222cb
+  data.tar.gz: 9b15edce5dc418753069b56004480bd9836104bfd9508b3e2dc89c31acdf3433253b76717bde7959dc6e4dcc53fcbbdedea1f8dee79f95359f2615feb37f402f

data/README.md

@@ -29,7 +29,7 @@ Or install it yourself as:
 
 ```ruby
 Net::SSH.start('host', 'user', password: "password") do |ssh|
-  cli = ssh.open_cli_channel(default_prompt: /(\nuser@host):/m)
+  cli = ssh.cli(default_prompt: /(\nuser@host):/m)
   cli.cmd ""
   # => "Last login: \nuser@host:"
 
@@ -40,18 +40,18 @@ end
 
 ```ruby
   net_ssh = Net::SSH.start('host', 'user', password: "password")
-  cli = Net::SSH::CLI::Channel.new(net_ssh: net_ssh)
+  cli = Net::SSH::CLI::Session.new(net_ssh: net_ssh)
   cli.cmd ""
 ```
 
 ```ruby
-  cli = Net::SSH::CLI::Channel.new(net_ssh_options: {host: 'host', user: 'user', password: 'password'})
+  cli = Net::SSH::CLI::Session.new(net_ssh_options: {host: 'host', user: 'user', password: 'password'})
   cli.cmd ""
 ```
 
 ### #cmd
 ```ruby
-  cli = ssh.open_cli_channel(default_prompt: /(\nuser@host):/m)
+  cli = ssh.cli(default_prompt: /(\nuser@host):/m)
   cli.cmd "echo 'bananas'"
   # => "echo 'bananas'\nbananas\nuser@host:"
   cli.cmd "echo 'bananas'", rm_command: true
@@ -64,7 +64,7 @@ end
 
 Remove the command and the prompt for #cmd & #dialog by default
 ```ruby
-  cli = ssh.open_cli_channel(default_prompt: /(\nuser@host):/m, cmd_rm_command: true, cmd_rm_prompt: true)
+  cli = ssh.cli(default_prompt: /(\nuser@host):/m, cmd_rm_command: true, cmd_rm_prompt: true)
   cli.cmd "echo 'bananas'"
   # => "bananas"
 ```
@@ -76,6 +76,50 @@ Remove the command and the prompt for #cmd & #dialog by default
   cli.cmd "yes"
 ```
 
+### #read & #write
+
+```ruby
+  cli.write "echo 'hello'\n"
+  # => "echo 'hello'\n"
+  cli.read
+  # => "echo 'hello'\nhello\nuser@host:"
+```
+
+### #write_n
+```ruby
+  cli.write_n "echo 'hello'"
+  # => "echo 'hello'\n"
+```
+
+### #read_till
+keep on processing till the stdout matches to given|default prompt and then read the whole stdin.
+```ruby
+  cli.write "\n"
+  # => "echo 'hello'\n"
+  cli.read_till
+  # => "echo 'hello'\nhello\nuser@host:"
+```
+
+This method is used by #cmd
+
+## Configuration
+
+Have a deep look at ``Net::SSH::CLI::OPTIONS`` at ``lib/net/ssh/cli.rb``
+
+### Callbacks
+
+The following callbacks are available
+ - #before_open_channel
+ - #after_open_channel
+ - #before_on_data
+ - #before_on_data
+
+```ruby
+cli.before_open_channel do
+  puts "The channel will open soon"
+end
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/bin/localhost

@@ -3,35 +3,29 @@
 
 require 'bundler/setup'
 require 'net/ssh/cli'
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
 require 'irb'
 
-def reload!
-  load __FILE__
-end
-
-$CLI = nil
 begin
-  $CLI = Net::SSH::CLI::Channel.new(host: 'localhost', user: ENV['USER'], default_prompt: '@')
+  $NET_SSH = Net::SSH.start("localhost")
+  $CLI = Net::SSH::CLI::Session.new(net_ssh: $NET_SSH, default_prompt: "@")
   $CLI.open_channel
-  puts "\nPUTS #{$CLI.read}"
-  sleep 0.3
-  puts "\nPUTS #{$CLI.read}"
-  puts "\nPUTS #{$CLI.write "\n"}"
-  puts "\nPUTS TILL #{$CLI.read_till}"
-  puts "try $CLI.cmd"
-  puts File.read(__FILE__)
+  puts "assuming your prompt contains '@'"
+  puts $CLI.cmd "echo 'hello world'"
 rescue StandardError => error
-  puts error.class
-  puts error.message
+  puts "#{error.class} #{error.message}"
   puts error.backtrace
 ensure
+  puts ""
+  puts File.read(__FILE__).lines.map {|line| "[bin/localhost] " + line}
+  puts ""
   IRB.start(__FILE__)
 end
+
+## Try one of those
+# $CLI.cmd "echo 'hello world'"
+# $CLI.detect_prompt
+# $CLI.default_prompt
+# $CLI.cmd "cat /etc/passwd"
+# $CLI.write "cat /etc/passwd"
+# $CLI.read
+# $CLI.cmd "echo 'hello world'"

data/lib/net/ssh/cli/version.rb

@@ -1,7 +1,7 @@
 module Net
   module SSH
     module CLI
-      VERSION = "0.2.0"
+      VERSION = "0.3.0"
     end
   end
 end

data/lib/net/ssh/cli.rb

@@ -16,42 +16,50 @@ module Net
         class UndefinedMatch < Error; end
         class OpenChannelTimeout < Error; end
         class ReadTillTimeout < Error; end
+        class PromptDetection < Error; end
+      end
+
+      # Example
+      # net_ssh = Net::SSH.start("localhost")
+      # net_ssh_cli = Net::SSH::CLI.start(net_ssh: net_ssh)
+      # net_ssh_cli.cmd "cat /etc/passwd"
+      # => "root:x:0:0:root:/root:/bin/bash\n..."
+      def self.start(**opts)
+        Net::SSH::CLI::Session.new(**opts)
       end
 
       def initialize(**opts)
         options.merge!(opts)
         self.net_ssh = options.delete(:net_ssh)
         self.logger = options.delete(:logger) || Logger.new(STDOUT, level: Logger::WARN)
-        open_channel unless lazy
-        @with_prompt = []
       end
 
-      attr_accessor :channel, :stdout, :stderr, :net_ssh, :logger
-
-      ## make everthing configurable!
-      #
-
-      DEFAULT = ActiveSupport::HashWithIndifferentAccess.new(
-        default_prompt: /^(\S+@.*)\z/,
-        process_time: 0.00001,
-        read_till_timeout: nil,
-        read_till_rm_prompt: false,
-        cmd_rm_prompt: false,
-        cmd_rm_command: false,
-        lazy: true
+      attr_accessor :channel, :stdout, :net_ssh, :logger
+
+      OPTIONS = ActiveSupport::HashWithIndifferentAccess.new(
+        default_prompt:            /\n?^(\S+@.*)\z/,                             # the default prompt to search for
+        cmd_rm_prompt:             false,                                        # whether the prompt should be removed in the output of #cmd
+        cmd_rm_command:            false,                                        # whether the given command should be removed in the output of #cmd
+        read_till_timeout:         nil,                                          # timeout for #read_till to find the match
+        named_prompts:             ActiveSupport::HashWithIndifferentAccess.new, # you can used named prompts for #with_prompt {} 
+        before_on_stdout_procs:    ActiveSupport::HashWithIndifferentAccess.new, # procs to call before data arrives from the underlying connection 
+        after_on_stdout_procs:     ActiveSupport::HashWithIndifferentAccess.new, # procs to call after  data arrives from the underlying connection
+        before_open_channel_procs: ActiveSupport::HashWithIndifferentAccess.new, # procs to call before opening a channel 
+        after_open_channel_procs:  ActiveSupport::HashWithIndifferentAccess.new, # procs to call after  opening a channel, for example you could call #detect_prompt or #read_till
+        open_channel_timeout:      nil,                                          # timeout to open the channel
+        net_ssh_options:           ActiveSupport::HashWithIndifferentAccess.new, # a wrapper for options to pass to Net::SSH.start in case net_ssh is undefined
+        process_time:              0.00001,                                      # how long #process is processing net_ssh#process or sleeping (waiting for something)
+        background_processing:     false,                                        # default false, whether the process method maps to the underlying net_ssh#process or the net_ssh#process happens in a separate loop
       )
 
-      def default
-        @default ||= DEFAULT.clone
-      end
-
-      def default!(**defaults)
-        default.merge!(**defaults)
-      end
-
-      # don't even think about nesting hashes here
       def options
-        @options ||= default
+        @options ||= begin
+          opts = OPTIONS.clone
+          opts.each do |key,value|
+            opts[key] = value.clone if value.is_a?(Hash)
+          end
+          opts
+        end
       end
 
       # don't even think about nesting hashes here
@@ -59,63 +67,28 @@ module Net
         options.merge!(opts)
       end
 
-      # don't even think about nesting hashes here
       def options=(opts)
         @options = ActiveSupport::HashWithIndifferentAccess.new(opts)
       end
 
-      %i[default_prompt process_time read_till_timeout cmd_rm_command cmd_rm_prompt read_till_rm_prompt lazy].each do |name|
+      OPTIONS.keys.each do |name|
         define_method name do
           options[name]
         end
         define_method "#{name}=" do |value|
           options[name] = value
         end
-      end
-
-      %i[process_stdout_procs process_stderr_procs named_prompts net_ssh_options open_channel_options].each do |name|
-        define_method name do
-          options[name] ||= ActiveSupport::HashWithIndifferentAccess.new
-        end
-        define_method "#{name}!" do |**opts|
-          send(name).merge!(**opts)
-        end
-        define_method "#{name}=" do |value|
-          options[name] = ActiveSupport::HashWithIndifferentAccess.new(value)
+        define_method "#{name}?" do
+          !!options[name]
         end
       end
 
-      def formatted_net_ssh_options
-        net_ssh_options.symbolize_keys.reject {|k,v| [:host, :ip, :user].include?(k)}
-      end
-
-      ## Net::SSH instance
-      #
-
-      def net_ssh
-        return @net_ssh if @net_ssh
-
-        logger.debug { 'Net:SSH #start' }
-        self.net_ssh = Net::SSH.start(net_ssh_options[:ip] || net_ssh_options[:host], net_ssh_options[:user] || ENV['USER'], formatted_net_ssh_options)
-      rescue StandardError => error
-        self.net_ssh = nil
-        raise
-      end
-      alias proxy net_ssh
-
-      def host
-        net_ssh_options[:host] || net_ssh_options[:hostname] || net_ssh_options[:ip] || @net_ssh&.host
-      end
-      alias to_s host
-      alias hostname host
-
-      def ip
-        net_ssh_options[:ip]
+      OPTIONS.keys.select {|key| key.to_s.include? "procs"}.each do |name|
+        define_method name.sub("_procs","") do |&blk|
+          self.send(name)[SecureRandom.uuid] = Proc.new {blk.call}
+        end
       end
 
-      ## channel & stderr|stdout stream handling
-      #
-
       def stdout
         @stdout ||= String.new
       end
@@ -126,65 +99,15 @@ module Net
         var
       end
 
-      def stderr
-        @stderr ||= String.new
-      end
-
-      def stderr!
-        var = stderr
-        self.stderr = String.new
-        var
-      end
-
-      def open_channel # cli_channel
-        ::Timeout.timeout(open_channel_options[:timeout], Error::OpenChannelTimeout) do
-          net_ssh.open_channel do |channel_|
-            logger.debug 'channel is open'
-            self.channel = channel_
-            channel_.request_pty do |_ch, success|
-              raise Error::Pty, "#{host || ip} Failed to open ssh pty" unless success
-            end
-            channel_.send_channel_request('shell') do |_ch, success|
-              raise Error::RequestShell, 'Failed to open ssh shell' unless success
-            end
-            channel_.on_data do |_ch, data|
-              process_stdout(data)
-            end
-            channel_.on_extended_data do |_ch, type, data|
-              process_stderr(data, type)
-            end
-            channel_.on_close do
-              close
-            end
-          end
-          until channel do process end
-        end
-        logger.debug 'channel is ready, running callbacks now'
-        read_till if open_channel_options[:after_read_till_prompt]
-        open_channel_options[:after_proc]&.call
-        process
-      rescue StandardError => error
-        close
-        raise
-      end
-
-      def process_stdout(data)
+      def on_stdout(data)
+        before_on_stdout_procs.each { |_name, a_proc| a_proc.call }
         stdout << data
+        after_on_stdout_procs.each  { |_name, a_proc| a_proc.call }
         process # if we receive data, we probably receive more - improves performance
-        process_stdout_procs.each { |_name, a_proc| a_proc.call }
         stdout
       end
 
-      def process_stderr(data, _type)
-        stderr << data
-        process # if we receive data, we probably receive more - improves performance
-        process_stderr_procs.each { |_name, a_proc| a_proc.call }
-        stderr
-      end
-
       def write(content = String.new)
-        raise Error, 'channel is not stablished or gone' unless channel
-
         logger.debug { "#write #{content.inspect}" }
         channel.send_data content
         process
@@ -196,7 +119,6 @@ module Net
         write content + "\n"
       end
 
-      # returns the stdout buffer and empties it
       def read
         process
         var = stdout!
@@ -208,7 +130,7 @@ module Net
       #
 
       def current_prompt
-        @with_prompt[-1] || default_prompt
+        with_prompts[-1] || default_prompt
       end
 
       def with_named_prompt(name)
@@ -219,19 +141,26 @@ module Net
         end
       end
 
-      def detect_prompt(seconds: 5)
-        process(seconds)
-        self.default_prompt = read[/.*\z/]
+      def detect_prompt(seconds: 3)
+        write_n
+        future = Time.now + seconds
+        while future > Time.now
+          process
+          sleep 0.1
+        end
+        self.default_prompt = read[/\n?^.*\z/]
+        raise Error::PromptDetection, "couldn't detect a prompt" unless default_prompt.present?
+        default_prompt
       end
 
       # prove a block where the default prompt changes
       def with_prompt(prompt)
         logger.debug { "#with_prompt: #{current_prompt.inspect} => #{prompt.inspect}" }
-        @with_prompt << prompt
+        with_prompts << prompt
         yield
         prompt
       ensure
-        @with_prompt.delete_at(-1)
+        with_prompts.delete_at(-1)
         logger.debug { "#with_prompt: => #{current_prompt.inspect}" }
       end
 
@@ -240,59 +169,51 @@ module Net
 
         ::Timeout.timeout(timeout, Error::ReadTillTimeout.new("output did not prompt #{prompt.inspect} within #{timeout}")) do
           with_prompt(prompt) do
-            process until stdout[current_prompt]
+            until stdout[current_prompt] do
+              process
+              sleep 0.1
+            end
           end
         end
         read
       end
 
       def read_for(seconds:)
-        process
-        sleep seconds
-        process
+        process(seconds)
         read
       end
 
       def dialog(command, prompt, **opts)
-        pre_read = read
-        logger.debug { "#dialog ignores the following pre-output #{pre_read.inspect}" } if pre_read.present?
-        write command
-        output = read_till(prompt: prompt, **opts)
-        rm_prompt!(output, prompt: prompt, **opts)
-        rm_command!(output, command, prompt: prompt, **opts)
-        output
+        opts = opts.clone.merge(prompt: prompt) 
+        cmd(command, opts)
       end
 
       # 'read' first on purpuse as a feature. once you cmd you ignore what happend before. otherwise use read|write directly.
       # this should avoid many horrible state issues where the prompt is not the last prompt
-      def cmd(command, **opts)
-        pre_read = read
-        logger.debug { "#cmd ignoring pre-read: #{pre_read.inspect}" } if pre_read.present?
+      def cmd(command, pre_read: true, rm_prompt: cmd_rm_prompt, rm_command: cmd_rm_command, prompt: current_prompt, **opts)
+        opts = opts.clone.merge(pre_read: pre_read, rm_prompt: rm_prompt, rm_command: rm_command, prompt: prompt) 
+        if pre_read
+          pre_read_data = read
+          logger.debug { "#cmd ignoring pre-command output: #{pre_read_data.inspect}" } if pre_read_data.present?
+        end
         write_n command
-        output = read_till(**opts)
-        rm_prompt!(output, **opts)
-        rm_command!(output, command, **opts)
+        output = read_till(opts)
+        rm_prompt!(output, opts)
+        rm_command!(output, command, opts)
         output
       end
       alias command cmd
+      alias exec cmd
 
       def cmds(commands, **opts)
         commands.map { |command| [command, cmd(command, **opts)] }
       end
       alias commands cmds
 
-      def rm_command?(**opts)
-        opts[:rm_cmd].nil? ? cmd_rm_command : opts[:rm_cmd]
-      end
-
       def rm_command!(output, command, **opts)
         output[command + "\n"] = '' if rm_command?(opts) && output[command + "\n"]
       end
 
-      def rm_prompt?(**opts)
-        opts[:rm_prompt].nil? ? cmd_rm_prompt : opts[:rm_prompt]
-      end
-
       def rm_prompt!(output, **opts)
         if rm_prompt?(opts)
           prompt = opts[:prompt] || current_prompt
@@ -302,61 +223,97 @@ module Net
         end
       end
 
+      def host
+        @net_ssh&.host
+      end
+      alias hostname host
+      alias to_s host
+
       ## NET::SSH
       #
 
+      def net_ssh
+        return @net_ssh if @net_ssh
+
+        logger.debug { 'Net:SSH #start' }
+        self.net_ssh = Net::SSH.start(net_ssh_options[:ip] || net_ssh_options[:host] || "localhost", net_ssh_options[:user] || ENV['USER'], formatted_net_ssh_options)
+      rescue StandardError => error
+        self.net_ssh = nil
+        raise
+      end
+      alias proxy net_ssh
+
+      # have a deep look at the source of Net::SSH
+      # session#process https://github.com/net-ssh/net-ssh/blob/dd13dd44d68b7fa82d4ca9a3bbe18e30c855f1d2/lib/net/ssh/connection/session.rb#L227 
+      # session#loop    https://github.com/net-ssh/net-ssh/blob/dd13dd44d68b7fa82d4ca9a3bbe18e30c855f1d2/lib/net/ssh/connection/session.rb#L179
+      # because the (cli) channel stays open, we always need to ensure that the ssh layer gets "processed" further. This can be done inside here automatically or outside in a separate event loop for the net_ssh connection.
       def process(time = process_time)
-        net_ssh.process(time)
+        background_processing? ? sleep(time) : net_ssh.process(time)
       rescue IOError => error
         raise Error, error.message
       end
 
-      def close
-        return unless net_ssh
+      def open_channel # cli_channel
+        before_open_channel_procs.each  { |_name, a_proc| a_proc.call }
+        ::Timeout.timeout(open_channel_timeout, Error::OpenChannelTimeout) do
+          net_ssh.open_channel do |new_channel|
+            logger.debug 'channel is open'
+            self.channel = new_channel
+            new_channel.request_pty do |_ch, success|
+              raise Error::Pty, "#{host || ip} Failed to open ssh pty" unless success
+            end
+            new_channel.send_channel_request('shell') do |_ch, success|
+              raise Error::RequestShell, 'Failed to open ssh shell' unless success
+            end
+            new_channel.on_data do |_ch, data|
+              on_stdout(data)
+            end
+            #new_channel.on_extended_data do |_ch, type, data| end
+            #new_channel.on_close do end
+          end
+          until channel do process end
+        end
+        logger.debug 'channel is ready, running callbacks now'
+        after_open_channel_procs.each  { |_name, a_proc| a_proc.call }
+        process
+        self
+      end
 
-        net_ssh.cleanup_channel(channel) if channel
+      def close_channel
+        net_ssh&.cleanup_channel(channel) if channel
         self.channel = nil
-        # ssh.close if ssh.channels.none? # should the connection be closed if the last channel gets closed?
       end
 
-      def connect
-        open_channel unless channel
-      end
+      private 
 
-      def reconnect
-        disconnect
-        connect
+      def with_prompts
+        @with_prompts ||= []
       end
 
-      # feels wrong
-
-      def disconnect
-        close
-        net_ssh&.close
-        self.net_ssh = nil
+      def formatted_net_ssh_options
+        net_ssh_options.symbolize_keys.reject {|k,v| [:host, :ip, :user].include?(k)}
       end
 
-      def shutdown!
-        net_ssh&.shutdown!
+      def rm_prompt?(**opts)
+        opts[:rm_prompt].nil? ? cmd_rm_prompt : opts[:rm_prompt]
       end
 
-      private
-
+      def rm_command?(**opts)
+        opts[:rm_cmd].nil? ? cmd_rm_command : opts[:rm_cmd]
+      end
     end
   end
 end
 
-class Net::SSH::CLI::Channel
+class Net::SSH::CLI::Session
   include Net::SSH::CLI
-  def initialize(**options)
-    super
-    # open_channel
-  end
 end
 
 class Net::SSH::Connection::Session
   attr_accessor :cli_channels
-  def open_cli_channel(**opts)
-    Net::SSH::CLI::Channel.new({ net_ssh: self, lazy: false }.merge(opts))
+  def cli(**opts)
+    cli_session = Net::SSH::CLI::Session.new({net_ssh: self}.merge(opts))
+    cli_session.open_channel
+    cli_session
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: net-ssh-cli
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Fabian Stillhart
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-02-25 00:00:00.000000000 Z
+date: 2019-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler