maxcube-client 0.4.1 → 0.5.0

data/lib/maxcube/messages/udp/serializer.rb

@@ -4,14 +4,27 @@ require 'maxcube/messages/serializer'
 module MaxCube
   module Messages
     module UDP
+      # Extends {Messages::Serializer} and {UDP::Handler} of routines
+      # connected to UDP Cube messages serializing.
       class Serializer
-        include Handler
+        include UDP::Handler
         include Messages::Serializer
 
+        # Known message types in the direction client -> Cube.
         MSG_TYPES = %w[I N h c R].freeze
 
+        # {UDP::MSG_PREFIX} with a suffix.
         MSG_PREFIX = (UDP::MSG_PREFIX + "*\x00").freeze
 
+        # Serializes data from a single hash
+        # into UDP Cube message.
+        # Calls {#check_udp_hash} at the begin
+        # and {#check_udp_msg} at the end.
+        # @param hash [Hash] particular message contents separated into hash.
+        # @option hash [String] :serial_number if not specified,
+        #   it is set to universal value.
+        #   It is used for broadcast messages.
+        # @return [String] output message.
         def serialize_udp_hash(hash)
           check_udp_hash(hash)
           serial_number = hash[:serial_number] || '*' * 10
@@ -21,6 +34,9 @@ module MaxCube
 
         private
 
+        # Tells how to get message type from a message.
+        # @param msg [String] input message.
+        # @return [String] message type.
         def msg_msg_type(msg)
           msg[18]
         end

data/lib/maxcube/messages/udp/type/h.rb

@@ -3,9 +3,11 @@ module MaxCube
   module Messages
     module UDP
       class Parser
+        # Get URL information message.
         module MessageH
           private
 
+          # Mandatory keys.
           KEYS = (Parser::KEYS + %i[port url path]).freeze
 
           def parse_udp_h(_body)

data/lib/maxcube/messages/udp/type/i.rb

@@ -3,9 +3,12 @@ module MaxCube
   module Messages
     module UDP
       class Parser
+        # Identify message.
+        # It can be used in broadcast.
         module MessageI
           private
 
+          # Mandatory keys.
           KEYS = (Parser::KEYS + %i[unknown
                                     rf_address firmware_version]).freeze
 

data/lib/maxcube/messages/udp/type/n.rb

@@ -3,10 +3,13 @@ module MaxCube
   module Messages
     module UDP
       class Parser
+        # Get network address message.
         module MessageN
           private
 
+          # Local keys without the common ones.
           N_KEYS = %i[ip_address gateway subnet_mask dns1 dns2].freeze
+          # Mandatory keys.
           KEYS = (Parser::KEYS + N_KEYS).freeze
 
           def parse_udp_n(_body)

data/lib/maxcube/network.rb

@@ -1,13 +1,17 @@
 require 'socket'
-require 'thread'
 
 require 'yaml'
 
 require 'maxcube'
 
 module MaxCube
+  # Encapsulates network structures providing clients and servers
+  # that comply Cube messages protocol.
+  # It utilizes parsing and serializing features from {Messages}.
   module Network
+    # Common localhost IP address.
     LOCALHOST = 'localhost'.freeze
+    # Common broadcast IP address.
     BROADCAST = '<broadcast>'.freeze
   end
 end

data/lib/maxcube/network/tcp.rb

@@ -4,7 +4,10 @@ require 'maxcube/messages/tcp/serializer'
 
 module MaxCube
   module Network
+    # This module contains classes aimed onto TCP network tools
+    # related to Cube protocol.
     module TCP
+      # Common port used in Cube TCP communication.
       PORT = 62_910
     end
   end

data/lib/maxcube/network/tcp/client.rb

@@ -4,8 +4,37 @@ require_relative 'client/commands'
 module MaxCube
   module Network
     module TCP
+      # Fundamental class that provides TCP communication
+      # with Cube gateway and connected devices.
+      # After connecting to Cube ({#connect}),
+      # interactive shell is launched.
+      #
+      # Communication with Cube is performed via messages,
+      # whereas client works with hashes,
+      # which have particular message contents divided
+      # and is human readable.
+      # An issue is how to pass contents of hashes
+      # as arguments of message serialization.
+      # For simple hashes client provides and option
+      # to pass arguments explicitly on command line.
+      # This would be difficult to accomplish
+      # for large hashes with subhashes,
+      # so YAML files are used in these cases,
+      # which are able to be generated both automatically and manually.
+      # This file has to be loaded into internal hash before each such message.
+      #
+      # Client interactive shell contains quite detailed usage message.
       class Client
-        def initialize
+        # Default verbose mode on startup.
+        DEFAULT_VERBOSE = true
+        # Default persist mode on startup.
+        DEFAULT_PERSIST = true
+
+        # Creates all necessary internal variables.
+        # Internal hash is invalid on startup.
+        # @param verbose [Boolean] verbose mode on startup.
+        # @param persist [Boolean] persist mode on startup.
+        def initialize(verbose: DEFAULT_VERBOSE, persist: DEFAULT_PERSIST)
           @parser = Messages::TCP::Parser.new
           @serializer = Messages::TCP::Serializer.new
           @queue = Queue.new
@@ -22,16 +51,27 @@ module MaxCube
           @load_data_dir = @data_dir + 'load'
           @save_data_dir = @data_dir + 'save'
 
-          @verbose = true
-          @persist = true
+          @verbose = verbose
+          @persist = persist
         end
 
+        # Connects to concrete address and starts interactive shell ({#shell}).
+        # Calls {#receiver} in separate thread to receive all incoming messages.
+        # @param host remote host address.
+        # @param port remote host port.
         def connect(host = LOCALHOST, port = PORT)
           @socket = TCPSocket.new(host, port)
           @thread = Thread.new(self, &:receiver)
           shell
         end
 
+        # Routine started in separate thread
+        # that receives and parses all incoming messages in loop
+        # and stores them info thread-safe queue.
+        # Parsing is done via
+        # {Messages::TCP::Parser#parse_tcp_msg}.
+        # It should close gracefully on any +IOError+
+        # or on shell's initiative.
         def receiver
           puts '<Starting receiver thread ...>'
           while (data = @socket.gets)
@@ -50,6 +90,17 @@ module MaxCube
           puts e.to_s.capitalize
         end
 
+        # Interactive shell that maintains all operations with Cube.
+        # It is yet only simple +STDIN+ parser
+        # without any command history and other features
+        # that possess all decent shells.
+        # It calls {#command} on every input.
+        # It provides quite detailed usage message ({#cmd_usage}).
+        #
+        # It should close gracefully
+        # from user's will, when connection closes,
+        # or when soft interrupt appears.
+        # Calls {#close} when closing.
         def shell
           puts "Welcome to interactive shell!\n" \
                "Type 'help' for list of commands.\n\n"
@@ -64,6 +115,7 @@ module MaxCube
           close
         end
 
+        # Closes client gracefully.
         def close
           STDIN.close
           send_msg('q')
@@ -73,6 +125,9 @@ module MaxCube
 
         private
 
+        # Moves contents of receiver's queue to internal buffer.
+        # Queue is being filled from {#receiver}.
+        # Operation is thread-safe.
         def refresh_buffer
           until @queue.empty?
             data, hashes = @queue.pop
@@ -81,11 +136,22 @@ module MaxCube
           end
         end
 
+        # Returns only current or all (without or with history)
+        # collected part of buffer and history
+        # (contents of buffer is moved to history on clear command).
+        # @param dir_key [:recv, :sent] received or sent data.
+        # @param data_key [:hashes, :data] hashes or raw data (set of messages).
+        # @param history [Boolean] whether to include history.
+        # @return [Array<Hash>, String] demanded data.
         def buffer(dir_key, data_key, history = false)
           return @buffer[dir_key][data_key] unless history
           @history[dir_key][data_key] + @buffer[dir_key][data_key]
         end
 
+        # Executes command from shell command line.
+        # It calls a method dynamically according to {COMMANDS},
+        # or displays usage message {#cmd_usage}.
+        # @param line [String] command line from +STDIN+
         def command(line)
           cmd, *args = line.chomp.split
           return nil unless cmd
@@ -102,6 +168,19 @@ module MaxCube
           cmd_usage
         end
 
+        include Commands
+
+        # Zips +args+ with appropriate keys
+        # according to {Messages::Handler#msg_type_hash_keys}
+        # and {Messages::Handler#msg_type_hash_opt_keys}.
+        # @param type [String] message type.
+        # @param args [Array<String>] arguments from command line.
+        # @param opts [Hash] options that modifies interpreting of +args+.
+        # @option opts [Boolean] :last_array whether to insert
+        #   all rest arguments into array that will be stored into the last key.
+        # @option opts [Boolean] :array_nonempty whether to require +last_array+
+        #   _not_ to be empty.
+        # @return [Hash, nil] resulting hash, or +nil+ on failure.
         def send_msg_hash_from_keys_args(type, *args, **opts)
           keys = @serializer.msg_type_hash_keys(type) +
                  @serializer.msg_type_hash_opt_keys(type)
@@ -118,18 +197,40 @@ module MaxCube
           keys.zip(args).to_h.reject { |_, v| v.nil? }
         end
 
+        # Returns hash via {#cmd_load}.
+        # It is used to combine sending a message with loading a hash from file.
+        # On success and in non-persistive mode,
+        # it simultaneously invalidates internal hash flag.
+        # @param args [Array<String>] arguments from command line.
+        # @return [Hash, nil] loaded hash, or +nil+ on failure.
         def send_msg_hash_from_internal(*args, **_opts)
           return nil unless cmd_load(*args.drop(1))
           @hash_set = false unless @persist
           @hash
         end
 
+        # Command line token that enables loading arguments (hash) from file.
         ARGS_FROM_HASH = '-'.freeze
 
+        # @param args [Array<String>] arguments from command line.
+        # @return [Boolean] whether to enable loading arguments (hash)
+        #   from file.
         def args_from_hash?(args)
           args.first == ARGS_FROM_HASH
         end
 
+        # Returns hash with contents necessary for serialization
+        # of message of given message type.
+        # It is either built from command line +args+
+        # ({#send_msg_hash_from_keys_args}),
+        # or loaded from YAML file ({#send_msg_hash_from_internal}).
+        # @param type [String] message type.
+        # @param args [Array<String>] arguments from command line.
+        # @param opts [Hash] options that modifies interpreting of +args+.
+        # @option opts [Boolean] :load_only means that hash
+        #   must be loaded from file (contents are too complex).
+        #   Specifying {ARGS_FROM_HASH} is optional in this case.
+        # @return [Hash] resulting hash.
         def send_msg_hash(type, *args, **opts)
           if opts[:load_only] && !args_from_hash?(args)
             args.unshift(ARGS_FROM_HASH)
@@ -143,6 +244,17 @@ module MaxCube
           send_msg_hash_from_keys_args(type, *args, **opts)
         end
 
+        # Performs message serialization and sends it to Cube.
+        # It builds the hash to serialize from by {#send_msg_hash},
+        # and serializes it with
+        # {Messages::TCP::Serializer#serialize_tcp_hash}.
+        #
+        # Both sent message and built hash are buffered.
+        #
+        # It catches all {Messages::InvalidMessage} exceptions.
+        # @param type [String] message type.
+        # @param args [Array<String>] arguments from command line.
+        # @param opts [Hash] options that modifies interpreting of +args+.
         def send_msg(type, *args, **opts)
           hash = send_msg_hash(type, *args, **opts)
           return unless hash
@@ -165,6 +277,8 @@ module MaxCube
           puts e.to_s.capitalize
         end
 
+        # Prints hash in human readable way.
+        # @param hash [Hash] input hash.
         def print_hash(hash)
           puts hash.to_yaml
         end

data/lib/maxcube/network/tcp/client/commands.rb

@@ -3,282 +3,349 @@ module MaxCube
   module Network
     module TCP
       class Client
-        private
-
-        COMMANDS = {
-          'usage' => %w[? h help],
-          'data' => %w[B buffer d],
-          'history' => %w[H hist],
-          'clear' => %w[C],
-          'dump' => %w[D],
-          'list' => %w[l],
-          'config' => %w[c],
-          'send' => %w[cmd s set],
-          'pair' => %w[n],
-          'ntp' => %w[N f],
-          'url' => %w[U u],
-          'wake' => %w[w z],
-          'metadata' => %w[m meta],
-          'delete' => %w[del],
-          'reset' => %w[],
-          'verbose' => %w[V],
-          'save' => %w[S],
-          'load' => %w[L],
-          'persist' => %w[P],
-          'quit' => %w[q],
-        }.freeze
-
-        def usage_line(command, args, description,
-                       message = nil, response = nil)
-          cmds_str = (COMMANDS[command].dup << command).join('|')
-          cmds_str << ' ' << args unless args.empty?
-
-          description, *rest = description.split("\n")
-          rest << "[#{message} message]" if message
-          rest << "[#{response} response]" if response
-          rest = if rest.empty?
-                   ''
-                 else
-                   rest.map { |s| ' ' * 52 + s }.join("\n") << "\n"
-                 end
-
-          '  ' << cmds_str << ' ' * (48 - cmds_str.size) <<
-            description << "\n" << rest
-        end
-
-        def cmd_usage
-          puts "\nUSAGE: <command> [<arguments...>]\nCOMMADS:\n" <<
-               usage_line('usage', '',
-                          'Prints this message') <<
-               usage_line('data', '',
-                          'Lists buffered received data (hashes)') <<
-               usage_line('history', '',
-                          'Lists all received data incl. the cleared') <<
-               usage_line('clear', '',
-                          "Clears collected data\n" \
-                          '(resp. moves it to history)') <<
-               usage_line('dump', '',
-                          "Shortcut for 'data' + 'clear'") <<
-               usage_line('list', '',
-                          'Requests for new list of devices', 'l', 'L') <<
-               usage_line('config', '',
-                          'Requests for configuration message', 'c', 'C') <<
-               usage_line('send', '{}',
-                          'Sends settings to connected devices',
-                          's', 'S') <<
-               usage_line('pair', '{<timeout>}',
-                          'Sets device into pairing mode' \
-                          " with optional timeout\n" \
-                          '(request for a new device)', 'n', 'N') <<
-               usage_line('ntp', '{<NTP servers...>}',
-                          'Requests for NTP servers' \
-                          ' and optionally updates them',
-                          'f', 'F') <<
-               usage_line('url', '{<URL> <port>}',
-                          'Configures Cube\'s portal URL', 'u') <<
-               usage_line('wake', '{<time> <scope> [<ID>]}',
-                          'Wake-ups the Cube',
-                          'z', 'A') <<
-               usage_line('metadata', '{}',
-                          'Serializes metadata for the Cube',
-                          'm', 'M') <<
-               usage_line('delete', '{<count> <force> <RF addresses...>}',
-                          'Deletes one or more devices from the Cube (!)',
-                          't', 'A') <<
-               usage_line('reset', '',
-                          'Requests for factory reset (!)', 'a', 'A') <<
-               usage_line('verbose', '',
-                          "Toggles verbose mode (whether is incoming data\n" \
-                          'printed immediately or is not printed)') <<
-               usage_line('save', '[a|A|all]',
-                          "Saves buffered [all] received and sent data\n" \
-                          "into files at '#{@save_data_dir}'") <<
-               usage_line('load', '[<path>]',
-                          'Loads first hash from YAML file' \
-                          " to internal variable\n" \
-                          "-> to pass data with outgoing message\n" \
-                          'If path is relative,' \
-                          " it looks in '#{@load_data_dir}'\n" \
-                          "(loads previous valid hash if no file given)\n" \
-                          '(command can be combined' \
-                          " using '#{ARGS_FROM_HASH}'\n" \
-                          " with other commands which have '{}' arguments)") <<
-               usage_line('persist', '',
-                          'Toggles persistent mode' \
-                          "(whether is internal hash\n" \
-                          'not invalidated after use)') <<
-               usage_line('quit', '',
-                          "Shuts the client down gracefully\n" \
-                          '(SIGINT and EOF also work)', 'q') <<
-               "\n[<arg>] means optional argument <arg>" \
-               "\n[<args...>] means multiple arguments <args...> or none" \
-               "\n  (<args...> requires at least one)" \
-               "\n{<arg>} means that either <arg>" \
-               " or '#{ARGS_FROM_HASH}' is expected" \
-               "\n  (when '#{ARGS_FROM_HASH}' specified as first argument," \
-               ' internal hash is used' \
-               "\n   -> 'load' command is called with rest arguments)" \
-               "\n  ({} means that only internal hash can be used," \
-               "\n   '#{ARGS_FROM_HASH}' is not necessary in this case)"
-        end
+        # Provides handling of concrete commands from shell command line.
+        module Commands
+          private
+
+          # List of commands and their aliases.
+          COMMANDS = {
+            'usage' => %w[? h help],
+            'data' => %w[B buffer d],
+            'history' => %w[H hist],
+            'clear' => %w[C],
+            'dump' => %w[D],
+            'list' => %w[l],
+            'config' => %w[c],
+            'send' => %w[cmd s set],
+            'pair' => %w[n],
+            'ntp' => %w[N f],
+            'url' => %w[U u],
+            'wake' => %w[w z],
+            'metadata' => %w[m meta],
+            'delete' => %w[del],
+            'reset' => %w[],
+            'verbose' => %w[V],
+            'save' => %w[S],
+            'load' => %w[L],
+            'persist' => %w[P],
+            'quit' => %w[q],
+          }.freeze
+
+          # Returns usage message for a single command.
+          # @param command [String] command key from {COMMANDS}.
+          # @param args [String] arguments accepted by command.
+          # @param description [String] description of command.
+          # @param message [String, nil] optional message type
+          #   that is about to be sent by the command.
+          # @param response [String, nil] optional message type
+          #   of expected response to this message.
+          # @return [String] usage message for +command+.
+          def usage_cmd(command, args, description,
+                        message = nil, response = nil)
+            cmds_str = (COMMANDS[command].dup << command).join('|')
+            cmds_str << ' ' << args unless args.empty?
+
+            description, *rest = description.split("\n")
+            rest << "[#{message} message]" if message
+            rest << "[#{response} response]" if response
+            rest = if rest.empty?
+                     ''
+                   else
+                     rest.map { |s| ' ' * 52 + s }.join("\n") << "\n"
+                   end
+
+            '  ' << cmds_str << ' ' * (48 - cmds_str.size) <<
+              description << "\n" << rest
+          end
 
-        def list_hashes(history)
-          buffer(:recv, :hashes, history).each_with_index do |h, i|
-            puts "<#{i + 1}>"
-            print_hash(h)
-            puts
+          # Prints usage message composed mainly
+          # from particular {#usage_cmd} calls.
+          def cmd_usage
+            puts "\nUSAGE: <command> [<arguments...>]\nCOMMADS:\n" <<
+                 usage_cmd('usage', '',
+                           'Prints this message') <<
+                 usage_cmd('data', '',
+                           'Lists buffered received data (hashes)') <<
+                 usage_cmd('history', '',
+                           'Lists all received data incl. the cleared') <<
+                 usage_cmd('clear', '',
+                           "Clears collected data\n" \
+                           '(resp. moves it to history)') <<
+                 usage_cmd('dump', '',
+                           "Shortcut for 'data' + 'clear'") <<
+                 usage_cmd('list', '',
+                           'Requests for new list of devices', 'l', 'L') <<
+                 usage_cmd('config', '',
+                           'Requests for configuration message', 'c', 'C') <<
+                 usage_cmd('send', '{}',
+                           'Sends settings to connected devices',
+                           's', 'S') <<
+                 usage_cmd('pair', '{<timeout>}',
+                           'Sets device into pairing mode' \
+                           " with optional timeout\n" \
+                           '(request for a new device)', 'n', 'N') <<
+                 usage_cmd('ntp', '{<NTP servers...>}',
+                           'Requests for NTP servers' \
+                           ' and optionally updates them',
+                           'f', 'F') <<
+                 usage_cmd('url', '{<URL> <port>}',
+                           'Configures Cube\'s portal URL', 'u') <<
+                 usage_cmd('wake', '{<time> <scope> [<ID>]}',
+                           'Wake-ups the Cube',
+                           'z', 'A') <<
+                 usage_cmd('metadata', '{}',
+                           'Serializes metadata for the Cube',
+                           'm', 'M') <<
+                 usage_cmd('delete', '{<count> <force> <RF addresses...>}',
+                           'Deletes one or more devices from the Cube (!)',
+                           't', 'A') <<
+                 usage_cmd('reset', '',
+                           'Requests for factory reset (!)', 'a', 'A') <<
+                 usage_cmd('verbose', '',
+                           "Toggles verbose mode (whether is incoming data\n" \
+                           'printed immediately or is not printed)') <<
+                 usage_cmd('save', '[a|A|all]',
+                           "Saves buffered [all] received and sent data\n" \
+                           "into files at '#{@save_data_dir}'") <<
+                 usage_cmd('load', '[<path>]',
+                           'Loads first hash from YAML file' \
+                           " to internal variable\n" \
+                           "-> to pass data with outgoing message\n" \
+                           'If path is relative,' \
+                           " it looks in '#{@load_data_dir}'\n" \
+                           "(loads previous valid hash if no file given)\n" \
+                           '(command can be combined' \
+                           " using '#{ARGS_FROM_HASH}'\n" \
+                           ' with other commands' \
+                           " which have '{}' arguments)") <<
+                 usage_cmd('persist', '',
+                           'Toggles persistent mode' \
+                           "(whether is internal hash\n" \
+                           'not invalidated after use)') <<
+                 usage_cmd('quit', '',
+                           "Shuts the client down gracefully\n" \
+                           '(SIGINT and EOF also work)', 'q') <<
+                 "\n[<arg>] means optional argument <arg>" \
+                 "\n[<args...>] means multiple arguments <args...> or none" \
+                 "\n  (<args...> requires at least one)" \
+                 "\n{<arg>} means that either <arg>" \
+                 " or '#{ARGS_FROM_HASH}' is expected" \
+                 "\n  (when '#{ARGS_FROM_HASH}' specified as first argument," \
+                 ' internal hash is used' \
+                 "\n   -> 'load' command is called with rest arguments)" \
+                 "\n  ({} means that only internal hash can be used," \
+                 "\n   '#{ARGS_FROM_HASH}' is not necessary in this case)"
           end
-        end
 
-        def cmd_data
-          list_hashes(false)
-        end
+          # Displays received hashes optionally with history.
+          # Calls {#buffer}.
+          # @param history [Boolean] whether to include history.
+          def list_hashes(history)
+            buffer(:recv, :hashes, history).each_with_index do |h, i|
+              puts "<#{i + 1}>"
+              print_hash(h)
+              puts
+            end
+          end
 
-        def cmd_history
-          list_hashes(true)
-        end
+          # Calls {#list_hashes} without history.
+          def cmd_data
+            list_hashes(false)
+          end
 
-        def cmd_clear
-          %i[data hashes].each do |sym|
-            @history[:recv][sym] += @buffer[:recv][sym]
-            @buffer[:recv][sym].clear
+          # Calls {#list_hashes} with history.
+          def cmd_history
+            list_hashes(true)
           end
-        end
 
-        def cmd_dump
-          cmd_data
-          cmd_clear
-        end
+          # Clears all buffered received data
+          # (i.e. moves them to history).
+          def cmd_clear
+            %i[data hashes].each do |sym|
+              @history[:recv][sym] += @buffer[:recv][sym]
+              @buffer[:recv][sym].clear
+            end
+          end
 
-        def cmd_list
-          send_msg('l')
-        end
+          # Calls {#cmd_data} and {#cmd_clear}.
+          def cmd_dump
+            cmd_data
+            cmd_clear
+          end
 
-        def cmd_config
-          send_msg('c')
-        end
+          # Calls {#send_msg} with message type 'l'
+          # (device list request).
+          def cmd_list
+            send_msg('l')
+          end
 
-        def cmd_send(*args)
-          send_msg('s', *args, load_only: true)
-        end
+          # Calls {#send_msg} with message type 'c'
+          # (configuration message request).
+          def cmd_config
+            send_msg('c')
+          end
 
-        def cmd_pair(*args)
-          send_msg('n', *args)
-        end
+          # Calls {#send_msg} with message type 's'
+          # (send command message)
+          # and +args+ and +load_only+ option.
+          # @param args [Array<String>] arguments from command line.
+          def cmd_send(*args)
+            send_msg('s', *args, load_only: true)
+          end
 
-        def cmd_url(*args)
-          send_msg('u', *args)
-        end
+          # Calls {#send_msg} with message type 'n'
+          # (new device request)
+          # and +args+.
+          # @param args [Array<String>] arguments from command line.
+          def cmd_pair(*args)
+            send_msg('n', *args)
+          end
 
-        def cmd_ntp(*args)
-          send_msg('f', *args, last_array: true)
-        end
+          # Calls {#send_msg} with message type 'u'
+          # (set portal URL message)
+          # and +args+.
+          # @param args [Array<String>] arguments from command line.
+          def cmd_url(*args)
+            send_msg('u', *args)
+          end
 
-        def cmd_wake(*args)
-          send_msg('z', *args)
-        end
+          # Calls {#send_msg} with message type 'f'
+          # (NTP servers message)
+          # and +args+ and +last_array+ option.
+          # @param args [Array<String>] arguments from command line.
+          def cmd_ntp(*args)
+            send_msg('f', *args, last_array: true)
+          end
 
-        def cmd_metadata(*args)
-          send_msg('m', *args, load_only: true)
-        end
+          # Calls {#send_msg} with message type 'z'
+          # (wake-up message)
+          # and +args+.
+          # @param args [Array<String>] arguments from command line.
+          def cmd_wake(*args)
+            send_msg('z', *args)
+          end
 
-        def cmd_delete(*args)
-          send_msg('t', *args, last_array: true, array_nonempty: true)
-        end
+          # Calls {#send_msg} with message type 'm'
+          # (metadata message)
+          # and +args+ and +load_only+ option.
+          # @param args [Array<String>] arguments from command line.
+          def cmd_metadata(*args)
+            send_msg('m', *args, load_only: true)
+          end
 
-        def cmd_reset
-          send_msg('a')
-        end
+          # Calls {#send_msg} with message type 't'
+          # (delete a device request)
+          # and +args+, and +last_array+ and +array_nonempty+ options.
+          # @param args [Array<String>] arguments from command line.
+          def cmd_delete(*args)
+            send_msg('t', *args, last_array: true, array_nonempty: true)
+          end
 
-        def toggle(name, flag)
-          puts "#{name}: #{flag} -> #{!flag}"
-          !flag
-        end
+          # Calls {#send_msg} with message type 'a'
+          # (factory reset request).
+          def cmd_reset
+            send_msg('a')
+          end
 
-        def cmd_verbose
-          @verbose = toggle('verbose', @verbose)
-        end
+          def cmd_save(what = nil)
+            buffer = !what
+            all = %w[a A all].include?(what)
+            unless all || buffer
+              puts "Unrecognized argument: '#{what}'"
+              return
+            end
 
-        def cmd_save(what = nil)
-          buffer = !what
-          all = %w[a A all].include?(what)
-          unless all || buffer
-            puts "Unrecognized argument: '#{what}'"
-            return
-          end
+            dir = @save_data_dir + Time.now.strftime('%Y%m%d-%H%M')
+            dir.mkpath
 
-          dir = @save_data_dir + Time.now.strftime('%Y%m%d-%H%M')
-          dir.mkpath
+            %i[recv sent].each do |sym|
+              data_fn = dir + (sym.to_s << '.data')
+              File.open(data_fn, 'w') do |f|
+                f.puts(buffer(sym, :data, all).join)
+              end
 
-          %i[recv sent].each do |sym|
-            data_fn = dir + (sym.to_s << '.data')
-            File.open(data_fn, 'w') do |f|
-              f.puts(buffer(sym, :data, all).join)
+              hashes_fn = dir + (sym.to_s << '.yaml')
+              File.open(hashes_fn, 'w') do |f|
+                buffer(sym, :hashes, all).to_yaml(f)
+              end
             end
 
-            hashes_fn = dir + (sym.to_s << '.yaml')
-            File.open(hashes_fn, 'w') do |f|
-              buffer(sym, :hashes, all).to_yaml(f)
-            end
+            which = buffer ? 'Buffered' : 'All'
+            puts "#{which} received and sent raw data and hashes" \
+                 " saved into '#{dir}'"
+          rescue SystemCallError => e
+            puts "Files could not been saved:\n#{e}"
           end
 
-          which = buffer ? 'Buffered' : 'All'
-          puts "#{which} received and sent raw data and hashes" \
-               " saved into '#{dir}'"
-        rescue SystemCallError => e
-          puts "Files could not been saved:\n#{e}"
-        end
+          def parse_hash(path)
+            unless path.file? && path.readable?
+              return puts "File is not readable: '#{path}'"
+            end
 
-        def parse_hash(path)
-          unless path.file? && path.readable?
-            return puts "File is not readable: '#{path}'"
+            hash = YAML.load_file(path)
+            hash = hash.first while hash.is_a?(Array)
+            raise YAML::SyntaxError unless hash.is_a?(Hash)
+            hash
+          rescue YAML::SyntaxError => e
+            puts "File '#{path}' does not contain proper YAML hash", e
           end
 
-          hash = YAML.load_file(path)
-          hash = hash.first while hash.is_a?(Array)
-          raise YAML::SyntaxError unless hash.is_a?(Hash)
-          hash
-        rescue YAML::SyntaxError => e
-          puts "File '#{path}' does not contain proper YAML hash", e
-        end
+          def load_hash(path = nil)
+            if path
+              path = Pathname.new(path)
+              path = @load_data_dir + path if path.relative?
+              return parse_hash(path)
+            end
+            return @hash if @hash && @hash_set
 
-        def load_hash(path = nil)
-          if path
-            path = Pathname.new(path)
-            path = @load_data_dir + path if path.relative?
-            return parse_hash(path)
+            if @hash
+              puts 'Internal hash is not set'
+            else
+              puts 'No internal hash loaded yet'
+              cmd_usage
+            end
           end
-          return @hash if @hash && @hash_set
 
-          if @hash
-            puts 'Internal hash is not set'
-          else
-            puts 'No internal hash loaded yet'
-            cmd_usage
+          def assign_hash(hash)
+            valid_hash = !hash.nil?
+            @hash = hash if valid_hash
+            @hash_set |= valid_hash
+            valid_hash
           end
-        end
 
-        def assign_hash(hash)
-          valid_hash = !hash.nil?
-          @hash = hash if valid_hash
-          @hash_set |= valid_hash
-          valid_hash
-        end
+          def cmd_load(path = nil)
+            hash = load_hash(path)
+            return false unless assign_hash(hash)
+            print_hash(hash)
+            true
+          end
 
-        def cmd_load(path = nil)
-          hash = load_hash(path)
-          return false unless assign_hash(hash)
-          print_hash(hash)
-          true
-        end
+          # Helper method that 'toggles' boolean value and prints context info.
+          # (It actually does not modify +flag+.)
+          # @param name [String] variable name.
+          # @param flag [Boolean] boolean value to be 'toggled'.
+          # @return [Boolean] negated value of +flag+.
+          def toggle(name, flag)
+            puts "#{name}: #{flag} -> #{!flag}"
+            !flag
+          end
 
-        def cmd_persist
-          @persist = toggle('persist', @persist)
-          @hash_set = @persist if @hash
-        end
+          # Calls {#toggle} with verbose mode variable.
+          def cmd_verbose
+            @verbose = toggle('verbose', @verbose)
+          end
 
-        def cmd_quit
-          raise Interrupt
+          # Calls {#toggle} with persist mode variable.
+          def cmd_persist
+            @persist = toggle('persist', @persist)
+            @hash_set = @persist if @hash
+          end
+
+          # Manages to close the client gracefully
+          # (it should lead to {#close}).
+          def cmd_quit
+            raise Interrupt
+          end
         end
       end
     end