sevenscale-adhearsion 0.7.1000

data/lib/adhearsion/voip/asterisk/ami/machine.rl

@@ -0,0 +1,109 @@
+module Adhearsion
+	module VoIP
+		module Asterisk
+			class AMI
+				module Machine
+				%%{
+				    machine ami;
+
+						cr = "\r";
+						lf = "\n";
+						crlf = cr lf;
+
+						action _key 	{ mark("key") 	}
+						action key 		{ set("key");		}
+						action _value { mark("value") }
+						action value 	{ set("value"); }
+						Attr = [a-zA-Z\-]+ >_key %key ': ' (any* -- crlf) >_value %value crlf;
+						Privilege = "Privilege" >_key %key ': ' (any* -- crlf) >_value %value crlf;
+						ActionID = "ActionID" >_key %key ': ' (any* -- crlf) >_value %value crlf;
+
+						action _event { mark("event") }
+						action event 	{ set("event"); @current_packet = EventPacket.new(@__ragel_event) }
+						Event = "Event: " alpha+ >_event %event crlf;
+
+						action _success { @current_packet = Packet.new; }
+						action _error 	{ @current_packet = ErrorPacket.new; }
+						Response 	= "Response: ";
+						Success		= Response "Success" >_success crlf;
+						Pong 			= Response "Pong" >_success crlf;
+						Error 		= Response "Error" >_error crlf;
+						Events		= Response "Events " ("On" | "Off") >_success crlf;
+
+						action _follows { @current_packet = FollowsPacket.new; }
+						Follows 		= Response "Follows" >_follows crlf;
+						EndFollows 	= "--END COMMAND--" crlf;
+
+						# Capture the prompt. Signal any waiters.
+						Prompt = "Asterisk Call Manager/";
+						prompt := |*
+							graph+ 	>{ mark("version"); };
+							crlf 		>{ set("version"); @signal.signal	} => { fgoto main; };
+							*|;
+
+						# For typical commands with responses with headers
+						response_normal := |*
+							Attr => { pair; };
+							crlf => { packet; fgoto main; };
+							*|;
+				
+						# For immediate or raw commands
+						Raw = (any+ >{ mark_array("raw"); } -- lf) lf;
+
+						# For immediate or raw commands
+						Imm = (any+ >{ mark_array("raw") } -- crlf) crlf %{ insert("raw") };
+
+						# For raw commands
+						response_follows := |*
+							Privilege 			=> { pair; };
+							ActionID 				=> { pair; };
+							Raw 						=> { insert("raw") };
+							EndFollows crlf => { packet; fgoto main; };
+							*|;
+			
+						main := |*
+							Prompt 	@{ fgoto prompt; 						};
+							Success @{ fgoto response_normal; 	};
+							Pong 		@{ fgoto response_normal; 	};
+							Error 	@{ fgoto response_normal; 	};
+							Event 	@{ fgoto response_normal; 	};
+							Events 	@{ fgoto response_normal; 	};
+							Follows @{ fgoto response_follows; 	};
+
+							# Must also handle immediate responses with raw data
+							Imm crlf crlf => { @current_packet = ImmediatePacket.new; packet; };
+						*|;
+				}%%
+	
+					class << self
+						def extended(base)
+							# Rename the Ragel variables. Not strictly necessary if
+							# we were to make accessors for them.
+							base.instance_eval do
+								%%{
+									variable p @__ragel_p;
+									variable pe @__ragel_pe;
+									variable cs @__ragel_cs;
+									variable act @__ragel_act;
+									variable data @__ragel_data;
+									variable tokstart @__ragel_tokstart;
+									variable tokend @__ragel_tokend;
+									write data nofinal;
+								}%%
+							end			
+						end
+					end
+
+					private					
+					def ragel_init
+						%% write init;
+					end
+					
+					def ragel_exec
+						%% write exec;
+					end
+				end
+			end
+		end
+	end
+end

data/lib/adhearsion/voip/asterisk/ami/parser.rb

@@ -0,0 +1,262 @@
+require 'drb'
+require 'adhearsion/voip/asterisk/ami/machine'
+
+module Adhearsion
+  module VoIP
+    module Asterisk
+      class AMI
+        class Packet < Hash
+          def error?
+            false
+          end
+          
+          def raw?
+            false
+          end
+          
+          def is_event?
+            false
+          end
+          
+          # Return the hash, without the internal Action ID
+          def body
+            returning clone do |packet|
+              packet.delete 'ActionID'
+            end
+          end
+          
+          def message
+            self['Message']
+          end
+        end
+
+        class EventPacket < Packet
+          attr_accessor :event
+          def initialize(event)
+            @event = event
+            super(false)
+          end
+          
+          def is_event?
+            true
+          end
+        end
+        
+        class ErrorPacket < Packet
+          def error?
+            true
+          end
+        end
+        
+        class FollowsPacket < Packet
+          def raw?
+            true
+          end
+        end
+        
+        class ImmediatePacket < Packet
+          def raw?
+            true
+          end
+        end
+        
+        class Parser
+          # Size of the scanner buffer
+          BUFSIZE = 1024
+          
+          attr_accessor :logger
+          attr_reader :events
+
+          def initialize
+            self.extend Machine
+            
+            # Add the variables and accessors used for marking seen data
+            %w(event key value version).each do |name|
+              instance_eval <<-STR
+                class << self
+                  send(:attr_accessor, "__ragel_mark_#{name}")
+                  send(:attr_accessor, "__ragel_#{name}")
+                end
+                send("__ragel_mark_#{name}=", 0)
+                send("__ragel_#{name}=", nil)
+              STR
+            end
+
+            %w(raw).each do |name|
+              instance_eval <<-STR
+                class << self
+                  send(:attr_accessor, "__ragel_mark_#{name}")
+                  send(:attr_accessor, "__ragel_#{name}")
+                end
+                send("__ragel_mark_#{name}=", 0)
+                send("__ragel_#{name}=", [])
+              STR
+            end
+            @signal         = ConditionVariable.new
+            @mutex          = Mutex.new
+            @events         = Queue.new
+            @current_packet = nil
+            @logger         = Logger.new STDOUT
+          end
+
+          private
+          
+          # Set the starting marker position
+          def mark(name)
+            send("__ragel_mark_#{name}=", @__ragel_p)
+          end
+
+          # Set the starting marker position for capturing raw data in an array
+          def mark_array(name)
+            send("__ragel_mark_#{name}=", @__ragel_p)
+          end
+
+          # Capture the marked data from the marker to the current position
+          def set(name)
+            mark = send("__ragel_mark_#{name}")
+            return if @__ragel_p == mark
+            send("__ragel_#{name}=", @__ragel_data[mark..@__ragel_p-1])
+            send("__ragel_mark_#{name}=", 0)
+          end
+
+          # Insert the data marked from the marker to the current position in the array
+          def insert(name)
+            mark = send("__ragel_mark_#{name}")
+            return if @__ragel_p == mark
+            var = send("__ragel_#{name}")
+            var << @__ragel_data[mark..@__ragel_p-1]
+            send("__ragel_#{name}=", var)
+          end
+    
+          # Capture a key / value pair in a response packet
+          def pair
+            @current_packet[@__ragel_key] = @__ragel_value
+          end
+    
+          # This method completes a packet. Add the current raw data to it if it
+          # is an immediate or raw response packet. If it has an action ID, it belongs
+          # to a command, so signal any waiters. If it does not, it is an asynchronous
+          # event, so add it to the event queue.
+          def packet
+            return if not @current_packet
+            @current_packet[:raw] = @__ragel_raw.join("\n") if @current_packet.raw?
+            action_id = nil
+            if not @current_packet.is_event? or @current_packet['ActionID']
+              action_id = @current_packet['ActionID'] || 0
+            end
+            logger.debug "Packet end: #{@__ragel_p}, #{@current_packet.class}, #{action_id.inspect}"
+            logger.debug "=====>#{@current_packet[:raw]}<=====" if @current_packet.raw?
+            if action_id
+              # Packets with IDs are associated with the action of the same ID
+              action = Actions::Action[action_id]
+              action << @current_packet
+            else
+              # Asynchronous events without IDs go into the event queue
+              @events.push(@current_packet)
+            end
+            @signal.broadcast
+            @current_packet = nil
+            @__ragel_raw = []
+          end
+          
+          public
+          # Wait for any packets (including events) that have the specified Action ID.
+          # Do not stop waiting until all of the packets for the specified Action ID
+          # have been seen.
+          def wait(action)
+            logger.debug "Waiting for #{action.action_id.inspect}"
+            @mutex.synchronize do
+              loop do
+                action.check_error!
+                return action.packets! if action.done?
+                @signal.wait(@mutex)
+              end
+            end
+          end
+
+          # Receive an event packet from the event packet queue.
+          def receive
+            @events.pop
+          end
+
+          # Stop the scanner.
+          def stop
+            @mutex.synchronize do
+              @thread.kill if @thread
+            end
+            @thread = nil
+          end
+          
+          # Run the scanner on the specified socket.
+          def run(socket)
+            @__ragel_eof = nil
+            @__ragel_data = " " * BUFSIZE
+            @__ragel_raw = []
+
+            ragel_init
+
+            # Synchronize, so we can wait for the command prompt before the
+            # scanner actually starts.
+            @mutex.synchronize do
+              @thread = Thread.new do
+                have = 0
+                loop do
+                  # Grab as many bytes as we can for now.
+                  space = BUFSIZE - have
+                  raise RuntimeError, "No space" if space == 0
+                  bytes = 0
+                  begin
+                    socket.synchronize do
+                      if IO.select([socket], nil, nil, 1.0)
+                        bytes = socket.read_nonblock(space)
+                      else
+                        retry
+                      end
+                    end
+                  rescue Errno::EAGAIN
+                    # Nothing available. Try again.
+                    retry
+                  rescue EOFError
+                    # Socket closed. We are done.
+                    break
+                  end
+
+                  # Adjust the pointers.
+                  logger.debug "Got #{bytes.length} bytes, #{bytes.inspect}"
+                  @__ragel_p = have
+                  @__ragel_data[@__ragel_p..@__ragel_p + bytes.size - 1] = bytes
+                  @__ragel_pe = @__ragel_p + bytes.size
+                  logger.debug "P: #{@__ragel_p} PE: #{@__ragel_pe}"
+
+                  # Run the scanner state machine.
+                  @mutex.synchronize do
+                    ragel_exec
+                  end
+                  
+                  if @__ragel_tokstart.nil? or @__ragel_tokstart == 0
+                    have = 0
+                  else
+                    # Slide the window.
+                    have = @__ragel_pe - @__ragel_tokstart
+                    logger.debug "Sliding #{have} from #{@__ragel_tokstart} to 0 (tokend: #{@__ragel_tokend.inspect})"
+                    @__ragel_data[0..have-1] = @__ragel_data[@__ragel_tokstart..@__ragel_tokstart + have - 1]
+                    @__ragel_tokend -= @__ragel_tokstart if @__ragel_tokend
+                    @__ragel_tokstart = 0
+                    logger.debug "Data: #{@__ragel_data[0..have-1].inspect}"
+                  end
+                end
+                @thread = nil
+              end
+              # Wait for the command prompt.
+              while @__ragel_version.blank?
+                @signal.wait(@mutex)
+              end
+            end
+            # Return the version number.
+            @__ragel_version
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/voip/asterisk/ami.rb

@@ -0,0 +1,147 @@
+require 'rubygems'
+require 'pp'
+require 'yaml'
+require 'socket'
+require 'thread'
+require 'monitor'
+require 'adhearsion/voip/asterisk/ami/parser'
+require 'adhearsion/voip/asterisk/ami/actions'
+
+module Adhearsion
+  module VoIP
+    module Asterisk
+      class AMI
+        
+        include Actions
+        
+        attr_reader :action_sock, :host, :user, :password, :port, :event_thread, :scanner, :version
+
+        def initialize(user, pass, host='127.0.0.1', options={})
+          @host, @user, @password, @port = host, user, pass, options[:port] || 5038
+          @events_enabled = options[:events]
+        end
+        
+        include Adhearsion::Publishable
+        
+        publish :through => :proxy do
+          
+          def originate(options={})
+            options[:callerid] = options.delete :caller_id if options[:caller_id]
+            execute_ami_command! :originate, options
+          end
+
+          def ping
+            execute_ami_command! :ping
+          end
+          
+          # An introduction connects two endpoints together. The first argument is
+          # the first person the PBX will call. When she's picked up, Asterisk will
+          # play ringing while the second person is being dialed.
+          #
+          # The first argument is the person called first. Pass this as a canonical
+          # IAX2/server/user type argument. Destination takes the same format, but
+          # comma-separated Dial() arguments can be optionally passed after the
+          # technology.
+          #
+          # TODO: Provide an example when this works.
+          def introduce(caller, callee, opts={})
+            dial_args  = callee
+            dial_args += "|#{opts[:options]}" if opts[:options]
+            call_and_exec caller, "Dial", :args => dial_args, :caller_id => opts[:caller_id]
+          end
+
+          def call_and_exec(channel, app, opts={})
+            args = { :channel => channel, :application => app }
+            args[:caller_id] = opts[:caller_id] if opts[:caller_id]
+            args[:data] = opts[:args] if opts[:args]
+            originate args
+          end
+          
+          def call_into_context(channel, context, options={})
+            args = {:channel => channel, :context => context}
+            args[:priority] = options[:priority] || 1
+            args[:extension] = options[:extension] if options[:extension]
+            args[:caller_id] = options[:caller_id] if options[:caller_id]
+            if options[:variables] && options[:variables].kind_of?(Hash)
+              args[:variable] = options[:variables].map {|pair| pair.join('=')}.join('|')
+            end
+            originate args
+          end
+
+          def method_missing(name, hash={}, &block)
+            execute_ami_command! name, hash, &block
+          end
+
+        end
+
+        def connect!
+          disconnect!
+          start_event_thread! if events_enabled?
+          login! host, user, password, port, events_enabled?
+        end
+        
+        def disconnect!
+          action_sock.close if action_sock && !action_sock.closed?
+          event_thread.kill if event_thread
+          scanner.stop if scanner
+        end
+
+        def events_enabled?
+          @events_enabled
+        end
+        
+        private
+  
+        def login!(host, user, pass, port, events)
+          begin
+            @action_sock = TCPSocket.new host, port
+          rescue Errno::ECONNREFUSED => refusal_error
+            raise Errno::ECONNREFUSED, "Could not connect with AMI to Asterisk server at #{host}:#{port}. " +
+                                       "Is enabled set to 'yes' in manager.conf?"
+          end
+          action_sock.extend(MonitorMixin)
+          @scanner = Parser.new
+          @version = scanner.run(action_sock)
+          begin
+            execute_ami_command! :login, :username => user, :secret => password, :events => (events_enabled? ? "On" : "Off")
+          rescue ActionError
+            raise AuthenticationFailedException, "Invalid AMI username/password! Check manager.conf."
+          else
+            # puts "Manager connection established to #{host}:#{port} with user '#{user}'"
+          end
+        end
+  
+        def execute_ami_command!(name, options={}, &block)
+          action = Action.build(name, options, &block)
+          action_sock.synchronize do
+            connect! if !action_sock || action_sock.closed?
+            action_sock.write action.to_s
+          end
+          
+          return unless action.has_response?
+          scanner.wait(action)
+        end
+        
+        def start_event_thread!
+          @event_thread = Thread.new(scanner) do |scanner|
+            loop do
+              # TODO: This is totally screwed up. __read_event doesn't exist.
+              AMI::EventHandler.handle! __read_event(scanner.events.pop)
+            end
+          end
+          event_thread.abort_on_exception = true
+        end
+  
+        # Method simply defined as private to prevent method_missing from catching it.
+        def events() end
+  
+        class EventHandler
+          # TODO: Refactor me!
+        end
+  
+        class AuthenticationFailedException < Exception; end
+        class ActionError < RuntimeError; end
+      end
+    end
+  end
+end