smartware 0.1.30 → 0.2

data/lib/smartware/drivers/watchdog/dummy.rb

@@ -0,0 +1,29 @@
+module Smartware
+  module Driver
+    module Watchdog
+
+      class Dummy
+
+        def initialize(config)
+
+        end
+
+        def model
+          "Dummy watchdog"
+        end
+
+        def version
+          ""
+        end
+
+        def reboot_modem
+
+        end
+
+        def error
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/smartware/drivers/watchdog/watchdog_daemon.rb

@@ -0,0 +1,40 @@
+module Smartware
+  module Driver
+    module Watchdog
+
+      class WatchdogDaemon
+
+        attr_reader :error
+
+        def initialize(config)
+          @error = nil
+          @config = config
+        end
+
+        def model
+          "watchdogd-controlled watchdog"
+        end
+
+        def version
+          ""
+        end
+
+        def reboot_modem
+          begin
+            File.open(@config["pidfile"], "r") do |io|
+              pid = io.read.to_i
+
+              Process.kill :USR1, pid
+            end
+
+            @error = nil
+          rescue => e
+            Smartware::Logging.logger.warn "Watchdog communication error: #{e}"
+
+            @error = Interface::Watchdog::WATCHDOG_NOT_AVAILABLE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smartware/interfaces/cash_acceptor.rb

@@ -1,142 +1,187 @@
-require 'drb'
-
 module Smartware
   module Interface
+    class CashAcceptor < Interface
+
+      DROP_CASETTE_FULL = 1
+      DROP_CASETTE_OUT_OF_POSITION = 2
+      VALIDATOR_JAMMED = 3
+      DROP_CASETTE_JAMMED = 4
+      CHEATED = 5
+      PAUSE = 6
+      BILL_VALIDATOR_FAILURE = 7
+      STACK_MOTOR_FAILURE = 8
+      TRANSPORT_MOTOR_SPEED_FAILURE = 9
+      TRANSPORT_MOTOR_FAILURE = 10
+      ALIGNING_MOTOR_FAILURE = 11
+      INITIAL_CASETTE_STATUS_FAILURE = 12
+      OPTIC_CANAL_FAILURE = 13
+      MAGNETIC_CANAL_FAILURE = 14
+      CAPACITANCE_CANAL_FAILURE = 15
+      COMMUNICATION_ERROR = 16
+
+      def initialize(config)
+        super
+
+        @limit = nil
+        @banknotes = {}
+        @banknotes.default = 0
 
-    module CashAcceptor
-
-      #
-      # Init vars
-      #
-      @configured = false
-      @no_limit = true
-      @banknotes = {}
-      @commands = %w(monitor)
-      @status = { :cassette => true }
-
-      #
-      # (re)configure device
-      #
-      def self.configure!(port=nil, driver=nil)
-        @device = Smartware::Driver::CashAcceptor.const_get(
-            Smartware::Service.config['cash_acceptor_driver']).new(
-            Smartware::Service.config['cash_acceptor_port'])
-        @session.kill if @session and @session.alive?
-		    @commands = %w(monitor)
-        @device.cancel_accept
-        @session = self.start_poll!
+        update_status do
+          @status[:casette] = true
+        end
+
+        @accepting = false
+        @commands = Queue.new
+        @commands.push :close
+
+        Thread.new &method(:dispatch_commands)
+        Thread.new &method(:periodic)
         Smartware::Logging.logger.info "Cash acceptor monitor started"
-        @configured = true
-      rescue => e
-        @configured = false
-        Smartware::Logging.logger.error e.message
-        Smartware::Logging.logger.error e.backtrace.join("\n")
       end
 
-      def self.open_session(limit_min, limit_max)
-        @commands << 'open'
-        @banknotes = {}
-        if !limit_min.nil? && !limit_max.nil?
-          @no_limit = false
-          @limit_min = limit_min
-          @limit_max = limit_max
+      def open_session(limit_min, limit_max)
+        @banknotes.clear
+
+        if limit_min.nil? || limit_max.nil?
+          @limit = nil
+
+          Smartware::Logging.logger.info "Session open, unlimited"
         else
-          @no_limit = true
+          @limit = limit_min..limit_max
+
+          Smartware::Logging.logger.info "Session open, limit: #{@limit}"
         end
+
+        @commands.push :open
+        @commands.push :get_money
       end
 
-      def self.close_session
-        @commands << 'close'
-        @limit_min = nil
-        @limit_max = nil
-        @no_limit = true
+      def close_session
+        Smartware::Logging.logger.info "Session closed"
+
+        @commands.push :close
+        @limit = nil
       end
 
-      def self.configured?
-        @configured
+      def banknotes
+        update_status { @banknotes }
       end
 
-      def self.error
-        @status[:error] || ''
+      def cashsum
+        self.banknotes.inject(0) do |result, (key, value)|
+          result + key.to_i * value.to_i
+        end
       end
 
-      def self.status
-        @status
+      private
+
+      def limit_satisfied(sum)
+        @limit.nil? or @limit.include? sum
       end
 
-      def self.model
-        @status[:model]
+      def execute_open
+        @device.reset
+        @device.accept
+        Smartware::Logging.logger.info "Cash acceptor open"
+
+        @accepting = true
       end
 
-      def self.version
-        @status[:version]
+      def execute_get_money
+        res = @device.current_banknote
+
+        case res
+        when Integer
+          if limit_satisfied(self.cashsum + res)
+            @device.stack
+            update_status do
+              @banknotes[res] += 1
+            end
+            Smartware::Logging.logger.info "Cash acceptor bill stacked, #{res}"
+          else
+            @device.return
+            Smartware::Logging.logger.info "Cash acceptor limit violation, return #{res}"
+          end
+
+        when String
+          Smartware::Logging.logger.error "Cash acceptor error #{res}"
+
+          update_status do
+            @status[:error] = res
+          end
+        end
+
+        if !@limit.nil? && @limit.end > 0 && @limit.end == self.cashsum
+          # Close cash acceptor if current cashsum equal max-limit
+
+          execute_close
+        end
       end
 
-      def self.cashsum
-        @banknotes.inject(0){ |result, (key, value)| result + key.to_i*value.to_i }
+      def execute_close
+        @device.cancel_accept
+        Smartware::Logging.logger.info "Cash acceptor close"
+
+        @accepting = false
       end
 
-      def self.banknotes
-        @banknotes
+      def execute_monitor
+
+        error = @device.error || ''
+        model = @device.model
+        version = @device.version
+        cassette = @device.cassette?
+
+        update_status do
+          @status[:error] = error
+          @status[:model] = model
+          @status[:version] = version
+          @status[:cassette] = cassette
+        end
       end
 
-      #
-      # Session private method
-      #
-      private
-        def self.start_poll!
-          t = Thread.new do
-            loop do
-              case @commands[0]
-                when 'open'
-                  @device.reset
-                  @device.accept
-                  Smartware::Logging.logger.info "Cash acceptor open: #{@commands}"
-
-                  @commands.shift
-                  @commands << 'get_money'
-                when 'get_money'
-                  res = @device.current_banknote
-                  if res.is_a? Integer # Have a banknote
-                    if @no_limit or (@limit_min..@limit_max).include?(self.cashsum + res)
-                      @device.stack
-                      @banknotes[res] = (@banknotes[res]||0) + 1
-                      Smartware::Logging.logger.info "Cash acceptor bill stacked, #{res}"
-                    else
-                      @device.return
-                      Smartware::Logging.logger.info "Cash acceptor limit violation, return #{res}"
-                    end
-                  elsif res.is_a? String # Have a error, errors always as String
-                    Smartware::Logging.logger.error "Cash acceptor error #{res}"
-                    @status[:error] = res
-                  end
-                  @device.cancel_accept if !@no_limit && (@limit_max == self.cashsum and @limit_max > 0) # Close cash acceptor if current cashsum equal max-limit
-
-                  @commands.shift
-                  @commands << 'get_money' if @commands.empty?
-                when 'close'
-                  @device.cancel_accept
-                  Smartware::Logging.logger.info "Cash acceptor close: #{@commands}"
-
-                  @commands.shift
-                when 'monitor'
-                  @status[:error] = @device.error || ''
-                  @status[:model] = @device.model
-                  @status[:version] = @device.version
-                  @status[:cassette] = @device.cassette?
-                  @commands.shift
-                else
-                  @commands << 'monitor'
-              end
-              sleep 0.5
+      def dispatch_commands
+        loop do
+          command = @commands.pop
+
+          begin
+            start = Time.now
+
+            send :"execute_#{command}"
+
+            complete = Time.now
+            if complete - start > 1
+              Smartware::Logging.logger.warn "#{command} has been running for #{complete - start} seconds."
+            end
+
+          rescue => e
+            Smartware::Logging.logger.error "Execution of #{command} failed:"
+            Smartware::Logging.logger.error e.to_s
+            e.backtrace.each do |line|
+              Smartware::Logging.logger.error line
             end
           end
         end
+      end
+
+      def periodic
+        loop do
+          begin
+            if @commands.empty?
+              @commands.push :monitor
+              @commands.push :get_money if @accepting
+            end
 
-      self.configure!
+            sleep 0.5
+          rescue => e
+            Smartware::Logging.logger.error "Error in periodic failed:"
+            Smartware::Logging.logger.error e.to_s
+            e.backtrace.each do |line|
+              Smartware::Logging.logger.error line
+            end
+          end
+        end
+      end
     end
   end
 end
-
-DRb.start_service('druby://localhost:6001', Smartware::Interface::CashAcceptor)
-DRb.thread.join

data/lib/smartware/interfaces/interface.rb

@@ -0,0 +1,47 @@
+module Smartware
+  module Interface
+    class Interface
+      attr_reader :config
+
+      def initialize(config)
+        @config = config
+        @status_mutex = Mutex.new
+        @status = {
+          model: '',
+          version: ''
+        }
+
+        iface = @config["name"]
+        driver = @config["driver"]
+
+        require "smartware/drivers/#{iface.underscore}/#{driver.underscore}"
+
+        @device = Smartware::Driver.const_get(iface.to_s)
+                                   .const_get(driver.to_s)
+                                   .new(config)
+      end
+
+      def error
+        self.status[:error]
+      end
+
+      def model
+        self.status[:model]
+      end
+
+      def version
+        self.status[:version]
+      end
+
+      def status
+        @status_mutex.synchronize { @status }
+      end
+
+      protected
+
+      def update_status(&block)
+        @status_mutex.synchronize &block
+      end
+    end
+  end
+end

data/lib/smartware/interfaces/modem.rb

@@ -1,78 +1,49 @@
-require 'drb'
-
 module Smartware
   module Interface
+    class Modem < Interface
+      MODEM_NOT_AVAILABLE = 1
 
-    module Modem
-      @configured = false
-      @status = {}
-
-      def self.configure!
-        Smartware::Logging.logger.debug "Creating modem"
-        @device = Smartware::Driver::Modem.const_get(
-            Smartware::Service.config['modem_driver']).new(
-            Smartware::Service.config['modem_config'])
-        Smartware::Logging.logger.debug "Starting modem"
-        @session.kill if @session
-        @session = self.poll_status!
-        @configured = true
-        Smartware::Logging.logger.info 'Modem monitor started'
-        @status = {}
-      rescue => e
-        Smartware::Logging.logger.error e.message
-        Smartware::Logging.logger.error e.backtrace.join("\n")
-        @configured = false
-      end
-
-      def self.configured?
-        @configured
-      end
-
-      def self.error
-        @status[:error]
-      end
+      def initialize(config)
+        super
 
-      def self.model
-        @status[:model]
-      end
+        update_status do
+          @status[:balance] = ''
+          @status[:signal_level] = ''
+        end
 
-      def self.version
-        @status[:version]
+        @session = Thread.new &method(:poll)
+        Smartware::Logging.logger.info 'Modem monitor started'
       end
 
-      def self.balance
-        @status[:balance]
+      def balance
+        self.status[:balance]
       end
 
-      def self.signal_level
-        @status[:signal_level]
+      def signal_level
+        self.status[:signal_level]
       end
 
       private
-        def self.poll_status!
-          t = Thread.new do
-            begin
-              loop do
-                @device.tick
 
-                @status[:signal_level] = @device.signal_level
-                @status[:model] = @device.model
-                @status[:version] = @device.version
-                @status[:error] = @device.error || ''
-                @status[:balance] = @device.balance
-              end
-            rescue => e
-              Smartware::Logging.logger.error e.message
-              Smartware::Logging.logger.error e.backtrace.join("\n")
+      def poll
+        begin
+          loop do
+            @device.tick
+
+            update_status do
+              @status[:signal_level] = @device.signal_level
+              @status[:model] = @device.model
+              @status[:version] = @device.version
+              @status[:error] = @device.error || ''
+              @status[:balance] = @device.balance
             end
           end
+        rescue => e
+          Smartware::Logging.logger.error e.message
+          Smartware::Logging.logger.error e.backtrace.join("\n")
         end
-
-      self.configure!
+      end
     end
   end
 end
 
-DRb.start_service('druby://localhost:6002', Smartware::Interface::Modem)
-DRb.thread.join
-