eric-adhearsion 0.7.999

data/lib/adhearsion/host_definitions.rb

@@ -0,0 +1,63 @@
+require 'yaml'
+
+module Adhearsion
+  class HostDefinition
+    
+    SUPPORTED_KEYS = [:host, :username, :password, :key, :name]
+    
+    cattr_reader :definitions
+    @@definitions ||= []
+    
+    class << self
+      def import_from_data_structure(local_definitions)
+        case local_definitions
+          when Array
+            local_definitions.each do |definition|
+              raise HostDefinitionException, "Unrecognized definition: #{definition}" unless definition.is_a?(Hash)
+            end
+            local_definitions.map { |definition| new definition }
+          when Hash
+            local_definitions.map do |(name,definition)|
+              new definition.merge(:name => name)
+            end
+          else
+            raise HostDefinitionException, "Unrecognized definition #{local_definitions}"
+        end
+      end
+      
+      def import_from_yaml(yaml_string)
+        import_from_data_structure YAML.load(yaml_string)
+      end
+      
+      def import_from_yaml_file(file)
+        import_from_yaml YAML.load_file(file)
+      end
+      
+      def clear_definitions!
+        definitions.clear
+      end
+    end
+    
+    attr_reader :name, :host, :username, :password, :key
+    def initialize(hash)
+      @host, @username, @password, @key, @name = hash.values_at(*SUPPORTED_KEYS)
+      @name ||= uuid
+      
+      unrecognized_keys = hash.keys - SUPPORTED_KEYS
+      raise HostDefinitionException, "Unrecognized key(s): #{unrecognized_keys.map(&:inspect).to_sentence}" if unrecognized_keys.any? 
+      raise HostDefinitionException, "You must supply a password or key!" if username && !(password || key)
+      raise HostDefinitionException, "You must supply a username!" unless username
+      raise HostDefinitionException, 'You cannot supply both a password and key!' if password && key
+      raise HostDefinitionException, 'You must supply a host!' unless host
+      
+      self.class.definitions << self
+    end
+    
+    class HostDefinitionException < Exception
+      
+    end
+    
+  end
+  
+  
+end

data/lib/adhearsion/initializer/asterisk.rb

@@ -0,0 +1,59 @@
+require 'adhearsion/voip/asterisk'
+module Adhearsion
+  class Initializer
+    
+    class AsteriskInitializer
+      
+      cattr_accessor :config, :agi_server, :ami_client
+      class << self
+        
+        def start
+          self.config     = Adhearsion::AHN_CONFIG.asterisk
+          self.agi_server = initialize_agi
+          self.ami_client = initialize_ami if config.ami_enabled?
+          join_server_thread_after_initialized
+        end
+
+        def stop
+          agi_server.stop
+          ami_client.disconnect! if ami_client
+        end
+
+        private
+
+        def initialize_agi
+          Adhearsion::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]
+        end
+        
+        def ami_options
+          %w(host port username password events).inject({}) do |options, property|
+            options[property.to_sym] = config.ami.send property
+            options
+          end
+        end
+        
+        def join_server_thread_after_initialized
+          Adhearsion::Hooks::AfterInitialized.create_hook { agi_server.start }
+          Adhearsion::Hooks::ThreadsJoinedAfterInitialized.create_hook { agi_server.join }
+        end
+        
+        def start_ami_after_initialized
+          Adhearsion::Hooks::AfterInitialized.create_hook do
+            ami_client.connect!
+          end
+        end
+
+      end
+    end
+    
+  end
+end

data/lib/adhearsion/initializer/configuration.rb

@@ -0,0 +1,202 @@
+module Adhearsion
+  class Configuration
+    module ConfigurationEntryPoint
+      def add_configuration_for(name)
+        configuration_class_name = "#{name}Configuration"
+        lowercased_name          = name.to_s.underscore
+
+        class_eval(<<-EVAL, __FILE__, __LINE__)
+          def enable_#{lowercased_name}(configuration_options = {})
+            @#{lowercased_name}_configuration = #{configuration_class_name}.new(configuration_options)
+          end
+
+          def #{lowercased_name}
+            @#{lowercased_name}_configuration
+          end
+
+          def #{lowercased_name}_enabled?
+            !#{lowercased_name}.nil?
+          end
+        EVAL
+      end
+    end
+    extend ConfigurationEntryPoint
+    
+    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))
+      end
+    end
+    
+    attr_accessor :automatically_answer_incoming_calls
+    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
+      @end_call_on_error                   = true
+      yield self if block_given?
+    end
+    
+    class AbstractConfiguration
+      extend ConfigurationEntryPoint
+      
+      class << self
+        private
+          def abstract_method!
+            raise "Must be implemented in subclasses"
+          end
+      end
+      
+      def initialize(overrides = {})
+        overrides.each_pair do |attribute, value|
+          send("#{attribute}=", value)
+        end
+      end
+    end
+    
+    # Abstract superclass for AsteriskConfiguration and FreeSwitchConfiguration.
+    class TelephonyPlatformConfiguration < AbstractConfiguration
+      attr_accessor :listening_port
+      attr_accessor :listening_host
+      
+      class << self
+        def default_listening_port
+          abstract_method!
+        end
+        
+        def default_listening_host
+          '0.0.0.0'
+        end
+      end
+        
+      def initialize(overrides = {})
+        @listening_port = self.class.default_listening_port
+        @listening_host = self.class.default_listening_host
+        super
+      end
+    end
+    
+    class AsteriskConfiguration < TelephonyPlatformConfiguration
+      class << self
+        attr_accessor :speech_engine
+        
+        def default_listening_port
+          4573
+        end
+      end
+      
+      class AMIConfiguration < AbstractConfiguration
+        attr_accessor :port, :username, :password, :events, :host
+        
+        class << self
+          def default_port
+            5038
+          end
+
+          def default_events
+            false
+          end
+          
+          def default_host
+            'localhost'
+          end
+        end
+        
+        def initialize(overrides = {})
+          self.host   = self.class.default_host
+          self.port   = self.class.default_port
+          self.events = self.class.default_events
+          super
+        end
+      end
+      add_configuration_for :AMI
+    end
+    add_configuration_for :Asterisk
+    
+    class FreeswitchConfiguration < TelephonyPlatformConfiguration
+      class << self
+        def default_listening_port
+          4572
+        end
+      end
+    end
+    add_configuration_for :Freeswitch
+    
+    class DatabaseConfiguration < AbstractConfiguration
+      attr_accessor :connection_options, :orm
+      def initialize(options)
+        @orm                = options.delete(:orm) || :active_record # TODO: ORM is a misnomer
+        @connection_options = options
+      end
+    end
+    add_configuration_for :Database
+    
+    class DrbConfiguration < AbstractConfiguration
+      attr_accessor :port
+      attr_accessor :host
+      attr_accessor :acl
+
+      # ACL = Access Control List
+
+      class << self
+        def default_port
+          9050
+        end
+        
+        def default_host
+          'localhost'
+        end
+      end
+      
+      def initialize(overrides = {})
+        self.port = overrides[:port] || self.class.default_port
+        self.host = overrides[:host] || self.class.default_host
+        self.acl  = overrides[:raw_acl]
+        
+        unless acl
+          self.acl = []
+          overrides[ :deny].to_a.each { |ip| acl << 'deny' << ip }
+          overrides[:allow].to_a.each { |ip| acl << 'allow' << ip }
+          acl.concat %w[allow 127.0.0.1] if acl.empty?
+        end
+      end
+    end
+    add_configuration_for :Drb
+    
+    class RailsConfiguration < AbstractConfiguration
+      
+      SUPPORTED_RAILS_ENVIRONMENTS = [:development, :test, :production]
+      
+      attr_accessor :rails_root, :environment
+      def initialize(options)
+        path_to_rails, environment = check_options options
+        @rails_root = File.expand_path(path_to_rails)
+        @environment = environment.to_sym
+        raise ArgumentError, "Unrecognized environment type #@environment. Supported: " +
+          SUPPORTED_RAILS_ENVIRONMENTS.to_sentence unless SUPPORTED_RAILS_ENVIRONMENTS.include?(@environment)
+      end
+    
+      private
+      
+      def check_options(options)
+        options = options.clone
+        path    = options.delete :path
+        env     = options.delete :env
+        raise ArgumentError, "Unrecognied argument(s) #{options.keys.to_sentence} in Rails initializer!" unless options.size.zero?
+        raise ArgumentError, "Must supply an :env argument to the Rails initializer!" unless env
+        raise ArgumentError, "Must supply an :path argument to the Rails initializer!" unless path
+        [path, env]
+      end
+    
+    end
+    add_configuration_for :Rails
+    
+  end
+end

data/lib/adhearsion/initializer/database.rb

@@ -0,0 +1,92 @@
+# TODO: Have all of the initializer modules required and then traverse the subclasses, asking them if they're enabled. If they are enabled, then they should do their initialization stuff. Is this really necessary to develop this entirely new system when the components system exists?
+
+module Adhearsion
+  class Initializer
+    
+    class DatabaseInitializer
+      
+      class << self
+
+        def start
+          require_dependencies
+          require_models
+          @@config = Adhearsion::AHN_CONFIG.database
+          ActiveRecord::Base.allow_concurrency = true
+          establish_connection
+          create_call_hook_for_connection_cleanup
+        end
+
+        def stop
+          ActiveRecord::Base.remove_connection
+        end
+
+        private
+
+        def create_call_hook_for_connection_cleanup
+          Hooks::BeforeCall.create_hook do
+            ActiveRecord::Base.verify_active_connections!
+          end
+        end
+
+        def require_dependencies
+          require 'active_record'
+        end
+
+        def require_models
+          all_models.each do |model|
+            load model
+          end
+        end
+        
+        def establish_connection
+          ActiveRecord::Base.establish_connection @@config.connection_options
+        end
+
+      end
+    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

data/lib/adhearsion/initializer/drb.rb

@@ -0,0 +1,25 @@
+require 'drb'
+require 'drb/acl'
+require 'thread'
+
+module Adhearsion
+  class Initializer
+
+    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
+          ahn_log "Starting DRb on #{config.host}:#{config.port}"
+        end
+  
+        def stop
+          DRb.stop_service
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/initializer/freeswitch.rb

@@ -0,0 +1,22 @@
+# THIS FREESWITCH LIBRARY HASN'T BEEN INTEGRATED INTO THE REFACTORED 0.8.0 YET.
+# WHAT EXISTS HERE IS OLD, MUST BE CHANGED, AND DOES NOT EVEN GET LOADED AT THE MOMENT.
+require "adhearsion/voip/freeswitch/oes_server"
+require "adhearsion/voip/freeswitch/event_handler"
+require "adhearsion/voip/freeswitch/inbound_connection_manager"
+require "adhearsion/voip/dsl/dialplan/control_passing_exception"
+
+oes_enabled = Adhearsion::Configuration.core.voip.freeswitch.oes && Adhearsion::Configuration.core.voip.freeswitch.oes.port
+                
+
+if oes_enabled
+
+  port = Adhearsion::Configuration.core.voip.freeswitch.oes.port
+  host = Adhearsion::Configuration.core.voip.freeswitch.oes.host
+
+  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 }
+
+end

data/lib/adhearsion/initializer/paths.rb

@@ -0,0 +1,55 @@
+module Adhearsion
+  
+  # Paths are a way for helpers to have Adhearsion manage dynamic
+  # paths.
+  module Paths
+    
+    # May need to build some kind of namespacing?
+    
+    @@path_managers = {}
+    
+    def self.manager_for(name, hash)
+      globs = Array hash[:pattern] || hash[:patterns]
+      directory = hash[:directory]
+      name = name.to_s.underscore
+      singular, plural = name.singularize, name.pluralize
+      @@path_managers[singular] = globs
+      #TODO: YAGNI.  Bad magic
+      Kernel.module_eval do
+        define_method "#{singular}_path" do |query|
+          target = nil
+          globs.each do |mgr|
+            Dir.glob(mgr).each do |f|
+              #return f if File.basename(f) == query
+              target = File.expand_path(f) if File.basename(f) == query
+            end
+          end
+          target
+        end
+        define_method "all_#{plural}" do
+          globs.map { |g| Dir.glob g }.flatten
+        end
+      end
+    end
+    
+    def self.manager_for?(name)
+      @@path_managers[name.to_s.underscore.singularize]
+    end
+    
+    def self.remove_manager_for(name)
+      name = name.to_s
+      singular, plural = name.singularize, name.pluralize
+      Kernel.module_eval do
+        undef_method "all_#{plural}", "#{singular}_path"
+      end
+    end
+
+    # When creating with a combined managers, the first
+    # writable directory is returned.
+    def self.combine_managers(name, *managers)
+      # TODO: Searches several managers in sequence.
+      name = name.to_s.underscore
+      singular, plural = name.singularize, name.pluralize
+    end
+  end
+end

data/lib/adhearsion/initializer/rails.rb

@@ -0,0 +1,40 @@
+require 'adhearsion/voip/asterisk'
+
+module Adhearsion
+  class Initializer    
+    class RailsInitializer
+      
+      cattr_accessor :rails_root, :config, :environment
+      class << self
+        
+        def start
+          ahn_config       = Adhearsion::AHN_CONFIG
+          self.config      = ahn_config.rails
+          self.rails_root  = config.rails_root 
+          self.environment = config.environment
+          raise "You cannot enable the database and Rails at the same time!" if ahn_config.database_enabled?
+          raise "Error loading Rails environment in #{rails_root.inspect}. "  +
+                "It's not a directory!" unless File.directory?(rails_root)
+          load_rails
+          if defined? ActiveRecord
+            ActiveRecord::Base.allow_concurrency = true
+            Hooks::BeforeCall.create_hook do
+              ActiveRecord::Base.verify_active_connections!
+            end
+          end
+        end
+        
+        private
+        
+        def load_rails
+          environment_file = File.expand_path(rails_root + "/config/environment.rb")
+          raise "There is no config/environment.rb file!" unless File.exists?(environment_file)
+          ENV['RAILS_ENV'] = environment.to_s
+          require environment_file
+        end
+        
+      end
+      
+    end
+  end
+end