lifx-lan 0.1.0

data/lib/lifx/lan/tag_manager.rb

@@ -0,0 +1,111 @@
+require 'weakref'
+
+module LIFX
+  module LAN
+    # @api private
+    # @private
+    class TagManager
+      # TagManager handles discovery of tags, resolving tags to [site_id, tags_field] pairs,
+      # creating, setting and removing tags.
+
+      # Stores site <-> [tag_name, tag_id]
+      include Utilities
+      include Logging
+      include RequiredKeywordArguments
+
+      attr_reader :context
+
+      class TagLimitReached < StandardError; end
+
+      def initialize(context: required!(:context), tag_table: required!(:tag_table))
+        @context = WeakRef.new(context)
+        @tag_table = tag_table
+      end
+
+      def create_tag(label: required!(:label), site_id: required!(:site_id))
+        id = next_unused_id_on_site_id(site_id)
+        raise TagLimitReached if id.nil?
+        # Add the entry for the tag we're about to create to prevent a case where
+        # we don't receive a StateTagLabels before another tag gets created
+        @tag_table.update_table(tag_id: id, label: label, site_id: site_id)
+        context.send_message(target: Target.new(site_id: site_id),
+                             payload: Protocol::Device::SetTagLabels.new(tags: id_to_tags_field(id), label: label.encode('utf-8')))
+      end
+
+      def add_tag_to_device(tag: required!(:tag), device: required!(:device))
+        tag_entry = entry_with(label: tag, site_id: device.site_id)
+        if !tag_entry
+          create_tag(label: tag, site_id: device.site_id)
+          tag_entry = entry_with(label: tag, site_id: device.site_id)
+        end
+
+        device_tags_field = device.tags_field
+        device_tags_field |= id_to_tags_field(tag_entry.tag_id)
+        device.send_message!(Protocol::Device::SetTags.new(tags: device_tags_field), wait_for: Protocol::Device::StateTags) do
+          device.tags.include?(tag)
+        end
+      end
+
+      def remove_tag_from_device(tag: required!(:tag), device: required!(:device))
+        tag_entry = entry_with(label: tag, site_id: device.site_id)
+        return if !tag_entry
+
+        device_tags_field = device.tags_field
+        device_tags_field &= ~id_to_tags_field(tag_entry.tag_id)
+        device.send_message!(Protocol::Device::SetTags.new(tags: device_tags_field), wait_for: Protocol::Device::StateTags) do
+          !device.tags.include?(tag)
+        end
+      end
+
+      def tags
+        @tag_table.tags
+      end
+
+      def unused_tags
+        @tag_table.tags.select do |tag|
+          context.lights.with_tag(tag).empty?
+        end
+      end
+
+      # This will clear out tags that currently do not resolve to any devices.
+      # If used when devices that are tagged with a tag that is not attached to an
+      # active device, it will effectively untag them when they're back on.
+      def purge_unused_tags!
+        unused_tags.each do |tag|
+          logger.info("Purging tag '#{tag}'")
+          entries_with(label: tag).each do |entry|
+            payload = Protocol::Device::SetTagLabels.new(tags: id_to_tags_field(entry.tag_id), label: '')
+            context.send_message(target: Target.new(site_id: entry.site_id),
+                                 payload: payload,
+                                 acknowledge: true)
+          end
+        end
+        Timeout.timeout(5) do
+          while !unused_tags.empty?
+            sleep 0.1
+          end
+        end
+      end
+
+      protected
+
+      VALID_TAG_IDS = (0...64).to_a.freeze
+
+      def entry_with(**args)
+        entries_with(**args).first
+      end
+
+      def entries_with(**args)
+        @tag_table.entries_with(**args)
+      end
+
+      def id_to_tags_field(id)
+        2 ** id
+      end
+
+      def next_unused_id_on_site_id(site_id)
+        (VALID_TAG_IDS - entries_with(site_id: site_id).map(&:tag_id)).first
+      end
+    end
+  end
+end

data/lib/lifx/lan/tag_table.rb

@@ -0,0 +1,49 @@
+module LIFX
+  module LAN
+    # @api private
+    class TagTable
+      class Entry < Struct.new(:tag_id, :label, :device_id); end
+
+      def initialize(entries: {})
+        @entries = Hash.new { |h, k| h[k] = {} }
+        entries.each do |k, v|
+          @entries[k] = v
+        end
+      end
+
+      def entries_with(tag_id: nil, device_id: nil, label: nil)
+        entries.select do |entry|
+          ret = []
+          ret << (entry.tag_id == tag_id) if tag_id
+          ret << (entry.device_id == device_id) if device_id
+          ret << (entry.label == label) if label
+          ret.all?
+        end
+      end
+
+      def entry_with(**args)
+        entries_with(**args).first
+      end
+
+      def update_table(tag_id: self.tag_id, label: self.label, device_id: self.device_id)
+        entry = @entries[device_id][tag_id] ||= Entry.new(tag_id, label, device_id)
+        entry.label = label
+      end
+
+      def delete_entries_with(tag_id: nil, device_id: nil, label: nil)
+        matching_entries = entries_with(tag_id: tag_id, device_id: device_id, label: label)
+        matching_entries.each do |entry|
+          @entries[entry.device_id].delete(entry.tag_id)
+        end
+      end
+
+      def tags
+        entries.map(&:label).uniq
+      end
+
+      def entries
+        @entries.values.map(&:values).flatten
+      end
+    end
+  end
+end

data/lib/lifx/lan/target.rb

@@ -0,0 +1,24 @@
+module LIFX
+  module LAN
+    # Target is a high-level abstraction for the target of a Message
+    # @api private
+    class Target
+
+      attr_reader :site_id, :device_id, :tag, :broadcast
+      def initialize(device_id: nil, site_id: nil, tag: nil, broadcast: nil)
+        @site_id   = site_id
+        @device_id = device_id
+        @tag       = tag
+        @broadcast = broadcast
+      end
+
+      def broadcast?
+        !!broadcast
+      end
+
+      def tag?
+        !!tag
+      end
+    end
+  end
+end

data/lib/lifx/lan/thread.rb

@@ -0,0 +1,13 @@
+require 'thread'
+
+module LIFX
+  module LAN
+    class Thread < ::Thread
+      def abort
+        if alive?
+          kill.join
+        end
+      end
+    end
+  end
+end

data/lib/lifx/lan/timers.rb

@@ -0,0 +1,29 @@
+require 'timers'
+module LIFX
+  module LAN
+    # @private
+    module Timers
+      protected
+      def initialize_timer_thread
+        timers.after(1) {} # Just so timers.wait doesn't complain when there's no timer
+        @timer_thread = Thread.start do
+          loop do
+            timers.wait
+          end
+        end
+      end
+
+      def stop_timers
+        timers.each(&:cancel)
+        if @timer_thread
+          @timer_thread.abort
+        end
+      end
+
+      public
+      def timers
+        @timers ||= ::Timers.new
+      end
+    end
+  end
+end

data/lib/lifx/lan/transport.rb

@@ -0,0 +1,46 @@
+require 'lifx/lan/observable'
+
+module LIFX
+  module LAN
+    # @api private
+    class Transport
+      include Logging
+      include Observable
+
+      attr_reader :host, :port
+
+      def initialize(host, port, ignore_unpackable_messages: true)
+        @host = host
+        @port = port
+        @ignore_unpackable_messages = ignore_unpackable_messages
+      end
+
+      def listen
+        raise NotImplementedError
+      end
+
+      def write(message)
+        raise NotImplementedError
+      end
+
+      def close
+        remove_observers
+      end
+
+      def to_s
+        %Q{#<#{self.class.name} #{host}:#{port}>}
+      end
+      alias_method :inspect, :to_s
+
+      def observer_callback_definition
+        {
+          message_received: -> (message: nil, ip: nil, transport: nil) {},
+          disconnected: -> {}
+        }
+      end
+    end
+  end
+end
+
+require 'lifx/lan/transport/udp'
+require 'lifx/lan/transport/tcp'

data/lib/lifx/lan/transport/tcp.rb

@@ -0,0 +1,91 @@
+require 'socket'
+
+module LIFX
+  module LAN
+    class Transport
+      # @api private
+      # @private
+      class TCP < Transport
+        include Logging
+
+        def initialize(*args)
+          super
+          connect
+        end
+
+        def connected?
+          !!(@socket && !@socket.closed?)
+        end
+
+        CONNECT_TIMEOUT = 3
+        def connect
+          Timeout.timeout(CONNECT_TIMEOUT) do
+            @socket = TCPSocket.new(host, port) # Performs the connection
+          end
+          @socket.setsockopt(Socket::SOL_SOCKET,  Socket::SO_SNDBUF,    1024)
+          @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY,  1)
+          logger.info("#{self}: Connected.")
+        rescue => ex
+          logger.warn("#{self}: Exception occurred in #connect - #{ex}")
+          logger.debug("#{self}: Backtrace: #{ex.backtrace.join("\n")}")
+          @socket = nil
+        end
+
+        def close
+          super
+          return if !@socket
+          if !@socket.closed?
+            @socket.close
+            notify_observers(:disconnected)
+          end
+          @socket = nil
+          if @listener
+            @listener.abort
+          end
+          @listener = nil
+        end
+
+        HEADER_SIZE = 8
+        def listen
+          return if @listener
+          @listener = Thread.start do
+            while @socket do
+              begin
+                header_data = @socket.recv(HEADER_SIZE, Socket::MSG_PEEK)
+                header      = Protocol::Header.read(header_data)
+                size        = header.msg_size
+                data        = @socket.recv(size)
+                message     = Message.unpack(data)
+
+                notify_observers(:message_received, {message: message, ip: host, transport: self})
+              rescue Message::UnpackError
+                if Config.log_invalid_messages
+                  logger.info("#{self}: Exception occurred while decoding message - #{ex}")
+                  logger.info("Data: #{data.inspect}")
+                end
+              rescue => ex
+                logger.warn("#{self}: Exception occurred in #listen - #{ex}")
+                logger.debug("#{self}: Backtrace: #{ex.backtrace.join("\n")}")
+                close
+              end
+            end
+          end
+        end
+
+        SEND_TIMEOUT = 2
+        def write(message)
+          data = message.pack
+          Timeout.timeout(SEND_TIMEOUT) do
+            @socket.write(data)
+          end
+          true
+        rescue => ex
+          logger.warn("#{self}: Exception in #write: #{ex}")
+          logger.debug("#{self}: Backtrace: #{ex.backtrace.join("\n")}")
+          close
+          false
+        end
+      end
+    end
+  end
+end

data/lib/lifx/lan/transport/udp.rb

@@ -0,0 +1,87 @@
+require 'socket'
+module LIFX
+  module LAN
+    class Transport
+      # @api private
+      # @private
+      class UDP < Transport
+        def initialize(*args)
+          super
+          @socket = create_socket
+        end
+
+        def connected?
+          !!@socket
+        end
+
+        def write_raw(data)
+          logger.debug("-> #{data}")
+          @socket.send(data.scan(/../).map { |x| x.hex.chr }.join, 0, host, port)
+          true
+        rescue => ex
+          logger.warn("#{self}: Error on #write: #{ex}")
+          logger.debug("#{self}: Backtrace: #{ex.backtrace.join("\n")}")
+          close
+          false
+        end
+
+        def write(message)
+          logger.debug("-> Broadcast UDP message: #{message}")
+          logger.debug("-> #{message.to_hex}")
+          data = message.pack
+          @socket.send(data, 0, host, port)
+          true
+        rescue => ex
+          logger.warn("#{self}: Error on #write: #{ex}")
+          logger.debug("#{self}: Backtrace: #{ex.backtrace.join("\n")}")
+          close
+          false
+        end
+
+        def listen(ip: self.host, port: self.port)
+          if @listener
+            raise "Socket already being listened to"
+          end
+
+          @listener = Thread.start do
+            reader = UDPSocket.new
+            reader.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+            reader.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, true) if Socket.const_defined?('SO_REUSEPORT')
+            reader.bind(ip, port)
+            loop do
+              begin
+                bytes, (_, _, ip, _) = reader.recvfrom(128)
+                logger.debug("<- #{bytes.each_byte.map { |b| b.to_s(16).rjust(2, '0') }.join}")
+                message = Message.unpack(bytes)
+                logger.debug("<- Incoming message: #{message}")
+                notify_observers(:message_received, {message: message, ip: ip, transport: self})
+              rescue Message::UnpackError
+                if Config.log_invalid_messages
+                  logger.warn("#{self}: Unrecognised bytes: #{bytes.bytes.map { |b| '%02x ' % b }.join}")
+                end
+              end
+            end
+          end
+        end
+
+        def close
+          super
+          return if !@socket
+          @socket.close
+          @socket = nil
+          if @listener
+            @listener.abort
+          end
+        end
+
+        protected
+
+        def create_socket
+          UDPSocket.new.tap do |socket|
+            socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
+          end
+        end
+      end
+    end
+  end
+end