eric-adhearsion 0.7.999

data/lib/adhearsion/initializer.rb

@@ -0,0 +1,217 @@
+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)
+        if File.directory? location
+          location = File.join location, ".ahnrc"
+        end
+        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_from_init_file(file, ahn_app_path)
+        return if defined?(@@started) && @@started
+        new(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
+    #    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]
+      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
+      
+      ahn_log "Adhearsion initialized!"
+      
+      trigger_after_initialized_hooks
+      join_framework_threads
+    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
+      end
+      Adhearsion::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
+      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 }
+      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 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 = 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
+      end
+    end
+    
+    def default_pid_path
+      File.join AHN_ROOT, 'adhearsion.pid'
+    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/services/scheduler.rb

@@ -0,0 +1,5 @@
+module Adhearsion
+  module Scheduler
+    
+  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/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,15 @@
+require 'rake/testtask'
+require 'adhearsion'
+require 'adhearsion/tasks/database'
+require 'adhearsion/tasks/testing'
+require 'adhearsion/tasks/generating'
+require 'adhearsion/tasks/lint'
+
+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,78 @@
+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)
+              Hooks::BeforeCall.trigger_hooks
+          	  call = Adhearsion.receive_call_from(io)
+          	  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 OnFailedCall hooks."
+                Hooks::OnFailedCall.trigger_hooks(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 OnHungupCall hooks."
+                Hooks::OnHungupCall.trigger_hooks(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")
+            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