sevenscale-adhearsion 0.7.1003 → 0.8.0

data/lib/adhearsion/foundation/synchronized_hash.rb

@@ -0,0 +1,96 @@
+##
+# Implementation of a Thread-safe Hash. Works by delegating methods to a Hash behind-the-scenes after obtaining an exclusive # lock. Use exactly as you would a normal Hash.
+#
+class SynchronizedHash
+  
+  def self.atomically_delegate(method_name)
+    class_eval(<<-RUBY, __FILE__, __LINE__)
+      def #{method_name}(*args, &block)
+        @lock.synchronize do
+          @delegate.send(#{method_name.inspect}, *args, &block)
+        end
+      end
+    RUBY
+  end
+  
+  # Hash-related methods
+  
+  atomically_delegate :[]
+  atomically_delegate :[]=
+  atomically_delegate :all?
+  atomically_delegate :any?
+  atomically_delegate :clear
+  atomically_delegate :collect
+  atomically_delegate :default
+  atomically_delegate :default=
+  atomically_delegate :delete
+  atomically_delegate :delete_if
+  atomically_delegate :detect
+  atomically_delegate :each
+  atomically_delegate :each_key
+  atomically_delegate :each_pair
+  atomically_delegate :each_value
+  atomically_delegate :each_with_index
+  atomically_delegate :empty?
+  atomically_delegate :entries
+  atomically_delegate :fetch
+  atomically_delegate :find
+  atomically_delegate :find_all
+  atomically_delegate :grep
+  atomically_delegate :has_key?
+  atomically_delegate :has_value?
+  atomically_delegate :include?
+  atomically_delegate :index
+  atomically_delegate :indexes
+  atomically_delegate :indices
+  atomically_delegate :inject
+  atomically_delegate :invert
+  atomically_delegate :key?
+  atomically_delegate :keys
+  atomically_delegate :length
+  atomically_delegate :map
+  atomically_delegate :max
+  atomically_delegate :member?
+  atomically_delegate :merge
+  atomically_delegate :merge!
+  atomically_delegate :min
+  atomically_delegate :partition
+  atomically_delegate :rehash
+  atomically_delegate :reject
+  atomically_delegate :reject!
+  atomically_delegate :replace
+  atomically_delegate :select
+  atomically_delegate :shift
+  atomically_delegate :size
+  atomically_delegate :sort
+  atomically_delegate :sort_by
+  atomically_delegate :store
+  atomically_delegate :to_hash
+  atomically_delegate :update
+  atomically_delegate :value?
+  atomically_delegate :values
+  atomically_delegate :values_at
+  atomically_delegate :zip
+  
+  # Object-related methods
+  
+  atomically_delegate :inspect
+  atomically_delegate :to_s
+  atomically_delegate :marshal_dump
+  
+  def initialize(*args, &block)
+    @delegate = Hash.new(*args, &block)
+    @lock     = Mutex.new
+  end
+  
+  ##
+  # If you need to do many operations atomically (a la transaction), you can call this method and access the yielded Hash
+  # which can be safely modified for the duration of your block.
+  #
+  # @yield [Hash] the Hash on which you can safely operate during your block.
+  #
+  def with_lock(&block)
+    @lock.synchronize { yield @delegate }
+  end
+  
+end

data/lib/adhearsion/host_definitions.rb

@@ -1,6 +1,10 @@
 require 'yaml'
 
 module Adhearsion
+  
+  ##
+  # This class isn't yet tied into Adhearsion.
+  #
   class HostDefinition
     
     SUPPORTED_KEYS = [:host, :username, :password, :key, :name]
@@ -41,7 +45,7 @@ module Adhearsion
     attr_reader :name, :host, :username, :password, :key
     def initialize(hash)
       @host, @username, @password, @key, @name = hash.values_at(*SUPPORTED_KEYS)
-      @name ||= uuid
+      @name ||= new_guid
       
       unrecognized_keys = hash.keys - SUPPORTED_KEYS
       raise HostDefinitionException, "Unrecognized key(s): #{unrecognized_keys.map(&:inspect).to_sentence}" if unrecognized_keys.any? 

data/lib/adhearsion/initializer/asterisk.rb

@@ -8,9 +8,9 @@ module Adhearsion
       class << self
         
         def start
-          self.config     = Adhearsion::AHN_CONFIG.asterisk
+          self.config     = AHN_CONFIG.asterisk
           self.agi_server = initialize_agi
-          self.ami_client = initialize_ami if config.ami_enabled?
+          self.ami_client = VoIP::Asterisk.manager_interface = initialize_ami if config.ami_enabled?
           join_server_thread_after_initialized
         end
 
@@ -22,16 +22,25 @@ module Adhearsion
         private
 
         def initialize_agi
-          Adhearsion::VoIP::Asterisk::AGI::Server.new :host => config.listening_host,
-                                                      :port => config.listening_port
+          VoIP::Asterisk::AGI::Server.new :host => config.listening_host,
+                                          :port => config.listening_port
         end
         
         def initialize_ami
           options = ami_options
           start_ami_after_initialized
-          Adhearsion::VoIP::Asterisk::AMI.new options[:username], options[:password],
-                                              options[:host], :port => options[:port],
-                                              :events => options[:events]
+          returning VoIP::Asterisk::Manager::ManagerInterface.new(options) do
+            class << VoIP::Asterisk
+              if respond_to?(:manager_interface)
+                ahn_log.warn "Asterisk.manager_interface already initialized?"
+              else
+                def manager_interface
+                  # ahn_log.ami.warn "Warning! This Asterisk.manager_interface() notation is for Adhearsion version 0.8.0 only. Subsequent versions of Adhearsion will use a feature called SuperManager. Migrating to use SuperManager will be very simple. See http://docs.adhearsion.com/AMI for more information."
+                  Adhearsion::Initializer::AsteriskInitializer.ami_client
+                end
+              end
+            end
+          end
         end
         
         def ami_options
@@ -42,13 +51,26 @@ module Adhearsion
         end
         
         def join_server_thread_after_initialized
-          Adhearsion::Hooks::AfterInitialized.create_hook { agi_server.start }
-          Adhearsion::Hooks::ThreadsJoinedAfterInitialized.create_hook { agi_server.join }
+          Events.register_callback(:after_initialized) do
+            begin
+              agi_server.start
+            rescue => e
+              ahn_log.fatal "Failed to start AGI server! #{e.inspect}"
+              abort
+            end
+          end
+          IMPORTANT_THREADS << agi_server
         end
         
         def start_ami_after_initialized
-          Adhearsion::Hooks::AfterInitialized.create_hook do
-            ami_client.connect!
+          Events.register_callback(:after_initialized) do
+            begin
+              self.ami_client.connect!
+            rescue Errno::ECONNREFUSED
+              ahn_log.ami.error "Connection refused when connecting to AMI! Please check your configuration."
+            rescue => e
+              ahn_log.ami.error "Error connecting to AMI! #{e.inspect}"
+            end
           end
         end
 

data/lib/adhearsion/initializer/configuration.rb

@@ -24,8 +24,11 @@ module Adhearsion
     
     class << self
       def configure(&block)
-        Adhearsion.module_eval { remove_const(:AHN_CONFIG) } if Adhearsion.const_defined?(:AHN_CONFIG)
-        Adhearsion.const_set(:AHN_CONFIG, new(&block))
+        if Adhearsion.const_defined?(:AHN_CONFIG)
+          yield AHN_CONFIG if block_given?
+        else
+          Adhearsion.const_set(:AHN_CONFIG, new(&block))
+        end
       end
     end
     
@@ -33,10 +36,6 @@ module Adhearsion
     attr_accessor :end_call_on_hangup
     attr_accessor :end_call_on_error
     
-    def logging(options)
-      Adhearsion::Logging.logging_level = options[:level]
-    end
-    
     def initialize
       @automatically_answer_incoming_calls = true
       @end_call_on_hangup                  = true
@@ -44,6 +43,59 @@ module Adhearsion
       yield self if block_given?
     end
     
+    def ahnrc
+      @ahnrc
+    end
+    
+    ##
+    # Load the contents of an .ahnrc file into this Configuration.
+    #
+    # @param [String, Hash] ahnrc String of YAML .ahnrc data or a Hash of the pre-loaded YAML data structure
+    #
+    def ahnrc=(new_ahnrc)
+      case new_ahnrc
+        when Hash
+          @raw_ahnrc = new_ahnrc.to_yaml.freeze
+          @ahnrc = new_ahnrc.clone.freeze
+        when String
+          @raw_ahnrc = new_ahnrc.clone.freeze
+          @ahnrc = YAML.load(new_ahnrc).freeze
+      end
+    end
+    
+    def logging(options)
+      Adhearsion::Logging.logging_level = options[:level]
+    end
+    
+    ##
+    # Adhearsion's .ahnrc file is used to define paths to certain parts of the framework. For example, the name dialplan.rb
+    # is actually specified in .ahnrc. This file can actually be just a filename, a filename with a glob (.e.g "*.rb"), an
+    # Array of filenames or even an Array of globs.
+    #
+    # @param [String,Array] String segments which convey the nesting of Hash keys through .ahnrc
+    # @raise [RuntimeError] If ahnrc has not been set yet with #ahnrc=()
+    # @raise [NameError] If the path through the ahnrc is invalid
+    #
+    def files_from_setting(*path_through_config)
+      raise RuntimeError, "No ahnrc has been set yet!" unless @ahnrc
+      queried_nested_setting = path_through_config.flatten.inject(@ahnrc) do |hash,key_name|
+        if hash.kind_of?(Hash) && hash.has_key?(key_name)
+          hash[key_name]
+        else
+          raise NameError, "Paths #{path_through_config.inspect} not found in .ahnrc!"
+        end
+      end
+      raise NameError, "Paths #{path_through_config.inspect} not found in .ahnrc!" unless queried_nested_setting
+      queried_nested_setting = Array queried_nested_setting
+      queried_nested_setting.map { |filename| files_from_glob(filename) }.flatten.uniq
+    end
+    
+    private
+    
+    def files_from_glob(glob)
+      Dir.glob "#{AHN_ROOT}/#{glob}"
+    end
+    
     class AbstractConfiguration
       extend ConfigurationEntryPoint
       

data/lib/adhearsion/initializer/database.rb

@@ -23,7 +23,7 @@ module Adhearsion
         private
 
         def create_call_hook_for_connection_cleanup
-          Hooks::BeforeCall.create_hook do
+          Events.register_callback([:asterisk, :before_call]) do
             ActiveRecord::Base.verify_active_connections!
           end
         end
@@ -33,7 +33,7 @@ module Adhearsion
         end
 
         def require_models
-          all_models.each do |model|
+          AHN_CONFIG.files_from_setting("paths", "models").each do |model|
             load model
           end
         end
@@ -46,47 +46,4 @@ module Adhearsion
     end
     
   end
-end
-
-=begin
-db_config = Adhearsion::Configuration.core.database
-if db_config
-  unless Adhearsion::Paths.manager_for? "models"
-    raise "No paths specified for the database 'models' in .ahnrc! Aborting."
-  end
-  require 'active_record'
-  
-  ActiveRecord::Base.verification_timeout = 14400
-  ActiveRecord::Base.logger = Logger.new("log/database.log")
-  ActiveRecord::Base.establish_connection db_config
-  
-  all_models.each { |model| require model }
-  
-  # Below is a monkey patch for keeping ActiveRecord connections alive.
-  # http://www.sparecycles.org/2007/7/2/saying-goodbye-to-lost-connections-in-rails
-  
-  module ActiveRecord
-    module ConnectionAdapters
-      class MysqlAdapter
-        def execute(sql, name = nil) #:nodoc:
-          reconnect_lost_connections = true
-          begin
-            log(sql, name) { @connection.query(sql) }
-          rescue ActiveRecord::StatementInvalid => exception
-            if reconnect_lost_connections and exception.message =~ /(Lost connection to MySQL server during query|MySQL server has gone away)/
-              reconnect_lost_connections = false
-              reconnect!
-              retry
-            elsif exception.message.split(":").first =~ /Packets out of order/
-              raise ActiveRecord::StatementInvalid, "'Packets out of order' error was received from the database. Please update your mysql bindings (gem install mysql) and read http://dev.mysql.com/doc/mysql/en/password-hashing.html for more information.  If you're on Windows, use the Instant Rails installer to get the updated mysql bindings." 
-            else
-              raise
-            end
-          end
-        end
-      end
-    end
-  end
-  
-end
-=end
+end

data/lib/adhearsion/initializer/drb.rb

@@ -8,17 +8,23 @@ module Adhearsion
     class DrbInitializer
 
       class << self
-
+        
         def start
           config = Adhearsion::AHN_CONFIG.drb
           DRb.install_acl ACL.new(config.acl) if config.acl
-          DRb.start_service "druby://#{config.host}:#{config.port}", Adhearsion::DrbDoor.instance
+          
+          drb_door = Object.new
+          Components.component_manager.extend_object_with(drb_door, :rpc)
+          
+          DRb.start_service "druby://#{config.host}:#{config.port}", drb_door
+          
           ahn_log "Starting DRb on #{config.host}:#{config.port}"
         end
-  
+        
         def stop
           DRb.stop_service
         end
+        
       end
     end
   end

data/lib/adhearsion/initializer/freeswitch.rb

@@ -15,8 +15,8 @@ if oes_enabled
 
   server = Adhearsion::VoIP::FreeSwitch::OesServer.new port, host
 
-  Adhearsion::Hooks::AfterInitialized.create_hook { server.start }
-  Adhearsion::Hooks::ThreadsJoinedAfterInitialized.create_hook { server.join }
-  Adhearsion::Hooks::TearDown.create_hook { server.stop }
+  Events.register_callback(:after_initialized) { server.start }
+  Events.register_callback(:shutdown) { server.stop }
+  IMPORTANT_THREADS << server
 
 end

data/lib/adhearsion/initializer/rails.rb

@@ -18,7 +18,7 @@ module Adhearsion
           load_rails
           if defined? ActiveRecord
             ActiveRecord::Base.allow_concurrency = true
-            Hooks::BeforeCall.create_hook do
+            Events.register_callback([:asterisk, :before_call]) do
               ActiveRecord::Base.verify_active_connections!
             end
           end