jicksta-adhearsion 0.7.999

data/lib/adhearsion/initializer.rb

@@ -0,0 +1,373 @@
+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)
+      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
+    
+    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
+    
+    # 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
+      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_important_threads
+      
+      self
+    end
+    
+    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
+    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 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
+      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
+      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 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 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
+    
+    def should_daemonize?
+      @daemon || ENV['DAEMON']
+    end
+    
+    def daemonize!
+      ahn_log "Daemonizing now! Creating #{pid_file}."
+      extend Adhearsion::CustomDaemonizer
+      daemonize log_file
+    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 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 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 load_components
+      if Components.component_manager
+        Components.component_manager.load_components
+      end
+    end
+    
+    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
+  end
+end

data/lib/adhearsion/logging.rb

@@ -0,0 +1,92 @@
+require 'log4r'
+
+module Adhearsion
+  module Logging
+    
+    @@logging_level_lock = Mutex.new
+    
+    class << self
+      
+      def silence!
+        self.logging_level = :fatal
+      end
+
+      def unsilence!
+        self.logging_level = :info
+      end
+      
+      def logging_level=(new_logging_level)
+        new_logging_level = Log4r.const_get(new_logging_level.to_s.upcase)
+        @@logging_level_lock.synchronize do
+          @@logging_level = new_logging_level
+          Log4r::Logger.each_logger do |logger|
+            logger.level = new_logging_level
+          end
+        end
+      end
+      
+      def logging_level
+        @@logging_level_lock.synchronize do
+          return @@logging_level ||= Log4r::INFO
+        end
+      end
+    end
+    
+    class AdhearsionLogger < Log4r::Logger
+      
+      @@outputters = [Log4r::Outputter.stdout]
+      
+      class << self
+        def outputters
+          @@outputters
+        end
+        
+        def outputters=(other)
+          @@outputters = other
+        end
+      end
+      
+      def initialize(*args)
+        super
+        redefine_outputters
+      end
+      
+      def redefine_outputters
+        self.outputters = @@outputters
+      end
+      
+      def method_missing(logger_name, *args, &block)
+        define_logging_method(logger_name, self.class.new(logger_name.to_s))
+        send(logger_name, *args, &block)
+      end
+      
+      private
+      
+      def define_logging_method(name, logger)
+        # Can't use Module#define_method() because blocks in Ruby 1.8.x can't
+        # have their own block arguments.
+        self.class.class_eval(<<-CODE, __FILE__, __LINE__)
+          def #{name}(*args, &block)
+            logger = Log4r::Logger['#{name}']
+            if args.any? || block_given?
+              logger.info(*args, &block)
+            else
+              logger
+            end
+          end
+        CODE
+      end
+    end
+    
+    DefaultAdhearsionLogger = AdhearsionLogger.new 'ahn'
+    
+  end
+end
+
+def ahn_log(*args)
+  if args.any?
+    Adhearsion::Logging::DefaultAdhearsionLogger.info(*args)
+  else
+    Adhearsion::Logging::DefaultAdhearsionLogger
+  end
+end

data/lib/adhearsion/tasks/database.rb

@@ -0,0 +1,5 @@
+task:migrate do
+  require 'active_record'
+  %w.db/migrate db/ahn..each
+  ActiveRecord::Migrator.migrate 'db/migrate', ENV['VERSION'] ? ENV['VERSION'].to_i : nil
+end

data/lib/adhearsion/tasks/deprecations.rb

@@ -0,0 +1,59 @@
+namespace :deprecations do
+  desc <<-DESC
+Older versions of Adhearsion had an .ahnrc "paths" section similar to the following...
+
+  paths:
+    models:
+      directory: models
+      pattern: *.rb
+
+This has been deprecated. The new format is this:
+
+  paths:
+    models: {models,gui/app/models}/*.rb
+
+This Rake task will fix your .ahnrc if you have 
+  DESC
+  task :fix_ahnrc_path_format do
+    puts "\nThis will remove all comments from your .ahnrc file. A backup will be created as .ahnrc.backup."
+    puts "If you wish to do this manually to preserve your comments, simply overwrite .ahnrc with .ahnrc.backup"
+    puts "and apply the change manually."
+    puts 
+    
+    require 'fileutils'
+    require 'yaml'
+    
+    ahnrc_file = File.expand_path(".ahnrc")
+    
+    FileUtils.cp ahnrc_file, ahnrc_file + ".backup"
+    ahnrc_contents = YAML.load_file ahnrc_file
+    
+    abort '.ahnrc does not have a "paths" section!' unless ahnrc_contents.has_key? "paths"
+    
+    paths = ahnrc_contents["paths"]
+    paths.clone.each_pair do |key,value|
+      if value.kind_of?(Hash)
+        if value.has_key?("directory") || value.has_key?("pattern")
+          directory, pattern = value.values_at "directory", "pattern"
+          new_path = "#{directory}/#{pattern}"
+          
+          puts "!!! CHANGING KEY #{key.inspect}!"
+          puts "!!! NEW: #{new_path.inspect}"
+          puts "!!! OLD:\n#{{key => value}.to_yaml.sub("---", "")}\n\n"
+          
+          paths[key] = new_path
+        end
+      end
+    end
+    
+    ahnrc_contents["paths"] = paths
+    new_yaml = ahnrc_contents.to_yaml.gsub("--- \n", "")
+    
+    puts "New .ahnrc file:\n" + ("#" * 25) + "\n"
+    puts new_yaml
+    puts '#' * 25
+    
+    File.open(ahnrc_file, "w") { |file| file.puts new_yaml }
+    puts "Wrote to .ahnrc. Done!"
+  end
+end

data/lib/adhearsion/tasks/generating.rb

@@ -0,0 +1,20 @@
+namespace:create do
+
+  task:war do
+    # Hmm, this will is a tough one
+  end
+  
+  task:rails_plugin do
+    
+  end
+
+  task:migration do
+    name = ARGV.shift
+  end
+end
+
+namespace:delete do
+  task:migration do
+    # Take arg.underscore and remove it
+  end
+end

data/lib/adhearsion/tasks/lint.rb

@@ -0,0 +1,4 @@
+task :sanity do
+  puts "Performing many checks on your Adhearsion application!"
+  # TODO: Anything that should be brought to the user's attention should be placed here!
+end

data/lib/adhearsion/tasks/testing.rb

@@ -0,0 +1,37 @@
+namespace:test do
+  desc "Run tests for a component specified by COMPONENT=<component_name>.  If no component is specified, tests will be executed for all components"
+  task :component do
+    component = ENV['COMPONENT']
+    components_to_test = component.nil? ? all_component_directories : [full_path_for(component)]
+    components_to_test.each do |component_name|
+      setup_and_execute(component_name)
+    end
+  end
+  
+  private  
+  
+    def setup_and_execute(component_path)
+      task = create_test_task_for(component_path)
+      Rake::Task[task.name].execute
+    end
+    
+    def create_test_task_for(component_path)
+      Rake::TestTask.new(task_name_for(component_path)) do |t|
+         t.libs = ["lib", "test"].map{|subdir| File.join(component_path, subdir)}
+         t.test_files = FileList["#{component_path}/test/test_*.rb"]
+         t.verbose = true
+       end
+    end
+    
+    def task_name_for(component_path)
+      "test_#{component_path.split(/\//).last}"
+    end
+    
+    def all_component_directories
+      Dir['components/*']
+    end
+  
+    def full_path_for(component)
+      component =~ /^components\// ? component : File.join("components", component)
+    end
+end

data/lib/adhearsion/tasks.rb

@@ -0,0 +1,16 @@
+require 'rake/testtask'
+require 'adhearsion'
+require 'adhearsion/tasks/database'
+require 'adhearsion/tasks/testing'
+require 'adhearsion/tasks/generating'
+require 'adhearsion/tasks/lint'
+require 'adhearsion/tasks/deprecations'
+
+namespace :adhearsion do
+  desc "Dump useful information about this application's adhearsion environment"
+  task :about do
+    puts "Adhearsion version: #{Adhearsion::VERSION::STRING}"
+  end
+end
+
+task :default => "adhearsion:about"

data/lib/adhearsion/version.rb

@@ -0,0 +1,9 @@
+module Adhearsion #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0   unless defined? MAJOR
+    MINOR = 7   unless defined? MINOR
+    TINY  = 999 unless defined? TINY
+
+    STRING = [MAJOR, MINOR, TINY].join('.') unless defined? STRING
+  end
+end

data/lib/adhearsion/voip/asterisk/agi_server.rb

@@ -0,0 +1,81 @@
+require 'gserver'
+module Adhearsion
+  module VoIP
+    module Asterisk
+      module AGI
+        class Server
+          
+          class RubyServer < GServer
+            
+            def initialize(port, host)
+              super(port, host, (1.0/0.0)) # (1.0/0.0) == Infinity
+            end
+            
+            def serve(io)
+              call = Adhearsion.receive_call_from(io)
+              Events.trigger_immediately([:asterisk, :before_call], call)
+          	  ahn_log.agi "Handling call with variables #{call.variables.inspect}"
+          	  
+          	  return DialPlan::ConfirmationManager.handle(call) if DialPlan::ConfirmationManager.confirmation_call?(call)
+          	  
+      	      # This is what happens 99.9% of the time.
+      	      
+      	      DialPlan::Manager.handle call
+            rescue DialPlan::Manager::NoContextError => e
+              ahn_log.agi e.message
+              call.hangup!
+            rescue FailedExtensionCallException => failed_call
+              begin
+                ahn_log.agi "Received \"failed\" meta-call with :failed_reason => #{failed_call.call.failed_reason.inspect}. Executing Executing /asterisk/failed_call event callbacks."
+                Events.trigger [:asterisk, :failed_call], failed_call.call
+                call.hangup!
+              rescue => e
+                ahn_log.agi.error e
+              end
+            rescue HungupExtensionCallException => hungup_call
+              begin
+                ahn_log.agi "Received \"h\" meta-call. Executing /asterisk/call_hangup event callbacks."
+                Events.trigger [:asterisk, :call_hangup], hungup_call.call
+                call.hangup!
+              rescue => e
+                ahn_log.agi.error e
+              end
+            rescue UselessCallException
+              ahn_log.agi "Ignoring meta-AGI request"
+              call.hangup!
+        	  # TBD: (may have more hooks than what Jay has defined in hooks.rb)
+            rescue => e
+              ahn_log.agi.error e.inspect
+              ahn_log.agi.error e.backtrace.map { |s| " " * 5 + s }.join("\n")
+            ensure
+              Adhearsion.remove_inactive_call call rescue nil
+            end
+            
+          end
+         
+          DEFAULT_OPTIONS = { :server_class => RubyServer, :port => 4573, :host => "0.0.0.0" } unless defined? DEFAULT_OPTIONS
+          attr_reader :host, :port, :server_class, :server
+
+          def initialize(options = {})
+            options                     = DEFAULT_OPTIONS.merge options
+            @host, @port, @server_class = options.values_at(:host, :port, :server_class)
+            @server                     = server_class.new(port, host)
+          end
+
+          def start
+            server.start
+          end
+
+          def shutdown
+            server.stop
+          end
+          
+          def join
+            server.join
+          end
+          
+        end
+      end
+    end
+  end
+end