eric-adhearsion 0.7.999 → 0.8.0

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

@@ -1,109 +0,0 @@
-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

@@ -1,262 +0,0 @@
-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/script/destroy

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-APP_ROOT = File.join(File.dirname(__FILE__), '..')
-
-begin
-  require 'rubigen'
-rescue LoadError
-  require 'rubygems'
-  require 'rubigen'
-end
-require 'rubigen/scripts/destroy'
-
-ARGV.shift if ['--help', '-h'].include?(ARGV[0])
-RubiGen::Base.use_component_sources! [:rubygems, "test_unit"]
-RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-APP_ROOT = File.join(File.dirname(__FILE__), '..')
-
-begin
-  require 'rubigen'
-rescue LoadError
-  require 'rubygems'
-  require 'rubigen'
-end
-require 'rubigen/scripts/generate'
-
-ARGV.shift if ['--help', '-h'].include?(ARGV[0])
-RubiGen::Base.use_component_sources! [:rubygems, "test_unit"]
-RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/fixtures/dialplan.rb

@@ -1,3 +0,0 @@
-sample_context {
-  raise 'the body of this context should not have been evaluated'
-}

data/spec/initializer/test_configuration.rb

@@ -1,267 +0,0 @@
-require File.dirname(__FILE__) + "/../test_helper"
-
-context "Configuration defaults" do
-  include ConfigurationTestHelper
-  attr_reader :config
-  
-  setup do
-    @config = default_config
-  end
-  
-  test "incoming calls are answered by default" do
-    assert config.automatically_answer_incoming_calls
-  end
-  
-  test "calls are ended when hung up" do
-    assert config.end_call_on_hangup
-  end
-  
-  test "if an error occurs, a call is hungup" do
-    assert config.end_call_on_error
-  end
-  
-  test "asterisk is enabled by default" do
-    assert config.asterisk_enabled?
-  end
-  
-  test "default asterisk configuration is available" do
-    assert_kind_of Adhearsion::Configuration::AsteriskConfiguration, config.asterisk
-  end
-  
-  test "database access is NOT enabled by default" do
-    assert !config.database_enabled?
-  end
-  
-  test "freeswith is NOT enabled by default" do
-    assert !config.freeswitch_enabled?
-  end
-  
-  test "AMI is NOT enabled by default" do
-    assert !config.asterisk.ami_enabled?
-  end
-  
-  test "Drb is NOT enabled by default" do
-    assert !config.drb_enabled?
-  end
-end
-
-context "Asterisk AGI configuration defaults" do
-  attr_reader :config
-  
-  setup do
-    @config = Adhearsion::Configuration::AsteriskConfiguration.new
-  end
-  
-  test "asterisk configuration sets default listening port" do
-    config.listening_port.should.equal Adhearsion::Configuration::AsteriskConfiguration.default_listening_port
-  end
-  
-  test "asterisk configuration sets default listening host" do
-    config.listening_host.should.equal Adhearsion::Configuration::AsteriskConfiguration.default_listening_host
-  end
-end
-
-context 'Logging configuration' do
-  
-  attr_reader :config
-  before :each do
-    @config = Adhearsion::Configuration.new
-  end
-  
-  after :each do
-    Adhearsion::Logging.logging_level = :fatal
-  end
-  
-  test 'the logging level should translate from symbols into Log4r constants' do
-    Adhearsion::Logging.logging_level.should.not.equal Log4r::WARN
-    config.logging :level => :warn
-    Adhearsion::Logging.logging_level.should.equal Log4r::WARN
-  end
-  
-end
-
-context "AMI configuration defaults" do
-  attr_reader :config
-  
-  setup do
-    @config = Adhearsion::Configuration::AsteriskConfiguration::AMIConfiguration.new
-  end
-  
-  test "ami configuration sets default port" do
-    config.port.should.equal Adhearsion::Configuration::AsteriskConfiguration::AMIConfiguration.default_port
-  end
-  
-  test "ami allows you to configure a username and a password, both of which default to nil" do
-    config.username.should.be.nil
-    config.password.should.be.nil
-  end
-end
-
-context "Rails configuration defaults" do
-  test "should require the path to the Rails app in the constructor" do
-    config = Adhearsion::Configuration::RailsConfiguration.new :path => "path here doesn't matter right now", :env => :development
-    config.rails_root.should.not.be.nil
-  end
-  
-  test "should expand_path() the first constructor parameter" do
-    rails_root = "gui"
-    flexmock(File).should_receive(:expand_path).once.with(rails_root)
-    config = Adhearsion::Configuration::RailsConfiguration.new :path => rails_root, :env => :development
-  end
-  
-  test "should ensure that the environment provided is one supported by Rails" do
-    the_following_code {
-      Adhearsion::Configuration::RailsConfiguration.new :path => "doesnt matter", :env => :this_is_not_a_rails_env
-    }.should.raise ArgumentError
-    
-    the_following_code {
-      Adhearsion::Configuration::RailsConfiguration.new :path => "doesnt matter", :env => :development
-      Adhearsion::Configuration::RailsConfiguration.new :path => "doesnt matter", :env => :production
-      Adhearsion::Configuration::RailsConfiguration.new :path => "doesnt matter", :env => :test
-    }.should.not.raise ArgumentError
-  end
-  
-  test "should convert the environment into a Symbol" do
-    Adhearsion::Configuration::RailsConfiguration::SUPPORTED_RAILS_ENVIRONMENTS.should.not.be.empty
-    Adhearsion::Configuration::RailsConfiguration::SUPPORTED_RAILS_ENVIRONMENTS.each do |env|
-      config = Adhearsion::Configuration::RailsConfiguration.new :path => "doesnt matter", :env => env.to_s
-      config.environment.should.equal env
-    end
-  end
-end
-
-context "Database configuration defaults" do
-  
-  setup do
-    Adhearsion.send(:remove_const, :AHN_CONFIG) if Adhearsion.const_defined?(:AHN_CONFIG)
-    Adhearsion::Configuration.configure {}
-  end
-  
-  it "should store the constructor's argument in connection_options()" do
-    sample_options = { :adapter => "sqlite3", :dbfile => "foo.sqlite3" }
-    config = Adhearsion::Configuration::DatabaseConfiguration.new(sample_options)
-    config.connection_options.should.equal sample_options
-  end
-  it "should remove the :orm key from the connection options" do
-    sample_options = { :orm => :active_record, :adapter => "mysql", :host => "::1",
-                       :user => "a", :pass => "b", :database => "ahn" }
-    config = Adhearsion::Configuration::DatabaseConfiguration.new(sample_options.clone)
-    config.orm.should.equal sample_options.delete(:orm)
-    config.connection_options.should.equal sample_options
-  end
-end
-
-context "Freeswitch configuration defaults" do
-  attr_reader :config
-  
-  setup do
-    @config = Adhearsion::Configuration::FreeswitchConfiguration.new
-  end
-  
-  test "freeswitch configuration sets default listening port" do
-    config.listening_port.should.equal Adhearsion::Configuration::FreeswitchConfiguration.default_listening_port
-  end
-  
-  test "freeswitch configuration sets default listening host" do
-    config.listening_host.should.equal Adhearsion::Configuration::FreeswitchConfiguration.default_listening_host
-  end
-end
-
-context "Configuration scenarios" do
-  include ConfigurationTestHelper
-  
-  test "enabling AMI using all its defaults" do
-    config = enable_ami
-    
-    assert config.asterisk.ami_enabled?
-    config.asterisk.ami.should.be.kind_of Adhearsion::Configuration::AsteriskConfiguration::AMIConfiguration
-  end
-  
-  test "enabling AMI with custom configuration overrides the defaults" do
-    overridden_port = 911
-    config = enable_ami :port => overridden_port
-    config.asterisk.ami.port.should.equal overridden_port
-  end
-  
-  test "enabling Drb without any configuration" do
-    config = enable_drb
-    assert config.drb
-    config.drb.should.be.kind_of Adhearsion::Configuration::DrbConfiguration
-  end
-  
-  test "enabling Drb with a port specified sets the port" do
-    target_port = 911
-    config = enable_drb :port => target_port
-    config.drb.port.should.be.equal target_port
-  end
-  
-  private
-    def enable_ami(*overrides)
-      default_config do |config|
-        config.asterisk.enable_ami(*overrides)
-      end
-    end
-    
-    def enable_drb(*overrides)
-      default_config do |config|
-        config.enable_drb *overrides
-      end
-    end
-end
-
-context "AHN_CONFIG" do
-  setup do
-    Adhearsion.send(:remove_const, :AHN_CONFIG) if Adhearsion.const_defined?(:AHN_CONFIG)
-  end
-  
-  test "Running configure sets configuration to Adhearsion::AHN_CONFIG" do
-    assert !Adhearsion.const_defined?(:AHN_CONFIG)
-    Adhearsion::Configuration.configure do |config|
-      # Nothing needs to happen here
-    end
-    
-    assert Adhearsion.const_defined?(:AHN_CONFIG)
-    Adhearsion::AHN_CONFIG.should.be.kind_of(Adhearsion::Configuration)
-  end
-end
-
-context "DRb configuration" do
-  test "should not add any ACL rules when :raw_acl is passed in" do
-    config = Adhearsion::Configuration::DrbConfiguration.new :raw_acl => :this_is_an_acl
-    config.acl.should.equal :this_is_an_acl
-  end
-  
-  test "should, by default, allow only localhost connections" do
-    config = Adhearsion::Configuration::DrbConfiguration.new
-    config.acl.should == %w[allow 127.0.0.1]
-  end
-  
-  test "should add ACL 'deny' rules before 'allow' rules" do
-    config = Adhearsion::Configuration::DrbConfiguration.new :allow => %w[1.1.1.1  2.2.2.2],
-                                                             :deny  => %w[9.9.9.9]
-    config.acl.should == %w[deny 9.9.9.9 allow 1.1.1.1 allow 2.2.2.2]
-  end
-  
-  test "should allow both an Array and a String to be passed as an allow/deny ACL rule" do
-    config = Adhearsion::Configuration::DrbConfiguration.new :allow => "1.1.1.1", :deny => "9.9.9.9"
-    config.acl.should == %w[deny 9.9.9.9 allow 1.1.1.1]
-  end
-  
-  test "should have a default host and port" do
-    config = Adhearsion::Configuration::DrbConfiguration.new
-    config.host.should.not.equal nil
-    config.port.should.not.equal nil
-  end
-  
-end
-
-BEGIN {
-  module ConfigurationTestHelper
-    def default_config(&block)
-      Adhearsion::Configuration.new do |config|
-        config.enable_asterisk
-        yield config if block_given?
-      end
-    end
-  end
-}