adhearsion 1.2.6 → 2.0.0.alpha1

data/lib/adhearsion/foundation/all.rb

@@ -1,13 +1,6 @@
 require 'English'
 require 'tmpdir'
 require 'tempfile'
-begin
-  # Try ActiveSupport >= 2.3.0
-  require 'active_support/all'
-rescue LoadError
-  # Assume ActiveSupport < 2.3.0
-  require 'active_support'
-end
 
 # Require all other files here.
 Dir.glob File.join(File.dirname(__FILE__), "*rb") do |file|

data/lib/adhearsion/foundation/custom_daemonizer.rb

@@ -17,15 +17,13 @@ module Adhearsion
     end
 
     # This method causes the current running process to become a daemon
-    def daemonize(log_file='/dev/null')
+    def daemonize(log_file = '/dev/null')
       oldmode = 0
       srand # Split rand streams between spawning and daemonized process
       safefork and exit # Fork and exit from the parent
 
       # Detach from the controlling terminal
-      unless sess_id = Process.setsid
-        raise 'Cannot detach from controlled terminal'
-      end
+      raise 'Cannot detach from controlled terminal' unless sess_id = ::Process.setsid
 
       # Prevent the possibility of acquiring a controlling terminal
       if oldmode.zero?
@@ -39,7 +37,7 @@ module Adhearsion
       STDIN.reopen "/dev/null"
       STDOUT.reopen '/dev/null', "a"
       STDERR.reopen log_file, "a"
-      return oldmode ? sess_id : 0
+      oldmode ? sess_id : 0
     end
   end
-end
+end

data/lib/adhearsion/foundation/exception_handler.rb

@@ -0,0 +1,9 @@
+class Object
+  def catching_standard_errors(&block)
+    begin
+      yield
+    rescue StandardError => e
+      Adhearsion::Events.trigger :exception, e
+    end
+  end
+end

data/lib/adhearsion/foundation/object.rb

@@ -1,10 +1,28 @@
-# Monkey patch Object to support the #tap method.
-# This method is present in Ruby 1.8.7 and later.
-unless Object.respond_to?(:tap)
-  class Object
-    def tap
-      yield self
-      self
+require 'adhearsion/logging'
+
+class Object
+  def pb_logger
+    logger
+  end
+
+  def logger_id
+    self
+  end
+
+  def method_missing(method_id, *arguments, &block)
+    if method_id == Adhearsion::Logging::METHOD
+      self.class.send :define_method, method_id do
+        Logging.logger[logger_id]
+      end
+      Logging.logger[logger_id]
+    else
+      super
     end
   end
-end
+
+  def respond_to?(method_id, include_private = false)
+    return true if method_id == Adhearsion::Logging::METHOD
+
+    super
+  end
+end

data/lib/adhearsion/foundation/synchronized_hash.rb

@@ -7,14 +7,13 @@ class SynchronizedHash
     class_eval(<<-RUBY, __FILE__, __LINE__)
       def #{method_name}(*args, &block)
         @lock.synchronize do
-          @delegate.send(#{method_name.inspect}, *args, &block)
+          @delegate.send #{method_name.inspect}, *args, &block
         end
       end
     RUBY
   end
 
   # Hash-related methods
-
   atomically_delegate :[]
   atomically_delegate :[]=
   atomically_delegate :all?
@@ -73,13 +72,12 @@ class SynchronizedHash
   atomically_delegate :zip
 
   # Object-related methods
-
   atomically_delegate :inspect
   atomically_delegate :to_s
   atomically_delegate :marshal_dump
 
   def initialize(*args, &block)
-    @delegate = Hash.new(*args, &block)
+    @delegate = Hash.new *args, &block
     @lock     = Mutex.new
   end
 
@@ -92,5 +90,4 @@ class SynchronizedHash
   def with_lock(&block)
     @lock.synchronize { yield @delegate }
   end
-
-end
+end

data/lib/adhearsion/foundation/thread_safety.rb

@@ -1,7 +1,23 @@
 require 'thread'
+
 class Object
   def synchronize(&block)
     @mutex ||= Mutex.new
     @mutex.synchronize &block
   end
-end
+end
+
+class ThreadSafeArray
+  include Enumerable
+
+  def initialize
+    @mutex = Mutex.new
+    @array = []
+  end
+
+  def method_missing(method, *args, &block)
+    @mutex.synchronize do
+      @array.send method, *args, &block
+    end
+  end
+end

data/lib/adhearsion/generators/app/app_generator.rb

@@ -12,11 +12,7 @@ module Adhearsion
     class AppGenerator < Thor::Group
       include Thor::Actions
 
-      BASEDIRS = %w{
-        components
-        config
-        script
-      }
+      BASEDIRS = %w( config lib script )
 
       argument :app_action, :type => :string
       argument :app_path,   :type => :string
@@ -33,14 +29,9 @@ module Adhearsion
       def setup_project
         self.destination_root = @app_path
         BASEDIRS.each { |dir| directory dir }
-        %w{
-          .ahnrc
-          dialplan.rb
-          events.rb
-          README
-          Rakefile
-          Gemfile
-        }.each { |file| copy_file file }
+        copy_file "Gemfile"
+        copy_file "Rakefile"
+        copy_file "README.md"
       end
     end
   end

data/lib/adhearsion/generators/app/templates/Gemfile

@@ -1,10 +1,15 @@
-source "http://rubygems.org"
+source :rubygems
 
-gem "adhearsion", ">= 1.2.4"
+gem "adhearsion", :git => 'git://github.com/adhearsion/adhearsion.git', :branch => :develop
 
 #
-# Here are some example components you might like to use. Simply
-# uncomment them, run `bundle install` and enable in startup.rb.
+# Here are some example plugins you might like to use. Simply
+# uncomment them and run `bundle install`.
 #
 
-# gem 'ahn-restful-rpc'
+# gem 'adhearsion-asterisk'
+# gem 'adhearsion-rails'
+# gem 'adhearsion-activerecord'
+# gem 'adhearsion-ldap'
+# gem 'adhearsion-xmpp'
+# gem 'adhearsion-drb'

data/lib/adhearsion/generators/app/templates/Procfile

@@ -0,0 +1 @@
+ahn: bundle exec ahn start .

data/lib/adhearsion/generators/app/templates/README.md

@@ -0,0 +1,28 @@
+# Welcome to Adhearsion
+
+You've got a fresh app and you're almost ready to get started. Firstly, you'll need to configure your VoIP platform:
+
+## Asterisk
+
+Edit `extensions.conf` to include the following:
+
+```
+[your_context_name]
+exten => _.,1,AGI(agi:async)
+```
+
+and setup a user in `manager.conf` with read/write access to `all`.
+
+## Voxeo PRISM
+
+Install the [rayo-server](https://github.com/rayo/rayo-server) app into PRISM 11 and follow the [configuration guide](https://github.com/rayo/rayo-server/wiki/Single-node-and-cluster-configuration-reference).
+
+## Configure your app
+
+In `config/adhearsion.rb` you'll need to set the VoIP platform you're using, along with the correct credentials. You'll find example config there, so follow the comments.
+
+## Ready, set, go!
+
+Start your new app with "ahn start /path/to/your/app". You'll get a lovely console and should be presented with the SimonGame
+
+Check out [the Adhearsion website](http://adhearsion.com) for more details of where to go from here.

data/lib/adhearsion/generators/app/templates/config/adhearsion.rb

@@ -0,0 +1,41 @@
+# Centralized way to overwrite any Adhearsion platform or plugin configuration
+# - Execute rake adhearsion:config:desc to get the configuration options
+# - Execute rake adhearsion:config:show to get the configuration values
+#
+# To update a plugin configuration you can write either:
+#
+#    * Option 1
+#        Adhearsion.config.<plugin-name> do |config|
+#          config.<key> = <value>
+#        end
+#
+#    * Option 2
+#        Adhearsion.config do |config|
+#          config.<plugin-name>.<key> = <value>
+#        end
+
+Adhearsion.config do |config|
+
+  config.development do |dev|
+    dev.platform.logging.level = :debug
+  end
+
+  ##
+  # Use with Voxeo PRISM or other Rayo installation
+  #
+  # config.punchblock.username = "" # Your XMPP JID for use with Rayo
+  # config.punchblock.password = "" # Your XMPP password
+
+  ##
+  # Use with Asterisk
+  #
+  # config.punchblock.platform = :asterisk # Your AMI username
+  # config.punchblock.username = "" # Your AMI username
+  # config.punchblock.password = "" # Your AMI password
+  # config.punchblock.host = "127.0.0.1" # Your AMI host
+  # config.punchblock.port = 5038 # Your AMI port
+end
+
+Adhearsion.router do
+  route 'default', SimonGame
+end

data/lib/adhearsion/generators/app/templates/{components/simon_game → lib}/simon_game.rb

@@ -1,17 +1,6 @@
-methods_for :dialplan do
-  def simon_game
-    SimonGame.new(self).start
-  end
-end
-
-class SimonGame
-
-  def initialize(call)
-    @call = call
+class SimonGame < Adhearsion::CallController
+  def run
     reset
-  end
-
-  def start
     loop do
       say_number
       collect_attempt
@@ -29,18 +18,18 @@ class SimonGame
 
   def say_number
     update_number
-    @call.say_digits @number
+    speak @number
   end
 
   def collect_attempt
-    @attempt = @call.input @number.length
+    @attempt = input @number.length
   end
 
   def verify_attempt
     if attempt_correct?
-      @call.play 'good'
+      speak 'good'
     else
-      @call.play %W[#{@number.length-1} times wrong-try-again-smarty]
+      speak "#{@number.length - 1} times wrong, try again smarty"
       reset
     end
   end
@@ -52,5 +41,4 @@ class SimonGame
   def reset
     @attempt, @number = '', ''
   end
-
 end

data/lib/adhearsion/generators/app/templates/script/ahn

@@ -3,6 +3,6 @@
 require File.expand_path('../../config/environment',  __FILE__)
 
 require 'adhearsion'
-require 'adhearsion/commands'
+require 'adhearsion/cli_commands'
 
-Adhearsion::CLI::AhnCommand.execute!
+Adhearsion::CLI::AhnCommand.start

data/lib/adhearsion/initializer.rb

@@ -1,115 +1,19 @@
-module Adhearsion
-
-  mattr_accessor :status
-
-  class << self
-
-    ##
-    # Shuts down the framework.
-    #
-    def shutdown!
-      if self.status == :stopping
-        # This is the second shutdown request we've received while attempting
-        # to shut down gracefully.  At this point, let's pull the plug...
-        ahn_log.warning "Shutting down immediately at #{Time.now}"
-        exit
-      end
-      ahn_log "Shutting down gracefully at #{Time.now}."
-      self.status = :stopping
-      Events.trigger_immediately :shutdown
-      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
+require 'adhearsion/punchblock_plugin'
 
+module Adhearsion
   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
+    extend ActiveSupport::Autoload
 
-      def ahn_root=(path)
-        if Object.constants.map(&:to_sym).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
+    autoload :Logging
 
+    class << self
       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
+    attr_reader :path, :daemon, :pid_file
 
     # Creation of pid_files
     #
@@ -122,198 +26,163 @@ module Adhearsion
     #    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={})
+    def initialize(options = {})
       @@started = true
       @path     = path
       @mode     = options[:mode]
       @pid_file = options[:pid_file].nil? ? ENV['PID_FILE'] : options[:pid_file]
       @loaded_init_files  = options[:loaded_init_files]
-      self.class.ahn_root = path
+      Adhearsion.ahn_root = '.'
     end
 
     def start
-      Adhearsion.status = :starting
-
       resolve_pid_file_path
-      resolve_log_file_path
+      load_lib_folder
+      load_plugins_methods
+      load_config
+      initialize_log_paths
       daemonize! if should_daemonize?
       launch_console if need_console?
-      switch_to_root_directory
       catch_termination_signal
-      create_pid_file if pid_file
-      bootstrap_rc
-      initialize_log_file
+      create_pid_file
+      start_logging
+      logger.info "Loaded config in <#{Adhearsion.config.platform.environment}> environment"
       initialize_exception_logger
-      load_all_init_files
-      init_datasources
-      init_components_subsystem
-      init_modules
-      init_events_subsystem
-      load_components
-      init_events_file
+      update_rails_env_var
+      init_plugins
 
-      ahn_log "Adhearsion v#{Adhearsion::VERSION::STRING} initialized!"
-      Adhearsion.status = :running
+      logger.info "Adhearsion v#{Adhearsion::VERSION} initialized!"
+      Adhearsion::Process.booted
 
       trigger_after_initialized_hooks
       join_important_threads
-
       self
     end
 
+    def update_rails_env_var
+      env = ENV['AHN_ENV']
+      if env && Adhearsion.config.valid_environment?(env.to_sym)
+        if ENV['RAILS_ENV'] != env
+          logger.warn "Updating AHN_RAILS variable to <#{env}>"
+          ENV['RAILS_ENV'] = env
+        else
+          logger.info "Using the configured value for RAILS_ENV : <#{env}>"
+        end
+      else
+        env = ENV['RAILS_ENV']
+        unless env
+          env = Adhearsion.config.platform.environment.to_s
+          logger.info "Defining AHN_RAILS variable to <#{env}>"
+          ENV['RAILS_ENV'] = env
+        else
+          logger.info "Using the configured value for RAILS_ENV : <#{env}>"
+        end
+      end
+      env
+    end
+
     def default_pid_path
-      File.join AHN_ROOT, 'adhearsion.pid'
+      File.join Adhearsion.config.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 = (@mode == :daemon) ? default_pid_path : nil
+      @pid_file = if pid_file.equal?(true)
+        default_pid_path
+      elsif pid_file.equal?(false)
+        nil
+      elsif pid_file
+        File.expand_path pid_file
+      else
+        should_daemonize? ? 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
+      _log_file = Adhearsion.config.platform.logging.outputters
+      _log_file = _log_file[0] if _log_file.is_a?(Array)
+      _log_file = File.expand_path(Adhearsion.config.root.dup.concat("/").concat(_log_file)) unless _log_file.start_with?("/")
+      _log_file
     end
 
     def catch_termination_signal
       %w'INT TERM'.each do |process_signal|
         trap process_signal do
-          Adhearsion.shutdown!
+          Adhearsion::Process.shutdown
         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.
+      trap 'QUIT' do
+        Adhearsion::Process.hard_shutdown
+      end
 
-Adhearsion will abort until you fix this. Sorry for the incovenience.
-              WARNING
-            end
-          end
-        end
+      trap 'ABRT' do
+        Adhearsion::Process.force_stop
       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
+    ##
+    # Loads files in application lib folder
+    # @return [Boolean] if files have been loaded (lib folder is configured to not nil and actually exists)
+    def load_lib_folder
+      return false if Adhearsion.config.platform.lib.nil?
+
+      lib_folder = [Adhearsion.config.platform.root, Adhearsion.config.platform.lib].join '/'
+      return false unless File.directory? lib_folder
+
+      Dir.chdir lib_folder do
+        rbfiles = File.join "**", "*.rb"
+        Dir.glob(rbfiles).each do |file|
+          require "#{lib_folder}/#{file}"
         end
       end
+      true
     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 }
+    def load_config
+      require "#{Adhearsion.config.root}/config/adhearsion.rb"
     end
 
-    def init_datasources
-      require 'adhearsion/initializer/database.rb'
-      require 'adhearsion/initializer/ldap.rb'
-
-      DatabaseInitializer.start   if AHN_CONFIG.database_enabled?
-      LdapInitializer.start       if AHN_CONFIG.ldap_enabled?
+    def init_get_logging_appenders
+      @file_loggers ||= memoize_logging_appenders
     end
 
-    def init_modules
-
-      require 'adhearsion/initializer/asterisk.rb'
-      require 'adhearsion/initializer/drb.rb'
-      require 'adhearsion/initializer/rails.rb'
-      require 'adhearsion/initializer/xmpp.rb'
-      # require 'adhearsion/initializer/freeswitch.rb'
-
-      AsteriskInitializer.start   if AHN_CONFIG.asterisk_enabled?
-      DrbInitializer.start        if AHN_CONFIG.drb_enabled?
-      RailsInitializer.start      if AHN_CONFIG.rails_enabled?
-      XMPPInitializer.start       if AHN_CONFIG.xmpp_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!
+    def memoize_logging_appenders
+      appenders = Array(Adhearsion.config.platform.logging.outputters.dup)
+      # Any filename in the outputters array is mapped to a ::Logging::Appenders::File instance
+      appenders.map! do |a|
+        case a
+        when String
+          f = File.expand_path(Adhearsion.config.root.dup.concat("/").concat(a)) unless a.start_with?("/")
+          ::Logging.appenders.file(f,
+            :layout => ::Logging.layouts.pattern(
+              :pattern => Adhearsion::Logging.adhearsion_pattern
+            )
+          )
+        else
+         a
         end
-        Events.framework_theatre.start!
+      end
+
+      if should_daemonize?
+        appenders
       else
-        ahn_log.events.warn 'No entries in the "events" section of .ahnrc. Skipping its initialization.'
+        stdout = ::Logging.appenders.stdout(
+                            'stdout',
+                            :layout => ::Logging.layouts.pattern(
+                              :pattern => Adhearsion::Logging.adhearsion_pattern,
+                              :color_scheme => 'bright'
+                            )
+                          )
+        appenders << stdout
       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
+    def load_plugins_methods
+      Plugin.load_methods
+    end
+
+    def init_plugins
+      Plugin.init_plugins
     end
 
     def should_daemonize?
@@ -325,71 +194,60 @@ Adhearsion will abort until you fix this. Sorry for the incovenience.
     end
 
     def daemonize!
-      ahn_log "Daemonizing now! Creating #{pid_file}."
+      logger.info "Daemonizing now!"
+      logger.info "Creating PID file #{pid_file}"
       extend Adhearsion::CustomDaemonizer
-      daemonize log_file
+      daemonize resolve_log_file_path
     end
 
     def launch_console
-      require 'adhearsion/console'
-      Thread.new do
-        begin
-          puts "Starting console"
+      Adhearsion::Process.important_threads << Thread.new do
+        catching_standard_errors do
           Adhearsion::Console.run
-          Adhearsion.shutdown!
-        rescue Exception => e
-          puts e.message
-          puts e.backtrace.join("\n")
+          Adhearsion::Process.shutdown
         end
       end
     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
+    # Creates the relative paths associated to log files
+    # i.e.
+    # - log_file = "log/adhearsion.log"      => creates 'log' folder
+    # - log_file = "log/test/adhearsion.log" => creates 'log' and 'log/test' folders
+    def initialize_log_paths
+      outputters = Array(Adhearsion.config.platform.logging.outputters)
+      outputters.select{|o| o.is_a?(String)}.each do |o|
+        o = o.split("/")
+        unless o[0].empty? # only if relative path
+          o.pop # not consider filename
+          o.inject("") do |path, folder|
+            path = path.concat(folder).concat("/")
+            Dir.mkdir(path) unless File.directory? path
+            path
+          end
+        end
       end
-      Logging::DefaultAdhearsionLogger.redefine_outputters
+    end
+
+    def start_logging
+      outputters = init_get_logging_appenders
+      Logging.start outputters, Adhearsion.config.platform.logging.level, Adhearsion.config.platform.logging.formatter
     end
 
     def initialize_exception_logger
-      Events.register_callback :exception do |e|
-        ahn_log.error "#{e.class}: #{e.message}"
-        ahn_log.debug e.backtrace.join("\n\t")
+      Events.register_handler :exception do |e|
+        logger.error e
       end
     end
 
     def create_pid_file
-      if pid_file
-        File.open pid_file, 'w' do |file|
-          file.puts Process.pid
-        end
+      return unless pid_file
 
-        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."
+      File.open pid_file, 'w' do |file|
+        file.puts ::Process.pid
       end
-    end
 
-    def load_components
-      if Components.component_manager
-        Components.component_manager.load_components
+      Events.register_callback :shutdown do
+        File.delete(pid_file) if File.exists?(pid_file)
       end
     end
 
@@ -398,24 +256,24 @@ Adhearsion will abort until you fix this. Sorry for the incovenience.
     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().
+    # This method will block Thread.main() until calling join() has returned for all Threads in Adhearsion::Process.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
+      until index == Adhearsion::Process.important_threads.size
         begin
-          IMPORTANT_THREADS[index].join
+          Adhearsion::Process.important_threads[index].join
         rescue => e
-          ahn_log.error "Error after join()ing Thread #{Thread.inspect}. #{e.message}"
+          logger.error "Error after joining Thread #{Thread.inspect}. #{e.message}"
         ensure
           index = index + 1
         end
       end
     end
 
-    class InitializationFailedError < StandardError; end
+    InitializationFailedError = Class.new StandardError
   end
 end