socket_switcher 0.1.0

data/lib/socket_switcher/errors.rb

@@ -0,0 +1,26 @@
+module SocketSwitcher
+  class SocketSwitcherError < StandardError
+    def self.for_device(device, message)
+      new(message).tap do |error|
+        error.device = device
+      end
+    end
+
+    def self.wrap(device, exception)
+      for_device(device, "wrapped #{exception.class}: #{exception}").tap do |e|
+        e.set_backtrace exception.backtrace
+      end
+    end
+
+    attr_accessor :device
+  end
+
+  class CommunicationError < SocketSwitcherError
+  end
+
+  class InvalidResponse < SocketSwitcherError
+  end
+
+  class TryAgainError < SocketSwitcherError
+  end
+end

data/lib/socket_switcher/port.rb

@@ -0,0 +1,134 @@
+require 'serialport'
+require 'thread'
+
+class SocketSwitcher::Port
+  def initialize(specifier, debug: false, timeout: 2_000, attempts: 3)
+    @serial_port = SerialPort.new(
+      specifier,
+      "baud"      => 9600,
+      "data_bits" => 8,
+      "stop_bits" => 1,
+      "parity"    => 0
+    )
+    @debug    = debug
+    @timeout  = timeout
+    @attempts = attempts
+    @devices  = {}
+    @mutex    = Mutex.new
+  rescue => e
+    raise SocketSwitcher::CommunicationError.wrap(nil, e)
+  end
+
+  attr_accessor :debug
+
+  attr_accessor :timeout
+
+  def ready?
+    request do |response|
+      if response =~ /^RDY (\d+) (\d+)/
+        # initalize all devices
+        ($1.to_i..$2.to_i).each { |i| device(i) }
+        return true
+      else
+        try_again or return false
+      end
+    end
+  end
+
+  def devices(range = nil)
+    if range
+      devices.select { |d| range.member?(d.number) }
+    else
+      ready?
+      @devices.values
+    end
+  end
+
+  def device(number)
+    @devices[number] ||= SocketSwitcher::Device.new(self, number)
+  end
+
+  private
+
+  def debug_output(message)
+    if debug
+      STDERR.puts message
+    end
+  end
+
+  def set_state(device, state)
+    request(device, state) do |response|
+      case response
+      when /^ACK/
+        return true
+      when /^RDY/
+        try_again SocketSwitcher::TryAgainError.for_device(
+          device, "not ready after #@attempt attempts"
+        )
+      when /^NAK device/
+        raise SocketSwitcher::InvalidResponse.for_device(
+          device, "invalid device number: #{device.number}")
+      when /^NAK state/
+        raise SocketSwitcher::InvalidResponse.for_device(
+          device, "invalid state number: #{state}")
+      else
+        try_again SocketSwitcher::TryAgainError.for_device(
+          device, "unexpected response #{response.inspect} after #@attempt attempts")
+      end
+    end
+  end
+
+  def synchronize(&block)
+    @mutex.synchronize(&block)
+  end
+
+  def try_again(exception = nil)
+    if @attempt < @attempts
+      @attempt += 1
+      sleep @timeout.to_f / 1000
+      throw :again
+    elsif exception
+      raise exception
+    else
+      return false
+    end
+  end
+
+  def set_timeout
+    @serial_port.read_timeout = @timeout
+    begin
+      @serial_port.write_timeout = @timeout
+    rescue NotImplementedError
+    end
+  end
+
+  def request(device = nil, state = nil, &block)
+    synchronize do
+      begin
+        @attempt = 1
+        loop do
+          set_timeout
+          catch :again do
+            query = ''
+            device && state and query << "#{device.number} #{state}"
+            query << "\r\n"
+            debug_output "<< #{query.inspect}"
+            @serial_port.print(query)
+            unless response = @serial_port.gets
+              try_again SocketSwitcher::TryAgainError.for_device(
+                device, "timeout after #@attempt attempts"
+              )
+            end
+            debug_output ">> #{response.inspect}"
+            block[response]
+          end
+        end
+      rescue => e
+        unless SocketSwitcher::SocketSwitcherError === e
+          e = SocketSwitcher::CommunicationError.wrap(device, e)
+        end
+        raise e
+      end
+    end
+  end
+end

data/lib/socket_switcher/version.rb

@@ -0,0 +1,8 @@
+module SocketSwitcher
+  # SocketSwitcher version
+  VERSION         = '0.1.0'
+  VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end

data/socket_switcher.gemspec

@@ -0,0 +1,49 @@
+# -*- encoding: utf-8 -*-
+# stub: socket_switcher 0.1.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "socket_switcher"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Florian Frank"]
+  s.date = "2015-01-02"
+  s.description = "Switches devices on and off. Yes, it does\u{2026}"
+  s.email = "flori@ping.de"
+  s.extra_rdoc_files = ["README.md", "lib/socket_switcher.rb", "lib/socket_switcher/device.rb", "lib/socket_switcher/errors.rb", "lib/socket_switcher/port.rb", "lib/socket_switcher/version.rb"]
+  s.files = [".gitignore", ".rspec", ".utilsrc", "Gemfile", "README.md", "Rakefile", "VERSION", "arduino-receiver/receiver/receiver.ino", "arduino/lib/.holder", "arduino/lib/RCSwitch/RCSwitch.cpp", "arduino/lib/RCSwitch/RCSwitch.h", "arduino/lib/RCSwitch/examples/ReceiveDemo_Advanced/ReceiveDemo_Advanced.pde", "arduino/lib/RCSwitch/examples/ReceiveDemo_Advanced/helperfunctions.ino", "arduino/lib/RCSwitch/examples/ReceiveDemo_Advanced/output.ino", "arduino/lib/RCSwitch/examples/ReceiveDemo_Simple/ReceiveDemo_Simple.pde", "arduino/lib/RCSwitch/examples/SendDemo/SendDemo.pde", "arduino/lib/RCSwitch/examples/TypeA_WithDIPSwitches/TypeA_WithDIPSwitches.pde", "arduino/lib/RCSwitch/examples/TypeA_WithDIPSwitches_Lightweight/TypeA_WithDIPSwitches_Lightweight.ino", "arduino/lib/RCSwitch/examples/TypeB_WithRotaryOrSlidingSwitches/TypeB_WithRotaryOrSlidingSwitches.pde", "arduino/lib/RCSwitch/examples/TypeC_Intertechno/TypeC_Intertechno.pde", "arduino/lib/RCSwitch/examples/TypeD_REV/TypeD_REV.ino", "arduino/lib/RCSwitch/examples/Webserver/Webserver.pde", "arduino/lib/RCSwitch/keywords.txt", "arduino/src/switcher/switcher.ino.erb", "config/default.yml", "config/traffic_lights.yml", "examples/blinkenlights.rb", "lib/socket_switcher.rb", "lib/socket_switcher/device.rb", "lib/socket_switcher/errors.rb", "lib/socket_switcher/port.rb", "lib/socket_switcher/version.rb", "socket_switcher.gemspec", "spec/socket_switcher/device_spec.rb", "spec/socket_switcher/port_spec.rb", "spec/spec_helper.rb"]
+  s.homepage = "http://github.com/flori/socket_switcher"
+  s.licenses = ["GPL-2"]
+  s.rdoc_options = ["--title", "SocketSwitcher - Switches devices on and off", "--main", "README.md"]
+  s.rubygems_version = "2.2.2"
+  s.summary = "Switches devices on and off"
+  s.test_files = ["spec/socket_switcher/device_spec.rb", "spec/socket_switcher/port_spec.rb", "spec/spec_helper.rb"]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<gem_hadar>, ["~> 1.1.2"])
+      s.add_development_dependency(%q<simplecov>, ["~> 0.9"])
+      s.add_development_dependency(%q<rspec>, ["~> 3.0"])
+      s.add_runtime_dependency(%q<tins>, ["~> 1.0"])
+      s.add_runtime_dependency(%q<serialport>, ["~> 1.3"])
+      s.add_runtime_dependency(%q<complex_config>, [">= 0"])
+    else
+      s.add_dependency(%q<gem_hadar>, ["~> 1.1.2"])
+      s.add_dependency(%q<simplecov>, ["~> 0.9"])
+      s.add_dependency(%q<rspec>, ["~> 3.0"])
+      s.add_dependency(%q<tins>, ["~> 1.0"])
+      s.add_dependency(%q<serialport>, ["~> 1.3"])
+      s.add_dependency(%q<complex_config>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<gem_hadar>, ["~> 1.1.2"])
+    s.add_dependency(%q<simplecov>, ["~> 0.9"])
+    s.add_dependency(%q<rspec>, ["~> 3.0"])
+    s.add_dependency(%q<tins>, ["~> 1.0"])
+    s.add_dependency(%q<serialport>, ["~> 1.3"])
+    s.add_dependency(%q<complex_config>, [">= 0"])
+  end
+end

data/spec/socket_switcher/device_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe SocketSwitcher::Device do
+  let :port do
+    double('Port')
+  end
+
+  let :device do
+    SocketSwitcher::Device.new(port, 23)
+  end
+
+  it 'knows about port' do
+    expect(device.port).to eq port
+  end
+
+  it 'knows its own number' do
+    expect(device.number).to eq 23
+  end
+
+  it 'sets state to 1 after receiving on' do
+    expect(port).to receive(:set_state).with(device, 1)
+    device.on
+  end
+
+  it 'sets state to 0 after receiving off' do
+    expect(port).to receive(:set_state).with(device, 0)
+    device.off
+  end
+
+  it 'has a nice #to_s' do
+    expect(device.to_s).to eq '#<SocketSwitcher::Device number=23>'
+  end
+
+  it 'has a nice #inspect' do
+    expect(device.inspect).to eq '#<SocketSwitcher::Device number=23>'
+  end
+end

data/spec/socket_switcher/port_spec.rb

@@ -0,0 +1,216 @@
+require 'spec_helper'
+
+describe SocketSwitcher::Port do
+  let :serial_port do
+    double('SerialPort').tap do |sp|
+      allow(sp).to receive(:read_timeout=)
+      allow(sp).to receive(:write_timeout=)
+      allow(sp).to receive(:print).with("\r\n")
+    end
+  end
+
+  before do
+    allow(SerialPort).to receive(:new).and_return serial_port
+  end
+
+  let :port do
+    SocketSwitcher::Port.new('foo')
+  end
+
+  context 'instantiation and configuration' do
+    it 'can be instantiated' do
+      expect(port).to be_a SocketSwitcher::Port
+      expect(port.debug).to eq false
+      expect(port.timeout).to eq 2_000
+    end
+
+    it 'can be instantiated in debugging mode' do
+      expect(SocketSwitcher::Port.new('foo', debug: true).debug).to eq true
+    end
+
+    it 'has a configurable debugging mode' do
+      port.debug = true
+      expect(port.debug).to eq true
+    end
+
+    it 'can be instantiated with a timeout' do
+      expect(SocketSwitcher::Port.new('foo', timeout: 666).timeout).to eq 666
+    end
+
+    it 'has a configurable timeout' do
+      port.timeout = 4_000
+      expect(port.timeout).to eq 4_000
+    end
+
+    it 'wraps all unknown errors in SocketSwitcher::CommunicationError' do
+      expect(SerialPort).to receive(:new).and_raise(Errno::ENXIO)
+      expect { port }.to raise_error SocketSwitcher::CommunicationError
+    end
+  end
+
+  describe '#ready?' do
+    context 'sucessfull' do
+      before do
+        allow(serial_port).to receive(:gets).and_return("RDY 0 3\r\n")
+      end
+
+      it 'can query the ready state' do
+        expect(port).to be_ready
+      end
+
+      context 'with debugging' do
+        let :port do
+          SocketSwitcher::Port.new('foo', debug: true)
+        end
+
+        it 'can query the ready state with debugging' do
+          expect(STDERR).to receive(:puts).at_least(1)
+          expect(port).to receive(:debug_output).with('<< "\r\n"').and_call_original
+          expect(port).to receive(:debug_output).with('>> "RDY 0 3\r\n"').and_call_original
+          expect(port).to be_ready
+        end
+      end
+    end
+
+    context 'some problem' do
+      it 'does not handle too many garbled responses, but returns false' do
+        expect(serial_port).to receive(:print).with("\r\n").at_least(1)
+        expect(serial_port).to receive(:gets).and_return("RD…garbled…").at_least(1)
+        expect(port).to receive(:sleep).with(port.timeout.to_f / 1000).at_least(1)
+        expect(port).not_to be_ready
+      end
+    end
+  end
+
+  context 'timeout' do
+    let :serial_port do
+      double('SerialPort').tap do |sp|
+        allow(sp).to receive(:print).with("\r\n")
+        allow(sp).to receive(:gets).and_return("RDY 0 3\r\n")
+      end
+    end
+
+    it 'sets the read_timeout and write_timeout' do
+      expect(serial_port).to receive(:read_timeout=)
+      expect(serial_port).to receive(:write_timeout=)
+      expect(port).to be_ready
+    end
+
+    it 'ingores not implemented write_timeout' do
+      expect(serial_port).to receive(:read_timeout=)
+      expect(serial_port).to receive(:write_timeout=).and_raise(NotImplementedError)
+      expect(port).to be_ready
+    end
+  end
+
+  describe '#devices' do
+    context 'successful' do
+      before do
+        allow(serial_port).to receive(:gets).and_return("RDY 0 3\r\n")
+      end
+
+      it 'returns all supported devices' do
+        expect(port.devices.size).to eq 4
+      end
+
+      it 'can return a range of devices' do
+        expect(port.devices(0..1).size).to eq 2
+        expect(port.devices([0, 3]).size).to eq 2
+      end
+    end
+
+    context 'some problem' do
+      it 'returns all supported devices' do
+        expect(serial_port).to receive(:gets).and_return("RD…garbled…")
+        expect(serial_port).to receive(:gets).and_return("RDY 0 3\r\n")
+        expect(port).to receive(:sleep).with(port.timeout.to_f / 1000)
+        expect(port).to receive(:try_again).and_call_original
+        expect(port.devices.size).to eq 4
+      end
+    end
+  end
+
+  describe '#device' do
+    let :device do
+      port.device(23)
+    end
+
+    it 'returns a device for number' do
+      expect(device.number).to eq 23
+    end
+
+    it 'can be switched on' do
+      expect(serial_port).to receive(:print).with("23 1\r\n")
+      expect(serial_port).to receive(:gets).and_return("ACK\r\n")
+      expect(device.on).to eq true
+    end
+
+    it 'can be switched off' do
+      expect(serial_port).to receive(:print).with("23 0\r\n")
+      expect(serial_port).to receive(:gets).and_return("ACK\r\n")
+      expect(device.off).to eq true
+    end
+
+    it 'throws exceptions for device errors' do
+      expect(serial_port).to receive(:print).with("23 0\r\n")
+      expect(serial_port).to receive(:gets).and_return("NAK device\r\n")
+      expect { device.off }.to raise_error SocketSwitcher::InvalidResponse
+    end
+
+    it 'throws exceptions for state errors' do
+      expect(serial_port).to receive(:print).with("23 1\r\n")
+      expect(serial_port).to receive(:gets).and_return("NAK state\r\n")
+      expect { device.on }.to raise_error SocketSwitcher::InvalidResponse
+    end
+
+    it 'handles some garbled responses' do
+      expect(serial_port).to receive(:print).with("23 1\r\n").twice
+      expect(serial_port).to receive(:gets).and_return("RD…garbled…")
+      expect(port).to receive(:sleep).with(port.timeout.to_f / 1000)
+      expect(serial_port).to receive(:gets).and_return("ACK\r\n")
+      expect(device.on).to eq true
+    end
+
+    it 'does not handle too many unexpected responses' do
+      expect(serial_port).to receive(:print).with("23 1\r\n").at_least(1)
+      expect(serial_port).to receive(:gets).and_return("RD…garbled…").at_least(1)
+      expect(port).to receive(:sleep).with(port.timeout.to_f / 1000).at_least(1)
+      expect { device.on }.to raise_error SocketSwitcher::TryAgainError
+    end
+
+    it 'can handle some ready responses' do
+      expect(serial_port).to receive(:print).with("23 0\r\n").twice
+      expect(serial_port).to receive(:gets).and_return("RDY 0 3\r\n")
+      expect(port).to receive(:sleep).with(port.timeout.to_f / 1000)
+      expect(serial_port).to receive(:gets).and_return("ACK\r\n")
+      expect(device.off).to eq true
+    end
+
+    it 'does not handle too many ready responses' do
+      expect(serial_port).to receive(:print).with("23 0\r\n").at_least(1)
+      expect(serial_port).to receive(:gets).and_return("RDY 0 3\r\n").at_least(1)
+      expect(port).to receive(:sleep).with(port.timeout.to_f / 1000).at_least(1)
+      expect { device.off }.to raise_error SocketSwitcher::TryAgainError
+    end
+
+    it 'can handle some timeouts' do
+      expect(serial_port).to receive(:print).with("23 0\r\n").twice
+      expect(serial_port).to receive(:gets).and_return(nil)
+      expect(port).to receive(:sleep).with(port.timeout.to_f / 1000)
+      expect(serial_port).to receive(:gets).and_return("ACK\r\n")
+      expect(device.off).to eq true
+    end
+
+    it 'does not handle too many ready responses' do
+      expect(serial_port).to receive(:print).with("23 0\r\n").at_least(1)
+      expect(serial_port).to receive(:gets).and_return(nil).at_least(1)
+      expect(port).to receive(:sleep).with(port.timeout.to_f / 1000).at_least(1)
+      expect { device.off }.to raise_error SocketSwitcher::TryAgainError
+    end
+
+    it 'wraps all unknown errors in SocketSwitcher::CommunicationError' do
+      expect(serial_port).to receive(:print).and_raise(Errno::ENXIO)
+      expect { device.on }.to raise_error SocketSwitcher::CommunicationError
+    end
+  end
+end