ruby_ami 1.3.4 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87d233c2b2c4e712089b0f2ce6c1f6ef75b877cf
-  data.tar.gz: f04dff4a31a2b235babc6c8ab3c0ae5561574841
+  metadata.gz: cb7606f130bf3753537649990fbc188a62b31441
+  data.tar.gz: eef9574ee77d8721fb9b480978595ec412a82857
 SHA512:
-  metadata.gz: d462a5e08948fdd719b76929d60da79983bafa4d4b9bc9155bc787a0937ec3ba930fffd91886f344a40944410186ddd6078b2b732e0d1c3356066a3786f23feb
-  data.tar.gz: 7e2a487f30a366182462c0301960d864dadfa17235721038d1e261062c79646fde4d16f1c08ce4ff4ad52bdccf648cf2c59b4aa0ab5a74c394d39c8c90fdc973
+  metadata.gz: 29b7868e1c9e4a99babf6a169b97741b53ea05dfa5b8a0d31de0caa6e919912b8aab09863ec3c874c6e2fabec9e674789e9524212117a64c198b4b9799eba34e
+  data.tar.gz: 4213b880af9d91452b351b15ee5d55261e00954bacd79632f04467343e52371a1ee725d301216046d01ed83005b7f23e90eb8adce24ef63c94c9dce289be075e

data/.travis.yml

@@ -2,6 +2,7 @@ language: ruby
 rvm:
   - 1.9.2
   - 1.9.3
+  - 2.0.0
   - jruby-19mode
   - rbx-19mode
   - ruby-head

data/CHANGELOG.md

@@ -1,7 +1,10 @@
 # [develop](https://github.com/adhearsion/ruby_ami)
 
-# [1.3.4](https://github.com/adhearsion/ruby_ami/compare/v1.3.3...v1.3.4) - [2013-04-25](https://rubygems.org/gems/ruby_ami/versions/1.3.4)
-  * Bugfix: Handle AGI 5xx responses
+# [2.0.0](https://github.com/adhearsion/ruby_ami/compare/v1.3.3...v2.0.0) - [2013-04-15](https://rubygems.org/gems/ruby_ami/versions/2.0.0)
+  * Major refactoring for simplification and performance
+  * Actions are no longer synchronised on the wire since ActionID is now a reliable method of response/event association
+  * Callbacks are no longer required. #send_action now simply blocks waiting for a response
+  * Client still starts up two Streams, one for actions and one for events, but only for possible performance gains. It is possible to use Stream directly since it now does its own login and response association. Client is a very thin routing layer. It's encouraged that if you expect low traffic, you should use Stream directly. Client may be removed in v3.0.
 
 # [1.3.3](https://github.com/adhearsion/ruby_ami/compare/v1.3.2...v1.3.3) - [2013-04-09](https://rubygems.org/gems/ruby_ami/versions/1.3.3)
   * Bugfix: DBGet actions are now not terminated specially

data/README.md

@@ -1,5 +1,5 @@
 # RubyAMI [![Build Status](https://secure.travis-ci.org/adhearsion/ruby_ami.png?branch=master)](http://travis-ci.org/adhearsion/ruby_ami)
-RubyAMI is an AMI client library in Ruby and based on EventMachine with the sole purpose of providing an connection to the Asterisk Manager Interface. RubyAMI does not provide any features beyond connection management and protocol parsing. Actions are sent over the wire, and responses come back via callbacks. It's up to you to match these up into something useful. In this regard, RubyAMI is very similar to [Blather](https://github.com/sprsquish/blather) for XMPP or [Punchblock](https://github.com/adhearsion/punchblock), the Ruby 3PCC library. In fact, Punchblock uses RubyAMI under the covers for its Asterisk implementation, including an implementation of AsyncAGI.
+RubyAMI is an AMI client library in Ruby and based on EventMachine with the sole purpose of providing a connection to the Asterisk Manager Interface. RubyAMI does not provide any features beyond connection management and protocol parsing. Actions are sent over the wire, and responses are returned. Events are passed to a callback you define. It's up to you to match these up into something useful. In this regard, RubyAMI is very similar to [Blather](https://github.com/sprsquish/blather) for XMPP or [Punchblock](https://github.com/adhearsion/punchblock), the Ruby 3PCC library. In fact, Punchblock uses RubyAMI under the covers for its Asterisk implementation, including an implementation of AsyncAGI.
 
 NB: If you're looking to develop an application on Asterisk, you should take a look at the [Adhearsion](http://adhearsion.com) framework first. This library is much lower level.
 
@@ -10,31 +10,30 @@ NB: If you're looking to develop an application on Asterisk, you should take a l
 ```ruby
 require 'ruby_ami'
 
-include RubyAMI
-
-client = Client.new :username       => 'test',
-                    :password       => 'test',
-                    :host           => '127.0.0.1',
-                    :port           => 5038,
-                    :event_handler  => lambda { |e| handle_event e },
-                    :logger         => Logger.new(STDOUT),
-                    :log_level      => Logger::DEBUG,
-                    :timeout        => 10 
+client = RubyAMI::Client.new username: 'test',
+                        password:      'test',
+                        host:          '127.0.0.1',
+                        port:          5038,
+                        event_handler: ->(e) { handle_event e },
+                        logger:        Logger.new(STDOUT),
+                        log_level:     Logger::DEBUG,
+                        timeout:       10
 
 def handle_event(event)
   case event.name
   when 'FullyBooted'
-    client.send_action 'Originate', 'Channel' => 'SIP/foo'
+    client.async.send_action 'Originate', 'Channel' => 'SIP/foo'
   end
 end
 
 client.start
+
+Celluloid::Actor.join client
 ```
 
 ## Development Requirements
 
-ruby_ami uses [ragel](http://www.complang.org/ragel/) to generate some of it's
-files.
+ruby_ami uses [ragel](http://www.complang.org/ragel/) to generate some of it's files.
 
 On OS X (if you use homebrew):
 
@@ -64,4 +63,4 @@ Once you are inside the repository, before anything else, you will want to run:
 
 ## Copyright
 
-Copyright (c) 2011 Ben Langfeld, Jay Phillips. MIT licence (see LICENSE for details).
+Copyright (c) 2013 Ben Langfeld, Jay Phillips. MIT licence (see LICENSE for details).

data/features/support/lexer_helper.rb

@@ -1,5 +1,23 @@
 FIXTURES = YAML.load_file File.dirname(__FILE__) + "/ami_fixtures.yml"
 
+class Object
+  def metaclass
+    class << self
+      self
+    end
+  end
+
+  def meta_eval(&block)
+    metaclass.instance_eval &block
+  end
+
+  def meta_def(name, &block)
+    meta_eval do
+      define_method name, &block
+    end
+  end
+end
+
 def fixture(path, overrides = {})
   path_segments = path.split '/'
   selected_event = path_segments.inject(FIXTURES.clone) do |hash, segment|

data/lib/ruby_ami/action.rb

@@ -1,8 +1,6 @@
 module RubyAMI
   class Action
-    attr_reader :name, :headers, :action_id
-
-    attr_accessor :state
+    attr_reader :name, :headers, :action_id, :response
 
     CAUSAL_EVENT_NAMES = %w[queuestatus sippeers iaxpeers parkedcalls dahdishowchannels coreshowchannels
                             dbget status agents konferencelist confbridgelist confbridgelistrooms] unless defined? CAUSAL_EVENT_NAMES
@@ -11,19 +9,14 @@ module RubyAMI
       @name       = name.to_s.downcase.freeze
       @headers    = headers.freeze
       @action_id  = RubyAMI.new_uuid
-      @response   = FutureResource.new
-      @response_callback = block
-      @state      = :new
+      @response   = nil
+      @complete   = false
       @events     = []
-      @event_lock = Mutex.new
-    end
-
-    [:new, :sent, :complete].each do |state|
-      define_method("#{state}?") { @state == state }
+      @callback   = block
     end
 
-    def replies_with_action_id?
-      !UnsupportedActionName::UNSUPPORTED_ACTION_NAMES.include? name
+    def complete?
+      @complete
     end
 
     ##
@@ -71,46 +64,20 @@ module RubyAMI
       )
     end
 
-    #
-    # If the response has simply not been received yet from Asterisk, the calling Thread will block until it comes
-    # in. Once the response comes in, subsequent calls immediately return a reference to the ManagerInterfaceResponse
-    # object.
-    #
-    def response(timeout = nil)
-      @response.resource(timeout).tap do |resp|
-        raise resp if resp.is_a? Exception
-      end
-    end
-
-    def response=(other)
-      @state = :complete
-      @response.resource = other
-      @response_callback.call other if @response_callback
-    end
-
     def <<(message)
       case message
       when Error
         self.response = message
+        complete!
       when Event
         raise StandardError, 'This action should not trigger events. Maybe it is now a causal action? This is most likely a bug in RubyAMI' unless has_causal_events?
-        @event_lock.synchronize do
-          @events << message
-        end
-        self.response = @pending_response if message.name.downcase == causal_event_terminator_name
+        response.events << message
+        complete! if message.name.downcase == causal_event_terminator_name
       when Response
-        if has_causal_events?
-          @pending_response = message
-        else
-          self.response = message
-        end
-      end
-    end
-
-    def events
-      @event_lock.synchronize do
-        @events.dup
+        self.response = message
+        complete! unless has_causal_events?
       end
+      self
     end
 
     def eql?(other)
@@ -118,28 +85,15 @@ module RubyAMI
     end
     alias :== :eql?
 
-    def sync_timeout
-      name.downcase == 'originate' && !headers[:async] ? 60 : 10
-    end
+    private
 
-    ##
-    # This class will be removed once this AMI library fully supports all known protocol anomalies.
-    #
-    class UnsupportedActionName < ArgumentError
-      UNSUPPORTED_ACTION_NAMES = %w[queues] unless defined? UNSUPPORTED_ACTION_NAMES
-
-      # Blacklist some actions depends on the Asterisk version
-      def self.preinitialize(version)
-        if version < 1.8
-          %w[iaxpeers muteaudio mixmonitormute aocmessage].each do |action|
-            UNSUPPORTED_ACTION_NAMES << action
-          end
-        end
-      end
+    def response=(other)
+      @response = other
+    end
 
-      def initialize(name)
-        super "At the moment this AMI library doesn't support the #{name.inspect} action because it causes a protocol anomaly. Support for it will be coming shortly."
-      end
+    def complete!
+      @complete = true
+      @callback.call response if @callback
     end
   end
 end # RubyAMI

data/lib/ruby_ami/agi_result_parser.rb

@@ -4,7 +4,7 @@ module RubyAMI
   class AGIResultParser
     attr_reader :code, :result, :data
 
-    FORMAT          = /^(?<code>\d{3})( result=(?<result>-?\d*))? ?(?<data>\(?.*\)?)?$/.freeze
+    FORMAT          = /^(?<code>\d{3}) result=(?<result>-?\d*) ?(?<data>\(?.*\)?)?$/.freeze
     DATA_KV_FORMAT  = /(?<key>[\w\d]+)=(?<value>[\w\d]*)/.freeze
     DATA_CLEANER    = /(^\()|(\)$)/.freeze
 
@@ -31,7 +31,7 @@ module RubyAMI
 
     def parse
       @code = match[:code].to_i
-      @result = match[:result] ? match[:result].to_i : nil
+      @result = match[:result].to_i
       @data = match[:data] ? match[:data].gsub(DATA_CLEANER, '').freeze : nil
     end
 

data/lib/ruby_ami/client.rb

@@ -1,44 +1,19 @@
 # encoding: utf-8
 module RubyAMI
   class Client
-    attr_reader :options, :action_queue, :events_stream, :actions_stream
+    include Celluloid
 
-    def initialize(options)
-      @options          = options
-      @logger           = options[:logger] || Logger.new(STDOUT)
-      @logger.level     = options[:log_level] || Logger::DEBUG if @logger
-      @event_handler    = @options[:event_handler]
-      @state            = :stopped
-
-      if RubyAMI.rbx?
-        logger.warn 'The "timeout" parameter is not supported when using Rubinius'
-      end
-
-      stop_writing_actions
-
-      @pending_actions  = {}
-      @sent_actions     = {}
-      @actions_lock     = Mutex.new
-
-      @action_queue = GirlFriday::WorkQueue.new(:actions, :size => 1, :error_handler => ErrorHandler) do |action|
-        @actions_write_blocker.wait
-        _send_action action
-        begin
-          action.response action.sync_timeout
-        rescue Timeout::Error => e
-          logger.error "Timed out waiting for a response to #{action}"
-        rescue RubyAMI::Error
-          nil
-        end
-      end
+    trap_exit :stream_died
 
-      @message_processor = GirlFriday::WorkQueue.new(:messages, :size => 1, :error_handler => ErrorHandler) do |message|
-        handle_message message
-      end
+    attr_reader :events_stream, :actions_stream
 
-      @event_processor = GirlFriday::WorkQueue.new(:events, :size => 2, :error_handler => ErrorHandler) do |event|
-        handle_event event
-      end
+    def initialize(options)
+      @options        = options
+      @event_handler  = @options[:event_handler]
+      @state          = :stopped
+      client          = current_actor
+      @events_stream  = new_stream ->(event) { client.async.handle_event event }
+      @actions_stream = new_stream ->(message) { client.async.handle_message message }
     end
 
     [:started, :stopped, :ready].each do |state|
@@ -46,162 +21,56 @@ module RubyAMI
     end
 
     def start
-      @events_stream  = new_stream lambda { |event| @event_processor << event }
-      @actions_stream = new_stream lambda { |message| @message_processor << message }
-      streams.each { |stream| stream.async.run }
+      @events_stream.async.run
+      @actions_stream.async.run
       @state = :started
-      streams.each { |s| Celluloid::Actor.join s }
-    end
-
-    def stop
-      streams.each do |stream|
-        begin
-          stream.terminate if stream.alive?
-        rescue => e
-          logger.error e if logger
-        end
-      end
     end
 
-    def send_action(action, headers = {}, &block)
-      (action.is_a?(Action) ? action : Action.new(action, headers, &block)).tap do |action|
-        logger.trace "[QUEUE]: #{action.inspect}" if logger
-        register_pending_action action
-        action_queue << action
-      end
+    def send_action(*args)
+      actions_stream.send_action *args
     end
 
     def handle_message(message)
-      logger.trace "[RECV-ACTIONS]: #{message.inspect}" if logger
+      logger.trace "[RECV-ACTIONS]: #{message.inspect}"
       case message
       when Stream::Connected
-        login_actions
+        send_action 'Events', 'EventMask' => 'Off'
       when Stream::Disconnected
-        stop_writing_actions
-        stop
       when Event
-        action = @current_action_with_causal_events
-        if action
-          message.action = action
-          action << message
-          @current_action_with_causal_events = nil if action.complete?
-        else
-          if message.name == 'FullyBooted'
-            pass_event message
-            start_writing_actions
-          else
-            raise StandardError, "Got an unexpected event on actions socket! This AMI command may have a multi-message response. Try making Adhearsion treat it as causal action #{message.inspect}"
-          end
-        end
-      when Response, Error
-        action = sent_action_with_id message.action_id
-        raise StandardError, "Received an AMI response with an unrecognized ActionID!! This may be an bug! #{message.inspect}" unless action
-        message.action = action
-
-        # By this point the write loop will already have started blocking by calling the response() method on the
-        # action. Because we must collect more events before we wake the write loop up again, let's create these
-        # instance variable which will needed when the subsequent causal events come in.
-        @current_action_with_causal_events = action if action.has_causal_events?
-
-        action << message
+        pass_event message
       end
     end
 
     def handle_event(event)
-      logger.trace "[RECV-EVENTS]: #{event.inspect}" if logger
+      logger.trace "[RECV-EVENTS]: #{event.inspect}"
       case event
-      when Stream::Connected
-        login_events
-      when Stream::Disconnected
-        stop
+      when Stream::Connected, Stream::Disconnected
       else
         pass_event event
       end
     end
 
-    def _send_action(action)
-      logger.trace "[SEND]: #{action.inspect}" if logger
-      transition_action_to_sent action
-      actions_stream.send_action action
-      action.state = :sent
-      action
-    end
-
     private
 
     def pass_event(event)
       @event_handler.call event if @event_handler.respond_to? :call
     end
 
-    def register_pending_action(action)
-      @actions_lock.synchronize do
-        @pending_actions[action.action_id] = action
-      end
-    end
-
-    def transition_action_to_sent(action)
-      @actions_lock.synchronize do
-        @pending_actions.delete action.action_id
-        @sent_actions[action.action_id] = action
-      end
-    end
-
-    def sent_action_with_id(action_id)
-      @actions_lock.synchronize do
-        @sent_actions.delete action_id
-      end
-    end
-
-    def start_writing_actions
-      @actions_write_blocker.countdown!
-    end
-
-    def stop_writing_actions
-      @actions_write_blocker = CountDownLatch.new 1
-    end
-
-    def login_actions
-      action = login_action do |response|
-        pass_event response if response.is_a? Error
-        send_action 'Events', 'EventMask' => 'Off'
-      end
-
-      register_pending_action action
-      Thread.new { _send_action action }
-    end
-
-    def login_events
-      login_action.tap do |action|
-        events_stream.send_action action
-      end
-    end
-
-    def login_action(&block)
-      Action.new 'Login',
-                 'Username' => options[:username],
-                 'Secret'   => options[:password],
-                 'Events'   => 'On',
-                 &block
+    def new_stream(callback)
+      Stream.new_link @options[:host], @options[:port], @options[:username], @options[:password], callback, logger, @options[:timeout]
     end
 
-    def new_stream(callback)
-      Stream.new @options[:host], @options[:port], callback, logger, @options[:timeout]
+    def stream_died(stream, reason = nil)
+      terminate
     end
 
     def logger
       super
-    rescue NoMethodError
-      @logger
-    end
-
-    def streams
-      [actions_stream, events_stream].compact
-    end
-
-    class ErrorHandler
-      def handle(error)
-        puts error.message
-        puts error.backtrace.join("\n")
+    rescue
+      @logger ||= begin
+        logger = Logger
+        logger.define_singleton_method :trace, logger.method(:debug)
+        logger
       end
     end
   end

data/lib/ruby_ami/error.rb

@@ -3,8 +3,8 @@ module RubyAMI
   class Error < StandardError
     attr_accessor :message, :action
 
-    def initialize
-      @headers = Hash.new
+    def initialize(headers = {})
+      @headers = headers
     end
 
     def [](key)

data/lib/ruby_ami/event.rb

@@ -5,8 +5,8 @@ module RubyAMI
   class Event < Response
     attr_reader :name
 
-    def initialize(name)
-      super()
+    def initialize(name, headers = {})
+      super headers
       @name = name
     end
 

data/lib/ruby_ami/response.rb

@@ -3,8 +3,6 @@ module RubyAMI
   ##
   # This is the object containing a response from Asterisk.
   #
-  # Note: not all responses have an ActionID!
-  #
   class Response
     class << self
       def from_immediate_response(text)
@@ -14,12 +12,12 @@ module RubyAMI
       end
     end
 
-    attr_accessor :action,
-                  :text_body  # For "Response: Follows" sections
-    attr_reader   :events
+    attr_accessor :text_body, # For "Response: Follows" sections
+                  :events
 
-    def initialize
-      @headers = Hash.new
+    def initialize(headers = {})
+      @headers = headers
+      @events = []
     end
 
     def has_text_body?
@@ -47,7 +45,7 @@ module RubyAMI
     end
 
     def inspect_attributes
-      [:headers, :text_body, :events, :action]
+      [:headers, :text_body, :events]
     end
 
     def eql?(o, *fields)