lifx 0.0.1 → 0.4.0

data/lib/lifx/message.rb

@@ -0,0 +1,166 @@
+require 'forwardable'
+require 'lifx/protocol_path'
+
+module LIFX
+  # @api private
+
+  class Message
+    include Logging
+    extend Forwardable
+
+    class MessageError < StandardError; end
+    class UnpackError < MessageError; end
+    class PackError < MessageError; end
+    class NoPath < MessageError; end
+
+    class InvalidFrame < UnpackError; end
+    class UnsupportedProtocolVersion < UnpackError; end
+    class NotAddressableFrame < UnpackError; end
+    class NoPayload < PackError; end
+    class UnmappedPayload < MessageError; end
+    class InvalidFields < PackError; end
+
+    PROTOCOL_VERSION = 1024
+
+    class << self
+      attr_accessor :log_invalid_messages
+
+      def unpack(data)
+        raise InvalidFrame if data.length < 2
+
+        header = Protocol::Header.read(data)
+        raise UnsupportedProtocolVersion.new("Expected #{PROTOCOL_VERSION} but got #{header.protocol} instead") if header.protocol != PROTOCOL_VERSION
+        raise NotAddressableFrame if header.addressable == 0
+
+        message = Protocol::Message.read(data)
+        path = ProtocolPath.new(raw_site: message.raw_site, raw_target: message.raw_target, tagged: message.tagged)
+        payload_class = message_type_for_id(message.type.snapshot)
+        if payload_class.nil?
+          if self.log_invalid_messages
+            logger.error("Message.unpack: Unrecognised payload ID: #{message.type}")
+            logger.error("Message.unpack: Message: #{message}")
+          end
+          return nil # FIXME
+          raise UnmappedPayload.new("Unrecognised payload ID: #{message.type}")
+        end
+        begin
+          payload = payload_class.read(message.payload)
+        rescue => ex
+          if message.raw_site == "\x00" * 6
+            logger.info("Message.unpack: Ignoring malformed message from virgin bulb")
+          else
+            if self.log_invalid_messages
+              logger.error("Message.unpack: Exception while unpacking payload of type #{payload_class}: #{ex}")
+              logger.error("Message.unpack: Data: #{data.inspect}")
+            end
+          end
+        end
+        new(path, message, payload)
+      rescue => ex
+        if self.log_invalid_messages
+          logger.debug("Message.unpack: Exception while unpacking #{data.inspect}")
+          logger.debug("Message.unpack: #{ex} - #{ex.backtrace.join("\n")}")
+        end
+        raise ex
+      end
+
+      def message_type_for_id(type_id)
+        Protocol::TYPE_ID_TO_CLASS[type_id]
+      end
+
+      def type_id_for_message_class(klass)
+        Protocol::CLASS_TO_TYPE_ID[klass]
+      end
+
+      def valid_fields
+        @valid_fields ||= Protocol::Message.new.field_names.map(&:to_sym)
+      end
+    end
+
+    LIFX::Protocol::Message.fields.each do |field|
+      define_method(field.name) do
+        @message.send(field.name).snapshot
+      end
+
+      define_method("#{field.name}=") do |value|
+        @message.send("#{field.name}=", value)
+      end
+    end
+
+    alias_method :tagged?, :tagged
+    alias_method :addressable?, :addressable
+
+    def_delegators :path, :device_id, :site_id, :tagged
+    
+    attr_accessor :path, :payload
+    def initialize(*args)
+      if args.count == 3 
+        @path, @message, @payload = args
+      elsif (hash = args.first).is_a?(Hash)
+        path = hash.delete(:path)
+        payload = hash.delete(:payload)
+
+        check_valid_fields!(hash)
+
+        @message = Protocol::Message.new(hash)
+        self.payload = payload
+        self.path = path
+        @message.tagged = path.tagged? if path
+      else
+        @message = Protocol::Message.new
+      end
+      @message.msg_size = @message.num_bytes
+      @message.protocol = PROTOCOL_VERSION
+    rescue => ex
+      raise MessageError.new("Unable to initialize message with args: #{args.inspect} - #{ex}")
+    end
+
+    def payload=(payload)
+      @payload = payload
+      type_id = self.class.type_id_for_message_class(payload.class)
+      if type_id.nil?
+        raise UnmappedPayload.new("Unmapped payload class #{payload.class}")
+      end
+      @message.type = type_id
+      @message.payload = payload.pack
+    end
+
+    def pack
+      raise NoPayload if !payload
+      raise NoPath if !path
+      @message.raw_site = path.raw_site
+      @message.raw_target = path.raw_target
+      @message.tagged = path.tagged?
+      @message.msg_size = @message.num_bytes
+      @message.pack
+    end
+
+    def to_s
+      hash = {site: path.site_id}
+      if path.tagged?
+        hash[:tags] = path.tag_ids
+        hash[:tags] = 'all' if hash[:tags].empty?
+      else
+        hash[:device] = path.device_id
+      end
+      hash[:type] = payload.class.to_s.sub('LIFX::Protocol::', '')
+      hash[:addressable] = addressable? ? 'true' : 'false'
+      hash[:tagged] = path.tagged? ? 'true' : 'false'
+      hash[:at_time] = @message.at_time if @message.at_time && @message.at_time > 0
+      hash[:protocol] = protocol
+      hash[:payload] = payload.snapshot if payload
+      attrs = hash.map { |k, v| "#{k}=#{v}" }.join(' ')
+      %Q{#<LIFX::Message #{attrs}>}
+    end
+    alias_method :inspect, :to_s
+    
+    protected
+
+    def check_valid_fields!(hash)
+      invalid_fields = hash.keys - self.class.valid_fields
+      if invalid_fields.count > 0
+        raise InvalidFields.new("Invalid fields for Message: #{invalid_fields.join(', ')}")
+      end
+    end
+  end
+end

data/lib/lifx/network_context.rb

@@ -0,0 +1,200 @@
+require 'lifx/timers'
+require 'lifx/transport_manager'
+require 'lifx/routing_manager'
+require 'lifx/tag_manager'
+require 'lifx/light'
+require 'lifx/protocol_path'
+
+module LIFX
+  class NetworkContext
+    include Timers
+    include Logging
+    include Utilities
+    extend Forwardable
+
+    # NetworkContext stores lights and ties together TransportManager, TagManager and RoutingManager
+    attr_reader :transport_manager, :tag_manager, :routing_manager
+    
+    def initialize(transport: :lan)
+      @devices = {}
+
+      @transport_manager = case transport
+      when :lan
+        TransportManager::LAN.new
+      else
+        raise ArgumentError.new("Unknown transport method: #{transport}")
+      end
+      @transport_manager.add_observer(self) do |message:, ip:, transport:|
+        handle_message(message, ip, transport)
+      end
+
+      reset!
+
+      @threads = []
+      @threads << initialize_timer_thread
+      initialize_periodic_refresh
+      initialize_message_rate_updater
+    end
+
+    def discover
+      @transport_manager.discover
+    end
+
+    def refresh
+      @routing_manager.refresh
+    end
+
+    def reset!
+      @routing_manager = RoutingManager.new(context: self)
+      @tag_manager = TagManager.new(context: self, tag_table: @routing_manager.tag_table)
+    end
+
+    def stop
+      @transport_manager.stop
+      @threads.each do |thread|
+        Thread.kill(thread)
+      end
+    end
+
+    # Sends a message to their destination(s)
+    # @param target: [Target] Target of the message
+    # @param payload: [Protocol::Payload] Message payload
+    # @param acknowledge: [Boolean] If recipients must acknowledge with a response
+    def send_message(target:, payload:, acknowledge: false)
+      paths = @routing_manager.resolve_target(target)
+
+      messages = paths.map do |path|
+        Message.new(path: path, payload: payload, acknowledge: acknowledge)
+      end
+
+      if within_sync?
+        Thread.current[:sync_messages].push(*messages)
+        return
+      end
+
+      messages.each do |message|
+        @transport_manager.write(message)
+      end
+    end
+
+    protected def within_sync?
+      !!Thread.current[:sync_enabled]
+    end
+
+    # Synchronize asynchronous set_color, set_waveform and set_power messages to multiple devices.
+    # You cannot use synchronous methods in the block
+    # @note This is alpha
+    # @yield Block to synchronize commands in
+    # @return [Float] Delay before messages are executed
+    def sync(&block)
+      if within_sync?
+        raise "You cannot nest sync"
+      end
+      messages = Thread.new do
+        Thread.current[:sync_enabled] = true
+        Thread.current[:sync_messages] = messages = []
+        block.call
+        Thread.current[:sync_enabled] = false
+        messages
+      end.join.value
+
+      time = nil
+      try_until -> { time } do
+        light = gateways.sample
+        time = light && light.time
+      end
+
+      delay = (messages.count + 1) * (1.0 / message_rate) 
+      at_time = ((time.to_f + delay) * 1_000_000_000).to_i
+      messages.each do |m|
+        m.at_time = at_time
+        @transport_manager.write(m)
+      end
+      flush
+      delay
+    end
+
+    def flush(**options)
+      @transport_manager.flush(**options)
+    end
+
+    def register_device(device)
+      device_id = device.id
+      @devices[device_id] = device # What happens when there's already one registered?
+    end
+
+    def lights
+      LightCollection.new(context: self)
+    end
+
+    def all_lights
+      @devices.values
+    end
+
+    # Tags
+
+    def_delegators :@tag_manager, :tags,
+                                  :unused_tags,
+                                  :purge_unused_tags!,
+                                  :add_tag_to_device,
+                                  :remove_tag_from_device
+
+    def tags_for_device(device)
+      @routing_manager.tags_for_device_id(device.id)
+    end
+
+    def gateways
+      transport_manager.gateways.map(&:keys).flatten.map { |id| lights.with_id(id) }
+    end
+
+    def gateway_connections
+      transport_manager.gateways.map(&:values).flatten
+    end
+
+    protected
+
+    def handle_message(message, ip, transport)
+      logger.debug("<- #{self} #{transport}: #{message}")
+
+      @routing_manager.update_from_message(message)
+      if !message.tagged?
+        if @devices[message.device_id].nil?
+          device = Light.new(context: self, id: message.device_id, site_id: message.site_id)
+          register_device(device)
+        end
+        device = @devices[message.device_id]
+        device.handle_message(message, ip, transport)
+      end
+    end
+
+    def initialize_periodic_refresh
+      timers.every(10) do
+        refresh
+      end
+    end
+
+    def initialize_message_rate_updater
+      timers.every(5) do
+        missing_mesh_firmware = lights.select { |l| l.mesh_firmware(fetch: false).nil? }
+        if missing_mesh_firmware.count > 10
+          send_message(target: Target.new(broadcast: true), payload: Protocol::Device::GetMeshFirmware.new)
+        elsif missing_mesh_firmware.count > 0
+          missing_mesh_firmware.each { |l| l.send_message(Protocol::Device::GetMeshFirmware.new) }
+        else
+          @message_rate = lights.all? do |light|
+            m = light.mesh_firmware(fetch: false)
+            m && m >= '1.2'
+          end ? 20 : 5
+          gateway_connections.each do |connection|
+            connection.set_message_rate(@message_rate)
+          end
+        end
+      end
+    end
+
+    DEFAULT_MESSAGING_RATE = 5 # per second
+    def message_rate
+      @message_rate || 5
+    end
+  end
+end

data/lib/lifx/observable.rb

@@ -0,0 +1,46 @@
+module LIFX
+  module Observable
+    class ObserverCallbackMismatch < ArgumentError; end
+    def add_observer(obj, &callback)
+      if !callback_has_required_keys?(callback)
+        raise ObserverCallbackMismatch.new
+      end
+      observers[obj] = callback
+    end
+
+    def remove_observer(obj)
+      observers.delete(obj)
+    end
+
+    def notify_observers(**args)
+      observers.each do |_, callback|
+        callback.call(**args)
+      end
+    end
+
+    def callback_has_required_keys?(callback)
+      (required_keys_for_callback - required_keys_in_proc(callback)).empty?
+    end
+
+    def observer_callback_definition
+      nil
+    end
+
+    def required_keys_for_callback
+      @_required_keys_for_callback ||= begin
+        return [] if !observer_callback_definition
+        required_keys_in_proc(observer_callback_definition)
+      end
+    end
+
+    def required_keys_in_proc(proc)
+      proc.parameters.select do |type, _|
+        type == :keyreq
+      end.map(&:last)
+    end
+
+    def observers
+      @_observers ||= {}
+    end
+  end
+end

data/lib/lifx/protocol/address.rb

@@ -0,0 +1,21 @@
+module LIFX
+  module Protocol
+    module AddressFields
+      def AddressFields.included(mod)
+        mod.instance_eval do
+          hide :_reserved2
+          string :raw_target, length: 8
+          string :raw_site, length: 6
+          bool_bit1 :acknowledge
+          bit15le :_reserved2
+        end
+      end
+    end
+
+    class Address < BinData::Record
+      endian :little
+
+      include AddressFields
+    end
+  end
+end

data/lib/lifx/protocol/device.rb

@@ -0,0 +1,225 @@
+# Generated code ahoy!
+module LIFX
+  module Protocol
+    module Device
+      module Service
+        UDP = 1
+        TCP = 2
+      end
+
+      class SetSite < Payload
+        endian :little
+
+        string :site, length: 6
+      end
+
+      class GetPanGateway < Payload
+        endian :little
+
+      end
+
+      class StatePanGateway < Payload
+        endian :little
+
+        uint8 :service
+        uint32 :port
+      end
+
+      class GetTime < Payload
+        endian :little
+
+      end
+
+      class SetTime < Payload
+        endian :little
+
+        uint64 :time # Nanoseconds since epoch.
+      end
+
+      class StateTime < Payload
+        endian :little
+
+        uint64 :time # Nanoseconds since epoch.
+      end
+
+      class GetResetSwitch < Payload
+        endian :little
+
+      end
+
+      class StateResetSwitch < Payload
+        endian :little
+
+        uint8 :position
+      end
+
+      class GetMeshInfo < Payload
+        endian :little
+
+      end
+
+      class StateMeshInfo < Payload
+        endian :little
+
+        float :signal # Milliwatts.
+        uint32 :tx # Bytes.
+        uint32 :rx # Bytes.
+        int16 :mcu_temperature # Deci-celsius. 25.45 celsius is 2545
+      end
+
+      class GetMeshFirmware < Payload
+        endian :little
+
+      end
+
+      class StateMeshFirmware < Payload
+        endian :little
+
+        uint64 :build # Firmware build nanoseconds since epoch.
+        uint64 :install # Firmware install nanoseconds since epoch.
+        uint32 :version # Firmware human readable version.
+      end
+
+      class GetWifiInfo < Payload
+        endian :little
+
+      end
+
+      class StateWifiInfo < Payload
+        endian :little
+
+        float :signal # Milliwatts.
+        uint32 :tx # Bytes.
+        uint32 :rx # Bytes.
+        int16 :mcu_temperature # Deci-celsius. 25.45 celsius is 2545
+      end
+
+      class GetWifiFirmware < Payload
+        endian :little
+
+      end
+
+      class StateWifiFirmware < Payload
+        endian :little
+
+        uint64 :build # Firmware build nanoseconds since epoch.
+        uint64 :install # Firmware install nanoseconds since epoch.
+        uint32 :version # Firmware human readable version.
+      end
+
+      class GetPower < Payload
+        endian :little
+
+      end
+
+      class SetPower < Payload
+        endian :little
+
+        uint16 :level # 0 Standby. > 0 On.
+      end
+
+      class StatePower < Payload
+        endian :little
+
+        uint16 :level # 0 Standby. > 0 On.
+      end
+
+      class GetLabel < Payload
+        endian :little
+
+      end
+
+      class SetLabel < Payload
+        endian :little
+
+        string :label, length: 32, trim_padding: true
+      end
+
+      class StateLabel < Payload
+        endian :little
+
+        string :label, length: 32, trim_padding: true
+      end
+
+      class GetTags < Payload
+        endian :little
+
+      end
+
+      class SetTags < Payload
+        endian :little
+
+        uint64 :tags
+      end
+
+      class StateTags < Payload
+        endian :little
+
+        uint64 :tags
+      end
+
+      class GetTagLabels < Payload
+        endian :little
+
+        uint64 :tags
+      end
+
+      class SetTagLabels < Payload
+        endian :little
+
+        uint64 :tags
+        string :label, length: 32, trim_padding: true
+      end
+
+      class StateTagLabels < Payload
+        endian :little
+
+        uint64 :tags
+        string :label, length: 32, trim_padding: true
+      end
+
+      class GetVersion < Payload
+        endian :little
+
+      end
+
+      class StateVersion < Payload
+        endian :little
+
+        uint32 :vendor
+        uint32 :product
+        uint32 :version
+      end
+
+      class GetInfo < Payload
+        endian :little
+
+      end
+
+      class StateInfo < Payload
+        endian :little
+
+        uint64 :time # Nanoseconds since epoch.
+        uint64 :uptime # Nanoseconds since boot.
+        uint64 :downtime # Nanoseconds off last power cycle.
+      end
+
+      class GetMcuRailVoltage < Payload
+        endian :little
+
+      end
+
+      class StateMcuRailVoltage < Payload
+        endian :little
+
+        uint32 :voltage
+      end
+
+      class Reboot < Payload
+        endian :little
+
+      end
+
+    end
+  end
+end

data/lib/lifx/protocol/header.rb

@@ -0,0 +1,24 @@
+module LIFX
+  module Protocol
+    module HeaderFields
+      def HeaderFields.included(mod)
+        mod.instance_eval do
+          hide :_reserved, :_reserved1
+
+          uint16 :msg_size
+          bit12le :protocol
+          bool_bit1 :addressable, value: true
+          bool_bit1 :tagged
+          bit2le :_reserved
+          uint32 :_reserved1
+        end
+      end
+    end
+    
+    class Header < BinData::Record
+      endian :little
+
+      include HeaderFields
+    end
+  end
+end