hrr_rb_ssh 0.4.0.pre1 → 0.4.0.pre2

data/lib/hrr_rb_ssh/connection/request_handler/reference_exec_request_handler.rb

@@ -2,7 +2,6 @@
 # vim: et ts=2 sw=2
 
 require 'etc'
-require 'hrr_rb_ssh/logger'
 require 'hrr_rb_ssh/connection/request_handler'
 
 module HrrRbSsh
@@ -10,7 +9,6 @@ module HrrRbSsh
     class RequestHandler
       class ReferenceExecRequestHandler < RequestHandler
         def initialize
-          @logger = Logger.new self.class.name
           @proc = Proc.new { |context|
             ptm = context.vars[:ptm]
             pts = context.vars[:pts]
@@ -58,22 +56,22 @@ module HrrRbSsh
 
                 begin
                   pid, status = Process.waitpid2 pid
-                  context.logger.info { "program exited with status #{status.inspect}" }
+                  context.log_info { "program exited with status #{status.inspect}" }
                   status.exitstatus
                 ensure
                   unless status
-                    context.logger.info { "exiting program" }
+                    context.log_info { "exiting program" }
                     Process.kill :TERM, pid
                     begin
                       Timeout.timeout(1) do
                         pid, status = Process.waitpid2 pid
                       end
                     rescue Timeout::Error
-                      context.logger.warn { "force exiting program" }
+                      context.log_warn { "force exiting program" }
                       Process.kill :KILL, pid
                       pid, status = Process.waitpid2 pid
                     end
-                    context.logger.info { "program exited with status #{status.inspect}" }
+                    context.log_info { "program exited with status #{status.inspect}" }
                   end
                 end
               end

data/lib/hrr_rb_ssh/connection/request_handler/reference_pty_req_request_handler.rb

@@ -5,7 +5,6 @@ require 'etc'
 require 'fileutils'
 require 'pty'
 require 'io/console'
-require 'hrr_rb_ssh/logger'
 require 'hrr_rb_ssh/connection/request_handler'
 
 module HrrRbSsh
@@ -13,7 +12,6 @@ module HrrRbSsh
     class RequestHandler
       class ReferencePtyReqRequestHandler < RequestHandler
         def initialize
-          @logger = Logger.new self.class.name
           @proc = Proc.new { |context|
             begin
               ptm, pts = PTY.open
@@ -32,16 +30,16 @@ module HrrRbSsh
                       begin
                         context.io[1].write ptm.readpartial(10240)
                       rescue EOFError => e
-                        context.logger.info { "ptm is EOF in ptm_read_thread" }
+                        context.log_info { "ptm is EOF in ptm_read_thread" }
                         break
                       rescue IOError => e
-                        context.logger.warn { "IO Error in ptm_read_thread" }
+                        context.log_warn { "IO Error in ptm_read_thread" }
                         break
                       rescue Errno::EIO => e
-                        context.logger.info { "EIO Error in ptm_read_thread" }
+                        context.log_info { "EIO Error in ptm_read_thread" }
                         break
                       rescue => e
-                        context.logger.error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+                        context.log_error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
                         break
                       end
                     end
@@ -51,29 +49,29 @@ module HrrRbSsh
                       begin
                         ptm.write context.io[0].readpartial(10240)
                       rescue EOFError => e
-                        context.logger.info { "IO is EOF in ptm_write_thread" }
+                        context.log_info { "IO is EOF in ptm_write_thread" }
                         break
                       rescue IOError => e
-                        context.logger.warn { "IO Error in ptm_write_thread" }
+                        context.log_warn { "IO Error in ptm_write_thread" }
                         break
                       rescue Errno::EIO => e
-                        context.logger.info { "EIO Error in ptm_read_thread" }
+                        context.log_info { "EIO Error in ptm_read_thread" }
                         break
                       rescue => e
-                        context.logger.error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+                        context.log_error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
                         break
                       end
                     end
                   }
                   chain.call_next
                 ensure
-                  context.logger.info { "closing pty-req request handler chain_proc" }
+                  context.log_info { "closing pty-req request handler chain_proc" }
                   context.vars[:ptm].close rescue nil
                   context.vars[:pts].close rescue nil
                   ptm_read_thread.join
                   ptm_write_thread.exit
                   ptm_write_thread.join
-                  context.logger.info { "pty-req request handler chain_proc closed" }
+                  context.log_info { "pty-req request handler chain_proc closed" }
                 end
               }
             rescue => e

data/lib/hrr_rb_ssh/connection/request_handler/reference_shell_request_handler.rb

@@ -3,7 +3,6 @@
 
 require 'etc'
 require 'timeout'
-require 'hrr_rb_ssh/logger'
 require 'hrr_rb_ssh/connection/request_handler'
 
 module HrrRbSsh
@@ -11,7 +10,6 @@ module HrrRbSsh
     class RequestHandler
       class ReferenceShellRequestHandler < RequestHandler
         def initialize
-          @logger = Logger.new self.class.name
           @proc = Proc.new { |context|
             ptm = context.vars[:ptm]
             pts = context.vars[:pts]
@@ -49,22 +47,22 @@ module HrrRbSsh
 
               begin
                 pid, status = Process.waitpid2 pid
-                context.logger.info { "shell exited with status #{status.inspect}" }
+                context.log_info { "shell exited with status #{status.inspect}" }
                 status.exitstatus
               ensure
                 unless status
-                  context.logger.info { "exiting shell" }
+                  context.log_info { "exiting shell" }
                   Process.kill :TERM, pid
                   begin
                     Timeout.timeout(1) do
                       pid, status = Process.waitpid2 pid
                     end
                   rescue Timeout::Error
-                    context.logger.warn { "force exiting shell" }
+                    context.log_warn { "force exiting shell" }
                     Process.kill :KILL, pid
                     pid, status = Process.waitpid2 pid
                   end
-                  context.logger.info { "shell exited with status #{status.inspect}" }
+                  context.log_info { "shell exited with status #{status.inspect}" }
                 end
               end
             }

data/lib/hrr_rb_ssh/connection/request_handler/reference_window_change_request_handler.rb

@@ -2,7 +2,6 @@
 # vim: et ts=2 sw=2
 
 require 'io/console'
-require 'hrr_rb_ssh/logger'
 require 'hrr_rb_ssh/connection/request_handler'
 
 module HrrRbSsh
@@ -10,7 +9,6 @@ module HrrRbSsh
     class RequestHandler
       class ReferenceWindowChangeRequestHandler < RequestHandler
         def initialize
-          @logger = Logger.new self.class.name
           @proc = Proc.new { |context|
             context.vars[:ptm].winsize = [context.terminal_height_rows, context.terminal_width_columns, context.terminal_width_pixels, context.terminal_height_pixels]
           }

data/lib/hrr_rb_ssh/connection/request_handler.rb

@@ -1,15 +1,13 @@
 # coding: utf-8
 # vim: et ts=2 sw=2
 
-require 'hrr_rb_ssh/logger'
-
 module HrrRbSsh
   class Connection
     class RequestHandler
       def initialize &block
-        @logger = Logger.new self.class.name
         @proc = block
       end
+
       def run context
         @proc.call context
       end

data/lib/hrr_rb_ssh/connection.rb

@@ -1,27 +1,27 @@
 # coding: utf-8
 # vim: et ts=2 sw=2
 
-require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/loggable'
 require 'hrr_rb_ssh/error/closed_connection'
 require 'hrr_rb_ssh/connection/global_request_handler'
 require 'hrr_rb_ssh/connection/channel'
 
 module HrrRbSsh
   class Connection
+    include Loggable
+
     attr_reader \
       :username,
       :variables,
       :options,
       :mode
 
-    def initialize authentication, mode, options={}
-      @logger = Logger.new self.class.name
-
+    def initialize authentication, mode, options={}, logger: nil
+      self.logger = logger
       @authentication = authentication
       @mode = mode
       @options = options
-
-      @global_request_handler = GlobalRequestHandler.new self
+      @global_request_handler = GlobalRequestHandler.new self, logger: logger
       @channels = Hash.new
       @username = nil
       @variables = nil
@@ -48,7 +48,7 @@ module HrrRbSsh
     end
 
     def start foreground: true
-      @logger.info { "start connection" }
+      log_info { "start connection" }
       @authentication.start
       @closed = false
       @connection_loop_thread = connection_loop_thread
@@ -62,20 +62,20 @@ module HrrRbSsh
     end
 
     def close
-      @logger.info { "closing connection" }
+      log_info { "closing connection" }
       @closed = true
       @authentication.close
       @channels.values.each do |channel|
         begin
           channel.close
         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 }
         end
       end
       @channels.clear
       @global_request_handler.close
       @connection_loop_thread.join unless @connection_loop_thread == Thread.current
-      @logger.info { "connection closed" }
+      log_info { "connection closed" }
     end
 
     def closed?
@@ -83,14 +83,14 @@ module HrrRbSsh
     end
 
     def connection_loop_thread
-      @logger.info { "start connection loop" }
+      log_info { "start connection loop" }
       Thread.new do
         begin
           while true
             begin
               payload = @authentication.receive
             rescue Error::ClosedAuthentication => e
-              @logger.info { "authentication closed" }
+              log_info { "authentication closed" }
               break
             end
             @username ||= @authentication.username
@@ -115,22 +115,22 @@ module HrrRbSsh
             when Message::SSH_MSG_CHANNEL_CLOSE::VALUE
               channel_close payload
             else
-              @logger.warn { "received unsupported message: id: #{payload[0,1].unpack("C")[0]}" }
+              log_warn { "received unsupported message: id: #{payload[0,1].unpack("C")[0]}" }
             end
           end
         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 }
         ensure
-          @logger.info { "closing connection loop" }
+          log_info { "closing connection loop" }
           close
-          @logger.info { "connection loop closed" }
+          log_info { "connection loop closed" }
         end
       end
     end
 
     def global_request payload
-      @logger.info { 'received ' + Message::SSH_MSG_GLOBAL_REQUEST::ID }
-      message = Message::SSH_MSG_GLOBAL_REQUEST.decode payload
+      log_info { 'received ' + Message::SSH_MSG_GLOBAL_REQUEST::ID }
+      message = Message::SSH_MSG_GLOBAL_REQUEST.decode payload, logger: logger
       begin
         @global_request_handler.request message
       rescue
@@ -145,10 +145,10 @@ module HrrRbSsh
     end
 
     def channel_open_start address, port, socket
-      @logger.info { 'channel open start' }
-      channel = Channel.new self, {:'channel type' => "forwarded-tcpip"}, socket
+      log_info { 'channel open start' }
+      channel = Channel.new self, {:'channel type' => "forwarded-tcpip"}, socket, logger: logger
       @channels[channel.local_channel] = channel
-      @logger.info { 'channel opened' }
+      log_info { 'channel opened' }
       message = {
         :'message number'             => Message::SSH_MSG_CHANNEL_OPEN::VALUE,
         :'channel type'               => "forwarded-tcpip",
@@ -164,25 +164,25 @@ module HrrRbSsh
     end
 
     def channel_open payload
-      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_OPEN::ID }
-      message = Message::SSH_MSG_CHANNEL_OPEN.decode payload
+      log_info { 'received ' + Message::SSH_MSG_CHANNEL_OPEN::ID }
+      message = Message::SSH_MSG_CHANNEL_OPEN.decode payload, logger: logger
       begin
-        channel = Channel.new self, message
+        channel = Channel.new self, message, logger: logger
         @channels[channel.local_channel] = channel
         channel.start
         send_channel_open_confirmation channel
       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 }
         recipient_channel = message[:'sender channel']
         send_channel_open_failure recipient_channel, Message::SSH_MSG_CHANNEL_OPEN_FAILURE::ReasonCode::SSH_OPEN_CONNECT_FAILED, e.message
       end
     end
 
     def request_channel_open channel_type, channel_specific_message={}, wait_response=true
-      @logger.info { 'request channel open' }
+      log_info { 'request channel open' }
       case channel_type
       when "session"
-        channel = Channel.new self, {:'channel type' => channel_type}
+        channel = Channel.new self, {:'channel type' => channel_type}, logger: logger
         @channels[channel.local_channel] = channel
       end
       message = {
@@ -193,13 +193,13 @@ module HrrRbSsh
         :'maximum packet size'        => channel.local_maximum_packet_size,
       }
       send_channel_open message.merge(channel_specific_message)
-      @logger.info { 'sent channel open' }
+      log_info { 'sent channel open' }
       if wait_response
-        @logger.info { 'wait response' }
+        log_info { 'wait response' }
         channel.wait_until_started
       end
       unless channel.closed?
-        @logger.info { 'channel opened' }
+        log_info { 'channel opened' }
         channel
       else
         raise "Faild opening channel"
@@ -207,67 +207,67 @@ module HrrRbSsh
     end
 
     def channel_open_confirmation payload
-      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION::ID }
-      message = Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION.decode payload
+      log_info { 'received ' + Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION::ID }
+      message = Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION.decode payload, logger: logger
       channel = @channels[message[:'recipient channel']]
       channel.set_remote_parameters message
       channel.start
     end
 
     def channel_request payload
-      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_REQUEST::ID }
-      message = Message::SSH_MSG_CHANNEL_REQUEST.decode payload
+      log_info { 'received ' + Message::SSH_MSG_CHANNEL_REQUEST::ID }
+      message = Message::SSH_MSG_CHANNEL_REQUEST.decode payload, logger: logger
       local_channel = message[:'recipient channel']
       @channels[local_channel].receive_message_queue.enq message
     end
 
     def channel_window_adjust payload
-      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_WINDOW_ADJUST::ID }
-      message = Message::SSH_MSG_CHANNEL_WINDOW_ADJUST.decode payload
+      log_info { 'received ' + Message::SSH_MSG_CHANNEL_WINDOW_ADJUST::ID }
+      message = Message::SSH_MSG_CHANNEL_WINDOW_ADJUST.decode payload, logger: logger
       local_channel = message[:'recipient channel']
       @channels[local_channel].receive_message_queue.enq message
     end
 
     def channel_data payload
-      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_DATA::ID }
-      message = Message::SSH_MSG_CHANNEL_DATA.decode payload
+      log_info { 'received ' + Message::SSH_MSG_CHANNEL_DATA::ID }
+      message = Message::SSH_MSG_CHANNEL_DATA.decode payload, logger: logger
       local_channel = message[:'recipient channel']
       @channels[local_channel].receive_message_queue.enq message
     end
 
     def channel_extended_data payload
-      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_EXTENDED_DATA::ID }
-      message = Message::SSH_MSG_CHANNEL_EXTENDED_DATA.decode payload
+      log_info { 'received ' + Message::SSH_MSG_CHANNEL_EXTENDED_DATA::ID }
+      message = Message::SSH_MSG_CHANNEL_EXTENDED_DATA.decode payload, logger: logger
       local_channel = message[:'recipient channel']
       @channels[local_channel].receive_message_queue.enq message
     end
 
     def channel_eof payload
-      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_EOF::ID }
-      message = Message::SSH_MSG_CHANNEL_EOF.decode payload
+      log_info { 'received ' + Message::SSH_MSG_CHANNEL_EOF::ID }
+      message = Message::SSH_MSG_CHANNEL_EOF.decode payload, logger: logger
       local_channel = message[:'recipient channel']
       @channels[local_channel].receive_message_queue.enq message
     end
 
     def channel_close payload
-      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_CLOSE::ID }
-      message = Message::SSH_MSG_CHANNEL_CLOSE.decode payload
+      log_info { 'received ' + Message::SSH_MSG_CHANNEL_CLOSE::ID }
+      message = Message::SSH_MSG_CHANNEL_CLOSE.decode payload, logger: logger
       local_channel = message[:'recipient channel']
       channel = @channels[local_channel]
       channel.close
-      @logger.info { "wait until threads closed in channel" }
+      log_info { "wait until threads closed in channel" }
       channel.wait_until_closed
-      @logger.info { "channel closed" }
-      @logger.info { "deleting channel" }
+      log_info { "channel closed" }
+      log_info { "deleting channel" }
       @channels.delete local_channel
-      @logger.info { "channel deleted" }
+      log_info { "channel deleted" }
     end
 
     def send_request_success
       message = {
         :'message number' => Message::SSH_MSG_REQUEST_SUCCESS::VALUE,
       }
-      payload = Message::SSH_MSG_REQUEST_SUCCESS.encode message
+      payload = Message::SSH_MSG_REQUEST_SUCCESS.encode message, logger: logger
       @authentication.send payload
     end
 
@@ -275,12 +275,12 @@ module HrrRbSsh
       message = {
         :'message number' => Message::SSH_MSG_REQUEST_FAILURE::VALUE,
       }
-      payload = Message::SSH_MSG_REQUEST_FAILURE.encode message
+      payload = Message::SSH_MSG_REQUEST_FAILURE.encode message, logger: logger
       @authentication.send payload
     end
 
     def send_channel_open message
-      payload = Message::SSH_MSG_CHANNEL_OPEN.encode message
+      payload = Message::SSH_MSG_CHANNEL_OPEN.encode message, logger: logger
       @authentication.send payload
     end
 
@@ -293,7 +293,7 @@ module HrrRbSsh
         :'initial window size' => channel.local_window_size,
         :'maximum packet size' => channel.local_maximum_packet_size,
       }
-      payload = Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION.encode message
+      payload = Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION.encode message, logger: logger
       @authentication.send payload
     end
 
@@ -305,7 +305,7 @@ module HrrRbSsh
         :'description'         => description,
         :'language tag'        => "",
       }
-      payload = Message::SSH_MSG_CHANNEL_OPEN_FAILURE.encode message
+      payload = Message::SSH_MSG_CHANNEL_OPEN_FAILURE.encode message, logger: logger
       @authentication.send payload
     end
   end

data/lib/hrr_rb_ssh/loggable.rb

@@ -0,0 +1,42 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+module HrrRbSsh
+  module Loggable
+    attr_accessor :logger, :log_key
+
+    def log_fatal
+      if logger
+        logger.fatal(log_key){ yield }
+      end
+    end
+
+    def log_error
+      if logger
+        logger.error(log_key){ yield }
+      end
+    end
+
+    def log_warn
+      if logger
+        logger.warn(log_key){ yield }
+      end
+    end
+
+    def log_info
+      if logger
+        logger.info(log_key){ yield }
+      end
+    end
+
+    def log_debug
+      if logger
+        logger.debug(log_key){ yield }
+      end
+    end
+
+    def log_key
+      @log_key ||= self.class.to_s + "[%x]" % object_id
+    end
+  end
+end

data/lib/hrr_rb_ssh/server.rb

@@ -1,28 +1,30 @@
 # coding: utf-8
 # vim: et ts=2 sw=2
 
-require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/loggable'
 require 'hrr_rb_ssh/transport'
 require 'hrr_rb_ssh/authentication'
 require 'hrr_rb_ssh/connection'
 
 module HrrRbSsh
   class Server
-    def self.start io, options={}
-      server = self.new options
+    include Loggable
+
+    def self.start io, options={}, logger: nil
+      server = self.new options, logger: logger
       server.start io
     end
 
-    def initialize options={}
-      @logger = Logger.new self.class.name
+    def initialize options={}, logger: nil
+      self.logger = logger
       @options = options
     end
 
     def start io
-      @logger.info { "start server service" }
-      transport      = Transport.new      io, Mode::SERVER, @options
-      authentication = Authentication.new transport, Mode::SERVER, @options
-      connection     = Connection.new     authentication, Mode::SERVER, @options
+      log_info { "start server service" }
+      transport      = Transport.new      io, Mode::SERVER, @options, logger: logger
+      authentication = Authentication.new transport, Mode::SERVER, @options, logger: logger
+      connection     = Connection.new     authentication, Mode::SERVER, @options, logger: logger
       connection.start
     end
   end

data/lib/hrr_rb_ssh/transport/compression_algorithm/functionable.rb

@@ -2,14 +2,16 @@
 # vim: et ts=2 sw=2
 
 require 'zlib'
-require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/loggable'
 
 module HrrRbSsh
   class Transport
     class CompressionAlgorithm
       module Functionable
-        def initialize direction
-          @logger = Logger.new(self.class.name)
+        include Loggable
+
+        def initialize direction, logger: nil
+          self.logger = logger
           case direction
           when Direction::OUTGOING
             @deflator = ::Zlib::Deflate.new

data/lib/hrr_rb_ssh/transport/compression_algorithm/unfunctionable.rb

@@ -1,14 +1,16 @@
 # coding: utf-8
 # vim: et ts=2 sw=2
 
-require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/loggable'
 
 module HrrRbSsh
   class Transport
     class CompressionAlgorithm
       module Unfunctionable
-        def initialize direction=nil
-          @logger = Logger.new(self.class.name)
+        include Loggable
+
+        def initialize direction=nil, logger: nil
+          self.logger = logger
         end
 
         def deflate data

data/lib/hrr_rb_ssh/transport/encryption_algorithm/functionable.rb

@@ -1,20 +1,22 @@
 # coding: utf-8
 # vim: et ts=2 sw=2
 
-require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/loggable'
 
 module HrrRbSsh
   class Transport
     class EncryptionAlgorithm
       module Functionable
+        include Loggable
+
         def self.included klass
           cipher = OpenSSL::Cipher.new(klass::CIPHER_NAME)
           klass.const_set(:IV_LENGTH,  cipher.iv_len)
           klass.const_set(:KEY_LENGTH, cipher.key_len)
         end
 
-        def initialize direction, iv, key
-          @logger = Logger.new(self.class.name)
+        def initialize direction, iv, key, logger: nil
+          self.logger = logger
           @cipher = OpenSSL::Cipher.new(self.class::CIPHER_NAME)
           case direction
           when Direction::OUTGOING

data/lib/hrr_rb_ssh/transport/encryption_algorithm/unfunctionable.rb

@@ -1,19 +1,21 @@
 # coding: utf-8
 # vim: et ts=2 sw=2
 
-require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/loggable'
 
 module HrrRbSsh
   class Transport
     class EncryptionAlgorithm
       module Unfunctionable
+        include Loggable
+
         def self.included klass
           klass.const_set(:IV_LENGTH,  0)
           klass.const_set(:KEY_LENGTH, 0)
         end
 
-        def initialize direction=nil, iv=nil, key=nil
-          @logger = Logger.new(self.class.name)
+        def initialize direction=nil, iv=nil, key=nil, logger: nil
+          self.logger = logger
         end
 
         def block_size