lifx-lan 0.1.0

data/lib/lifx/lan/transport_manager.rb

@@ -0,0 +1,43 @@
+require 'lifx/lan/observable'
+
+module LIFX
+  module LAN
+    # @api private
+    module TransportManager
+      class Base
+        include Logging
+        include Observable
+        attr_accessor :context
+
+        def initialize(**args)
+        end
+
+        def discover
+          raise NotImplementedError
+        end
+
+        def write(message)
+          raise NotImplementedError
+        end
+
+        def flush(**options)
+          raise NotImplementedError
+        end
+
+        def stop
+          @context = nil
+          remove_observers
+        end
+
+        def observer_callback_definition
+          {
+            message_received: -> (message: nil, ip: nil, transport: nil) {},
+            disconnected: -> {}
+          }
+        end
+      end
+    end
+  end
+end
+
+require 'lifx/lan/transport_manager/lan'

data/lib/lifx/lan/transport_manager/lan.rb

@@ -0,0 +1,169 @@
+require 'lifx/lan/site'
+
+module LIFX
+  module LAN
+    module TransportManager
+      class LAN < Base
+        include Timers
+        def initialize(bind_ip: '0.0.0.0', send_ip: Config.broadcast_ip, port: 56700)
+          super
+          @bind_ip   = bind_ip
+          @send_ip   = send_ip
+          @port      = port
+
+          @sites = {}
+          @threads = []
+          @threads << initialize_timer_thread
+          initialize_transport
+          initialize_periodic_refresh
+          initialize_message_rate_updater
+        end
+
+        def flush(**options)
+          @sites.values.map do |site|
+            Thread.start 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
+          @discovery_thread = Thread.start do
+            @last_request_seen = Time.at(0)
+            message = Message.new(path: ProtocolPath.new(tagged: true), payload: Protocol::Device::GetService.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
+          if @discovery_thread
+            @discovery_thread.abort
+          end
+        end
+
+        def stop
+          super
+          stop_discovery
+          stop_timers
+          @threads.each do |thr|
+            thr.abort
+          end
+          @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
+          @message_rate_timer.reset
+        end
+
+        def on_network?
+          if Socket.respond_to?(:getifaddrs) # Ruby 2.1+
+            Socket.getifaddrs.any? { |ifaddr| ifaddr.broadaddr }
+          else # Ruby 2.0
+            Socket.ip_address_list.any? do |addrinfo|
+              # Not entirely sure how to check if on a LAN with IPv6
+              addrinfo.ipv4_private? || (addrinfo.respond_to?(:ipv6_unique_local?) && addrinfo.ipv6_unique_local?)
+            end
+          end
+        end
+
+        def broadcast(message)
+          if !@transport.connected?
+            create_broadcast_transport
+          end
+          @transport.write(message)
+        end
+
+        def sites
+          @sites.dup
+        end
+
+        def gateways
+          @sites.values.map(&:gateways).map(&:keys).flatten.uniq.map { |id| context.lights.with_id(id) }.compact
+        end
+
+        def gateway_connections
+          @sites.values.map(&:gateways).map(&:values).flatten
+        end
+
+        def message_rate
+          @message_rate || DEFAULT_MESSAGE_RATE
+        end
+
+        protected
+
+        def initialize_periodic_refresh
+          timers.every(10) do
+            context.refresh(force: false)
+          end
+        end
+
+        DEFAULT_MESSAGE_RATE = 5 # per second
+        MESSAGE_RATE_1_2 = 20
+        def initialize_message_rate_updater
+          @message_rate_timer = timers.every(2) do
+            @message_rate = MESSAGE_RATE_1_2
+            gateway_connections.each do |connection|
+              connection.set_message_rate(@message_rate)
+            end
+          end
+        end
+
+        def initialize_transport
+          create_broadcast_transport
+        end
+
+        def create_broadcast_transport
+          @transport = Transport::UDP.new(@send_ip, @port)
+          @transport.add_observer(self, :message_received) do |message: nil, ip: nil, transport: nil|
+            handle_broadcast_message(message, ip, @transport)
+            notify_observers(:message_received, message: message, ip: ip, transport: transport)
+          end
+          @transport.listen(ip: @bind_ip)
+        end
+
+        def handle_broadcast_message(message, ip, transport)
+          return if message.nil?
+          payload = message.payload
+          case payload
+          when Protocol::Device::StateService
+            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, :message_received) do |**args|
+                notify_observers(:message_received, **args)
+              end
+            end
+            @sites[message.path.site_id].handle_message(message, ip, transport)
+          when Protocol::Device::GetService
+            @last_request_seen = Time.now
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lifx/lan/utilities.rb

@@ -0,0 +1,36 @@
+module LIFX
+  module LAN
+    # @private
+    module Utilities
+      def try_until(condition_proc, timeout_exception: TimeoutError,
+                                              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
+end

data/lib/lifx/lan/version.rb

@@ -0,0 +1,5 @@
+module LIFX
+  module LAN
+    VERSION = "0.1.0"
+  end
+end

data/lifx-lan.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lifx/lan/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lifx-lan"
+  spec.version       = LIFX::LAN::VERSION
+  spec.authors       = ["Jack Chen (chendo), Julian Cheal (juliancheal)"]
+  spec.email         = ["julian.cheal+lifx-gem@lifx.co"]
+  spec.description   = %q{A Ruby gem that allows easy interaction with LIFX devices.}
+  spec.summary       = %q{A Ruby gem that allows easy interaction with LIFX devices. Handles discovery, rate limiting, tags, gateway connections and provides an object-based API for interacting with LIFX devices. }
+  spec.homepage      = "https://github.com/juliancheal/lifx-lan"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/).reject { |f| f =~ /^script\// }
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 2.0"
+
+  spec.add_dependency "bindata", "~> 2.0"
+  spec.add_dependency "timers", "~> 1.0"
+  spec.add_dependency "configatron", "~> 3.0"
+  spec.add_development_dependency "bundler", "~> 1.3"
+end

data/spec/color_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module LIFX
+  module LAN
+    describe Color do
+      let(:default_kelvin) { 3500 }
+
+      describe '.rgb' do
+        context 'translating from RGB' do
+          shared_examples 'translating color' do |name, rgb, expected|
+            it "translates #{name} correctly" do
+              translation = Color.rgb(*rgb).to_a
+              expect(translation).to eq [*expected, default_kelvin]
+            end
+          end
+
+          it_behaves_like 'translating color', 'red',    [255, 0, 0],     [0, 1, 1]
+          it_behaves_like 'translating color', 'yellow', [255, 255, 0],   [60, 1, 1]
+          it_behaves_like 'translating color', 'green',  [0, 255, 0],     [120, 1, 1]
+          it_behaves_like 'translating color', 'cyan',   [0, 255, 255],   [180, 1, 1]
+          it_behaves_like 'translating color', 'blue',   [0, 0, 255],     [240, 1, 1]
+          it_behaves_like 'translating color', 'white',  [255, 255, 255], [0, 0, 1]
+          it_behaves_like 'translating color', 'black',  [0, 0, 0],       [0, 0, 0]
+        end
+      end
+
+      describe '#similar_to?' do
+        it 'matches reds on on either end of hue spectrums' do
+          expect(Color.hsb(359.9, 1, 1)).to be_similar_to(Color.hsb(0, 1, 1))
+          expect(Color.hsb(0, 1, 1)).to be_similar_to(Color.hsb(359.9, 1, 1))
+        end
+
+        it 'does not match different colours' do
+          expect(Color.hsb(120, 1, 1)).to_not be_similar_to(Color.hsb(0, 1, 1))
+        end
+
+        it 'matches similar colours' do
+          expect(Color.hsb(120, 1, 1)).to be_similar_to(Color.hsb(120.3, 1, 1))
+        end
+      end
+    end
+  end
+end

data/spec/gateway_connection_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module LIFX
+  module LAN
+    describe GatewayConnection do
+      subject(:gateway) { GatewayConnection.new }
+
+      let(:message) { double(Message, is_a?: true, pack: '') }
+      let(:ip) { '127.0.0.1' }
+      let(:port) { 35_003 }
+
+      after { gateway.close }
+
+      context 'write queue resiliency' do
+        it 'does not send if there is no available connection' do
+          expect(gateway).to_not receive(:actually_write)
+          gateway.write(message)
+          expect { gateway.flush(timeout: 0.5) }.to raise_error(TimeoutError)
+        end
+
+        it 'pushes message back into queue if unable to write' do
+          gateway.connect_udp(ip, port)
+          expect(gateway).to receive(:actually_write).and_return(false, true)
+          gateway.write(message)
+          gateway.flush
+        end
+      end
+    end
+  end
+end

data/spec/integration/client_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module LIFX
+  module LAN
+    describe Client, integration: true do
+      describe '#sync' do
+        let(:minimum_lights) { 3 }
+        let(:udp) { Transport::UDP.new('0.0.0.0', 56_750) }
+        let(:white) { Color.white(brightness: 0.5) }
+
+        it 'schedules sending all messages to be executed at the same time' do
+          if lights.count < minimum_lights
+            pending 'This test requires 3 or more lights tagged under Test'
+            return
+          end
+
+          lifx.discover! { lights.count >= minimum_lights }
+
+          lights.set_color(white, duration: 0)
+          sleep 1
+
+          msgs = []
+          udp.add_observer(self, :message_received) do |message: nil, ip: nil, transport: nil|
+            msgs << message if message.payload.is_a?(Protocol::Light::SetWaveform)
+          end
+          udp.listen
+
+          lifx.sync do
+            lights.each do |light|
+              light.pulse(LIFX::LAN::Color.hsb(rand(360), 1, 1), period: 1)
+            end
+          end
+
+          expect(msgs.count).to eq lights.count
+          expect(msgs.map(&:at_time).uniq.count).to eq 1
+
+          flush
+        end
+      end
+    end
+  end
+end

data/spec/integration/light_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+module LIFX
+  module LAN
+    describe Light, integration: true do
+      describe '#set_power' do
+        it 'sets the power of the light asynchronously' do
+          light.set_power(:off)
+          wait { expect(light).to be_off }
+          light.set_power(:on)
+          wait { expect(light).to be_on }
+        end
+      end
+
+      describe '#set_power!' do
+        it 'sets the power of the light synchronously' do
+          light.set_power!(:off)
+          expect(light).to be_off
+          light.set_power!(:on)
+          expect(light).to be_on
+        end
+      end
+
+      describe '#set_color' do
+        let(:color) { Color.hsb(rand(360), rand, rand) }
+
+        it 'sets the color of the light asynchronously' do
+          light.set_color(color, duration: 0)
+          sleep 1
+          light.refresh
+          wait { expect(light.color).to be_similar_to(color) }
+        end
+      end
+
+      describe '#set_label' do
+        let!(:original_label) { light.label }
+
+        after do
+          light.set_label(original_label)
+        end
+
+        it 'sets the label of the light synchronously' do
+          label = light.label.sub(/\d+|$/, rand(100).to_s)
+          light.set_label(label)
+          expect(light.label).to eq(label)
+        end
+
+        it 'works with accented characters' do
+          label = 'tést'
+          light.set_label(label)
+          expect(light.label).to eq(label)
+        end
+      end
+    end
+  end
+end