maxcube-client 0.4.0

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

@@ -0,0 +1,30 @@
+require_relative 'handler'
+require 'maxcube/messages/serializer'
+
+module MaxCube
+  module Messages
+    module UDP
+      class Serializer
+        include Handler
+        include Messages::Serializer
+
+        MSG_TYPES = %w[I N h c R].freeze
+
+        MSG_PREFIX = (UDP::MSG_PREFIX + "*\x00").freeze
+
+        def serialize_udp_hash(hash)
+          check_udp_hash(hash)
+          serial_number = hash[:serial_number] || '*' * 10
+          msg = MSG_PREFIX + serial_number << @msg_type
+          check_udp_msg(msg)
+        end
+
+        private
+
+        def msg_msg_type(msg)
+          msg[18]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+
+module MaxCube
+  module Messages
+    module UDP
+      class Parser
+        module MessageH
+          private
+
+          KEYS = (Parser::KEYS + %i[port url path]).freeze
+
+          def parse_udp_h(_body)
+            port = read(2, true)
+            url, path = read.split(',')
+            {
+              port: port,
+              url: url,
+              path: path,
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+
+module MaxCube
+  module Messages
+    module UDP
+      class Parser
+        module MessageI
+          private
+
+          KEYS = (Parser::KEYS + %i[unknown
+                                    rf_address firmware_version]).freeze
+
+          def parse_udp_i(_body)
+            {
+              unknown: read(1),
+              rf_address: read(3, true),
+              firmware_version: read(2, 'H*'),
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+
+module MaxCube
+  module Messages
+    module UDP
+      class Parser
+        module MessageN
+          private
+
+          N_KEYS = %i[ip_address gateway subnet_mask dns1 dns2].freeze
+          KEYS = (Parser::KEYS + N_KEYS).freeze
+
+          def parse_udp_n(_body)
+            N_KEYS.map do |k|
+              [k, IPAddr.ntop(read(4))]
+            end.to_h
+          end
+        end
+      end
+    end
+  end
+end

data/lib/maxcube/network.rb

@@ -0,0 +1,14 @@
+require 'socket'
+require 'thread'
+require 'ipaddr'
+require 'pathname'
+
+require 'pp'
+require 'yaml'
+
+module MaxCube
+  module Network
+    LOCALHOST = 'localhost'.freeze
+    BROADCAST = '<broadcast>'.freeze
+  end
+end

data/lib/maxcube/network/tcp.rb

@@ -0,0 +1,11 @@
+require 'maxcube/network'
+require 'maxcube/messages/tcp/parser'
+require 'maxcube/messages/tcp/serializer'
+
+module MaxCube
+  module Network
+    module TCP
+      PORT = 62_910
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+require 'maxcube/network/tcp'
+require_relative 'client/commands'
+
+module MaxCube
+  module Network
+    module TCP
+      class Client
+        def initialize
+          @parser = Messages::TCP::Parser.new
+          @serializer = Messages::TCP::Serializer.new
+          @queue = Queue.new
+
+          @buffer = { recv: { hashes: [], data: [] },
+                      sent: { hashes: [], data: [] } }
+          @history = { recv: { hashes: [], data: [] },
+                       sent: { hashes: [], data: [] } }
+
+          @hash = nil
+          @hash_set = false
+
+          @data_dir = Pathname.new('../data')
+          @load_data_dir = @data_dir + 'load'
+          @save_data_dir = @data_dir + 'save'
+
+          @verbose = true
+          @persist = true
+        end
+
+        def connect(host = LOCALHOST, port = PORT)
+          @socket = TCPSocket.new(host, port)
+          @thread = Thread.new(self, &:receiver)
+          shell
+        end
+
+        def receiver
+          puts '<Starting receiver thread ...>'
+          while (data = @socket.gets)
+            hashes = @parser.parse_tcp_data(data)
+            if @verbose
+              hashes.each { |h| print_hash(h) }
+              puts
+            end
+            @queue << [data, hashes]
+          end
+          raise IOError
+        rescue IOError
+          STDIN.close
+          puts '<Closing receiver thread ...>'
+        rescue Messages::InvalidMessage => e
+          puts e.to_s.capitalize
+        end
+
+        def shell
+          puts "Welcome to interactive shell!\n" \
+               "Type 'help' for list of commands.\n\n"
+          STDIN.each do |line|
+            refresh_buffer
+            command(line)
+            puts
+          end
+          raise Interrupt
+        rescue IOError, Interrupt
+          puts "\nClosing shell ..."
+          close
+        end
+
+        def close
+          STDIN.close
+          send_msg('q')
+          @socket.close
+          @thread.join
+        end
+
+        private
+
+        def refresh_buffer
+          until @queue.empty?
+            data, hashes = @queue.pop
+            @buffer[:recv][:data] << data
+            @buffer[:recv][:hashes] << hashes
+          end
+        end
+
+        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
+
+        def command(line)
+          cmd, *args = line.chomp.split
+          return nil unless cmd
+
+          return send("cmd_#{cmd}", *args) if COMMANDS.key?(cmd)
+
+          keys = COMMANDS.find { |_, v| v.include?(cmd) }
+          return send("cmd_#{keys.first}", *args) if keys
+
+          puts "Unrecognized command: '#{cmd}'"
+          cmd_usage
+        rescue ArgumentError
+          puts "Invalid arguments: #{args}"
+          cmd_usage
+        end
+
+        def send_msg_hash_from_keys_args(type, *args, **opts)
+          keys = @serializer.msg_type_hash_keys(type) +
+                 @serializer.msg_type_hash_opt_keys(type)
+          if opts[:last_array]
+            hash_args = args.first(keys.size - 1)
+            ary_args = args.drop(keys.size - 1)
+            ary_args = nil if opts[:array_nonempty] && ary_args.empty?
+            args = hash_args << ary_args
+          end
+          if keys.size < args.size
+            return puts 'Additional arguments: ' \
+                        "#{args.last(args.size - keys.size)}"
+          end
+          keys.zip(args).to_h.reject { |_, v| v.nil? }
+        end
+
+        def send_msg_hash_from_internal(*args, **_opts)
+          return nil unless cmd_load(*args.drop(1))
+          @hash_set = false unless @persist
+          @hash
+        end
+
+        ARGS_FROM_HASH = '-'.freeze
+
+        def args_from_hash?(args)
+          args.first == ARGS_FROM_HASH
+        end
+
+        def send_msg_hash(type, *args, **opts)
+          if opts[:load_only] && !args_from_hash?(args)
+            args.unshift(ARGS_FROM_HASH)
+          end
+          return {} if args.empty?
+
+          if args_from_hash?(args)
+            return send_msg_hash_from_internal(*args, **opts)
+          end
+
+          send_msg_hash_from_keys_args(type, *args, **opts)
+        end
+
+        def send_msg(type, *args, **opts)
+          hash = send_msg_hash(type, *args, **opts)
+          return unless hash
+
+          if hash.key?(:type)
+            unless type == hash[:type]
+              puts "\nInternal hash message type mismatch: '#{hash[:type]}'" \
+                   " (should be '#{type}')"
+              return
+            end
+          else
+            hash[:type] = type
+          end
+          msg = @serializer.serialize_tcp_hash(hash)
+
+          @buffer[:sent][:data] << msg
+          @buffer[:sent][:hashes] << [hash]
+          @socket.write(msg)
+        rescue Messages::InvalidMessage => e
+          puts e.to_s.capitalize
+        end
+
+        def print_hash(hash)
+          puts hash.to_yaml
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,286 @@
+
+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
+
+        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_data
+          list_hashes(false)
+        end
+
+        def cmd_history
+          list_hashes(true)
+        end
+
+        def cmd_clear
+          %i[data hashes].each do |sym|
+            @history[:recv][sym] += @buffer[:recv][sym]
+            @buffer[:recv][sym].clear
+          end
+        end
+
+        def cmd_dump
+          cmd_data
+          cmd_clear
+        end
+
+        def cmd_list
+          send_msg('l')
+        end
+
+        def cmd_config
+          send_msg('c')
+        end
+
+        def cmd_send(*args)
+          send_msg('s', *args, load_only: true)
+        end
+
+        def cmd_pair(*args)
+          send_msg('n', *args)
+        end
+
+        def cmd_url(*args)
+          send_msg('u', *args)
+        end
+
+        def cmd_ntp(*args)
+          send_msg('f', *args, last_array: true)
+        end
+
+        def cmd_wake(*args)
+          send_msg('z', *args)
+        end
+
+        def cmd_metadata(*args)
+          send_msg('m', *args, load_only: true)
+        end
+
+        def cmd_delete(*args)
+          send_msg('t', *args, last_array: true, array_nonempty: true)
+        end
+
+        def cmd_reset
+          send_msg('a')
+        end
+
+        def toggle(name, flag)
+          puts "#{name}: #{flag} -> #{!flag}"
+          !flag
+        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
+
+          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
+
+            hashes_fn = dir + (sym.to_s << '.yaml')
+            File.open(hashes_fn, 'w') do |f|
+              buffer(sym, :hashes, all).to_yaml(f)
+            end
+          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
+
+          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
+
+          if @hash
+            puts 'Internal hash is not set'
+          else
+            puts 'No internal hash loaded yet'
+            cmd_usage
+          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_persist
+          @persist = toggle('persist', @persist)
+          @hash_set = @persist if @hash
+        end
+
+        def cmd_quit
+          raise Interrupt
+        end
+      end
+    end
+  end
+end