sant0sk1-adhearsion 0.7.999

data/lib/adhearsion/initializer/database.rb

@@ -0,0 +1,49 @@
+# 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
+          AHN_CONFIG.files_from_setting("paths", "models").each do |model|
+            load model
+          end
+        end
+        
+        def establish_connection
+          ActiveRecord::Base.establish_connection @@config.connection_options
+        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/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

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

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + "/dsl/numerical_string"
+require File.dirname(__FILE__) + "/asterisk/agi_server"
+require File.dirname(__FILE__) + "/asterisk/ami"
+require File.dirname(__FILE__) + "/asterisk/commands"
+
+# These will soon replace hooks
+#
+# [:before_call, :after_call, :hungup_call, :failed_call].each do |callback_name|
+#   Adhearsion::Events.framework_theatre.namespace_manager.register_namespace_name [:asterisk, callback_name]
+# 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)
+              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")
+            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

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

@@ -0,0 +1,147 @@
+require 'rubygems'
+require 'pp'
+require 'yaml'
+require 'socket'
+require 'thread'
+require 'monitor'
+require 'adhearsion/voip/asterisk/ami/parser'
+require 'adhearsion/voip/asterisk/ami/actions'
+
+module Adhearsion
+  module VoIP
+    module Asterisk
+      class AMI
+        
+        include Actions
+        
+        attr_reader :action_sock, :host, :user, :password, :port, :event_thread, :scanner, :version
+
+        def initialize(user, pass, host='127.0.0.1', options={})
+          @host, @user, @password, @port = host, user, pass, options[:port] || 5038
+          @events_enabled = options[:events]
+        end
+        
+        include Adhearsion::Publishable
+        
+        publish :through => :proxy do
+          
+          def originate(options={})
+            options[:callerid] = options.delete :caller_id if options[:caller_id]
+            execute_ami_command! :originate, options
+          end
+
+          def ping
+            execute_ami_command! :ping
+          end
+          
+          # An introduction connects two endpoints together. The first argument is
+          # the first person the PBX will call. When she's picked up, Asterisk will
+          # play ringing while the second person is being dialed.
+          #
+          # The first argument is the person called first. Pass this as a canonical
+          # IAX2/server/user type argument. Destination takes the same format, but
+          # comma-separated Dial() arguments can be optionally passed after the
+          # technology.
+          #
+          # TODO: Provide an example when this works.
+          def introduce(caller, callee, opts={})
+            dial_args  = callee
+            dial_args += "|#{opts[:options]}" if opts[:options]
+            call_and_exec caller, "Dial", :args => dial_args, :caller_id => opts[:caller_id]
+          end
+
+          def call_and_exec(channel, app, opts={})
+            args = { :channel => channel, :application => app }
+            args[:caller_id] = opts[:caller_id] if opts[:caller_id]
+            args[:data] = opts[:args] if opts[:args]
+            originate args
+          end
+          
+          def call_into_context(channel, context, options={})
+            args = {:channel => channel, :context => context}
+            args[:priority] = options[:priority] || 1
+            args[:extension] = options[:extension] if options[:extension]
+            args[:caller_id] = options[:caller_id] if options[:caller_id]
+            if options[:variables] && options[:variables].kind_of?(Hash)
+              args[:variable] = options[:variables].map {|pair| pair.join('=')}.join('|')
+            end
+            originate args
+          end
+
+          def method_missing(name, hash={}, &block)
+            execute_ami_command! name, hash, &block
+          end
+
+        end
+
+        def connect!
+          disconnect!
+          start_event_thread! if events_enabled?
+          login! host, user, password, port, events_enabled?
+        end
+        
+        def disconnect!
+          action_sock.close if action_sock && !action_sock.closed?
+          event_thread.kill if event_thread
+          scanner.stop if scanner
+        end
+
+        def events_enabled?
+          @events_enabled
+        end
+        
+        private
+  
+        def login!(host, user, pass, port, events)
+          begin
+            @action_sock = TCPSocket.new host, port
+          rescue Errno::ECONNREFUSED => refusal_error
+            raise Errno::ECONNREFUSED, "Could not connect with AMI to Asterisk server at #{host}:#{port}. " +
+                                       "Is enabled set to 'yes' in manager.conf?"
+          end
+          action_sock.extend(MonitorMixin)
+          @scanner = Parser.new
+          @version = scanner.run(action_sock)
+          begin
+            execute_ami_command! :login, :username => user, :secret => password, :events => (events_enabled? ? "On" : "Off")
+          rescue ActionError
+            raise AuthenticationFailedException, "Invalid AMI username/password! Check manager.conf."
+          else
+            # puts "Manager connection established to #{host}:#{port} with user '#{user}'"
+          end
+        end
+  
+        def execute_ami_command!(name, options={}, &block)
+          action = Action.build(name, options, &block)
+          action_sock.synchronize do
+            connect! if !action_sock || action_sock.closed?
+            action_sock.write action.to_s
+          end
+          
+          return unless action.has_response?
+          scanner.wait(action)
+        end
+        
+        def start_event_thread!
+          @event_thread = Thread.new(scanner) do |scanner|
+            loop do
+              # TODO: This is totally screwed up. __read_event doesn't exist.
+              AMI::EventHandler.handle! __read_event(scanner.events.pop)
+            end
+          end
+          event_thread.abort_on_exception = true
+        end
+  
+        # Method simply defined as private to prevent method_missing from catching it.
+        def events() end
+  
+        class EventHandler
+          # TODO: Refactor me!
+        end
+  
+        class AuthenticationFailedException < Exception; end
+        class ActionError < RuntimeError; end
+      end
+    end
+  end
+end