lifx-lan 0.1.0

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

@@ -0,0 +1,51 @@
+module LIFX
+  module LAN
+    module Protocol
+      # @api private
+      module Wan
+        class ConnectPlain < Payload
+          endian :little
+
+          string :user, length: 32, trim_padding: true
+          string :pass, length: 32, trim_padding: true
+        end
+
+        class ConnectKey < Payload
+          endian :little
+
+          string :auth_key, length: 32
+        end
+
+        class StateConnect < Payload
+          endian :little
+
+          string :auth_key, length: 32
+        end
+
+        class Sub < Payload
+          endian :little
+
+          string :target, length: 8
+          string :site, length: 6
+          bool :device # 0 - Targets a device. 1 - Targets a tag.
+        end
+
+        class Unsub < Payload
+          endian :little
+
+          string :target, length: 8
+          string :site, length: 6
+          bool :device # 0 - Targets a device. 1 - Targets a tag.
+        end
+
+        class StateSub < Payload
+          endian :little
+
+          string :target, length: 8
+          string :site, length: 6
+          bool :device # 0 - Targets a device. 1 - Targets a tag.
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+module LIFX
+  module LAN
+    module Protocol
+      # @api private
+      module Wifi
+        module Interface
+          SOFT_AP = 1
+          STATION = 2
+        end
+
+        module Security
+          UNKNOWN = 0
+          OPEN = 1
+          WEP_PSK = 2
+          WPA_TKIP_PSK = 3
+          WPA_AES_PSK = 4
+          WPA2_AES_PSK = 5
+          WPA2_TKIP_PSK = 6
+          WPA2_MIXED_PSK = 7
+        end
+
+        module Status
+          CONNECTING = 0
+          CONNECTED = 1
+          FAILED = 2
+          OFF = 3
+        end
+
+        # Gets interface status
+        class Get < Payload
+          endian :little
+
+          uint8 :interface # Interface to introspect
+        end
+
+        # Switch interface on/off
+        class Set < Payload
+          endian :little
+
+          uint8 :interface # Interface to introspect
+          bool  :active    # Turns off interface if active is false
+        end
+
+        # Describes interface state
+        class State < Payload
+          endian :little
+
+          uint8  :interface         # Interface to introspect
+          uint8  :status            # Interface status
+          uint32 :ipv4              # IPv4 address if interface is active
+          string :ipv6, length: 16  # IPv6 address if interface is active and is IPv6 addressable
+        end
+
+        # Scan for WiFi access points. Returns StateAccessPoints
+        class GetAccessPoints < Payload
+          endian :little
+
+        end
+
+        # The AP scan results for an interface
+        class StateAccessPoints < Payload
+          endian :little
+
+          uint8  :interface                            # Interface to introspect
+          string :ssid, length: 32, trim_padding: true # SSID of Access Point
+          uint8  :security                             # Security mode
+          int16  :strength                             # Signal strength in dB
+          uint16 :channel                              # Frequency channel
+        end
+
+        # Get WiFi access point information. Returns StateAccessPoint
+        class GetAccessPoint < Payload
+          endian :little
+
+          uint8 :interface          # Interface to introspect
+        end
+
+        # Configure interface, should return StateAccessPoint
+        class SetAccessPoint < Payload
+          endian :little
+
+          uint8  :interface                            # Interface to introspect
+          string :ssid, length: 32, trim_padding: true # SSID of Access Point
+          string :pass, length: 64, trim_padding: true # Passphrase used to authenticate
+          uint8  :security                             # Security mode
+        end
+
+        # Interface configuration
+        class StateAccessPoint < Payload
+          endian :little
+
+          uint8  :interface                            # Interface to introspect
+          string :ssid, length: 32, trim_padding: true # SSID of Access Point
+          uint8  :security                             # Security mode
+          int16  :strength                             # Signal strength in dB
+          uint16 :channel                              # Frequency channel
+        end
+
+      end
+    end
+  end
+end

data/lib/lifx/lan/protocol_path.rb

@@ -0,0 +1,85 @@
+require 'lifx/lan/utilities'
+
+module LIFX
+  module LAN
+    # @private
+    class ProtocolPath
+      # ProtocolPath contains all the addressable information that is required
+      # for the protocol.
+      # It handles the conversion between raw binary and hex strings
+      # as well as raw tags_field to tags array
+      include Utilities
+
+      attr_accessor :raw_site, :raw_target, :tagged
+
+      def initialize(raw_site: "\x00".b * 6, raw_target: "\x00".b * 8, tagged: false,
+                     site_id: nil, device_id: nil, tag_ids: nil)
+        self.raw_site = raw_site
+        self.raw_target = raw_target
+        self.tagged = tagged
+
+        self.site_id = site_id if site_id
+        self.device_id = device_id if device_id
+        self.tag_ids = tag_ids if tag_ids
+      end
+
+      def site_id
+        raw_site.unpack('H*').join
+      end
+
+      def site_id=(value)
+        self.raw_site = [value].pack('H12').b
+      end
+
+      def device_id
+        if !tagged?
+          raw_target[0...6].unpack('H*').join
+        else
+          nil
+        end
+      end
+
+      def device_id=(value)
+        self.raw_target = [value].pack('H16').b
+        self.tagged = false
+      end
+
+      def tag_ids
+        if tagged?
+          tag_ids_from_field(tags_field)
+        else
+          nil
+        end
+      end
+
+      def tag_ids=(values)
+        self.tags_field = values.reduce(0) do |value, tag_id|
+          value |= 2 ** tag_id
+        end
+      end
+
+      def tagged?
+        !!tagged
+      end
+
+      def all_sites?
+        site_id == "000000000000"
+      end
+
+      def all_tags?
+        tagged? && tag_ids.empty?
+      end
+
+      protected
+
+      def tags_field
+        raw_target.unpack('Q').first
+      end
+
+      def tags_field=(value)
+        self.raw_target = [value].pack('Q').b
+        self.tagged = true
+      end
+    end
+  end
+end

data/lib/lifx/lan/required_keyword_arguments.rb

@@ -0,0 +1,12 @@
+module LIFX
+  module LAN
+    module RequiredKeywordArguments
+      def required!(name)
+        backtrace = caller_locations(1).map { |c| c.to_s }
+        ex = ArgumentError.new("Missing required keyword argument '#{name}'")
+        ex.set_backtrace(backtrace)
+        raise ex
+      end
+    end
+  end
+end

data/lib/lifx/lan/routing_manager.rb

@@ -0,0 +1,114 @@
+require 'lifx/lan/routing_table'
+require 'lifx/lan/tag_table'
+require 'lifx/lan/utilities'
+require 'weakref'
+
+module LIFX
+  module LAN
+    # @private
+    class RoutingManager
+      include Logging
+      include Utilities
+      include RequiredKeywordArguments
+
+      # RoutingManager manages a routing table of site <-> device
+      # It can resolve a target to ProtocolPaths and manages the TagTable
+
+      attr_reader :context, :tag_table, :routing_table
+
+      STALE_ROUTING_TABLE_PURGE_INTERVAL = 60
+
+      def initialize(context: required!(:context))
+        @context = WeakRef.new(context)
+        @routing_table = RoutingTable.new
+        @tag_table = TagTable.new
+        @last_refresh_seen = {}
+        @context.timers.every(STALE_ROUTING_TABLE_PURGE_INTERVAL) do
+          routing_table.clear_stale_entries
+        end
+      end
+
+      def resolve_target(target)
+        if target.tag?
+          @tag_table.entries_with(label: target.tag).map do |entry|
+            ProtocolPath.new(site_id: entry.site_id, tag_ids: [entry.tag_id])
+          end
+        elsif target.broadcast?
+          [ProtocolPath.new(site_id: "\x00".b * 6, tag_ids: [])]
+        elsif target.site_id && target.device_id.nil?
+          [ProtocolPath.new(site_id: target.site_id, tag_ids: [])]
+        else
+          [ProtocolPath.new(site_id: target.site_id, device_id: target.device_id)]
+        end
+      end
+
+      def tags_for_device_id(device_id)
+        entry = @routing_table.entry_for_device_id(device_id)
+        return [] if entry.nil?
+        entry.tag_ids.map do |tag_id|
+          tag = @tag_table.entry_with(device_id: entry.device_id, tag_id: tag_id)
+          tag && tag.label
+        end.compact
+      end
+
+      def update_from_message(message)
+        return if message.site_id == NULL_SITE_ID
+        if message.tagged?
+          case message.payload
+          when Protocol::Light::Get
+            if message.path.all_tags?
+              @last_refresh_seen[message.device_id] = Time.now
+            end
+          end
+          return
+        end
+
+        payload = message.payload
+        if !@routing_table.device_ids.include?(message.device_id)
+          # New device detected, fire refresh events
+          refresh_site(message.site_id, message.device_id)
+        end
+        case payload
+        when Protocol::Device::StateTagLabels
+          tag_ids = tag_ids_from_field(payload.tags)
+          if payload.label.empty?
+            tag_ids.each do |tag_id|
+              @tag_table.delete_entries_with(device_id: message.device_id, tag_id: tag_id)
+            end
+          else
+            @tag_table.update_table(device_id: message.device_id, tag_id: tag_ids.first, label: payload.label.to_s.force_encoding('utf-8'))
+          end
+        when Protocol::Device::StateTags, Protocol::Light::State
+          @routing_table.update_table(site_id: message.site_id,
+                                      device_id: message.device_id,
+                                      tag_ids: tag_ids_from_field(message.payload.tags))
+        when Protocol::Device::StateService, Protocol::Device::StatePower
+          @routing_table.update_table(site_id: message.site_id, device_id: message.device_id)
+        end
+      end
+
+      MINIMUM_REFRESH_INTERVAL = 1
+      def refresh(force: false)
+        @routing_table.device_ids.each do |device_id|
+          next if (seen = @last_refresh_seen[device_id]) && Time.now - seen < MINIMUM_REFRESH_INTERVAL && !force
+          site_id = @routing_table.site_id_for_device_id(device_id)
+          refresh_site(site_id, device_id)
+        end
+      end
+
+      def refresh_site(site_id, device_id)
+        get_lights(site_id, device_id)
+        get_tag_labels(site_id, device_id)
+      end
+
+      def get_lights(site_id, device_id)
+        context.send_message(target: Target.new(site_id: site_id, device_id: device_id), payload: Protocol::Light::Get.new)
+      end
+
+      UINT64_MAX = 2 ** 64 - 1
+      def get_tag_labels(site_id, device_id)
+        context.send_message(target: Target.new(site_id: site_id, device_id: device_id), payload: Protocol::Device::GetTagLabels.new(tags: UINT64_MAX))
+      end
+    end
+  end
+end

data/lib/lifx/lan/routing_table.rb

@@ -0,0 +1,48 @@
+module LIFX
+  module LAN
+    # @private
+    class RoutingTable
+      include Logging
+
+      class Entry < Struct.new(:site_id, :device_id, :tag_ids, :last_seen); end
+      # RoutingTable stores the device <-> site mapping
+      def initialize(entries: {})
+        @device_site_mapping = entries
+      end
+
+      def update_table(site_id: self.site_id, device_id: self.device_id, tag_ids: nil, last_seen: Time.now)
+        device_mapping = @device_site_mapping[device_id] ||= Entry.new(site_id, device_id, [])
+        device_mapping.site_id = site_id
+        device_mapping.last_seen = last_seen
+        device_mapping.tag_ids = tag_ids if tag_ids
+      end
+
+      def entry_for_device_id(device_id)
+        @device_site_mapping[device_id]
+      end
+
+      def site_id_for_device_id(device_id)
+        entry = entry_for_device_id(device_id)
+        entry ? entry.site_id : nil
+      end
+
+      def site_ids
+        entries.map(&:site_id).uniq
+      end
+
+      def device_ids
+        entries.map(&:device_id).uniq
+      end
+
+      def entries
+        @device_site_mapping.values
+      end
+
+      def clear_stale_entries(threshold: 60 * 5)
+        @device_site_mapping.reject! do |device_id, entry|
+          entry.last_seen < Time.now - threshold
+        end
+      end
+    end
+  end
+end

data/lib/lifx/lan/seen.rb

@@ -0,0 +1,25 @@
+module LIFX
+  module LAN
+    module Seen
+      # Returns the time when the device was last seen.
+      # @return [Time]
+      def last_seen
+        @last_seen
+      end
+
+      # Returns the number of seconds since the device was last seen.
+      # If the device hasn't been seen yet, it will use Unix epoch as
+      # the time it was seen.
+      # @return [Float]
+      def seconds_since_seen
+        Time.now - (last_seen || Time.at(0))
+      end
+
+      # Marks the device as being seen.
+      # @private
+      def seen!
+        @last_seen = Time.now
+      end
+    end
+  end
+end

data/lib/lifx/lan/site.rb

@@ -0,0 +1,97 @@
+require 'lifx/lan/seen'
+require 'lifx/lan/timers'
+require 'lifx/lan/observable'
+require 'lifx/lan/gateway_connection'
+
+module LIFX
+  module LAN
+    # @api private
+    class Site
+      include Seen
+      include Timers
+      include Logging
+      include Observable
+      include RequiredKeywordArguments
+
+      attr_reader :id, :gateways, :tag_manager
+
+      def initialize(id: required!(:id))
+        @id            = id
+        @gateways      = {}
+        @gateways_mutex = Mutex.new
+        @threads       = []
+        @threads << initialize_timer_thread
+        initialize_stale_gateway_check
+      end
+
+      def write(message)
+        message.path.site_id = id
+        @gateways.values.each do |gateway|
+          gateway.write(message)
+        end
+      end
+
+      def handle_message(message, ip, transport)
+        logger.debug("<- #{self} #{transport}: #{message}")
+        payload = message.payload
+        case payload
+        when Protocol::Device::StateService
+          @gateways_mutex.synchronize do
+            @gateways[message.device_id] ||= GatewayConnection.new
+            @gateways[message.device_id].handle_message(message, ip, transport)
+            @gateways[message.device_id].add_observer(self, :message_received) do |**args|
+              notify_observers(:message_received, **args)
+            end
+          end
+        end
+        seen!
+      end
+
+      def flush(**options)
+        @gateways.values.map do |gateway|
+          Thread.start do
+            gateway.flush(**options)
+          end
+        end.each(&:join)
+      end
+
+      def to_s
+        %Q{#<LIFX::LAN::Site id=#{id}>}
+      end
+      alias_method :inspect, :to_s
+
+      def stop
+        @threads.each do |thread|
+          thread.abort
+        end
+        @gateways.values.each do |gateway|
+          gateway.close
+        end
+      end
+
+      def observer_callback_definition
+        {
+          message_received: -> (message: nil, ip: nil, transport: nil) {}
+        }
+      end
+
+
+      protected
+
+      STALE_GATEWAY_CHECK_INTERVAL = 10
+      def initialize_stale_gateway_check
+        timers.every(STALE_GATEWAY_CHECK_INTERVAL) do
+          @gateways_mutex.synchronize do
+            stale_gateways = @gateways.select do |k, v|
+              !v.connected?
+            end
+            stale_gateways.each do |id, _|
+              logger.info("#{self}: Dropping stale gateway id #{id}")
+              @gateways.delete(id)
+            end
+          end
+        end
+      end
+    end
+  end
+end