rzwaveway 0.0.4 → 0.0.6

data/lib/rzwaveway/zwave_device.rb

@@ -2,59 +2,142 @@ require 'json'
 
 module RZWaveWay
   class ZWaveDevice
+    include CommandClass
     include CommandClasses
 
+    attr_reader :name
     attr_reader :id
+    attr_reader :last_contact_time
+    attr_accessor :contact_frequency
 
     def initialize(id, data)
       @id = id
-      @command_classes = create_commandclasses_from data
-      $log.info "Created ZWaveDevice with id='#{id}'"
+      initialize_from data
+      $log.info "Created ZWaveDevice with name='#{name}' (id='#{id}')"
     end
 
-    def create_commandclasses_from data
-      cc_classes = {}
-      data['instances']['0']['commandClasses'].each do |cc_id, sub_tree|
-        cc_classes[cc_id.to_i] = CommandClass.new(cc_id.to_i, sub_tree)
-      end
-      cc_classes
+    def contacts_controller_periodically?
+      support_commandclass? CommandClass::WAKEUP
     end
 
-    def build_json
-      properties = {'deviceId' => @id}
-      @command_classes.each do |cc_id, cc|
-        properties.merge!(cc.properties)
-      end
-      properties.to_json
+    def next_contact_time
+      @last_contact_time + (@contact_frequency * (1 + @missed_contact_count) * 1.1)
+    end
+
+    def to_json
+      attributes = {
+        'name' => @name,
+        'deviceId' => @id,
+        # TODO remove these obsolete attributes (kept for backward compatibility)
+        'lastSleepTime' => @last_contact_time,
+        'lastWakeUpTime' => @last_contact_time,
+        'wakeUpInterval' => @contact_frequency
+        # ---
+        # 'lastContactTime' => @last_contact_time,
+        # 'contactFrequency' => @contact_frequency,
+        # 'properties' => @properties.to_json
+      }
+      attributes.to_json
     end
 
-    def support_commandclass? command_class
-      @command_classes.has_key? command_class
+    def support_commandclass?(command_class_id)
+      @command_classes.has_key? command_class_id
     end
 
     def process updates
       events = []
-      updates_per_commandclass =  group_per_commandclass updates
+      updates_per_commandclass = group_per_commandclass updates
       updates_per_commandclass.each do |cc, values|
         if @command_classes.has_key? cc
-          event = @command_classes[cc].process(values, @id)
+          event = @command_classes[cc].process(values)
           events << event if event
         else
           $log.warn "Could not find command class: '#{cc}'"
         end
       end
+      process_device_data(updates, events)
       events
     end
 
     def process_alive_check
-      if(support_commandclass? WAKEUP)
-        return @command_classes[WAKEUP].process_alive_check(@id)
+      return if @dead
+      if @contact_frequency > 0
+        current_time = Time.now.to_i
+        delta = current_time - next_contact_time
+        if delta > 0
+          count = ((current_time - @last_contact_time) / @contact_frequency).to_i
+          if count > MAXIMUM_MISSED_CONTACT
+            @dead = true
+            DeadEvent.new(@id)
+          elsif count > @missed_contact_count
+            @missed_contact_count = count
+            NotAliveEvent.new(@id, delta, count)
+          end
+        end
+      end
+    end
+
+    def notify_contacted(time)
+      if time.to_i > @last_contact_time
+        @dead = false
+        @last_contact_time = time.to_i
+        @missed_contact_count = 0
+        true
+      end
+    end
+
+    def add_property(name, value, updateTime)
+      @properties[name] = [value, updateTime]
+    end
+
+    def get_property(name)
+      @properties[name].dup
+    end
+
+    def update_property(name, value, updateTime)
+      if @properties.has_key?(name)
+        property = @properties[name]
+        if property[0] != value || property[1] < updateTime
+          property[0] = value
+          property[1] = updateTime
+          true
+        end
       end
     end
 
     private
 
+    MAXIMUM_MISSED_CONTACT = 10
+
+    def create_commandclasses_from data
+      cc_classes = {}
+      data['instances']['0']['commandClasses'].each do |id, sub_tree|
+        cc_id = id.to_i
+        cc_class = CommandClasses::Factory.instance.instantiate(cc_id, sub_tree, self)
+        cc_classes[cc_id] = cc_class
+        cc_class_name = cc_class.class.name.split('::').last
+        (class << self; self end).send(:define_method, cc_class_name) { cc_class } unless cc_class_name == 'Dummy'
+      end
+      cc_classes
+    end
+
+    def initialize_from data
+      @name = find('data.givenName.value', data)
+      last_contact_times = [
+        find('data.lastReceived.updateTime', data),
+        find('data.lastSend.updateTime', data)
+      ]
+      @last_contact_time = last_contact_times.max
+
+      @dead = false
+      @missed_contact_count = 0
+      @contact_frequency = 0
+      @properties = {}
+      @command_classes = create_commandclasses_from data
+    end
+
     def group_per_commandclass updates
+      other_updates = {}
       updates_per_commandclass = {}
       updates.each do | key, value |
         match_data = key.match(/\Ainstances.0.commandClasses.(\d+)./)
@@ -63,10 +146,23 @@ module RZWaveWay
           updates_per_commandclass[command_class] = {} unless updates_per_commandclass.has_key?(command_class)
           updates_per_commandclass[command_class][match_data.post_match] = value
         else
-          $log.warn "? #{key}" unless key.match(/\Adata./)
+          other_updates[key] = value
         end
       end
+      updates.clear
+      updates.merge!(other_updates)
       updates_per_commandclass
     end
+
+    def process_device_data(updates, events)
+      times = []
+      updates.each do | key, value |
+        if key == 'data.lastReceived' || key == 'data.lastSend'
+          times << value['updateTime']
+        end
+      end
+      time = times.max
+      events << AliveEvent.new(@id, time) if notify_contacted(time)
+    end
   end
-end
+end

data/lib/rzwaveway/zway.rb

@@ -1,38 +1,121 @@
-require 'httpclient'
+require 'singleton'
+
+require 'faraday'
 require 'log4r'
 require 'json'
 
 module RZWaveWay
-  module ZWay
-    extend self
+  class ZWay
+    include Singleton
     include Log4r
 
-    BASE_PATH='/ZWaveAPI/Data/'
+    attr_reader :devices
 
-    def self.init hostname
+    def initialize
       $log = Logger.new 'RZWaveWay'
+      formatter = PatternFormatter.new(:pattern => "[%l] %d - %m")
       outputter = Outputter.stdout
-      outputter.formatter = PatternFormatter.new(:pattern => "[%l] %d - %m")
-      $log.outputters = Outputter.stdout
-      @devices = {}
-      @update_time = "0"
-      @event_handlers = {}
-      @http_client = HTTPClient.new
+      outputter.formatter = formatter
+      outputter.level = Log4r::INFO
+      file_outputter = RollingFileOutputter.new('file', filename: 'rzwaveway.log', maxsize: 1048576, trunc: 86400)
+      file_outputter.formatter = formatter
+      file_outputter.level = Log4r::DEBUG
+      $log.outputters = [Outputter.stdout, file_outputter]
+    end
+
+    def execute(device_id, command_class, command_class_function, argument = nil)
+      raise "No device with id '#{device_id}'" unless @devices.has_key?(device_id)
+      raise "Device with id '#{device_id}' does not support command class '#{command_class}'" unless @devices[device_id].support_commandclass?(command_class)
+      function_name = command_class_function.to_s
+      run_zway_function(device_id, command_class, function_name, argument)
+    end
+
+    def find_extension(name, device_id)
+      device = @devices[device_id.to_i]
+      raise ArgumentError, "No device with id '#{device_id}'" unless device
+      clazz = qualified_const_get "RZWaveWay::Extensions::#{name}"
+      clazz.new(device)
+    end
+
+    def setup(hostname, *adapter_params)
+      adapter_params = :httpclient if adapter_params.compact.empty?
       @base_uri="http://#{hostname}:8083"
+      @connection = Faraday.new {|faraday| faraday.adapter *adapter_params}
     end
 
-    def get_devices
-      results = http_post_request
-      results["devices"].each do |device_id,device_data_tree|
-        device_id = device_id.to_i
-        @devices[device_id] = ZWaveDevice.new(device_id, device_data_tree) if device_id > 1
+    def start
+      @devices = {}
+      @event_handlers = {}
+      @update_time = '0'
+      loop do
+        results = get_zway_data_tree_updates
+        if results.has_key?('devices')
+          results['devices'].each {|device_id,device_data_tree| create_device(device_id.to_i, device_data_tree)}
+          break
+        else
+          sleep 1.0
+          $log.warn 'No devices found at start-up, retrying'
+        end
       end
-      @devices
+    end
+
+    def on_event(event, &listener)
+      @event_handlers[event] = listener
     end
 
     def process_events
+      check_devices
+      updates = get_zway_data_tree_updates
+      events = devices_process updates
+      check_not_alive_devices(events)
+      deliver_to_handlers(events)
+    end
+
+    private
+
+    DATA_TREE_BASE_PATH='/ZWaveAPI/Data/'
+    RUN_BASE_PATH='/ZWaveAPI/Run/'
+
+    def check_devices
+      @devices.values.each do |device|
+        unless device.contacts_controller_periodically?
+          current_time = Time.now.to_i
+          # TODO ensure last_contact_time is set in the device initializer
+          if (current_time % 10 == 0) && (current_time > device.next_contact_time - 60)
+            run_zway_no_operation device.id
+          end
+        end
+      end
+    end
+
+    def check_not_alive_devices(events)
+      @devices.values.each do |device|
+        event = device.process_alive_check
+        events << event if event
+      end
+    end
+
+    def create_device(device_id, device_data_tree)
+      if device_id > 1
+        device = ZWaveDevice.new(device_id, device_data_tree)
+        device.contact_frequency = 300 unless device.contacts_controller_periodically?
+        @devices[device_id] = device
+      end
+    end
+
+    def deliver_to_handlers events
+      events.each do |event|
+        handler = @event_handlers[event.class]
+        if handler
+          handler.call(event)
+        else
+          $log.warn "No event handler for #{event.class}"
+        end
+      end
+    end
+
+    def devices_process updates
       events = []
-      updates = http_post_request
       updates_per_device = group_per_device updates
       updates_per_device.each do | id, updates |
         if @devices[id]
@@ -42,16 +125,6 @@ module RZWaveWay
           $log.warn "Could not find device with id '#{id}'"
         end
       end
-      alive_events = check_not_alive_devices
-      events += alive_events unless alive_events.empty?
-      events.each do |event|
-        handler = @event_handlers[event.class]
-        if handler
-          handler.call(event)
-        else
-          $log.warn "no handler for #{event.class}"
-        end
-      end
       events
     end
 
@@ -64,36 +137,75 @@ module RZWaveWay
           updates_per_device[device_id] = {} unless(updates_per_device.has_key?(device_id))
           updates_per_device[device_id][match_data.post_match] = value
         else
-          $log.warn "? #{key}"
+          $log.debug "No device group match for key='#{key}'"
         end
       end
       updates_per_device
     end
 
-    def check_not_alive_devices
-      events = []
-      @devices.values.each do |device|
-        event = device.process_alive_check
-        events << event if event 
+    def get_zway_data_tree_updates
+      results = {}
+      url = @base_uri + DATA_TREE_BASE_PATH + "#{@update_time}"
+      begin
+        response = @connection.get(url)
+        if response.success?
+          results = JSON.parse response.body
+          @update_time = results.delete('updateTime')
+        else
+          $log.error(response.reason)
+        end
+      rescue StandardError => e
+        $log.error("Failed to communicate with ZWay HTTP server: #{e}")
       end
-      events
+      results
     end
 
-    def http_post_request
-      results = {}
-      url = @base_uri + BASE_PATH + "#{@update_time}"
-      response = @http_client.post(url)
-      if response.ok?
-        results = JSON.parse response.body
-        @update_time = results.delete("updateTime")
+    def qualified_const_get(str)
+      path = str.to_s.split('::')
+      from_root = path[0].empty?
+      if from_root
+        from_root = []
+        path = path[1..-1]
       else
-        $log.error(response.reason)
+        start_ns = ((Class === self)||(Module === self)) ? self : self.class
+        from_root = start_ns.to_s.split('::')
       end
-      results
+      until from_root.empty?
+        begin
+          return (from_root+path).inject(Object) { |ns,name| ns.const_get(name) }
+        rescue NameError
+          from_root.delete_at(-1)
+        end
+      end
+      path.inject(Object) { |ns,name| ns.const_get(name) }
     end
 
-    def on_event (event, &listener)
-      @event_handlers[event] = listener
+    def run_zway_function(device_id, command_class, function_name, argument)
+      command_path = "devices[#{device_id}].instances[0].commandClasses[#{command_class}]."
+      if argument
+        command_path += "#{function_name}(#{argument})"
+      else
+        command_path += "#{function_name}()"
+      end
+      run_zway command_path
+    end
+
+    def run_zway_no_operation device_id
+      run_zway "devices[#{device_id}].SendNoOperation()"
+    end
+
+    def run_zway command_path
+      begin
+        uri = URI.encode(@base_uri + RUN_BASE_PATH + command_path, '[]')
+        response = @connection.get(uri)
+        unless response.success?
+          $log.error(response.status)
+          $log.error(response.body)
+        end
+      rescue StandardError => e
+        $log.error("Failed to communicate with ZWay HTTP server: #{e}")
+        $log.error(e.backtrace)
+      end
     end
   end
-end
+end

data/lib/rzwaveway.rb

@@ -1,4 +1,5 @@
 require_relative 'rzwaveway/command_classes'
 require_relative 'rzwaveway/events'
 require_relative 'rzwaveway/zwave_device'
-require_relative 'rzwaveway/zway'
+require_relative 'rzwaveway/zway'
+require_relative 'rzwaveway/extensions'

data/rzwaveway.gemspec

@@ -1,18 +1,24 @@
+$LOAD_PATH.unshift 'lib'
+require 'rzwaveway/version'
+
 Gem::Specification.new do |s|
-  s.name = "rzwaveway"
-  s.version = "0.0.4"
-  s.authors = ["Vincent Touchard"]
+  s.name = 'rzwaveway'
+  s.version = RZWaveWay::VERSION
+  s.authors = ['Vincent Touchard']
   s.date = %q{2014-02-18}
   s.summary = 'ZWave API for ZWay'
   s.description = 'A Ruby API to use the Razberry ZWave ZWay interface'
-  s.email = 'vincentoo.ignore@yahoo.com'
+  s.email = 'touchardv@yahoo.com'
   s.homepage = 'https://github.com/touchardv/rzwaveway'
   s.files = `git ls-files`.split("\n")
   s.has_rdoc = false
 
   dependencies = [
-    [:runtime, "log4r", "~> 1.1.10"],
-    [:runtime, "httpclient", "~> 2.3.4.1"]
+    [:runtime, 'log4r', '~> 1.1.10'],
+    [:runtime, 'faraday'],
+    [:runtime, 'httpclient'],
+    [:development, 'bundler', '~> 1.0'],
+    [:development, 'rspec', '~> 3.0.0']
   ]
 
   dependencies.each do |type, name, version|

data/spec/command_classes/battery_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module RZWaveWay
+  module CommandClasses
+    describe Battery do
+      let(:device) { ZWaveDevice.new(create_id, create_device_data) }
+      let(:command_class) do
+        Battery.new(
+          {'data' => { 'last' => {
+                         'value' => 60,
+                         'type' => 'int',
+                         'updateTime' => 1409681662
+        }}}, device)
+      end
+
+      describe '#new' do
+        it 'stores interesting properties' do
+          command_class
+          expect(device.get_property(:battery_level)).to eq [60, 1409681662]
+        end
+      end
+
+      describe '#process' do
+        it 'does nothing when it processes no updates' do
+          expect(command_class.process({})).to be_nil
+        end
+
+        it 'returns a battery event' do
+          updates = {
+            'data.last' => {
+              'value' => 50,
+              'type' => 'int',
+              'updateTime' => 1409681762
+          }}
+          event = command_class.process(updates)
+          expect(event.class).to be RZWaveWay::BatteryValueEvent
+          expect(event.value).to eq 50
+          expect(event.device_id).to eq device.id
+          expect(event.time).to eq 1409681762
+        end
+      end
+    end
+  end
+end

data/spec/command_classes/sensor_binary_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module RZWaveWay
+  module CommandClasses
+    describe SensorBinary do
+      let(:device) { ZWaveDevice.new(create_id, create_device_data) }
+      let(:command_class) do
+        SensorBinary.new(
+          {'data' => { '1' => { 'level' => {
+                                  'value' => false,
+                                  'updateTime' => 1405102560
+        }}}}, device)
+      end
+
+      describe '#new' do
+        it 'stores interesting properties' do
+          command_class
+          expect(device.get_property(:level)).to eq [false, 1405102560]
+        end
+      end
+
+      describe '#process' do
+        it 'does nothing when it processes no updates' do
+          expect(command_class.process({})).to be_nil
+        end
+
+        it 'returns a level event' do
+          updates = {
+            'data.1' => { 'level' => {
+                            'value' => true,
+                            'updateTime' => 1405102860
+          }}}
+          event = command_class.process(updates)
+          expect(event.class).to be RZWaveWay::LevelEvent
+          expect(event.level).to eq true
+          expect(event.device_id).to eq device.id
+          expect(event.time).to eq 1405102860
+        end
+      end
+    end
+  end
+end

data/spec/command_classes/switch_binary_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module RZWaveWay
+  module CommandClasses
+    describe SwitchBinary do
+      let(:device) { ZWaveDevice.new(create_id, create_device_data) }
+      let(:command_class) do
+        SwitchBinary.new(
+          {'data' => { 'level' => {
+                         'value' => false,
+                         'updateTime' => 1405102560
+        }}}, device)
+      end
+
+      describe '#it caches the level' do
+        it 'stores interesting properties' do
+          command_class
+          expect(device.get_property(:level)).to eq [false, 1405102560]
+        end
+      end
+
+      describe '#process' do
+        it 'does nothing when it processes no updates' do
+          expect(command_class.process({})).to be_nil
+        end
+
+        it 'returns a multi level event' do
+          updates = {
+            'data.level' => {
+              'value' => true,
+              'updateTime' => 1405102860
+          }}
+          event = command_class.process(updates)
+          expect(event.class).to be RZWaveWay::LevelEvent
+          expect(event.level).to eq true
+          expect(event.device_id).to eq device.id
+          expect(event.time).to eq 1405102860
+        end
+      end
+    end
+  end
+end

data/spec/command_classes/switch_multi_level_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module RZWaveWay
+  module CommandClasses
+    describe SwitchMultiLevel do
+      let(:device) { ZWaveDevice.new(create_id, create_device_data) }
+      let(:command_class) do
+        SwitchMultiLevel.new(
+          {'data' => { 'level' => {
+                         'value' => 33,
+                         'updateTime' => 1405102560
+        }}}, device)
+      end
+
+      describe '#new' do
+        it 'stores interesting properties' do
+          command_class
+          expect(device.get_property(:level)).to eq [33, 1405102560]
+        end
+      end
+
+      describe '#process' do
+        it 'does nothing when it processes no updates' do
+          expect(command_class.process({})).to be_nil
+        end
+
+        it 'returns a multi level event' do
+          updates = {
+            'data.level' => {
+              'value' => 66,
+              'updateTime' => 1405102860
+          }}
+          event = command_class.process(updates)
+          expect(event.class).to be RZWaveWay::MultiLevelEvent
+          expect(event.level).to eq 66
+          expect(event.device_id).to eq device.id
+          expect(event.time).to eq 1405102860
+        end
+      end
+    end
+  end
+end