rami 0.1

data/LICENSE

@@ -0,0 +1,26 @@
+# Copyright (c) 2005, Chris Ochs
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#    * Redistributions of source code must retain the above copyright notice,
+#       this list of conditions and the following disclaimer.
+#    * Redistributions in binary form must reproduce the above copyright notice,
+#       this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#    * Neither the name of Chris Ochs nor the names of its contributors
+#       may be used to endorse or promote products derived from this software
+#       without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/README

@@ -0,0 +1,3 @@
+
+
+Documentation is in rdoc.  For a quick start look at bin/server.rb and bin/test.rb.

data/bin/server.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby -w
+
+require 'rubygems'
+require 'rami'
+include Rami
+
+server = RamiServer.new
+
+## if you want all events printed to the console set this to 1
+server.console =1
+
+## The username and secret used to login to the Asterisk manager interface
+server.username = 'asterisk'
+server.secret = 'secret'
+
+## The host and port that the manager interface is running on.  
+server.host = 'localhost'
+server.port = 5038  
+
+## DRb URI
+drburi = "druby://localhost:9000"
+
+server.run
+
+DRb.start_service(drburi, server)
+DRb.thread.join
+

data/bin/test.rb

@@ -0,0 +1,144 @@
+#!/usr/bin/env ruby -w
+
+require 'rubygems'
+require 'rami'
+include Rami
+
+def print_results(t)
+  if t.size > 0
+    t.each do |array|
+      array.each {|key,value| puts "#{key}: #{value}"}
+    end
+  end
+  puts "\n\n"
+end
+
+client = RamiClient.new
+
+## Redirect
+client.timeout = 10
+t =  client.redirect({'Action' => 'Redirect', 'Channel' => 'test','ExtraChannel' => 'test', 'Context' => 'mainmenu', 'Exten' => '201', 'Priority' => 1})
+print_results(t)
+
+## Queues
+client.timeout = 10
+t =  client.queues
+print_results(t)
+
+## IAXpeers
+client.timeout = 10
+t =  client.iax_peers
+print_results(t)
+
+## SIPpeers
+client.timeout = 10
+t =  client.sip_peers
+print_results(t)
+
+## SIPshowpeer
+client.timeout = 10
+t =  client.sip_show_peer('test_peer')
+print_results(t)
+
+## ParkedCalls
+client.timeout = 10
+t =  client.parked_calls
+print_results(t)
+
+## Hangup
+client.timeout = 10
+t =  client.hangup('SIP/test')
+print_results(t)
+
+## ExtensionState
+client.timeout = 10
+t =  client.extension_state('menu','201')
+print_results(t)
+
+## SetVar
+client.timeout = 10
+t =  client.setvar('IAX2/teliax-6','testmon',1)                                                                                              
+print_results(t)
+
+## GetVar
+client.timeout = 10
+t =  client.getvar('IAX2/teliax-6','testmon')                                                                                              
+print_results(t)
+
+## Monitor
+client.timeout = 10
+t =  client.monitor('SIP/test','testmon',1)
+print_results(t)
+
+## StopMonitor
+t =  client.stop_monitor('SIP/test')
+print_results(t)
+
+## ChangeMonitor
+t =  client.change_monitor('SIP/test','testmon')
+print_results(t)
+
+## Agents
+client.timeout = 10
+t =  client.agents
+print_results(t)
+
+## MailboxCount
+client.timeout = 10
+t =  client.mailbox_count(1002)
+print_results(t)
+
+## MailboxStatus
+t =  client.mailbox_status(1001)
+print_results(t)
+
+
+## Ping
+client.timeout = 10
+t =  client.ping
+print_results(t)
+
+## DBPut
+client.timeout = 10
+t =  client.dbput('testfamily','testkey','testval')
+print_results(t)
+
+## DBGet
+client.timeout = 10
+t =  client.dbget('testfamily','testkey')                                                                                                    
+print_results(t)
+
+## Originate
+# Waits for Hangup or OriginateFailed.  Returns all associated events
+client.timeout = 90
+t =  client.originate({'Channel' => 'IAX2/nbts', 'Context' =>'default','Exten' =>'1000','Priority' =>1})
+print_results(t)
+
+# Does not wait, returns immediately.  Associated events available via get_events or find_events.
+client.timeout = 10
+t =  client.originate({'Async' => 1,'Channel' => 'IAX2/nbts', 'Context' =>'default','Exten' =>'1000','Priority' =>1})
+print_results(t)
+
+## Status
+t =  client.status()
+print_results(t)
+
+## AbsoluteTimeout
+t =  client.absolute_timeout('IAX2/nbts',20)
+print_results(t)
+
+## Command
+t =  client.command('show manager commands')
+print_results(t)
+
+## Find events in the state queue
+t =  client.find_events('Event','NewCallerID')
+print_results(t)
+# OR
+t =  client.find_events('any','SIP/test_extension')
+print_results(t)
+
+## Get all events in the state queue
+t =  client.get_events
+print_results(t)
+

data/lib/rami.rb

@@ -0,0 +1,748 @@
+#
+# RAMI - Ruby classes for implementing a proxy server/client api for the Asterisk Manager Interface
+#
+#
+# Copyright (c) 2005, Chris Ochs
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#    * Redistributions of source code must retain the above copyright notice,
+#       this list of conditions and the following disclaimer.
+#    * Redistributions in binary form must reproduce the above copyright notice,
+#       this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#    * Neither the name of Chris Ochs nor the names of its contributors
+#       may be used to endorse or promote products derived from this software
+#       without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+require 'drb'
+require 'monitor'
+require 'socket'
+require 'timeout'
+
+# A proxy server/client api for the Asterisk Manager Interface
+module Rami
+
+# The Rami client library.  To use the library make sure the server has been started and then call RamiClient.new and set the 
+# host, port, and timeout attributes. All methods return an array of hashes, or an empty array if no data is available. 
+#
+# Each hash will contain an asterisk response packet.  Note that not all response packets are always returned.  If a response
+# packet is necessary for the actual communication with asterisk, but does not in itself have any meaningful content, then
+# the packet is droppped.  For example some actions might generate an initial response packet of something like "Response Follows",
+# followed by one or more response packets with the actual data, followed by a final response packet which contains "Response Complete".
+# In this case the first and last response will not be included in the array of hashes passed to the caller.
+#
+# I tried to document the things that need it the most. Some things should be fairly evident, such as methods for simple
+# commands like Monitor or Ping.
+# 
+# For examples, see test.rb in the bin directory.  It contains sample code for calling every available method.
+#
+# Not all manager commands are currently supported.  This is only because I have not yet had the time to add them.  
+# I tried to add the most complicated commands first, so adding the remaining commands is fairly simple.
+# If there is a command you need let me know and I will make sure it gets included.
+# If you want to add your own action command it's fairly simple.  Add a method in RamiClient for
+# the new command, and then add a section in the RamiClient::send_action loop to harvest the response.
+class RamiClient
+
+  # Server hostname.  Default localhost
+  attr_writer :host
+  # Server port.  Default 9000
+  attr_writer :port
+  # Number of seconds before a method call will timeout. Default 10.
+  attr_writer :timeout
+
+  def initialize
+    @host = 'localhost'
+    @port = 9000
+    @timeout = 10
+    @action_id = Time.now().to_f
+    DRb.start_service()
+    @client = DRbObject.new(nil,"druby://#{@host}:#{@port}")
+  end
+
+  def absolute_timeout(channel=nil,tout=nil)
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'AbsoluteTimeout', 'Channel' => channel, 'Timeout' => tout},@timeout)
+  end
+
+  def agents
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'Agents'},@timeout)
+  end
+
+  def change_monitor(channel=nil,file=nil)
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'ChangeMonitor', 'Channel' =>channel, 'File' => file},@timeout)
+  end
+
+  def command(command)
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'Command', 'Command' => command},@timeout)
+  end
+
+  def dbput(family,key,val)
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'DBPut', 'Family' => family, 'Key' => key, 'Val' => val},@timeout)
+  end
+
+  def dbget(family,key)
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'DBGet', 'Family' => family, 'Key' => key},@timeout)
+  end
+
+  def extension_state(context,exten)
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'ExtensionState', 'Context' => context, 'Exten' => exten},@timeout)
+  end
+
+  # If called with key and value, searches the state queue for events matching the key and value given.
+  # The key is an exact match, the value is a regex.  You can also call find_events with key=any, which will match
+  # any entry with the given value
+  # 
+  # The returned results are deleted from the queue.  See RamiServer for more information on the queue structure.
+  def find_events(key=nil,value=nil)
+    return @client.find_events(key,value)
+  end
+
+  # Get all events from the state queue.  The returned results are deleted from the queue.
+  # See RamiServer for more information on the queue structure.
+  def get_events
+    return @client.get_events
+  end
+
+  def getvar(channel,variable)
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'GetVar', 'Channel' => channel, 'Variable' => variable},@timeout)
+  end
+
+  def hangup(channel=nil)
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'Hangup', 'Channel' => channel},@timeout)
+  end
+
+  # IAXpeers is bugged.  The response does not contain an action id, nor does it contain any key/value pairs in the response.
+  # For this reason it gets put into the state queue where it can be retrieved using find_events('any','iax2 peers').  iax_peers
+  # will always return {'Response' => 'Success'}
+  def iax_peers
+    increment_action_id
+    @client.send_action({'ActionID' => @action_id, 'Action' => 'IAXpeers'},1)
+    return [{'Response' => 'Success'}]
+  end
+  
+  def monitor(channel=nil,file=nil,mix=nil)
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'Monitor', 'Channel' =>channel, 'File' => file, 'Mix' => mix},@timeout)
+  end
+
+  def mailbox_status(mailbox=nil)
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'MailboxStatus', 'Mailbox' => mailbox},@timeout)
+  end
+
+  def mailbox_count(mailbox=nil)
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'MailboxCount', 'Mailbox' => mailbox},@timeout)
+  end
+
+  # h is a hash with the following keys.  keys that are nil will not be passed to asterisk.
+  # * Channel
+  # * Context
+  # * Exten
+  # * Priority
+  # * Timeout
+  # * CallerID
+  # * Variable
+  # * Account
+  # * Application
+  # * Data
+  # * Async
+  # If Async has a value, the method will wait until the call is hungup or fails. On hangup,
+  # Asterisk will response with Hangup event, and on failure it will respond with an OriginateFailed event.
+  # If Async is nil, the method will return immediately and the associated events can be obtained by calling 
+  # find_events() or get_events().
+  def originate(h={})
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id,
+                                'Action' => 'Originate',
+                                'Channel' => h['Channel'],
+                                'Context' => h['Context'],
+                                'Exten' =>h['Exten'],
+                                'Priority' =>h['Priority'],
+                                'Timeout' =>h['Timeout'],
+                                'CallerID' =>h['CallerID'],
+                                'Variable' =>h['Variable'],
+                                'Account' =>h['Account'],
+                                'Application' =>h['Application'],
+                                'Data' =>h['Data'],
+                                'Async' => h['Async']}.delete_if {|key, value| value.nil? },@timeout)
+  end
+
+  def parked_calls
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'ParkedCalls'},@timeout)
+  end
+
+  def ping
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'Ping'},@timeout)
+  end
+
+  # Queues is just like IAXpeers.  You can use find_events('any','default') to get the response from the state queue.
+  def queues
+    increment_action_id
+    @client.send_action({'ActionID' => @action_id, 'Action' => 'Queues'},@timeout)
+    return [{'Response' => 'Success'}]
+  end
+
+  # h is a hash with the following keys.  keys that are nil will not be passed to asterisk.
+  # * Channel
+  # * ExtraChannel
+  # * Context
+  # * Exten
+  # * Priority
+  def redirect(h={})
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id,
+                                'Action' => 'Redirect',
+                                'Channel' => h['Channel'],
+                                'ExtraChannel' => h['ExtraChannel'],
+                                'Context' => h['Context'],
+                                'Exten' => h['Exten'],
+                                'Priority' => h['Priority']}.delete_if {|key,value| value.nil?},@timeout)
+  end
+
+  def setvar(channel,variable,value)
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'SetVar', 'Channel' => channel, 'Variable' => variable, 'Value' => value},@timeout)
+  end
+
+  # Unlike IAXpeers, SIPpeers returns an event for each peer that is easily parsed and usable.
+  def sip_peers
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'SIPpeers'},@timeout)
+  end
+
+  # Detailed information about a particular peer.
+  def sip_show_peer(peer)
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'SIPshowpeer', 'Peer' => peer},@timeout)
+  end
+
+  def status(channel=nil)
+    increment_action_id
+    if channel.nil?
+      return @client.send_action({'ActionID' => @action_id, 'Action' => 'Status'},@timeout)
+    else
+      return @client.send_action({'ActionID' => @action_id, 'Action' => 'Status', 'Channel' => channel},@timeout)
+    end
+  end
+
+  def stop_monitor(channel=nil)
+    increment_action_id
+    return @client.send_action({'ActionID' => @action_id, 'Action' => 'StopMonitor', 'Channel' =>channel},@timeout)
+  end
+
+private
+  def increment_action_id
+    @action_id = Time.now().to_f
+  end
+
+  def send_action(action=nil,tout=nil)
+    increment_action_id
+    action['ActionID'] = @action_id
+    return @client.send_action(action,tout)
+  end
+
+end
+
+
+# RamiServer maintains one open connection to asterisk.  It uses one thread to constantly read responses and stick them into
+# the appropriate queue.  Clients connect via DRb and are each serviced in their own thread.
+#
+# The server uses two queues to hold responses from asterisk.  The action queue holds all responses that contain an ActionID.
+# The state queue holds all responses that do not have an ActionID.  The action queue is only used internally, while the state
+# queue can be queried via RamiClient.get_events and RamiClient.find_events. 
+#
+# To run the server, call RamiServer.new, set the attributes, then call the run method.
+# For an example of how to run the server, see bin/server.rb.
+class RamiServer
+  # If set to 1, console logging is turned on.  Default 0
+  attr_writer :console
+  # Asterisk manager username.  Default asterisk.
+  attr_writer :username
+  # Asterisk manager secret.  Default secret. 
+  attr_writer :secret
+  # Asterisk manager hostname.  Default localhost
+  attr_writer :host
+  # Asterisk manager port.  Default 5038
+  attr_writer :port
+  # The number of responses to hold in the state queue. The state queue is a FIFO list.  Default is 100.
+  attr_writer :event_cache
+
+Thread.current.abort_on_exception=true
+
+include DRbUndumped
+
+def initialize
+    @console = 0
+    @username = 'asterisk'
+    @secret = 'secret'
+    @host = 'localhost'
+    @port = 5038
+    @eventcount = 1
+    @event_cache = 100
+
+    @sock = nil
+    @socklock = nil
+    @socklock.extend(MonitorMixin)
+
+    @action_events = []
+    @action_events.extend(MonitorMixin)
+    @action_events_pending = @action_events.new_cond
+
+    @state_events = []
+    @state_events.extend(MonitorMixin)
+    @state_events_pending = @state_events.new_cond
+
+end
+
+
+
+
+private
+
+def connect
+  @sock = TCPSocket.new(@host,@port)
+  login = {'Action' => 'login', 'Username' => @username, 'Secret' => @secret, 'Events' => 'On'}
+  writesock(login)
+  accum = {}
+  login = 0
+  status = Timeout.timeout(10) do
+    while login == 0
+      @sock.each("\r\n") do |line|
+        if line.include?(':')
+          key,value = parseline(line) if line.include?(':')
+          accum[key] = value
+        end
+        if @console == 1
+          print "#{Time.now} RECV #{@eventcount}: #{line}"
+        end
+        if line == "\r\n" and accum['Message'] == 'Authentication accepted' and accum['Response'] == 'Success'
+          login =1
+          @eventcount += 1
+          break
+        end
+      end
+    end
+  return true
+  end
+rescue Exception => e
+  puts "LOGIN TIMEOUT"
+  return false
+end
+
+
+def mainloop
+
+  ast_reader = Thread.new do
+    Thread.current.abort_on_exception=true
+    linecount = 0
+    loop do
+      event = {}
+      @sock.each("\r\n") do |line|
+        linecount += 1
+        type = 'state'
+        if @console == 1
+          print "#{Time.now} RECV #{@eventcount}: #{line}"
+        end
+        if line == "\r\n"
+          if event.size == 0
+            if @console == 1
+              print "#{Time.now} MSG: #{@eventcount} RECEIVED EXTRA CR/LF #{line}"
+            end
+            next
+          end
+          if event['ActionID']
+            type = 'action'
+          end
+
+          if @console == 1
+            print "#{Time.now} MSG: #{@eventcount} finished (type=#{type}) #{line}"
+          end
+
+          if type == 'action'
+            @action_events.synchronize do
+              @action_events << event.clone
+              event.clear
+              @action_events_pending.signal
+            end
+          elsif type == 'state'
+            @state_events.synchronize do
+              @state_events << event.clone
+              if @state_events.size >= @event_cache
+                @state_events.shift
+              end
+              event.clear
+              @state_events_pending.signal
+            end
+          end
+          @eventcount += 1
+        elsif line =~/^[\w\s\/-]*:[\s]*.*\r\n$/
+          key,value = parseline(line)
+          if key == 'ActionID'
+            value = value.gsub(' ','')
+          end
+          event[key] = value
+        else
+          event[linecount] = line
+        end
+      end
+    end
+  end
+end
+
+def parseline(line)
+  if line =~/(^[\w\s\/-]*:[\s]*)(.*\r\n$)/
+    key = $1
+    value = $2
+    key = key.gsub(/[\s:]*/,'')
+    value = value.gsub(/\r\n/,'')
+    return [key,value]
+  else
+    return ["UNKNOWN","UNKNOWN"]
+  end
+
+end
+
+def writelog(msg)
+  print "#{Time.now} #{msg}\r\n"
+end
+
+def writesock(action)
+  @socklock.synchronize do
+    action.each do |key,value|
+      @sock.write("#{key}: #{value}\r\n")
+      print "#{Time.now} SEND #{@eventcount}: #{key}: #{value}\r\n"
+    end
+    @sock.write("\r\n")
+    print "#{Time.now} SEND #{@eventcount}: \r\n"
+  end
+end
+
+
+public
+
+# Starts the server and connects to asterisk.
+def run
+  if connect
+    puts "#{Time.now} MSG: LOGGED IN"
+  else
+    puts "#{Time.now} MSG: LOGIN FAILED"
+    exit
+  end
+  mainloop
+end
+
+# Should only be called via Drb by RamiClient
+def find_events(key=nil,value=nil)
+  print "#{Time.now} find_events: #{key}: #{value}\r\n"
+  found = []
+  @state_events.synchronize do
+    if @state_events.empty?
+      return found
+    else
+      @state_events_pending.wait_while {@state_events.empty?}
+      @state_events.clone.each do |e|
+        if key == 'any' and e.to_s =~/#{value}/
+          found.push(e)
+          @state_events.delete(e)
+        elsif key != 'any' and e[key] =~/#{value}/
+          found.push(e)
+          @state_events.delete(e)
+        end
+      end
+      return found
+    end
+  end
+end
+
+# Should only be called via Drb by RamiClient
+def get_events
+  found = []
+  @state_events.synchronize do
+    if @state_events.empty?
+      return found
+    else
+      @state_events_pending.wait_while {@state_events.empty?}
+      @state_events.clone.each do |e|
+        found.push(e)
+      end
+      @state_events.clear
+      return found
+    end
+  end
+end
+
+# Should only be called via Drb by RamiClient
+def send_action(action=nil,t=10)
+  sent_id = action['ActionID'].to_s
+  result = []
+  finished = 0
+  status = Timeout.timeout(t) do
+    writesock(action)
+
+    ## Some action responses have no action id or specific formatting, so we just return immediately and the caller can call
+    ## get_events or find_events to get the response.
+
+    ## IAXpeer - Just return immediately
+    if action['Action'] == 'IAXpeers'
+      finished =1
+      return
+    end
+
+    ## Queues - Just return immediately
+    if action['Action'] == 'Queues'
+      finished =1
+      return
+    end
+
+
+    while finished == 0
+      @action_events.synchronize do
+        @action_events_pending.wait_while {@action_events.empty?}
+        @action_events.clone.each do |e|
+
+          ## Action responses that contain an ActionID
+          if e['ActionID'].to_s == sent_id
+
+            ## Ping - Single response has ActionID
+            if action['Action'] == 'Ping' and e['Response'].gsub(/\s/,'') == 'Pong'
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+            ## Command - Single response has ActionID
+            if action['Action'] == 'Command' and e['Response'].gsub(/\s/,'') == 'Follows'
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+            ## Hangup - Single response has ActionID
+            if action['Action'] == 'Hangup'
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+            ## ExtensionState - Single response has ActionID
+            if action['Action'] == 'ExtensionState'
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+            ## SetVar - Single response has ActionID
+            if action['Action'] == 'SetVar'
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+            ## GetVar - Single response has ActionID
+            if action['Action'] == 'GetVar'
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+            ## Redirect - Single response has ActionID
+            if action['Action'] == 'Redirect'
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+            ## DBPut - Single response has ActionID
+            if action['Action'] == 'DBPut'
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+            ## DBGet - Single response has ActionID
+            if action['Action'] == 'DBGet' and (e['Response'] == 'Error' or e['Event'] == 'DBGetResponse')
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+            ## Monitor - Single response has ActionID
+            if action['Action'] == 'Monitor'
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+            ## Stop Monitor - Single response has ActionID
+            if action['Action'] == 'StopMonitor'
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+            ## ChangeMonitor - Single response has ActionID
+            if action['Action'] == 'ChangeMonitor'
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+            ## MailboxStatus - Single response has ActionID
+            if action['Action'] == 'MailboxStatus'
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+            ## MailboxCount - Single response has ActionID
+            if action['Action'] == 'MailboxCount'
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+            ## AbsoluteTimeout - Single response has ActionID
+            if action['Action'] == 'AbsoluteTimeout'
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+            ## SIPshowpeer - Single response has ActionID
+            if action['Action'] == 'SIPshowpeer'
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+            ## Logoff - Single response has ActionID
+            if action['Action'] == 'Logoff'
+              @action_events.delete(e)
+              result << e
+              finished = 1
+            end
+
+
+            ## Originate - Single response has ActionID, multiple events generated
+            ## end event is Hangup or OriginateFailed.
+            if action['Action'] == 'Originate'
+              if action['Async']
+                if action['Action'] == 'Originate' and e['Message'] == 'Originate successfully queued'
+                  @action_events.delete(e)
+                  result << e
+                  finished = 1
+                end
+              else
+                eventfinished =0
+                while eventfinished == 0
+                  @state_events.synchronize do
+                    @state_events_pending.wait_while {@state_events.empty?}
+                    @state_events.clone.each do |s|
+                      if s['Channel'] =~/#{action['Channel']}/ and (s['Event'] == 'Hangup' or s['Event'] == 'OriginateFailed')
+                        @state_events.delete(s)
+                        result << s
+                        eventfinished =1
+                        finished =1
+                      elsif s['Channel'] =~/#{action['Channel']}/
+                        @state_events.delete(s)
+                        result << s
+                      end
+                    end
+                  end
+                end
+              end
+            end
+
+            ## ParkedCalls - multiple responses has ActionID
+            if action['Action'] == 'ParkedCalls'
+              if e['Message'] == 'Parked calls will follow'
+                @action_events.delete(e)
+              elsif e['Event'] == 'ParkedCallsComplete'
+                @action_events.delete(e)
+                finished =1
+              else
+                @action_events.delete(e)
+                result << e
+              end
+            end
+
+            ## SIPpeers - multiple responses has ActionID
+            if action['Action'] == 'SIPpeers'
+              if e['Message'] == 'Peer status list will follow'
+                @action_events.delete(e)
+              elsif e['Event'] == 'PeerlistComplete'
+                @action_events.delete(e)
+                finished =1
+              elsif e['Event'] == 'PeerEntry'
+                @action_events.delete(e)
+                result << e
+              end
+            end
+
+            ## Agents - multiple responses has ActionID
+            if action['Action'] == 'Agents'
+              if e['Message'] == 'Agents will follow'
+                @action_events.delete(e)
+              elsif e['Event'] == 'AgentsComplete'
+                @action_events.delete(e)
+                finished =1
+              elsif e['Event'] == 'Agents'
+                @action_events.delete(e)
+                result << e
+              end
+            end
+
+            ## Status - multiple responses has ActionID
+            if action['Action'] == 'Status'
+              if e['Message'] == 'Channel status will follow'
+                @action_events.delete(e)
+              elsif e['Event'] == 'StatusComplete'
+                @action_events.delete(e)
+                finished =1
+              elsif e['Event'] == 'Status'
+                @action_events.delete(e)
+                result << e
+              end
+            end
+
+          end
+        end
+      end
+      sleep 0.10
+    end
+  end
+  return result
+rescue Exception => e
+  puts "#{e}: TIMEOUT #{t} #{sent_id}"
+  return result
+end
+
+end
+  rescue Exception => e
+  puts e
+end

data/manager.txt

@@ -0,0 +1,43 @@
+# Action           Privilege        Synopsis                                               
+# ------           ---------        --------                                               
+# AbsoluteTimeout  call,all         Set Absolute Timeout                                   
+# AgentCallbackLo  agent,all        Sets an agent as logged in by callback                 
+# AgentLogoff      agent,all        Sets an agent as no longer logged in                   
+# Agents           agent,all        Lists agents and their status                          
+# ChangeMonitor    call,all         Change monitoring filename of a channel                
+# Command          command,all      Execute Asterisk CLI Command                           
+# DBGet            system,all       Get DB Entry                                           
+# DBPut            system,all       Put DB Entry                                           
+# Events           <none>           Control Event Flow                                     
+# ExtensionState   call,all         Check Extension Status                                 
+# Getvar           call,all         Gets a Channel Variable                                
+# Hangup           call,all         Hangup Channel                                         
+# IAXnetstats      <none>           Show IAX Netstats                                      
+# IAXpeers         <none>           List IAX Peers                                         
+# ListCommands     <none>           List available manager commands                        
+# Logoff           <none>           Logoff Manager                                         
+# MailboxCount     call,all         Check Mailbox Message Count                            
+# MailboxStatus    call,all         Check Mailbox                                          
+# Monitor          call,all         Monitor a channel                                      
+# Originate        call,all         Originate Call                                         
+# ParkedCalls      <none>           List parked calls                                      
+# Ping             <none>           Keepalive command                                      
+# QueueAdd         agent,all        Add interface to queue.                                
+# QueuePause       agent,all        Makes a queue member temporarily unavailable           
+# QueueRemove      agent,all        Remove interface from queue.                           
+# Queues           <none>           Queues                                                 
+# QueueStatus      <none>           Queue Status                                           
+# Redirect         call,all         Redirect (transfer) a call                             
+# SetCDRUserField  call,all         Set the CDR UserField                                  
+# Setvar           call,all         Set Channel Variable                                   
+# SIPpeers         system,all       List SIP peers (text format)                           
+# SIPshowpeer      system,all       Show SIP peer (text format)                            
+# Status           call,all         Lists channel status                                   
+# StopMonitor      call,all         Stop monitoring a channel                              
+# ZapDialOffhook   <none>           Dial over Zap channel while offhook                    
+# ZapDNDoff        <none>           Toggle Zap channel Do Not Disturb status OFF           
+# ZapDNDon         <none>           Toggle Zap channel Do Not Disturb status ON            
+# ZapHangup        <none>           Hangup Zap Channel                                     
+# ZapShowChannels  <none>           Show status zapata channels                            
+# ZapTransfer      <none>           Transfer Zap Channel                                   
+#

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: rami
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2005-10-17 00:00:00 -07:00
+summary: A proxy server/client api for the Asterisk Manager Interface
+require_paths: 
+  - lib
+email: chris@paymentonline.com
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: rami
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+  - Chris Ochs
+files: 
+  - README
+  - LICENSE
+  - manager.txt
+  - lib/rami.rb
+  - bin/server.rb
+  - bin/test.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: []