hrr_rb_ssh 0.4.0.pre1 → 0.4.0.pre2

data/lib/hrr_rb_ssh/authentication/method/password.rb

@@ -1,30 +1,32 @@
 # coding: utf-8
 # vim: et ts=2 sw=2
 
-require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/loggable'
 
 module HrrRbSsh
   class Authentication
     class Method
       class Password < Method
+        include Loggable
+
         NAME = 'password'
         PREFERENCE = 10
 
-        def initialize transport, options, variables, authentication_methods
-          @logger = Logger.new(self.class.name)
+        def initialize transport, options, variables, authentication_methods, logger: nil
+          self.logger = logger
           @transport = transport
-          @authenticator = options.fetch( 'authentication_password_authenticator', Authenticator.new { false } )
+          @authenticator = options.fetch( 'authentication_password_authenticator', Authenticator.new{ false } )
           @options = options
           @variables = variables
           @authentication_methods = authentication_methods
         end
 
         def authenticate userauth_request_message
-          @logger.info { "authenticate" }
-          @logger.debug { "userauth request: " + userauth_request_message.inspect }
+          log_info { "authenticate" }
+          log_debug { "userauth request: " + userauth_request_message.inspect }
           username = userauth_request_message[:'user name']
           password = userauth_request_message[:'plaintext password']
-          context = Context.new(username, password, @variables, @authentication_methods)
+          context = Context.new(username, password, @variables, @authentication_methods, logger: logger)
           @authenticator.authenticate context
         end
 
@@ -38,7 +40,7 @@ module HrrRbSsh
             :"FALSE"              => false,
             :"plaintext password" => password,
           }
-          payload = Message::SSH_MSG_USERAUTH_REQUEST.encode message
+          payload = Message::SSH_MSG_USERAUTH_REQUEST.encode message, logger: logger
           @transport.send payload
 
           payload = @transport.receive

data/lib/hrr_rb_ssh/authentication/method/publickey/algorithm/functionable.rb

@@ -1,7 +1,7 @@
 # coding: utf-8
 # vim: et ts=2 sw=2
 
-require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/loggable'
 require 'hrr_rb_ssh/algorithm/publickey'
 
 module HrrRbSsh
@@ -10,16 +10,18 @@ module HrrRbSsh
       class Publickey
         class Algorithm
           module Functionable
-            def initialize
-              @logger = Logger.new(self.class.name)
+            include Loggable
+
+            def initialize logger: nil
+              self.logger = logger
             end
 
             def verify_public_key public_key_algorithm_name, public_key, public_key_blob
               begin
-                publickey = HrrRbSsh::Algorithm::Publickey[self.class::NAME].new public_key
+                publickey = HrrRbSsh::Algorithm::Publickey[self.class::NAME].new public_key, logger: logger
                 public_key_algorithm_name == self.class::NAME && public_key_blob == publickey.to_public_key_blob
               rescue => e
-                @logger.error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+                log_error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
                 false
               end
             end
@@ -36,22 +38,22 @@ module HrrRbSsh
                   :'public key algorithm name' => message[:'public key algorithm name'],
                   :'public key blob'           => message[:'public key blob'],
                 }
-                signature_blob = SignatureBlob.encode signature_blob_h
-                publickey = HrrRbSsh::Algorithm::Publickey[self.class::NAME].new message[:'public key blob']
+                signature_blob = SignatureBlob.encode signature_blob_h, logger: logger
+                publickey = HrrRbSsh::Algorithm::Publickey[self.class::NAME].new message[:'public key blob'], logger: logger
                 publickey.verify message[:'signature'], signature_blob
               rescue => e
-                @logger.error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+                log_error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
                 false
               end
             end
 
             def generate_public_key_blob secret_key
-              publickey = HrrRbSsh::Algorithm::Publickey[self.class::NAME].new secret_key
+              publickey = HrrRbSsh::Algorithm::Publickey[self.class::NAME].new secret_key, logger: logger
               publickey.to_public_key_blob
             end
 
             def generate_signature session_id, username, service_name, method_name, secret_key
-              publickey = HrrRbSsh::Algorithm::Publickey[self.class::NAME].new secret_key
+              publickey = HrrRbSsh::Algorithm::Publickey[self.class::NAME].new secret_key, logger: logger
               publickey_blob = publickey.to_public_key_blob
               signature_blob_h = {
                 :'session identifier'        => session_id,
@@ -63,7 +65,7 @@ module HrrRbSsh
                 :'public key algorithm name' => self.class::NAME,
                 :'public key blob'           => publickey_blob
               }
-              signature_blob = SignatureBlob.encode signature_blob_h
+              signature_blob = SignatureBlob.encode signature_blob_h, logger: logger
               publickey.sign signature_blob
             end
           end

data/lib/hrr_rb_ssh/authentication/method/publickey/context.rb

@@ -1,13 +1,15 @@
 # coding: utf-8
 # vim: et ts=2 sw=2
 
-require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/loggable'
 
 module HrrRbSsh
   class Authentication
     class Method
       class Publickey
         class Context
+          include Loggable
+
           attr_reader \
             :username,
             :session_id,
@@ -22,7 +24,8 @@ module HrrRbSsh
             :public_key_blob,
             :signature
 
-          def initialize username, algorithm, session_id, message, variables, authentication_methods
+          def initialize username, algorithm, session_id, message, variables, authentication_methods, logger: nil
+            self.logger = logger
             @username   = username
             @algorithm  = algorithm
             @session_id = session_id

data/lib/hrr_rb_ssh/authentication/method/publickey.rb

@@ -1,21 +1,23 @@
 # coding: utf-8
 # vim: et ts=2 sw=2
 
-require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/loggable'
 
 module HrrRbSsh
   class Authentication
     class Method
       class Publickey < Method
+        include Loggable
+
         NAME = 'publickey'
         PREFERENCE = 20
 
-        def initialize transport, options, variables, authentication_methods
-          @logger = Logger.new(self.class.name)
+        def initialize transport, options, variables, authentication_methods, logger: nil
+          self.logger = logger
           @transport = transport
           @options = options
           @session_id = options['session id']
-          @authenticator = options.fetch( 'authentication_publickey_authenticator', Authenticator.new { false } )
+          @authenticator = options.fetch( 'authentication_publickey_authenticator', Authenticator.new{ false } )
           @variables = variables
           @authentication_methods = authentication_methods
         end
@@ -23,18 +25,18 @@ module HrrRbSsh
         def authenticate userauth_request_message
           public_key_algorithm_name = userauth_request_message[:'public key algorithm name']
           unless Algorithm.list_preferred.include?(public_key_algorithm_name)
-            @logger.info { "unsupported public key algorithm: #{public_key_algorithm_name}" }
+            log_info { "unsupported public key algorithm: #{public_key_algorithm_name}" }
             return false
           end
           unless userauth_request_message[:'with signature']
-            @logger.info { "public key algorithm is ok, require signature" }
+            log_info { "public key algorithm is ok, require signature" }
             public_key_blob = userauth_request_message[:'public key blob']
             userauth_pk_ok_message public_key_algorithm_name, public_key_blob
           else
-            @logger.info { "verify signature" }
+            log_info { "verify signature" }
             username = userauth_request_message[:'user name']
-            algorithm = Algorithm[public_key_algorithm_name].new
-            context = Context.new(username, algorithm, @session_id, userauth_request_message, @variables, @authentication_methods)
+            algorithm = Algorithm[public_key_algorithm_name].new logger: logger
+            context = Context.new(username, algorithm, @session_id, userauth_request_message, @variables, @authentication_methods, logger: logger)
             @authenticator.authenticate context
           end
         end
@@ -45,7 +47,7 @@ module HrrRbSsh
             :'public key algorithm name from the request' => public_key_algorithm_name,
             :'public key blob from the request'           => public_key_blob,
           }
-          payload = Message::SSH_MSG_USERAUTH_PK_OK.encode message
+          payload = Message::SSH_MSG_USERAUTH_PK_OK.encode message, logger: logger
         end
 
         def request_authentication username, service_name
@@ -62,7 +64,7 @@ module HrrRbSsh
         end
 
         def send_request_without_signature username, service_name, public_key_algorithm_name, secret_key
-          algorithm = Algorithm[public_key_algorithm_name].new
+          algorithm = Algorithm[public_key_algorithm_name].new logger: logger
           public_key_blob = algorithm.generate_public_key_blob(secret_key)
           message = {
             :'message number'            => Message::SSH_MSG_USERAUTH_REQUEST::VALUE,
@@ -73,12 +75,12 @@ module HrrRbSsh
             :'public key algorithm name' => public_key_algorithm_name,
             :'public key blob'           => public_key_blob,
           }
-          payload = Message::SSH_MSG_USERAUTH_REQUEST.encode message
+          payload = Message::SSH_MSG_USERAUTH_REQUEST.encode message, logger: logger
           @transport.send payload
         end
 
         def send_request_with_signature username, service_name, public_key_algorithm_name, secret_key
-          algorithm = Algorithm[public_key_algorithm_name].new
+          algorithm = Algorithm[public_key_algorithm_name].new logger: logger
           public_key_blob = algorithm.generate_public_key_blob(secret_key)
           signature = algorithm.generate_signature(@session_id, username, service_name, 'publickey', secret_key)
           message = {
@@ -91,7 +93,7 @@ module HrrRbSsh
             :'public key blob'           => public_key_blob,
             :'signature'                 => signature,
           }
-          payload = Message::SSH_MSG_USERAUTH_REQUEST.encode message
+          payload = Message::SSH_MSG_USERAUTH_REQUEST.encode message, logger: logger
           @transport.send payload
         end
       end

data/lib/hrr_rb_ssh/authentication.rb

@@ -1,7 +1,7 @@
 # coding: utf-8
 # vim: et ts=2 sw=2
 
-require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/loggable'
 require 'hrr_rb_ssh/message'
 require 'hrr_rb_ssh/error/closed_authentication'
 require 'hrr_rb_ssh/authentication/constant'
@@ -10,15 +10,16 @@ require 'hrr_rb_ssh/authentication/method'
 
 module HrrRbSsh
   class Authentication
+    include Loggable
     include Constant
 
-    def initialize transport, mode, options={}
+    def initialize transport, mode, options={}, logger: nil
+      self.logger = logger
+
       @transport = transport
       @mode = mode
       @options = options
 
-      @logger = Logger.new self.class.name
-
       @transport.register_acceptable_service SERVICE_NAME
 
       @closed = nil
@@ -81,42 +82,42 @@ module HrrRbSsh
 
     def respond_to_authentication
       authentication_methods = (@options['authentication_preferred_authentication_methods'].dup rescue nil) || Method.list_preferred # rescue nil.dup for Ruby version < 2.4
-      @logger.info { "preferred authentication methods: #{authentication_methods}" }
+      log_info { "preferred authentication methods: #{authentication_methods}" }
       loop do
         payload = @transport.receive
         case payload[0,1].unpack("C")[0]
         when Message::SSH_MSG_USERAUTH_REQUEST::VALUE
-          userauth_request_message = Message::SSH_MSG_USERAUTH_REQUEST.decode payload
+          userauth_request_message = Message::SSH_MSG_USERAUTH_REQUEST.decode payload, logger: logger
           method_name = userauth_request_message[:'method name']
-          @logger.info { "authentication method: #{method_name}" }
-          method = Method[method_name].new(@transport, {'session id' => @transport.session_id}.merge(@options), @variables, authentication_methods)
+          log_info { "authentication method: #{method_name}" }
+          method = Method[method_name].new(@transport, {'session id' => @transport.session_id}.merge(@options), @variables, authentication_methods, logger: logger)
           result = method.authenticate(userauth_request_message)
           case result
           when true, SUCCESS
-            @logger.info { "verified" }
+            log_info { "verified" }
             send_userauth_success
             @username = userauth_request_message[:'user name']
             @closed = false
             break
           when PARTIAL_SUCCESS
-            @logger.info { "partially verified" }
+            log_info { "partially verified" }
             authentication_methods.delete method_name
-            @logger.debug { "authentication methods that can continue: #{authentication_methods}" }
+            log_debug { "authentication methods that can continue: #{authentication_methods}" }
             if authentication_methods.empty?
-              @logger.info { "verified" }
+              log_info { "verified" }
               send_userauth_success
               @username = userauth_request_message[:'user name']
               @closed = false
               break
             else
-              @logger.info { "continue" }
+              log_info { "continue" }
               send_userauth_failure authentication_methods, true
             end
           when String
-            @logger.info { "send method specific message to continue" }
+            log_info { "send method specific message to continue" }
             send_method_specific_message result
           else # when false, FAILURE
-            @logger.info { "verify failed" }
+            log_info { "verify failed" }
             send_userauth_failure authentication_methods, false
           end
         else
@@ -128,33 +129,33 @@ module HrrRbSsh
 
     def request_authentication
       authentication_methods = (@options['authentication_preferred_authentication_methods'].dup rescue nil) || Method.list_preferred # rescue nil.dup for Ruby version < 2.4
-      @logger.info { "preferred authentication methods: #{authentication_methods}" }
+      log_info { "preferred authentication methods: #{authentication_methods}" }
       next_method_name = "none"
-      @logger.info { "authentication request begins with none method" }
+      log_info { "authentication request begins with none method" }
       loop do
-        @logger.info { "authentication method: #{next_method_name}" }
-        method = Method[next_method_name].new(@transport, {'session id' => @transport.session_id}.merge(@options), @variables, authentication_methods)
+        log_info { "authentication method: #{next_method_name}" }
+        method = Method[next_method_name].new(@transport, {'session id' => @transport.session_id}.merge(@options), @variables, authentication_methods, logger: logger)
         payload = method.request_authentication @options['username'], "ssh-connection"
         case payload[0,1].unpack("C")[0]
         when Message::SSH_MSG_USERAUTH_SUCCESS::VALUE
-          @logger.info { "verified" }
+          log_info { "verified" }
           @username = @options['username']
           @closed = false
           break
         when Message::SSH_MSG_USERAUTH_FAILURE::VALUE
-          message = Message::SSH_MSG_USERAUTH_FAILURE.decode payload
+          message = Message::SSH_MSG_USERAUTH_FAILURE.decode payload, logger: logger
           partial_success = message[:'partial success']
           if partial_success
-            @logger.info { "partially verified" }
+            log_info { "partially verified" }
           end
           authentication_methods_that_can_continue = message[:'authentications that can continue']
-          @logger.debug { "authentication methods that can continue: #{authentication_methods_that_can_continue}" }
+          log_debug { "authentication methods that can continue: #{authentication_methods_that_can_continue}" }
           next_method_name = authentication_methods.find{ |local_m| authentication_methods_that_can_continue.find{ |remote_m| local_m == remote_m } }
           if next_method_name
             authentication_methods.delete next_method_name
-            @logger.info { "continue" }
+            log_info { "continue" }
           else
-            @logger.info { "no more available authentication methods" }
+            log_info { "no more available authentication methods" }
             @closed = true
             raise "failed authentication"
           end
@@ -168,7 +169,7 @@ module HrrRbSsh
         :'authentications that can continue' => authentication_methods,
         :'partial success'                   => partial_success,
       }
-      payload = Message::SSH_MSG_USERAUTH_FAILURE.encode message
+      payload = Message::SSH_MSG_USERAUTH_FAILURE.encode message, logger: logger
       @transport.send payload
     end
 
@@ -176,7 +177,7 @@ module HrrRbSsh
       message = {
         :'message number' => Message::SSH_MSG_USERAUTH_SUCCESS::VALUE,
       }
-      payload = Message::SSH_MSG_USERAUTH_SUCCESS.encode message
+      payload = Message::SSH_MSG_USERAUTH_SUCCESS.encode message, logger: logger
       @transport.send payload
     end
 

data/lib/hrr_rb_ssh/client.rb

@@ -3,7 +3,7 @@
 
 require 'socket'
 require 'stringio'
-require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/loggable'
 require 'hrr_rb_ssh/mode'
 require 'hrr_rb_ssh/transport'
 require 'hrr_rb_ssh/authentication'
@@ -11,6 +11,8 @@ require 'hrr_rb_ssh/connection'
 
 module HrrRbSsh
   class Client
+    include Loggable
+
     def self.start target, options={}
       client = self.new target, options
       client.start
@@ -26,7 +28,6 @@ module HrrRbSsh
     end
 
     def initialize target, tmp_options={}
-      @logger = Logger.new self.class.name
       @closed = true
       options = initialize_options tmp_options
       io = case target
@@ -38,24 +39,25 @@ module HrrRbSsh
              port = 22
              io = TCPSocket.new target, port
            end
-      transport      = HrrRbSsh::Transport.new      io, HrrRbSsh::Mode::CLIENT, options
-      authentication = HrrRbSsh::Authentication.new transport, HrrRbSsh::Mode::CLIENT, options
-      @connection    = HrrRbSsh::Connection.new     authentication, HrrRbSsh::Mode::CLIENT, options
+      transport      = HrrRbSsh::Transport.new      io, HrrRbSsh::Mode::CLIENT, options, logger: logger
+      authentication = HrrRbSsh::Authentication.new transport, HrrRbSsh::Mode::CLIENT, options, logger: logger
+      @connection    = HrrRbSsh::Connection.new     authentication, HrrRbSsh::Mode::CLIENT, options, logger: logger
     end
 
     def initialize_options tmp_options
       tmp_options = Hash[tmp_options.map{|k, v| [k.to_s, v]}]
+      self.logger = tmp_options['logger']
       options = {}
       options['username'] = tmp_options['username']
       options['authentication_preferred_authentication_methods'] = tmp_options['authentication_preferred_authentication_methods']
-      options['client_authentication_password']             = tmp_options['password']
-      options['client_authentication_publickey']            = tmp_options['publickey']
-      options['client_authentication_keyboard_interactive'] = tmp_options['keyboard_interactive']
-      options['transport_preferred_encryption_algorithms']      = tmp_options['transport_preferred_encryption_algorithms']
-      options['transport_preferred_server_host_key_algorithms'] = tmp_options['transport_preferred_server_host_key_algorithms']
-      options['transport_preferred_kex_algorithms']             = tmp_options['transport_preferred_kex_algorithms']
-      options['transport_preferred_mac_algorithms']             = tmp_options['transport_preferred_mac_algorithms']
-      options['transport_preferred_compression_algorithms']     = tmp_options['transport_preferred_compression_algorithms']
+      options['client_authentication_password']                  = tmp_options['password']
+      options['client_authentication_publickey']                 = tmp_options['publickey']
+      options['client_authentication_keyboard_interactive']      = tmp_options['keyboard_interactive']
+      options['transport_preferred_encryption_algorithms']       = tmp_options['transport_preferred_encryption_algorithms']
+      options['transport_preferred_server_host_key_algorithms']  = tmp_options['transport_preferred_server_host_key_algorithms']
+      options['transport_preferred_kex_algorithms']              = tmp_options['transport_preferred_kex_algorithms']
+      options['transport_preferred_mac_algorithms']              = tmp_options['transport_preferred_mac_algorithms']
+      options['transport_preferred_compression_algorithms']      = tmp_options['transport_preferred_compression_algorithms']
       options
     end
 
@@ -73,20 +75,20 @@ module HrrRbSsh
     end
 
     def close
-      @logger.debug { "closing client" }
+      log_debug { "closing client" }
       @closed = true
       @connection.close
-      @logger.debug { "client closed" }
+      log_debug { "client closed" }
     end
 
     def exec! command, pty: false, env: {}
-      @logger.debug { "start exec!: #{command}" }
+      log_debug { "start exec!: #{command}" }
       out_buf = StringIO.new
       err_buf = StringIO.new
       begin
-        @logger.info { "Opning channel" }
+        log_info { "Opning channel" }
         channel = @connection.request_channel_open "session"
-        @logger.info { "Channel opened" }
+        log_info { "Channel opened" }
         if pty
           channel.send_channel_request_pty_req 'xterm', 80, 24, 580, 336, ''
         end
@@ -116,34 +118,34 @@ module HrrRbSsh
           begin
             t.join
           rescue => e
-            @logger.warn { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+            log_warn { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
           end
         }
       rescue => e
-        @logger.error { "Failed opening channel" }
-        @logger.error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+        log_error { "Failed opening channel" }
+        log_error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
         raise "Error in exec!"
       ensure
         if channel
-          @logger.info { "closing channel IOs" }
+          log_info { "closing channel IOs" }
           channel.io.each{ |io| io.close rescue nil }
-          @logger.info { "channel IOs closed" }
-          @logger.info { "closing channel" }
-          @logger.info { "wait until threads closed in channel" }
+          log_info { "channel IOs closed" }
+          log_info { "closing channel" }
+          log_info { "wait until threads closed in channel" }
           channel.wait_until_closed
           channel.close
-          @logger.info { "channel closed" }
+          log_info { "channel closed" }
         end
       end
       [out_buf.string, err_buf.string]
     end
 
     def exec command, pty: false, env: {}
-      @logger.debug { "start exec: #{command}" }
+      log_debug { "start exec: #{command}" }
       begin
-        @logger.info { "Opning channel" }
+        log_info { "Opning channel" }
         channel = @connection.request_channel_open "session"
-        @logger.info { "Channel opened" }
+        log_info { "Channel opened" }
         if pty
           channel.send_channel_request_pty_req 'xterm', 80, 24, 580, 336, ''
         end
@@ -153,30 +155,30 @@ module HrrRbSsh
         channel.send_channel_request_exec command
         yield channel.io
       rescue => e
-        @logger.error { "Failed opening channel" }
-        @logger.error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+        log_error { "Failed opening channel" }
+        log_error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
         raise "Error in shell"
       ensure
         if channel
-          @logger.info { "closing channel IOs" }
+          log_info { "closing channel IOs" }
           channel.io.each{ |io| io.close rescue nil }
-          @logger.info { "channel IOs closed" }
-          @logger.info { "closing channel" }
-          @logger.info { "wait until threads closed in channel" }
+          log_info { "channel IOs closed" }
+          log_info { "closing channel" }
+          log_info { "wait until threads closed in channel" }
           channel.wait_until_closed
           channel.close
-          @logger.info { "channel closed" }
+          log_info { "channel closed" }
         end
       end
       channel_exit_status = channel.exit_status rescue nil
     end
 
     def shell env: {}
-      @logger.debug { "start shell" }
+      log_debug { "start shell" }
       begin
-        @logger.info { "Opning channel" }
+        log_info { "Opning channel" }
         channel = @connection.request_channel_open "session"
-        @logger.info { "Channel opened" }
+        log_info { "Channel opened" }
         channel.send_channel_request_pty_req 'xterm', 80, 24, 580, 336, ''
         env.each{ |variable_name, variable_value|
           channel.send_channel_request_env variable_name, variable_value
@@ -184,46 +186,46 @@ module HrrRbSsh
         channel.send_channel_request_shell
         yield channel.io
       rescue => e
-        @logger.error { "Failed opening channel" }
-        @logger.error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+        log_error { "Failed opening channel" }
+        log_error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
         raise "Error in shell"
       ensure
         if channel
-          @logger.info { "closing channel IOs" }
+          log_info { "closing channel IOs" }
           channel.io.each{ |io| io.close rescue nil }
-          @logger.info { "channel IOs closed" }
-          @logger.info { "closing channel" }
-          @logger.info { "wait until threads closed in channel" }
+          log_info { "channel IOs closed" }
+          log_info { "closing channel" }
+          log_info { "wait until threads closed in channel" }
           channel.wait_until_closed
           channel.close
-          @logger.info { "channel closed" }
+          log_info { "channel closed" }
         end
       end
       channel_exit_status = channel.exit_status rescue nil
     end
 
     def subsystem name
-      @logger.debug { "start subsystem" }
+      log_debug { "start subsystem" }
       begin
-        @logger.info { "Opning channel" }
+        log_info { "Opning channel" }
         channel = @connection.request_channel_open "session"
-        @logger.info { "Channel opened" }
+        log_info { "Channel opened" }
         channel.send_channel_request_subsystem name
         yield channel.io
       rescue => e
-        @logger.error { "Failed opening channel" }
-        @logger.error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+        log_error { "Failed opening channel" }
+        log_error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
         raise "Error in subsystem"
       ensure
         if channel
-          @logger.info { "closing channel IOs" }
+          log_info { "closing channel IOs" }
           channel.io.each{ |io| io.close rescue nil }
-          @logger.info { "channel IOs closed" }
-          @logger.info { "closing channel" }
-          @logger.info { "wait until threads closed in channel" }
+          log_info { "channel IOs closed" }
+          log_info { "closing channel" }
+          log_info { "wait until threads closed in channel" }
           channel.wait_until_closed
           channel.close
-          @logger.info { "channel closed" }
+          log_info { "channel closed" }
         end
       end
       channel_exit_status = channel.exit_status rescue nil