tamashii-agent 0.1.7

data/lib/tamashii/agent.rb

@@ -0,0 +1,18 @@
+require "tamashii/common"
+require "tamashii/agent/version"
+require "tamashii/agent/master"
+require "tamashii/agent/config"
+
+
+module Tamashii
+  module Agent
+    def self.config(&block)
+      return Config.class_eval(&block) if block_given?
+      Config
+    end
+
+    def self.logger
+      @logger ||= Tamashii::Logger.new(Config.log_file)
+    end
+  end
+end

data/lib/tamashii/agent/adapter/base.rb

@@ -0,0 +1,28 @@
+require 'tamashii/common'
+require 'tamashii/agent/config'
+
+module Tamashii
+  module Agent
+    module Adapter
+      class Base
+        class << self
+          def object(*args, &block)
+            current_class.new(*args, &block)
+          end
+
+          def current_class
+            Config.env == "test" ? fake_class : real_class 
+          end
+
+          def real_class
+            raise NotImplementedError
+          end
+
+          def fake_class
+            raise NotImplementedError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tamashii/agent/adapter/buzzer.rb

@@ -0,0 +1,21 @@
+require 'tamashii/agent/adapter/base'
+require 'tamashii/agent/device/pi_buzzer'
+require 'tamashii/agent/device/fake_buzzer'
+
+module Tamashii
+  module Agent
+    module Adapter
+      class Buzzer < Base
+        class << self
+          def real_class
+            Device::PIBuzzer
+          end
+
+          def fake_class
+            Device::FakeBuzzer
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tamashii/agent/adapter/card_reader.rb

@@ -0,0 +1,20 @@
+require 'tamashii/agent/adapter/base'
+require 'tamashii/agent/device/fake_card_reader'
+
+module Tamashii
+  module Agent
+    module Adapter
+      class CardReader < Base
+        class << self
+          def real_class
+            MFRC522
+          end
+
+          def fake_class
+            Device::FakeCardReader
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tamashii/agent/buzzer.rb

@@ -0,0 +1,35 @@
+require 'tamashii/agent/component'
+require 'tamashii/agent/adapter/buzzer'
+
+module Tamashii
+  module Agent
+    class Buzzer < Component
+      def initialize
+        super
+        @buzzer = Adapter::Buzzer.object
+        logger.debug "Using buzzer instance: #{@buzzer.class}"
+      end
+
+      def process_event(ev_type, ev_body)
+        case ev_type
+        when EVENT_BEEP
+          logger.debug "Beep: #{ev_body}"
+          case ev_body
+          when "ok"
+            @buzzer.play_ok
+          when "no"
+            @buzzer.play_no
+          when "error"
+            @buzzer.play_error
+          end
+        end
+      end
+
+      def clean_up
+        super
+        @buzzer.stop
+      end
+    end
+  end
+end
+

data/lib/tamashii/agent/card_reader.rb

@@ -0,0 +1,57 @@
+require 'mfrc522'
+
+require 'tamashii/agent/component'
+require 'tamashii/agent/adapter/card_reader'
+
+
+module Tamashii
+  module Agent
+    class CardReader < Component
+      def initialize(master)
+        super()
+        @master = master
+        @reader = Adapter::CardReader.object
+        logger.debug "Using card_reader instance: #{@reader.class}"
+      end
+
+      # override
+      def worker_loop
+        loop do
+          handle_io
+          handle_card
+        end
+      end
+
+      def handle_io
+        ready = @selector.select(0.1)
+        ready.each { |m| m.value.call } if ready
+      end
+
+      def handle_card
+        # read card
+        return unless @reader.picc_request(MFRC522::PICC_REQA)
+
+        begin
+          uid, sak = @reader.picc_select
+          process_uid(uid.join("-"))
+        rescue CommunicationError, UnexpectedDataError => e
+          logger.error "Error when selecting card: #{e.message}"
+        rescue => e
+          logger.error "GemError when selecting card: #{e.message}"
+        end
+        @reader.picc_halt
+      end
+
+      def process_uid(uid)
+        logger.info "New card detected, UID: #{uid}"
+        @master.send_event(EVENT_CARD_DATA, uid)
+      end
+
+      # override
+      def process_event(ev_type, ev_body)
+        # silent is gold
+      end
+    end
+  end
+end
+

data/lib/tamashii/agent/common.rb

@@ -0,0 +1,13 @@
+require 'tamashii/agent/common/loggable'
+
+module Tamashii
+  module Agent
+    module Common
+    end
+    EVENT_BEEP = 1
+    EVENT_SYSTEM_COMMAND = 2
+    EVENT_AUTH_RESULT = 3
+    EVENT_CARD_DATA = 4
+    EVENT_CONNECTION_NOT_READY = 255
+  end
+end

data/lib/tamashii/agent/common/loggable.rb

@@ -0,0 +1,18 @@
+require 'tamashii/agent'
+
+module Tamashii
+  module Agent
+    module Common
+      module Loggable
+        def logger
+          Agent.logger.progname = self.progname
+          Agent.logger
+        end
+
+        def progname
+          @progname ||= ("%-10s" % self.class.to_s.split(":")[-1])
+        end
+      end
+    end
+  end
+end

data/lib/tamashii/agent/component.rb

@@ -0,0 +1,71 @@
+require 'nio'
+require 'tamashii/agent/common'
+
+module Tamashii
+  module Agent
+    class Component
+      include Common::Loggable
+
+      def initialize
+        @pipe_r, @pipe_w = IO.pipe
+      end
+
+      def send_event(type, body)
+        str = [type, body.bytesize].pack("Cn") + body
+        @pipe_w.write(str)
+      end
+
+      def receive_event
+        ev_type, ev_size = @pipe_r.read(3).unpack("Cn")
+        ev_body = @pipe_r.read(ev_size)
+        process_event(ev_type, ev_body)
+      end
+
+      def process_event(ev_type, ev_body)
+        logger.debug "Got event: #{ev_type}, #{ev_body}"
+      end
+
+      # worker
+      def run
+        @thr = Thread.start { run_worker_loop }
+      end
+
+      def run!
+        run_worker_loop
+      end
+      
+      def stop
+        logger.info "Stopping component"
+        @thr.exit if @thr
+        @thr = nil
+        clean_up
+      end
+
+      def clean_up
+      end
+
+      def run_worker_loop
+        create_selector
+        register_event_io
+        worker_loop
+      end
+
+      # a default implementation
+      def worker_loop
+        loop do
+          ready = @selector.select
+          ready.each { |m| m.value.call } if ready
+        end
+      end
+      
+      def register_event_io
+        _monitor = @selector.register(@pipe_r, :r)
+        _monitor.value = method(:receive_event)
+      end
+
+      def create_selector
+        @selector = NIO::Selector.new
+      end
+    end
+  end
+end

data/lib/tamashii/agent/config.rb

@@ -0,0 +1,26 @@
+require 'tamashii/common'
+module Tamashii
+  module Agent
+    class Config < Tamashii::Config
+      AUTH_TYPES = [:none, :token]
+
+      register :log_file, STDOUT
+      register :use_ssl, false
+      register :auth_type, :none
+      register :entry_point, "/tamashii"
+      register :manager_host, "localhost"
+      register :manager_port, 3000
+
+      def auth_type(type = nil)
+        return @auth_type ||= :none if type.nil?
+        return unless AUTH_TYPES.include?(type)
+        @auth_type = type.to_sym
+      end
+
+      def log_level(level = nil)
+        return Agent.logger.level if level.nil?
+        Agent.logger.level = level
+      end
+    end
+  end
+end

data/lib/tamashii/agent/connection.rb

@@ -0,0 +1,231 @@
+require 'socket'
+require 'websocket/driver'
+require 'aasm'
+
+require 'tamashii/common'
+
+require 'tamashii/agent/config'
+require 'tamashii/agent/component'
+require 'tamashii/agent/request_pool'
+
+require 'tamashii/agent/handler'
+
+module Tamashii
+  module Agent
+    class Connection < Component
+      include AASM
+
+      aasm do
+        state :init, initial: true
+        state :connecting
+        state :auth_pending
+        state :ready
+
+        event :connect do
+          transitions from: :init, to: :connecting, after: Proc.new { logger.info "Start connecting" }
+        end
+        
+        event :auth_request do
+          transitions from: :connecting, to: :auth_pending, after: Proc.new { logger.info "Sending authentication request" }
+        end
+        
+        event :auth_success do
+          transitions from: :auth_pending, to: :ready, after: Proc.new { logger.info "Authentication finished. Tag = #{@tag}" }
+        end
+
+        event :reset do
+          transitions to: :init, after: Proc.new { logger.info "Connection state reset" }
+        end
+      end
+
+      attr_reader :url
+      attr_reader :master
+      attr_reader :request_pool
+
+      def initialize(master, host, port)
+        super()
+        @master = master
+        @url = "#{Config.use_ssl ? "wss" : "ws"}://#{host}:#{port}/#{Config.entry_point}"
+        self.reset
+        
+        @host = host
+        @port = port
+        @tag = 0
+        
+        @request_pool = RequestPool.new
+        @request_pool.set_handler(:request_timedout, method(:handle_request_timedout))
+        @request_pool.set_handler(:request_meet, method(:handle_request_meet))
+        @request_pool.set_handler(:send_request, method(:handle_send_request))
+        
+        env_data = {connection: self}
+        Resolver.config do
+          [Type::REBOOT, Type::POWEROFF, Type::RESTART, Type::UPDATE].each do |type|
+            handle type,  Handler::System, env_data
+          end
+          handle Type::BUZZER_SOUND,  Handler::Buzzer, env_data
+          handle Type::RFID_RESPONSE_JSON,  Handler::RequestPoolResponse, env_data
+        end
+      end
+
+      def handle_request_timedout(req)
+        @master.send_event(EVENT_CONNECTION_NOT_READY, "Connection not ready for #{req.ev_type}:#{req.ev_body}")
+      end
+
+      def handle_request_meet(req, res)
+        logger.debug "Got packet: #{res.ev_type}: #{res.ev_body}"
+        case res.ev_type
+        when Type::RFID_RESPONSE_JSON
+          json = JSON.parse(res.ev_body)
+          handle_card_result(json)
+        else
+          logger.warn "Unhandled packet result: #{res.ev_type}: #{res.ev_body}"
+        end
+      end
+
+      def handle_card_result(result)
+        if result["auth"]
+          @master.send_event(EVENT_BEEP, "ok")
+        else
+          @master.send_event(EVENT_BEEP, "no")
+        end
+      end
+
+      def handle_send_request(req)
+        if self.ready?
+          @driver.binary(Packet.new(req.ev_type, @tag, req.wrap_body).dump)
+          true
+        else
+          false
+        end
+      end
+
+      # override
+      def worker_loop
+        loop do
+          @request_pool.update
+          ready = @selector.select(1)
+          ready.each { |m| m.value.call } if ready
+          if @io.nil?
+            @io = try_create_socket
+            if @io
+              # socket io opened
+              register_socket_io
+              # start ws
+              start_web_driver
+            end
+          end
+        end
+      end
+
+      def send_auth_request
+        # TODO: other types of auth 
+        @driver.binary(Packet.new(Type::AUTH_TOKEN, 0, [Type::CLIENT[:agent], @master.serial_number,Config.token].join(",")).dump)
+      end
+
+      def start_web_driver
+        @driver = WebSocket::Driver.client(self)
+        @driver.on :open, proc { |e| 
+          logger.info "Server opened"
+          self.auth_request
+          send_auth_request
+        }
+        @driver.on :close, proc { |e| 
+          logger.info "Server closed"
+          close_socket_io
+          self.reset
+        }
+        @driver.on :message, proc { |e|
+          pkt = Packet.load(e.data)
+          process_packet(pkt) if pkt
+        }
+        @driver.start
+        self.connect
+      end
+
+      def register_socket_io
+        _monitor = @selector.register(@io, :r)
+        _monitor.value = proc do
+          begin
+            msg = @io.recv_nonblock(65535)
+            if msg.empty?
+              # socket closed
+              logger.info "No message received from server. Connection reset"
+              close_socket_io
+              self.reset
+              sleep 1
+            else
+              @driver.parse(msg)
+            end
+          rescue => e
+            logger.error "#{e.message}"
+            logger.debug "Backtrace:"
+            e.backtrace.each {|msg| logger.debug msg}
+          end
+        end
+      end
+
+      def try_create_socket
+        logger.info "try to open socket..."
+        TCPSocket.new(@host, @port)
+      rescue
+        nil
+      end
+
+      def close_socket_io
+        logger.info "Socket IO Closed and Deregistered"
+        @selector.deregister(@io)
+        @io.close
+        @io = nil
+      end
+
+      def write(string)
+        @io.write(string)
+      rescue
+        logger.error "Write Error"
+        close_socket_io
+        self.reset
+      end
+
+      def process_packet(pkt)
+        if self.auth_pending?
+          if pkt.type == Type::AUTH_RESPONSE
+            if pkt.body == Packet::STRING_TRUE
+              @tag = pkt.tag
+              self.auth_success
+            else
+              logger.error "Authentication failed. Delay for 3 seconds"
+              sleep 3
+            end
+          else
+            logger.error "Authentication error: Not an authentication result packet"
+          end
+        else
+          if pkt.tag == @tag || pkt.tag == 0
+            Resolver.resolve(pkt) 
+          else
+            logger.debug "Tag mismatch packet: tag: #{pkt.tag}, type: #{pkt.type}"
+          end
+        end
+      end
+
+      def process_event(ev_type, ev_body)
+        case ev_type
+        when EVENT_CARD_DATA
+          req = RequestPool::Request.new(Type::RFID_NUMBER , ev_body, ev_body)
+          @request_pool.add_request(req)
+        end
+      end
+
+      def clean_up
+        super
+        if @io
+          @driver.close
+          close_socket_io
+        end
+      rescue => e
+        logger.warn "Error occured when clean up: #{e.to_s}"
+      end
+    end
+  end
+end
+