maxcube-client 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f724f91f573430c052cc4111ded2e56f36b02349702e6f9dd9ed7e1929f7eee2
+  data.tar.gz: 8a474badc26be87026e855763bfa959b2b89a3165a2891d199ac67a3c26928e0
+SHA512:
+  metadata.gz: d6e28eec5439846c020d105697f2263e060ebf5f638fbb7397f9d2d878d41452af13cdbd3cacd4caa71252a4ce4e4a364dc44eef2cfa07d72ace5c59abbb0b83
+  data.tar.gz: 5381d96a92770f4510da936f93cb88b0d5313833e771db10c0bca1d4fefd9b9ba284dcf455f8c7c4e0d468963aca004e40de651475d733318a281fc34fbda27c

data/.rubocop.yml

@@ -0,0 +1,32 @@
+AllCops:
+  TargetRubyVersion: 2.4
+
+Metrics/ModuleLength:
+  Max: 200
+
+Metrics/ClassLength:
+  Max: 200
+
+Metrics/MethodLength:
+  Max: 30
+
+Metrics/AbcSize:
+  Enabled: false
+
+Style/TrailingCommaInLiteral:
+  Enabled: false
+
+Style/TrailingCommaInArguments:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/RaiseArgs:
+  EnforcedStyle: compact
+
+Documentation:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gemspec

data/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Tomaqa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+# eQ3/ELV Max! Cube TCP client
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'maxcube-client'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install maxcube-client
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Tomaqa/maxcube-client.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'maxcube/network/tcp/client'
+require 'maxcube/network/udp/client'
+require 'irb'
+
+IRB.start(__FILE__)

data/bin/maxcube-client

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'maxcube/network/tcp/client'
+require 'maxcube/network/udp/client'
+
+HELP_KEYS = %w[h -h help -help --help ? -?].freeze
+
+help = ARGV.size == 1 && HELP_KEYS.include?(ARGV.first)
+wrong_args = ARGV.size > 2
+
+if help || wrong_args
+  puts "Wrong number of arguments: #{ARGV.size} (expected: 0..2)" if wrong_args
+  puts "USAGE: ruby #{__FILE__} [<help>|<host>] [<port>]\n" \
+       "  <help> - on of these: #{HELP_KEYS}\n\n" \
+       "If no arguments are given, UDP discovery is performed.\n" \
+       'Otherwise, TCP client is launched (unless help command entered).'
+  exit
+end
+
+if ARGV.empty?
+  puts "No arguments given - performing UDP discovery ...\n" \
+       "(For usage message, type one of these: #{HELP_KEYS})\n\n"
+  client = MaxCube::Network::UDP::Client.new
+  client.discovery
+  client.close
+  exit
+end
+
+client = MaxCube::Network::TCP::Client.new
+client.connect(*ARGV)

data/bin/sample_server

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'maxcube/network/tcp/sample_server'
+
+unless ARGV.size <= 1
+  puts "Wrong number of arguments: #{ARGV.size} (expected: 0..1)"
+  puts "Usage: ruby #{__FILE__} [port]"
+  exit
+end
+
+server = MaxCube::Network::TCP::SampleServer.new(*ARGV)
+server.run

data/bin/sample_socket

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'maxcube/network/udp/sample_socket'
+
+unless ARGV.size <= 1
+  puts "Wrong number of arguments: #{ARGV.size} (expected: 0..1)"
+  puts "Usage: ruby #{__FILE__} [port]"
+  exit
+end
+
+socket = MaxCube::Network::UDP::SampleSocket.new(*ARGV)
+socket.run

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/data/load/del

@@ -0,0 +1,6 @@
+---
+:type: t
+:count: 1
+:force: false
+:rf_addresses:
+- 0x123456

data/data/load/meta

@@ -0,0 +1,20 @@
+---
+:type: m
+:index: 0
+:unknown1: Vx
+:unknown2: "\x01"
+:rooms_count: 1
+:rooms:
+- :id: 33
+  :name_length: 2
+  :name: XY
+  :rf_address: 3224115
+:devices_count: 1
+:devices:
+- :type: shutter_contact
+  :rf_address: 5391937
+  :serial_number: serial_num
+  :name_length: 4
+  :name: NAME
+  :room_id: 33
+

data/data/load/ntp

@@ -0,0 +1,6 @@
+---
+:type: f
+:ntp_servers:
+- server1
+- server2
+

data/data/load/set_temp

@@ -0,0 +1,13 @@
+---
+:type: s
+:unknown: "\0"
+:command: :set_temperature
+:rf_address: 1033088
+:room_id: 0
+:comfort_temperature: 21.5
+:eco_temperature: 16.5
+:max_setpoint_temperature: 30.5
+:min_setpoint_temperature: 4.5
+:temperature_offset: 0
+:window_open_temperature: 12.0
+:window_open_duration: 15

data/data/load/set_temp_mode

@@ -0,0 +1,12 @@
+---
+:type: s
+:unknown: "\0"
+:command: :set_temperature_mode
+:rf_address_range: !ruby/range
+  begin: 4
+  end: 495872
+  excl: false
+:room_id: 1
+:temperature: 19.0
+:mode: :vacation
+:datetime_until: !ruby/object:DateTime 2011-08-29 02:00:00.000000000 Z

data/data/load/set_valve

@@ -0,0 +1,11 @@
+---
+:type: s
+:command: :config_valve
+:rf_address: 1033088
+:room_id: 1
+:boost_duration: '5'
+:valve_opening: '90.0'
+:decalcification_day: '6'
+:decalcification_hour: 12
+:max_valve_setting: '100'
+:valve_offset: 0.0

data/data/load/url

@@ -0,0 +1,4 @@
+---
+:type: u
+:url: url
+:port: 80

data/data/load/wake

@@ -0,0 +1,4 @@
+---
+:type: z
+:time: 5
+:scope: room

data/lib/maxcube/messages.rb

@@ -0,0 +1,148 @@
+require 'date'
+require 'ipaddr'
+
+module MaxCube
+  module Messages
+    DEVICE_MODE = %i[auto manual vacation boost].freeze
+    DEVICE_TYPE = %i[cube
+                     radiator_thermostat radiator_thermostat_plus
+                     wall_thermostat
+                     shutter_contact eco_switch].freeze
+
+    DAYS_OF_WEEK = %w[Saturday Sunday Monday
+                      Tuesday Wednesday Thursday Friday].freeze
+
+    PACK_FORMAT = %w[x C n N N].freeze
+
+    class InvalidMessage < RuntimeError; end
+
+    class InvalidMessageLength < InvalidMessage
+      def initialize(info = 'invalid message length')
+        super
+      end
+    end
+
+    class InvalidMessageType < InvalidMessage
+      def initialize(msg_type, info = 'invalid message type')
+        super("#{info}: #{msg_type}")
+      end
+    end
+
+    class InvalidMessageFormat < InvalidMessage
+      def initialize(info = 'invalid format')
+        super
+      end
+    end
+
+    class InvalidMessageBody < InvalidMessage
+      def initialize(msg_type, info = 'invalid format')
+        super("message type #{msg_type}: #{info}")
+      end
+    end
+
+    private
+
+    def conv_args(type, info, *args, &block)
+      info = info.to_s.tr('_', ' ')
+      args.map(&block)
+    rescue ArgumentError, TypeError
+      raise InvalidMessageBody
+        .new(@msg_type,
+             "invalid #{type} format of arguments #{args} (#{info})")
+    end
+
+    # Convert string of characters (not binary data!) to hex number
+    # For binary data use #String.unpack
+    def to_ints(base, info, *args)
+      base_str = base.zero? ? '' : "(#{base})"
+      conv_args("integer#{base_str}", info, *args) { |x| Integer(x, base) }
+    end
+
+    def to_int(base, info, arg)
+      to_ints(base, info, arg).first
+    end
+
+    def to_floats(info, *args)
+      conv_args('float', info, *args) { |x| Float(x) }
+    end
+
+    def to_float(info, arg)
+      to_floats(info, arg).first
+    end
+
+    def to_bools(info, *args)
+      conv_args('boolean', info, *args) do |arg|
+        if arg == !!arg
+          arg
+        elsif arg.nil?
+          false
+        elsif %w[true false].include?(arg)
+          arg == 'true'
+        else
+          !Integer(arg).zero?
+        end
+      end
+    end
+
+    def to_bool(info, arg)
+      to_bools(info, arg).first
+    end
+
+    def to_datetimes(info, *args)
+      conv_args('datetime', info, *args) do |arg|
+        if arg.is_a?(DateTime)
+          arg
+        elsif arg.respond_to?('to_datetime')
+          arg.to_datetime
+        else
+          DateTime.parse(arg)
+        end
+      end
+    end
+
+    def to_datetime(info, arg)
+      to_datetimes(info, arg).first
+    end
+
+    def ary_elem(ary, id, info)
+      elem = ary[id]
+      return elem if elem
+      raise InvalidMessageBody
+        .new(@msg_type, "unrecognized #{info} id: #{id}")
+    end
+
+    def ary_elem_id(ary, elem, info)
+      id = ary.index(elem)
+      return id if id
+      raise InvalidMessageBody
+        .new(@msg_type, "unrecognized #{info}: #{elem}")
+    end
+
+    def device_type(device_type_id)
+      ary_elem(DEVICE_TYPE, device_type_id, 'device type')
+    end
+
+    def device_type_id(device_type)
+      ary_elem_id(DEVICE_TYPE, device_type.to_sym, 'device type')
+    end
+
+    def device_mode(device_mode_id)
+      ary_elem(DEVICE_MODE, device_mode_id, 'device mode')
+    end
+
+    def device_mode_id(device_mode)
+      ary_elem_id(DEVICE_MODE, device_mode.to_sym, 'device mode')
+    end
+
+    def day_of_week(day_id)
+      ary_elem(DAYS_OF_WEEK, day_id, 'day of week')
+    end
+
+    def day_of_week_id(day)
+      if day.respond_to?('to_i') && day.to_i.between?(1, 7)
+        return (day.to_i + 1) % 7
+      end
+      ary_elem_id(DAYS_OF_WEEK, day.capitalize, 'day of week')
+    end
+  end
+end

data/lib/maxcube/messages/handler.rb

@@ -0,0 +1,154 @@
+require 'base64'
+require 'stringio'
+
+require 'maxcube/messages'
+
+module MaxCube
+  module Messages
+    module Handler
+      include Messages
+
+      def valid_data_type(raw_data)
+        raw_data.is_a?(String)
+      end
+
+      def check_data_type(raw_data)
+        raise TypeError unless valid_data_type(raw_data)
+        raw_data
+      end
+
+      def valid_msg_type(msg_type)
+        maybe_check_valid_msg_type(msg_type, false)
+      end
+
+      def check_msg_type(msg_type)
+        maybe_check_valid_msg_type(msg_type, true)
+        @msg_type
+      end
+
+      def valid_msg_msg_type(msg)
+        valid_msg_type(msg_msg_type(msg))
+      end
+
+      def check_msg_msg_type(msg)
+        check_msg_type(msg_msg_type(msg))
+      end
+
+      def valid_msg(msg)
+        valid_msg_msg_type(msg)
+      end
+
+      def check_msg(msg)
+        check_msg_msg_type(msg)
+      end
+
+      def valid_hash_msg_type(hash)
+        valid_msg_type(hash[:type])
+      end
+
+      def check_hash_msg_type(hash)
+        msg_type = hash[:type]
+        check_msg_type(msg_type)
+        msg_type
+      end
+
+      def msg_type_hash_keys(msg_type)
+        msg_type_which_hash_keys(msg_type, false)
+      end
+
+      def msg_type_hash_opt_keys(msg_type)
+        msg_type_which_hash_keys(msg_type, true)
+      end
+
+      def valid_hash_keys(hash)
+        maybe_check_valid_hash_keys(hash, false)
+      end
+
+      def check_hash_keys(hash)
+        maybe_check_valid_hash_keys(hash, true)
+        hash
+      end
+
+      def valid_hash_values(hash)
+        hash.none? { |_, v| v.nil? }
+      end
+
+      def check_hash_values(hash)
+        return hash if valid_hash_values(hash)
+        hash = hash.dup
+        hash.delete(:type)
+        raise InvalidMessageBody
+          .new(@msg_type, "invalid hash values: #{hash}")
+      end
+
+      def valid_hash(hash)
+        valid_hash_msg_type(hash) &&
+          valid_hash_keys(hash) &&
+          valid_hash_values(hash)
+      end
+
+      def check_hash(hash)
+        check_hash_msg_type(hash)
+        check_hash_keys(hash)
+        check_hash_values(hash)
+        hash
+      end
+
+      private
+
+      def msg_types
+        self.class.const_get('MSG_TYPES')
+      end
+
+      def maybe_check_valid_msg_type(msg_type, check)
+        valid = msg_type&.length == 1 &&
+                msg_types.include?(msg_type)
+        return valid ? msg_type : false unless check
+        @msg_type = msg_type
+        raise InvalidMessageType.new(@msg_type) unless valid
+      end
+
+      def valid_msg_part_lengths(lengths, *args)
+        return false if args.any?(&:nil?) ||
+                        args.length < lengths.length
+        args.each_with_index.all? do |v, i|
+          !lengths[i] || v.length == lengths[i]
+        end
+      end
+
+      def check_msg_part_lengths(lengths, *args)
+        return if valid_msg_part_lengths(lengths, *args)
+        raise InvalidMessageBody
+          .new(@msg_type,
+               "invalid lengths of message parts #{args}" \
+               " (lengths should be: #{lengths})")
+      end
+
+      def msg_type_which_hash_keys(msg_type, optional = false)
+        str = "Message#{msg_type.upcase}::" + (optional ? 'OPT_KEYS' : 'KEYS')
+        self.class.const_defined?(str) ? self.class.const_get(str) : []
+      end
+
+      def maybe_check_valid_hash_keys(hash, check)
+        keys = msg_type_hash_keys(@msg_type).dup
+        opt_keys = msg_type_hash_opt_keys(@msg_type)
+
+        hash_keys = hash.keys - opt_keys - [:type]
+
+        valid = hash_keys.sort == keys.sort
+        return valid if !check || valid
+        raise InvalidMessageBody
+          .new(@msg_type, "invalid hash keys: #{hash_keys} " \
+               "(should be: #{keys})")
+      end
+
+      def encode(data)
+        Base64.strict_encode64(data)
+      end
+
+      def decode(data)
+        Base64.decode64(data)
+      end
+    end
+  end
+end