lifx-lan 0.1.0

data/lib/lifx/lan/network_context.rb

@@ -0,0 +1,188 @@
+require 'lifx/lan/timers'
+require 'lifx/lan/transport_manager'
+require 'lifx/lan/routing_manager'
+require 'lifx/lan/tag_manager'
+require 'lifx/lan/light'
+require 'lifx/lan/protocol_path'
+require 'lifx/lan/timers'
+
+require 'weakref'
+
+module LIFX
+  module LAN
+    class NetworkContext
+      include Logging
+      include Utilities
+      include RequiredKeywordArguments
+      include Timers
+      extend Forwardable
+
+      # NetworkContext stores lights and ties together TransportManager, TagManager and RoutingManager
+      attr_reader :transport_manager, :tag_manager, :routing_manager
+
+      def initialize(transport_manager: required!('transport_manager'))
+        @devices = {}
+
+        @transport_manager = transport_manager
+        @transport_manager.context = WeakRef.new(self)
+        @transport_manager.add_observer(self, :message_received) do |message: nil, ip: nil, transport: nil|
+          handle_message(message, ip, transport)
+        end
+
+        reset!
+
+        @threads = []
+        @threads << initialize_timer_thread
+      end
+
+      def discover
+        @transport_manager.discover
+      end
+
+      def refresh(force: true)
+        @routing_manager.refresh(force: force)
+      end
+
+      def reset!
+        @routing_manager = RoutingManager.new(context: self)
+        @tag_manager = TagManager.new(context: self, tag_table: @routing_manager.tag_table)
+      end
+
+      def stop_discovery
+        @transport_manager.stop_discovery
+      end
+
+      def stop
+        @transport_manager.stop
+        stop_timers
+        @threads.each do |thread|
+          thread.abort
+          thread.join
+        end
+        @threads = nil
+      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
+      # @param at_time: [Integer] Unix epoch in milliseconds to run the payload. Only applicable to certain payload types.
+      def send_message(target: required!(:target), payload: required!(:payload), acknowledge: false, at_time: nil)
+        paths = @routing_manager.resolve_target(target)
+
+        messages = paths.map do |path|
+          Message.new(path: path, payload: payload, acknowledge: acknowledge, at_time: at_time)
+        end
+
+        if within_sync?
+          Thread.current[:sync_messages].push(*messages)
+          return
+        end
+
+        messages.each do |message|
+          @transport_manager.write(message)
+        end
+      end
+
+      def within_sync?
+        !!Thread.current[:sync_enabled]
+      end
+      protected :within_sync?
+
+      # 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
+      # @param delay: [Float] The delay to add to sync commands when dealing with latency.
+      # @yield Block to synchronize commands in
+      # @return [Float] Delay before messages are executed
+      NSEC_PER_SEC = 1_000_000_000
+      AT_TIME_DELTA = 0.002
+      def sync(delay: 0, &block)
+        if within_sync?
+          raise "You cannot nest sync"
+        end
+        messages = Thread.start do
+          Thread.current[:sync_enabled] = true
+          Thread.current[:sync_messages] = messages = []
+          block.call
+          Thread.current[:sync_enabled] = false
+          messages
+        end.join.value
+
+        time = nil
+        failed_lights = []
+        try_until -> { time }, timeout: 5, action_interval: 1 do
+          light = (lights.alive - failed_lights).sample
+          begin
+            time = light && light.send_message!(Protocol::Device::GetTime.new, wait_for: Protocol::Device::StateTime, wait_timeout: 1, retry_interval: 0.5) do |payload|
+              Time.at(payload.time.to_f / NSEC_PER_SEC)
+            end
+          rescue => ex
+            logger.debug("!!! Add light failed")
+            failed_lights << light
+          end
+        end
+
+        delay += (messages.count + 1) * (1.0 / @transport_manager.message_rate)
+        at_time = ((time.to_f + delay) * NSEC_PER_SEC).to_i
+        messages.each_with_index do |m, i|
+          m.at_time = at_time + (i * AT_TIME_DELTA * NSEC_PER_SEC).to_i
+          @transport_manager.write(m)
+        end
+        flush
+        delay
+      end
+
+      def flush(**options)
+        @transport_manager.flush(**options)
+      end
+
+      def register_device(device)
+        return if device.site_id == NULL_SITE_ID
+        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 to_s
+        %Q{#<LIFX::LAN::NetworkContext transport_manager=#{transport_manager}>}
+      end
+      alias_method :inspect, :to_s
+
+      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? && message.payload.is_a?(Protocol::Light::State)
+            device = Light.new(context: self, id: message.device_id, site_id: message.site_id)
+          end
+          device = @devices[message.device_id]
+          return if !device # Virgin bulb
+          device.handle_message(message, ip, transport)
+        end
+      end
+    end
+  end
+end

data/lib/lifx/lan/observable.rb

@@ -0,0 +1,66 @@
+module LIFX
+  module LAN
+    # @private
+    module Observable
+      class ObserverCallbackMismatch < ArgumentError; end
+      class ObserverCallbackNotFound < ArgumentError; end
+
+      def add_observer(obj, type, &callback)
+        if !callback_type_exists?(type)
+          raise ObserverCallbackNotFound.new("Callback #{type} not found in #{observer_callback_definition.keys}")
+        end
+        if !callback_has_required_keys?(type, callback)
+          raise ObserverCallbackMismatch.new
+        end
+        observers[type][obj] = callback
+      end
+
+      def remove_observer(obj, type)
+        observers[type].delete(obj)
+      end
+
+      def remove_observers
+        observers.clear
+      end
+
+      def notify_observers(type, **args)
+        if !callback_type_exists?(type)
+          raise ObserverCallbackNotFound.new("Callback #{type} not found in #{observer_callback_definition.keys}")
+        end
+        observers[type].each do |_, callback|
+          callback.call(**args)
+        end
+      end
+
+      def callback_type_exists?(type)
+        !!observer_callback_definition[type]
+      end
+
+      def callback_has_required_keys?(type, callback)
+        (required_keys_for_callback(type) - required_keys_in_proc(callback)).empty?
+      end
+
+      def observer_callback_definition
+        {}
+      end
+
+      def required_keys_for_callback(type)
+        @_required_keys_for_callback ||= {}
+        @_required_keys_for_callback[type] ||= begin
+          return [] if !observer_callback_definition[type]
+          required_keys_in_proc(observer_callback_definition[type])
+        end
+      end
+
+      def required_keys_in_proc(proc)
+        proc.parameters.select do |type, _|
+          type == :keyreq
+        end.map(&:last)
+      end
+
+      def observers
+        @_observers ||= Hash.new { |h, k| h[k] = {} }
+      end
+    end
+  end
+end

data/lib/lifx/lan/protocol/address.rb

@@ -0,0 +1,25 @@
+module LIFX
+  module LAN
+    module Protocol
+      module AddressFields
+        def AddressFields.included(mod)
+          mod.instance_eval do
+            hide :_reserved2
+            string    :raw_target, length: 8
+            string    :raw_site, length: 6 # Deprecated, should be zeros or "LIFXV2"
+            bit6le    :_reserved2
+            bool_bit1 :acknowledge  # Acknowledgement required
+            bool_bit1 :res_required # Response required
+            uint8     :sequence     # Wrap around message sequence number
+          end
+        end
+      end
+
+      class Address < BinData::Record
+        endian :little
+
+        include AddressFields
+      end
+    end
+  end
+end

data/lib/lifx/lan/protocol/device.rb

@@ -0,0 +1,387 @@
+module LIFX
+  module LAN
+    module Protocol
+      # @api private
+      module Device
+
+        # Describes the services exposed by the device
+        module Service
+          UDP = 1        # Datagram transport on specified port
+          TCP = 2        # Reliable transport on specified port
+          ONBOARDING = 3 # Onboarding service on specified port
+          OTA = 4        # Active over-the-air update service on specified port. This is only exposed when the device is in active OTA mode with degraded service
+        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
+
+        # Discover devices and services exposed
+        class GetService < Payload
+          endian :little
+        end
+
+        # Response to GetService. Specifies service and port. Service temporarily unavailable if port is 0
+        class StateService < Payload
+          endian :little
+
+          uint8  :service # maps to Service enumerated type above
+          uint32 :port
+        end
+
+        # Gets device current time
+        class GetTime < Payload
+          endian :little
+        end
+
+        # Set the device time
+        class SetTime < Payload
+          endian :little
+
+          uint64 :time # Nanoseconds since epoch.
+        end
+
+        # Returns the time at device when message was sent
+        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
+
+        # Get Host MCU information
+        class GetHostInfo < Payload
+          endian :little
+        end
+
+        # Host MCU information
+        class StateHostInfo < Payload
+          endian :little
+
+          float  :signal          # radio receive signal strength in Milliwatts (mw)
+          uint32 :tx              # bytes transmitted since power on
+          uint32 :rx              # bytes received since power on
+          int16  :mcu_temperature # internal temperature (deci-celsius). 25.45 celsius is 2545
+        end
+
+        # Gets Host MCU firmware
+        class GetHostFirmware < Payload
+          endian :little
+        end
+
+        class StateHostFirmware < Payload
+          endian :little
+
+          uint64 :build   # build time in nanonseconds since epoch
+          uint64 :install # install time, depricated
+          uint32 :version # firmware version
+        end
+
+        # Get Wifi subsystem information
+        class GetWifiInfo < Payload
+          endian :little
+        end
+
+        # Wifi subsystem information
+        class StateWifiInfo < Payload
+          endian :little
+
+          float  :signal          # radio receive signal strength in Milliwatts (mw)
+          uint32 :tx              # bytes transmitted since power on
+          uint32 :rx              # bytes received since power on
+          int16  :mcu_temperature # internal temperature (deci-celsius). 25.45 celsius is 2545
+        end
+
+        # Get Wifi subsystem firmware
+        class GetWifiFirmware < Payload
+          endian :little
+        end
+
+        class StateWifiFirmware < Payload
+          endian :little
+
+          uint64 :build   # build time in nanonseconds since epoch
+          uint64 :install # install time, depricated
+          uint32 :version # firmware version
+        end
+
+        # Get device power level
+        class GetPower < Payload
+          endian :little
+        end
+
+        # Set device power level
+        class SetPower < Payload
+          endian :little
+
+          uint16 :level # Zero implies standby and non-zero sets a corresponding power draw level on device. Currently only 0 and 65535 are supported
+        end
+
+        # Device power level
+        class StatePower < Payload
+          endian :little
+
+          uint16 :level # 0 Standby. > 0 On.
+        end
+
+        # Introspect the device label. Returns StateLabel
+        class GetLabel < Payload
+          endian :little
+        end
+
+        # Set the device label text
+        class SetLabel < Payload
+          endian :little
+
+          string :label, length: 32, trim_padding: true
+        end
+
+        # Device label
+        class StateLabel < Payload
+          endian :little
+
+          string :label, length: 32, trim_padding: true
+        end
+
+        # Get the device tags. Returns StateTags
+        class GetTags < Payload
+          endian :little
+        end
+
+        # Set the device tags
+        class SetTags < Payload
+          endian :little
+
+          uint64 :tags # Bitfield, allows 64 tags. A device can be tagged with one or more of them
+        end
+
+        # Device tags
+        class StateTags < Payload
+          endian :little
+
+          uint64 :tags
+        end
+
+        # Get the text labels describing the tags. Returns StateTagLabels
+        class GetTagLabels < Payload
+          endian :little
+
+          uint64 :tags # Retrieve the labels for tags selected in the bitfield
+        end
+
+        # Sets the text label for the corresponding tags. Note you can label or reset multiple labels at the same time
+        class SetTagLabels < Payload
+          endian :little
+
+          uint64 :tags # Set labels for tags selected in the bitfield
+          string :label, length: 32, trim_padding: true
+        end
+
+        # The tag label for tags in the bitfield
+        class StateTagLabels < Payload
+          endian :little
+
+          uint64 :tags
+          string :label, length: 32, trim_padding: true
+        end
+
+        # Get the hardware version. Returns StateVersion
+        class GetVersion < Payload
+          endian :little
+        end
+
+        # The hardware version of the device
+        class StateVersion < Payload
+          endian :little
+
+          uint32 :vendor  # Vendor ID
+          uint32 :product # Product ID
+          uint32 :version # Hardware version
+        end
+
+        # Get runtime information. Returns StateInfo
+        class GetInfo < Payload
+          endian :little
+        end
+
+        # Runtime information of device
+        class StateInfo < Payload
+          endian :little
+
+          uint64 :time     # wallclock time on device, nanoseconds since epoch
+          uint64 :uptime   # device uptime, nanoseconds since boot
+          uint64 :downtime # last measured downtime, accurate to 5s, 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
+
+        # Soft reboot the device in 1000ms from time received
+        class SetReboot < Payload
+          endian :little
+        end
+
+        # Sent back if reboot is pending on SetReboot
+        class StateReboot < Payload
+          endian :little
+        end
+
+        # Sent back from device on receipt of a message with ack_required set to 1
+        class Acknowledgement < Payload
+          endian :little
+        end
+
+        # Clear all settings from the device
+        class SetFactoryReset < Payload
+          endian :little
+        end
+
+        # Signifies pending reset
+        class StateFactoryReset < Payload
+          endian :little
+        end
+
+        # Get the device location
+        class GetLocation < Payload
+          endian :little
+        end
+
+        # Set the device location
+        class SetLocation < Payload
+          endian :little
+
+          string :location, length: 16                  # guid byte array
+          string :label, length: 32, trim_padding: true # text label for location
+        end
+
+        # Device location
+        class StateLocation < Payload
+          endian :little
+
+          string :location, length: 16                  # guid byte array
+          string :label, length: 32, trim_padding: true # text label for location
+        end
+
+        # Get the device group. A device can belong to a single logical group
+        class GetGroup < Payload
+          endian :little
+        end
+
+        # Set the device group
+        class SetGroup < Payload
+          endian :little
+
+          string :group, length: 16                     # guid byte array
+          string :label, length: 32, trim_padding: true # text label for group
+        end
+
+        # Set the device group
+        class StateGroup < Payload
+          endian :little
+
+          string :group, length: 16                     # guid byte array
+          string :label, length: 32, trim_padding: true # text label for group
+        end
+
+        # Introspect the device owner. Returns StateOwner
+        class GetOwner < Payload
+          endian :little
+        end
+
+        # Set the device owner
+        class SetOwner < Payload
+          endian :little
+
+          string :owner, length: 16                     # guid byte array
+          string :label, length: 32, trim_padding: true # text label of owner details
+        end
+
+        # Return the device owner information
+        class StateOwner < Payload
+          endian :little
+
+          string :owner, length: 16                     # guid byte array
+          string :label, length: 32, trim_padding: true # text label of owner details
+        end
+
+        # Request an arbitrary payload be echoed back
+        class EchoRequest < Payload
+          endian :little
+
+          string :payload, length: 64 # byte array
+        end
+
+        # Echo response with payload sent in request
+        class EchoResponse < Payload
+          endian :little
+
+          string :payload, length: 64 # byte array
+        end
+
+      end
+    end
+  end
+end