eric-adhearsion 0.7.999 → 0.8.0

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.rb

@@ -1,6 +1,45 @@
 module Adhearsion
   
+  class << self
+    
+    ##
+    # Shuts down the framework.
+    #
+    def self.shutdown!
+      ahn_log "Shutting down gracefully at #{Time.now}."
+      Events.stop!
+      exit
+    end    
+    
+  end
   class PathString < String
+    
+    class << self
+      
+      ##
+      # Will return a PathString for the application root folder to which the specified arbitrarily nested subfolder belongs.
+      # It works by traversing parent directories looking for the .ahnrc file. If no .ahnrc is found, nil is returned.
+      #
+      # @param [String] folder The path to the directory which should be a 
+      # @return [nil] if the subdirectory does not belong to a parent Adhearsion app directory
+      # @return [PathString] if a directory is found 
+      #
+      def from_application_subdirectory(folder)
+        folder = File.expand_path folder
+        ahn_rc = nil
+        
+        until ahn_rc || folder == "/"
+          possible_ahn_rc = File.join(folder, ".ahnrc")
+          if File.exists?(possible_ahn_rc)
+            ahn_rc = possible_ahn_rc
+          else
+            folder = File.expand_path(folder + "/..")
+          end
+        end
+        ahn_rc ? new(folder) : nil
+      end
+    end
+    
     attr_accessor :component_path, :dialplan_path, :log_path
     
     def initialize(path)
@@ -27,10 +66,6 @@ module Adhearsion
       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)
@@ -41,9 +76,7 @@ module Adhearsion
     
     class << self
       def get_rules_from(location)
-        if File.directory? location
-          location = File.join location, ".ahnrc"
-        end
+        location = File.join location, ".ahnrc" if File.directory? location
         File.exists?(location) ? YAML.load_file(location) : nil
       end
       
@@ -55,18 +88,19 @@ module Adhearsion
         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
-        new(ahn_app_path, :loaded_init_files => file)
+        start ahn_app_path, :loaded_init_files => file
       end
       
     end
   
     attr_reader :path, :daemon, :pid_file, :log_file, :ahn_app_log_directory
     
-    DEFAULT_RULES = { :pattern   => "*.rb",
-                      :directory => "helpers"}
-    
     # Creation of pid_files
     #
     #  - You may want to have Adhearsion create a process identification
@@ -80,39 +114,49 @@ module Adhearsion
     #    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]
+      @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
+      load_all_init_files
+      init_components_subsystem
+      init_modules
+      init_events_subsystem
       create_pid_file if pid_file
       load_components
+      init_events_file
       
       ahn_log "Adhearsion initialized!"
       
       trigger_after_initialized_hooks
-      join_framework_threads
+      join_important_threads
+      
+      self
     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?
-        Adhearsion::Logging::AdhearsionLogger.outputters  = file_logger
-      else
-        Adhearsion::Logging::AdhearsionLogger.outputters << file_logger
+    def default_pid_path
+      File.join AHN_ROOT, 'adhearsion.pid'
+    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
-      Adhearsion::Logging::DefaultAdhearsionLogger.redefine_outputters
     end
     
     def resolve_log_file_path      
@@ -120,16 +164,99 @@ module Adhearsion
       @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
+    def switch_to_root_directory
+      Dir.chdir AHN_ROOT
+    end
+    
+    def catch_termination_signal
+      %w'INT TERM'.each do |process_signal|
+        trap process_signal do
+          ahn_log "Shutting down gracefully at #{Time.now}."
+          Events.trigger :shutdown
+          exit
         end
-        
-        Hooks::TearDown.create_hook do
-          File.delete(pid_file) if File.exists?(pid_file)
+      end
+    end
+    
+    ##
+    # This step in the initialization process loads the .ahnrc in the given app folder. With the information in .ahnrc, we
+    # can continue the initialization knowing where certain files are specifically.
+    #
+    def bootstrap_rc
+      rules = self.class.get_rules_from AHN_ROOT
+      
+      AHN_CONFIG.ahnrc = rules
+      
+      # DEPRECATION: Check if the old paths format is being used. If so, abort and notify.
+      if rules.has_key?("paths") && rules["paths"].kind_of?(Hash)
+        paths = rules["paths"].each_pair do |key,value|
+          if value.kind_of?(Hash)
+            if value.has_key?("directory") || value.has_key?("pattern")
+              puts
+              puts *caller
+              puts
+                            
+              abort <<-WARNING
+Deprecation Warning
+-------------------
+The (hidden) .ahnrc file in this app is of an older format and needs to be fixed.
+
+There is a rake task to automatically fix it or you can do it manually. Note: it's
+best if you do it manually so you can retain the YAML comments in your .ahnrc file.
+  
+The rake task is called "deprecations:fix_ahnrc_path_format". 
+
+To do it manually, find all entries in the "paths" section of your ".ahnrc" file
+which look like the following:
+
+paths:
+  key_name_could_be_anything:
+    directory: some_folder
+    pattern: *.rb
+
+Note: the "models" section had this syntax before:
+
+models:
+  directory: models
+  pattern: "*.rb"
+
+The NEW syntax is as follows (using models as an example):
+
+models: models/*.rb
+
+This new format is much cleaner.
+
+Adhearsion will abort until you fix this. Sorry for the incovenience.
+              WARNING
+            end
+          end
         end
       end
+      
+      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 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 init_modules
@@ -146,28 +273,23 @@ module Adhearsion
       # 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
+    def init_events_subsystem
+      application_events_files = AHN_CONFIG.files_from_setting("paths", "events")
+      if application_events_files.any?
+        Events.register_callback(:shutdown) do
+          ahn_log.events "Performing a graceful stop of events subsystem"
+          Events.framework_theatre.graceful_stop!
+        end
+        Events.framework_theatre.start!
+      else
+        ahn_log.events.warn 'No entries in the "events" section of .ahnrc. Skipping its initialization.'
       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
-      if Paths.manager_for? "init"
-        init_files_from_rc = all_inits.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 }
+    def init_events_file
+      application_events_files = AHN_CONFIG.files_from_setting("paths", "events")
+      application_events_files.each do |file|
+        Events.framework_theatre.load_events_file file
       end
     end
     
@@ -181,35 +303,69 @@ module Adhearsion
       daemonize log_file
     end
     
-    def load_components
-      ComponentManager.load
-      ComponentManager.start
+    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 trigger_after_initialized_hooks
-      Hooks::AfterInitialized.trigger_hooks
+    def create_pid_file(file = pid_file)
+      if file
+        File.open pid_file, 'w' do |file|
+          file.puts Process.pid
+        end
+        
+        Events.register_callback :shutdown do
+          File.delete(pid_file) if File.exists?(pid_file)
+        end
+      end
     end
     
-    def join_framework_threads
-      Hooks::ThreadsJoinedAfterInitialized.trigger_hooks
+    def init_components_subsystem
+      @components_directory = File.expand_path "components"
+      if File.directory? @components_directory
+        Components.component_manager = Components::ComponentManager.new @components_directory
+        Kernel.send(:const_set, :COMPONENTS, Components.component_manager.lazy_config_loader)
+        Components.component_manager.globalize_global_scope!
+        Components.component_manager.extend_object_with(Theatre::CallbackDefinitionLoader, :events)
+      else
+        ahn_log.warn "No components directory found. Not initializing any components."
+      end
     end
     
-    def bootstrap_rc
-      rules = Initializer.get_rules_from(AHN_ROOT) || DEFAULT_RULES
-      paths = rules['paths'] || DEFAULT_RULES
-      paths.each_pair do |k,v|
-        if v.kind_of? Hash
-          directory, pattern = v['directory'] || '.', v['pattern'] || '*'
-          Paths.manager_for k, :pattern => File.join(directory, pattern)
-        else
-          directory, pattern = '.', v
-          Paths.manager_for k, :pattern => File.join(directory,pattern)
-        end
+    def load_components
+      if Components.component_manager
+        Components.component_manager.load_components
       end
     end
     
-    def default_pid_path
-      File.join AHN_ROOT, 'adhearsion.pid'
+    def trigger_after_initialized_hooks
+      Events.trigger_immediately :after_initialized
+    end
+    
+    ##
+    # This method will block Thread.main() until calling join() has returned for all Threads in IMPORTANT_THREADS.
+    # Note: IMPORTANT_THREADS won't always contain Thread instances. It simply requires the objects respond to join().
+    #
+    def join_important_threads
+      # Note: we're using this ugly accumulator to ensure that all threads have ended since IMPORTANT_THREADS will almost
+      # certainly change sizes after this method is called.
+      index = 0
+      until index == IMPORTANT_THREADS.size
+        begin
+          IMPORTANT_THREADS[index].join
+        rescue => e
+          ahn_log.error "Error after join()ing Thread #{thread.inspect}. #{e.message}"
+        ensure
+          index = index + 1
+        end
+      end
     end
     
     class InitializationFailedError < Exception; end

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