lifx 0.0.1 → 0.4.0

data/lib/lifx/site.rb

@@ -0,0 +1,89 @@
+require 'lifx/seen'
+require 'lifx/timers'
+require 'lifx/observable'
+require 'lifx/gateway_connection'
+
+module LIFX
+  # @api private
+  class Site
+    include Seen
+    include Timers
+    include Logging
+    include Observable
+    
+    attr_reader :id, :gateways, :tag_manager
+
+    def initialize(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::StatePanGateway
+        @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) do |**args|
+            notify_observers(**args)
+          end
+        end
+      end
+      seen!
+    end
+
+    def flush(**options)
+      @gateways.values.map do |gateway|
+        Thread.new do
+          gateway.flush(**options)
+        end
+      end.each(&:join)
+    end
+    
+    def to_s
+      %Q{#<LIFX::Site id=#{id}>}
+    end
+    alias_method :inspect, :to_s
+
+    def stop
+      @threads.each do |thread|
+        Thread.kill(thread)
+      end
+      @gateways.values.each do |gateway|
+        gateway.close
+      end
+    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

data/lib/lifx/tag_manager.rb

@@ -0,0 +1,105 @@
+module LIFX
+  # @api 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
+
+    attr_reader :context
+
+    class TagLimitReached < StandardError; end
+
+    def initialize(context:, tag_table:)
+      @context = context
+      @tag_table = tag_table
+    end
+
+    def create_tag(label:, 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))
+    end
+
+    def add_tag_to_device(tag:, 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:, 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

data/lib/lifx/tag_table.rb

@@ -0,0 +1,47 @@
+module LIFX
+  # @api private
+  class TagTable
+    class Entry < Struct.new(:tag_id, :label, :site_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, site_id: nil, label: nil)
+      entries.select do |entry|
+        ret = []
+        ret << (entry.tag_id == tag_id) if tag_id
+        ret << (entry.site_id == site_id) if site_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:, label:, site_id:)
+      entry = @entries[site_id][tag_id] ||= Entry.new(tag_id, label, site_id)
+      entry.label = label
+    end
+
+    def delete_entries_with(tag_id: nil, site_id: nil, label: nil)
+      matching_entries = entries_with(tag_id: tag_id, site_id: site_id, label: label)
+      matching_entries.each do |entry|
+        @entries[entry.site_id].delete(entry.tag_id)
+      end
+    end
+
+    def tags
+      entries.map(&:label).uniq
+    end
+
+    def entries
+      @entries.values.map(&:values).flatten
+    end
+  end
+end

data/lib/lifx/target.rb

@@ -0,0 +1,23 @@
+module LIFX
+  # @api private
+
+  class Target
+    # Target is a high-level abstraction for the target of a Message
+
+    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

data/lib/lifx/timers.rb

@@ -0,0 +1,18 @@
+require 'timers'
+module LIFX
+  module Timers
+    protected
+    def initialize_timer_thread
+      timers.after(1) {} # Just so timers.wait doesn't complain when there's no timer
+      Thread.new do
+        loop do
+          timers.wait
+        end
+      end
+    end
+
+    def timers
+      @timers ||= ::Timers.new
+    end
+  end
+end

data/lib/lifx/transport/tcp.rb

@@ -0,0 +1,81 @@
+require 'socket'
+
+module LIFX
+  class Transport
+    # @api 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 occured in #connect - #{ex}")
+        logger.debug("#{self}: Backtrace: #{ex.backtrace.join("\n")}")
+        @socket = nil
+      end
+
+      def close
+        return if !@socket
+        Thread.kill(@listener) if @listener
+        @listener = nil
+        @socket.close if !@socket.closed?
+        @socket = nil
+      end
+
+      HEADER_SIZE = 8
+      def listen
+        return if @listener
+        @listener = Thread.new 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: message, ip: host, transport: self)
+            rescue Message::UnpackError
+              if !@ignore_unpackable_messages
+                logger.warn("#{self}: Exception occured - #{ex}")
+              end
+            rescue => ex
+              logger.warn("#{self}: Exception occured 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

data/lib/lifx/transport/udp.rb

@@ -0,0 +1,67 @@
+require 'socket'
+module LIFX
+  class Transport
+    # @api private
+    class UDP < Transport
+      def initialize(*args)
+        super
+        @socket = create_socket
+      end
+
+      def connected?
+        !!@socket
+      end
+
+      def write(message)
+        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
+        
+        Thread.abort_on_exception = true
+        @listener = Thread.new do
+          reader = UDPSocket.new
+          reader.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+          reader.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEPORT, true)
+          reader.bind(ip, port)
+          loop do
+            begin
+              bytes, (_, _, ip, _) = reader.recvfrom(128)
+              message = Message.unpack(bytes)
+              notify_observers(message: message, ip: ip, transport: self)
+            rescue Message::UnpackError
+              if !@ignore_unpackable_messages
+                logger.warn("#{self}: Unrecognised bytes: #{bytes.bytes.map { |b| '%02x ' % b }.join}")
+              end
+            end
+          end
+        end
+      end
+
+      def close
+        Thread.kill(@listener) if @listener
+        return if !@socket
+        @socket.close
+        @socket = nil
+      end
+
+      protected
+
+      def create_socket
+        UDPSocket.new.tap do |socket|
+          socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
+        end
+      end
+    end
+  end
+end

data/lib/lifx/transport.rb

@@ -0,0 +1,41 @@
+require 'lifx/observable'
+
+module LIFX
+  # @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
+      raise NotImplementedError
+    end
+
+    def to_s
+      %Q{#<#{self.class.name} #{host}:#{port}>}
+    end
+    alias_method :inspect, :to_s
+
+    def observer_callback_definition
+      -> (message:, ip: nil, transport: nil) {}
+    end
+  end
+end
+
+require 'lifx/transport/udp'
+require 'lifx/transport/tcp'

data/lib/lifx/transport_manager/lan.rb

@@ -0,0 +1,140 @@
+require 'lifx/site'
+
+module LIFX
+  module TransportManager
+    class LAN < Base
+      def initialize(bind_ip: '0.0.0.0', send_ip: '255.255.255.255', port: 56700, peer_port: 56750)
+        super
+        @bind_ip   = bind_ip
+        @send_ip   = send_ip
+        @port      = port
+        @peer_port = peer_port
+        
+        @sites = {}
+        initialize_transports
+      end
+
+      def flush(**options)
+        @sites.values.map do |site|
+          Thread.new do
+            site.flush(**options)
+          end
+        end.each(&:join)
+      end
+
+      DISCOVERY_INTERVAL_WHEN_NO_SITES_FOUND = 1    # seconds
+      DISCOVERY_INTERVAL                     = 15   # seconds
+      def discover
+        stop_discovery
+        Thread.abort_on_exception = true
+        @discovery_thread = Thread.new do
+          @last_request_seen = Time.at(0)
+          message = Message.new(path: ProtocolPath.new(tagged: true), payload: Protocol::Device::GetPanGateway.new)
+          logger.info("Discovering gateways on #{@bind_ip}:#{@port}")
+          loop do
+            interval = @sites.empty? ?
+              DISCOVERY_INTERVAL_WHEN_NO_SITES_FOUND :
+              DISCOVERY_INTERVAL
+            if Time.now - @last_request_seen > interval
+              write(message)
+            end
+            sleep(interval / 2.0)
+          end
+        end
+      end
+
+      def stop_discovery
+        Thread.kill(@discovery_thread) if @discovery_thread
+      end
+
+      def stop
+        stop_discovery
+        @transport.close
+        @sites.values.each do |site|
+          site.stop
+        end
+      end
+
+      def write(message)
+        return unless on_network?
+        if message.path.all_sites?
+          broadcast(message)
+        else
+          site = @sites[message.path.site_id]
+          if site
+            site.write(message)
+          else
+            broadcast(message)
+          end
+        end
+        broadcast_to_peers(message)
+      end
+
+      def on_network?
+        Socket.getifaddrs.any? { |ifaddr| ifaddr.broadaddr }
+      end
+
+      def broadcast(message)
+        if !@transport.connected?
+          create_broadcast_transport
+        end
+        @transport.write(message)
+      end
+
+      def broadcast_to_peers(message)
+        if !@peer_transport.connected?
+          create_peer_transport
+        end
+        @peer_transport.write(message)
+      end
+
+      def sites
+        @sites.dup
+      end
+
+      def gateways
+        @sites.values.map(&:gateways)
+      end
+
+      protected
+
+      def initialize_transports
+        create_broadcast_transport
+        create_peer_transport
+      end
+
+      def create_broadcast_transport
+        @transport = Transport::UDP.new(@send_ip, @port)
+        @transport.add_observer(self) do |message:, ip:, transport:|
+          handle_broadcast_message(message, ip, @transport)
+          notify_observers(message: message, ip: ip, transport: transport)
+        end
+        @transport.listen(ip: @bind_ip)
+      end
+
+      def create_peer_transport
+        @peer_transport = Transport::UDP.new('255.255.255.255', @peer_port)
+        @peer_transport.add_observer(self) do |message:, ip:, transport:|
+          notify_observers(message: message, ip: ip, transport: transport)
+        end
+        @peer_transport.listen(ip: @bind_ip)
+      end
+
+      def handle_broadcast_message(message, ip, transport)
+        payload = message.payload
+        case payload
+        when Protocol::Device::StatePanGateway
+          if !@sites.has_key?(message.path.site_id)
+            @sites[message.path.site_id] = Site.new(id: message.path.site_id)
+            @sites[message.path.site_id].add_observer(self) do |**args|
+              notify_observers(**args)
+            end
+          end
+          @sites[message.path.site_id].handle_message(message, ip, transport)
+        when Protocol::Device::GetPanGateway
+          @last_request_seen = Time.now
+        end
+      end
+    end
+  end
+end

data/lib/lifx/transport_manager.rb

@@ -0,0 +1,34 @@
+require 'lifx/observable'
+
+module LIFX
+  # @api private
+  module TransportManager
+    class Base
+      include Logging
+      include Observable
+
+      def initialize(**args)
+      end
+
+      def discover
+        raise NotImplementedError
+      end
+
+      def write(message)
+        raise NotImplementedError
+      end
+
+      def flush(**options)
+        raise NotImplementedError
+      end
+
+      def stop
+        raise NotImplementedError
+      end
+
+
+    end
+  end
+end
+
+require 'lifx/transport_manager/lan'

data/lib/lifx/utilities.rb

@@ -0,0 +1,33 @@
+module LIFX
+  module Utilities
+    def try_until(condition_proc, timeout_exception: Timeout::Error,
+                                            timeout: 3,
+                                 condition_interval: 0.1,
+                                    action_interval: 0.5,
+                                             signal: nil, &action_block)
+      Timeout.timeout(timeout) do
+        m = Mutex.new
+        time = 0
+        while !condition_proc.call
+          if Time.now.to_f - time > action_interval
+            time = Time.now.to_f
+            action_block.call
+          end
+          if signal
+            m.synchronize do
+              signal.wait(m, condition_interval)
+            end
+          else
+            sleep(condition_interval)
+          end
+        end
+      end
+    rescue Timeout::Error
+      raise timeout_exception if timeout_exception
+    end
+
+    def tag_ids_from_field(tags_field)
+      (0...64).to_a.select { |t| (tags_field & (2 ** t)) > 0 }
+    end
+  end
+end

data/lib/lifx/version.rb

@@ -1,3 +1,3 @@
 module LIFX
-  VERSION = "0.0.1"
+  VERSION = "0.4.0"
 end