sant0sk1-adhearsion 0.7.999

data/lib/adhearsion/initializer.rb

@@ -0,0 +1,246 @@
+module Adhearsion
+  
+  class PathString < String
+    attr_accessor :component_path, :dialplan_path, :log_path
+    
+    def initialize(path)
+      super
+      defaults
+    end
+    
+    def defaults
+      @component_path = build_path_for "components"
+      @dialplan_path  = dup
+      @log_path       = build_path_for "logs"
+    end
+
+    def base_path=(value)
+      replace(value)
+      defaults
+    end
+    
+    def using_base_path(temporary_base_path, &block)
+      original_path = dup
+      self.base_path = temporary_base_path
+      block.call
+    ensure
+      self.base_path = original_path
+    end
+    
+    def dial_plan_named(name)
+      File.join(dialplan_path, name)
+    end
+    
+    private
+      def build_path_for(path)
+        File.join(to_s, path)
+      end
+  end
+  
+  class Initializer
+    
+    class << self
+      def get_rules_from(location)
+        location = File.join location, ".ahnrc" if File.directory? location
+        File.exists?(location) ? YAML.load_file(location) : nil
+      end
+      
+      def ahn_root=(path)
+        if Object.constants.include?("AHN_ROOT")
+          Object.const_get(:AHN_ROOT).base_path = File.expand_path(path)
+        else
+          Object.const_set(:AHN_ROOT, PathString.new(File.expand_path(path)))
+        end
+      end
+      
+      def start(*args, &block)
+        new(*args, &block).start
+      end
+      
+      def start_from_init_file(file, ahn_app_path)
+        return if defined?(@@started) && @@started
+        start ahn_app_path, :loaded_init_files => file
+      end
+      
+    end
+  
+    attr_reader :path, :daemon, :pid_file, :log_file, :ahn_app_log_directory
+    
+    DEFAULT_FRAMEWORK_EVENT_NAMESPACES = %w[
+      /framework/after_initialized
+      /framework/shutdown
+    ]
+    
+    # Creation of pid_files
+    #
+    #  - You may want to have Adhearsion create a process identification
+    #    file when it boots so that a crash monitoring program such as
+    #    Monit can reboot if necessary or so the init script can kill it
+    #    for system shutdowns.
+    #  - To have Adhearsion create a pid file in the default location (i.e.
+    #    AHN_INSTALL_DIR/adhearsion.pid), supply :pid_file with 'true'. Otherwise
+    #    one is not created UNLESS it is running in daemon mode, in which
+    #    case one is created. You can force Adhearsion to not create one
+    #    even in daemon mode by supplying "false".
+    def initialize(path=nil, options={})
+      @@started = true
+      @path     = path
+      @daemon   = options[:daemon]
+      @pid_file = options[:pid_file].nil? ? ENV['PID_FILE'] : options[:pid_file]
+      @loaded_init_files  = options[:loaded_init_files]
+    end
+    
+    def start
+      self.class.ahn_root = path
+      resolve_pid_file_path
+      resolve_log_file_path
+      switch_to_root_directory
+      catch_termination_signal
+      bootstrap_rc
+      load_all_init_files
+      init_modules
+      daemonize! if should_daemonize?
+      initialize_log_file
+      create_pid_file if pid_file
+      load_components
+      init_events
+      ahn_log "Adhearsion initialized!"
+      
+      trigger_after_initialized_hooks
+      join_framework_threads
+      
+      self
+    end
+    
+    def init_events
+        # 
+        # framework = 
+        # DEFAULT_FRAMEWORK_EVENT_NAMESPACES.each do |namespace|
+        #   .register_callback_name framework_event_callback_name
+        # end
+        ############
+        # else #...
+        # ahn_log.events.warn 'No "events" section in .ahnrc. Skipping its initialization.'
+    end
+    
+    def initialize_log_file
+      Dir.mkdir(ahn_app_log_directory) unless File.directory? ahn_app_log_directory
+      file_logger = Log4r::FileOutputter.new("Main Adhearsion log file", :filename => log_file, :trunc => false)
+      
+      if should_daemonize?
+        Logging::AdhearsionLogger.outputters  = file_logger
+      else
+        Logging::AdhearsionLogger.outputters << file_logger
+      end
+      Logging::DefaultAdhearsionLogger.redefine_outputters
+    end
+    
+    def resolve_log_file_path      
+      @ahn_app_log_directory = AHN_ROOT + '/log'
+      @log_file = File.expand_path(ahn_app_log_directory + "/adhearsion.log")
+    end
+    
+    def create_pid_file(file = pid_file)
+      if file
+        File.open pid_file, 'w' do |file|
+          file.puts Process.pid
+        end
+        
+        Hooks::TearDown.create_hook do
+          File.delete(pid_file) if File.exists?(pid_file)
+        end
+      end
+    end
+    
+    def init_modules
+      require 'adhearsion/initializer/database.rb'
+      require 'adhearsion/initializer/asterisk.rb'
+      require 'adhearsion/initializer/drb.rb'
+      require 'adhearsion/initializer/rails.rb'
+      # require 'adhearsion/initializer/freeswitch.rb'
+      
+      DatabaseInitializer.start if AHN_CONFIG.database_enabled?
+      AsteriskInitializer.start if AHN_CONFIG.asterisk_enabled?
+      DrbInitializer.start      if AHN_CONFIG.drb_enabled?
+      RailsInitializer.start    if AHN_CONFIG.rails_enabled?
+      # FreeswitchInitializer.start if AHN_CONFIG.freeswitch_enabled?
+    end
+    
+    def resolve_pid_file_path
+      @pid_file = if pid_file.equal?(true) then default_pid_path
+      elsif pid_file then pid_file
+      elsif pid_file.equal?(false) then nil
+      # FIXME @pid_file = @daemon? Assignment or equality? I'm assuming equality.
+      else @pid_file = @daemon ? default_pid_path : nil
+      end
+    end
+    
+    def switch_to_root_directory
+      Dir.chdir AHN_ROOT
+    end
+    
+    def catch_termination_signal
+      Hooks::TearDown.catch_termination_signals
+    end
+    
+    def load_all_init_files
+      init_files_from_rc = AHN_CONFIG.files_from_setting("paths", "init").map { |file| File.expand_path(file) }
+      already_loaded_init_files = Array(@loaded_init_files).map { |file| File.expand_path(file) }
+      (init_files_from_rc - already_loaded_init_files).each { |init| load init }
+    end
+    
+    def should_daemonize?
+      @daemon || ENV['DAEMON']
+    end
+    
+    def daemonize!
+      ahn_log "Daemonizing now! Creating #{pid_file}."
+      extend Adhearsion::CustomDaemonizer
+      daemonize log_file
+    end
+    
+    def load_components
+      ComponentManager.load
+      ComponentManager.start
+    end
+    
+    def trigger_after_initialized_hooks
+      Hooks::AfterInitialized.trigger_hooks
+    end
+    
+    def join_framework_threads
+      Hooks::ThreadsJoinedAfterInitialized.trigger_hooks
+    end
+    
+    def bootstrap_rc
+      rules = self.class.get_rules_from AHN_ROOT
+      
+      AHN_CONFIG.ahnrc = rules
+      
+      gems = rules['gems']
+      if gems.kind_of?(Hash) && gems.any? && respond_to?(:gem)
+        gems.each_pair do |gem_name,properties_hash|
+          if properties_hash && properties_hash["version"]
+            gem gem_name, properties_hash["version"]
+          else
+            gem gem_name
+          end
+          if properties_hash
+            case properties_hash["require"]
+              when Array
+                properties_hash["require"].each { |lib| require lib }
+              when String
+                require properties_hash["require"]
+            end 
+          end
+        end
+      end
+    end
+    
+    def default_pid_path
+      File.join AHN_ROOT, 'adhearsion.pid'
+    end
+    
+    class InitializationFailedError < 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,236 @@
+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 ahnrc
+      @ahnrc
+    end
+    
+    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
+    
+    def files_from_setting(*path_through_config)
+      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
+    
+    def initialize
+      @automatically_answer_incoming_calls = true
+      @end_call_on_hangup                  = true
+      @end_call_on_error                   = true
+      yield self if block_given?
+    end
+    
+    private
+    
+    def files_from_glob(glob)
+      Dir.glob "#{AHN_ROOT}/#{glob}"
+    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