adhearsion 1.2.6 → 2.0.0.alpha1

data/lib/adhearsion/calls.rb

@@ -0,0 +1,81 @@
+require 'thread'
+
+module Adhearsion
+  ##
+  # This manages the list of calls the Adhearsion service receives
+  class Calls
+    attr_reader :semaphore, :calls
+
+    def initialize
+      @semaphore = Monitor.new
+      @calls     = {}
+    end
+
+    def from_offer(offer)
+      Call.new(offer).tap do |call|
+        self << call
+      end
+    end
+
+    def <<(call)
+      atomically { calls[call.id] = call }
+    end
+
+    def any?
+      atomically { !calls.empty? }
+    end
+
+    def size
+      atomically { calls.size }
+    end
+
+    def remove_inactive_call(call)
+      atomically { calls.delete call.id }
+    end
+
+    # Searches all active calls by their id
+    def find(id)
+      atomically { calls[id] }
+    end
+    alias :[] :find
+
+    def clear!
+      atomically { calls.clear }
+    end
+
+    def with_tag(tag)
+      atomically do
+        calls.inject([]) do |calls_with_tag,(key,call)|
+          call.tagged_with?(tag) ? calls_with_tag << call : calls_with_tag
+        end
+      end
+    end
+
+    def each(&block)
+      atomically { calls.values.each &block }
+    end
+
+    def each_pair
+      calls.each_pair { |id, call| yield id, call }
+    end
+
+    def to_a
+      calls.values
+    end
+
+    def to_h
+      calls
+    end
+
+    def method_missing(m, *args)
+      atomically { calls.send m.to_sym, *args }
+    end
+
+    private
+
+    def atomically(&block)
+      semaphore.synchronize(&block)
+    end
+
+  end
+end

data/lib/adhearsion/cli.rb

@@ -4,6 +4,4 @@ require 'adhearsion/script_ahn_loader'
 # the rest of this script is not run.
 Adhearsion::ScriptAhnLoader.exec_script_ahn!
 
-require 'bundler/setup'
-require 'adhearsion'
-require 'adhearsion/commands'
+require 'adhearsion/cli_commands'

data/lib/adhearsion/cli_commands.rb

@@ -0,0 +1,142 @@
+require 'fileutils'
+require 'adhearsion/script_ahn_loader'
+require 'thor'
+
+module Adhearsion
+  module CLI
+    class AhnCommand < Thor
+      map %w(-h --h -help --help) => :help
+      map %w(-v --v -version --version) => :version
+      map %w(-) => :start
+
+      check_unknown_options!
+
+      def self.exit_on_failure?
+        true
+      end
+
+      desc "create /path/to/directory", "Create a new Adhearsion application under the given path"
+      def create(path)
+        require 'adhearsion/generators'
+        require 'adhearsion/generators/app/app_generator'
+        Adhearsion::Generators::AppGenerator.start
+      end
+
+      desc "version", "Shows Adhearsion version"
+      def version
+        say "Adhearsion v#{Adhearsion::VERSION}"
+        exit 0
+      end
+
+      desc "start </path/to/directory>", "Start the Adhearsion server in the foreground with a console"
+      def start(path = nil)
+        start_app path, :console
+      end
+
+      desc "daemon </path/to/directory>", "Start the Adhearsion server in the background"
+      method_option :pidfile, :type => :string, :aliases => %w(--pid-file)
+      def daemon(path = nil)
+        start_app path, :daemon, options[:pidfile]
+      end
+
+      desc "stop </path/to/directory>", "Stop a running Adhearsion server"
+      method_option :pidfile, :type => :string, :aliases => %w(--pid-file)
+      def stop(path = nil)
+        execute_from_app_dir! path, ARGV
+
+        pid_file = if options[:pidfile]
+          File.expand_path File.exists?(File.expand_path(options[:pidfile])) ?
+          options[:pidfile] :
+          File.join(path, options[:pidfile])
+        else
+          path + '/adhearsion.pid'
+        end
+
+        begin
+          pid = File.read(pid_file).to_i
+        rescue
+          raise CLIException, "Could not read pid file #{pid_file}"
+        end
+
+        raise CLIException, "Could not read pid" if pid.nil?
+
+        say "Stopping Adhearsion server at #{path} with pid #{pid}"
+        waiting_timeout = Time.now + 15
+        begin
+          ::Process.kill "TERM", pid
+          sleep 0.25 while process_exists?(pid) && Time.now < waiting_timeout
+          ::Process.kill "KILL", pid
+        rescue Errno::ESRCH
+        end
+      end
+
+      desc "restart </path/to/directory>", "Restart the Adhearsion server"
+      method_option :pidfile, :type => :string, :aliases => %w(--pid-file)
+      def restart(path = nil)
+        execute_from_app_dir! path, ARGV
+        invoke :stop
+        invoke :daemon
+      end
+
+      protected
+
+      def start_app(path, mode, pid_file = nil)
+        execute_from_app_dir! path, ARGV
+        say "Starting Adhearsion server at #{path}"
+        Adhearsion::Initializer.start :mode => mode, :pid_file => pid_file
+      end
+
+      def execute_from_app_dir!(path, *args)
+        return if in_app? and running_script_ahn?
+
+        path ||= '.' if in_app?
+
+        raise PathRequired, ARGV[0] if path.nil? or path.empty?
+        raise PathInvalid, path unless ScriptAhnLoader.in_ahn_application?(path)
+
+        Dir.chdir path do
+          args.flatten!
+          args[1] = '.'
+          ScriptAhnLoader.exec_script_ahn! args
+        end
+      end
+
+      def running_script_ahn?
+        $0.to_s == "script/ahn"
+      end
+
+      def in_app?
+        ScriptAhnLoader.in_ahn_application? or ScriptAhnLoader.in_ahn_application_subdirectory?
+      end
+
+      def process_exists?(pid = nil)
+        # FIXME: Raise some error here
+        return false if pid.nil?
+        `ps -p #{pid} | sed -e '1d'`.strip.empty?
+      end
+
+      def method_missing(action, *args)
+        help
+        raise UnknownCommand, [action, *args] * " "
+      end
+    end # AhnCommand
+
+    class UnknownCommand < Thor::Error
+      def initialize(cmd)
+        super "Unknown command: #{cmd}"
+      end
+    end
+
+    class PathRequired < Thor::Error
+      def initialize(cmd)
+        super "A valid path is required for #{cmd}, unless run from an Adhearson app directory"
+      end
+    end
+
+    class PathInvalid < Thor::Error
+      def initialize(path)
+        super "Directory #{path} does not belong to an Adhearsion project!"
+      end
+    end
+  end
+end

data/lib/adhearsion/configuration.rb

@@ -0,0 +1,149 @@
+module Adhearsion
+
+  class Configuration
+
+    ##
+    # Initialize the configuration object
+    #
+    # * &block platform configuration block
+    # Adhearsion::Configuration.new do
+    #   foo "bar", :desc => "My description"
+    # end
+    #
+    # @return [Adhearsion::Configuration]
+    def initialize(&block)
+      initialize_environments
+
+      Loquacious::Configuration.for :platform do
+        root nil, :desc => "Adhearsion application root folder"
+        lib "lib", :desc => <<-__
+          Folder to include the own libraries to be used. Adhearsion loads any ruby file located into this folder during the bootstrap
+          process. Set to nil if you do not want these files to be loaded. This folder is relative to the application root folder.
+        __
+        automatically_accept_incoming_calls true, :desc => "Adhearsion will accept automatically any inbound call"
+
+        environment :development, :desc => "Active environment. Supported values: development, production, staging, test"
+
+        desc "Log configuration"
+        logging {
+          level :info, :desc => <<-__
+            Supported levels (in increasing severity) -- :trace < :debug < :info < :warn < :error < :fatal
+          __
+          outputters ["log/adhearsion.log"], :desc => <<-__
+            An array of log outputters to use. The default is to log to stdout and log/adhearsion.log
+          __
+          formatter nil, :desc => <<-__
+            A log formatter to apply to all active outputters. If nil, the Adhearsion default formatter will be used.
+          __
+        }
+      end
+
+      Loquacious::Configuration.for :platform, &block if block_given?
+
+      self
+    end
+
+    def initialize_environments
+      # Create a method per each valid environment that, when invoked, may execute
+      # the block received if the environment is active
+      valid_environments.each do |enviro|
+        add_environment enviro
+      end
+    end
+
+    def valid_environment?(env)
+      env && self.valid_environments.include?(env.to_sym)
+    end
+
+    def valid_environments
+      @valid_environments ||= [:production, :development, :staging, :test]
+    end
+
+    def add_environment(env)
+      self.class.send(:define_method, env.to_sym) do |*args, &block|
+        unless block.nil? || env != self.platform.environment.to_sym
+          self.instance_eval &block
+        end
+        self
+      end
+    end
+
+    ##
+    # Direct access to a specific configuration object
+    #
+    # Adhearsion.config[:platform] => returns the configuration object associated to the Adhearsion platform
+    #
+    # @return [Loquacious::Configuration] configuration object or nil if the plugin does not exist
+    def [](value)
+      self.send value.to_sym
+    end
+
+    ##
+    # Wrapper to access to a specific configuration object
+    #
+    # Adhearsion.config.foo => returns the configuration object associated to the foo plugin
+    def method_missing(method_name, *args, &block)
+      config = Loquacious::Configuration.for method_name, &block
+      raise Adhearsion::ConfigurationError.new "Invalid plugin #{method_name}" if config.nil?
+      config
+    end
+
+    # root accessor
+    def root
+      platform.root
+    end
+
+    ##
+    # Handle the Adhearsion platform configuration
+    #
+    # It accepts a block that will be executed in the Adhearsion config var environment
+    # to update the desired values
+    #
+    # Adhearsion.config.platform do
+    #   foo "bar", :desc => "My new description"
+    # end
+    #
+    # values = Adhearsion.config.platform
+    # values.foo => "bar"
+    #
+    # @return [Loquacious::Configuration] configuration object or nil if the plugin does not exist
+    def platform(&block)
+      Loquacious::Configuration.for :platform, &block
+    end
+
+    ##
+    # Fetchs the configuration info for the Adhearsion platform or a specific plugin
+    # @param name [Symbol]
+    #     - :all      => Adhearsion platform and all the loaded plugins
+    #     - nil       => Adhearsion platform configuration
+    #     - :platform => Adhearsion platform configuration
+    #     - :<plugin-config-name> => Adhearsion plugin configuration
+    #
+    # @param args [Hash]
+    #     - @option :show_values [Boolean] true | false to return the current values or just the description
+    #
+    # @return string with the configuration description/values
+    def description(name, args = {:show_values => true})
+      desc = StringIO.new
+
+      name.nil? and name = :platform
+      if name.eql? :all
+        value = ""
+        Loquacious::Configuration.instance_variable_get("@table").keys.map do |config|
+          value.concat description config, args
+        end
+        return value
+      else
+        return "" if Loquacious::Configuration.for(name).nil?
+
+        config = Loquacious::Configuration.help_for name,
+                                :name_leader => "",
+                                :desc_leader => "# ",
+                                :colorize    => true,
+                                :io          => desc
+        config.show :values => args[:show_values]
+        "\n# ******* Configuration for #{name} **************\n\n#{desc.string}"
+      end
+    end
+  end
+end

data/lib/adhearsion/console.rb

@@ -20,11 +20,12 @@ module Adhearsion
                         end
                       ]
         Pry.config.command_prefix = "%"
-        pry
-      end
-
-      def logger
-        Adhearsion::Logging
+        if libedit?
+          logger.error "Cannot start. You are running Adhearsion on Ruby with libedit. You must use readline for the console to work."
+        else
+          logger.info "Starting up..."
+          pry
+        end
       end
 
       def calls
@@ -36,14 +37,24 @@ module Adhearsion
           raise ArgumentError unless Adhearsion.active_calls[call]
           call = Adhearsion.active_calls[call]
         end
-        Pry.prompt = [ proc { "AHN<#{call.channel}> "},
-                       proc { "AHN<#{call.channel}? "}  ]
+        Pry.prompt = [ proc { "AHN<#{call.channel}> " },
+                       proc { "AHN<#{call.channel}? " }  ]
 
         # Pause execution of the thread currently controlling the call
         call.with_command_lock do
           CallWrapper.new(call).pry
         end
       end
+
+      def libedit?
+        begin
+          # If NotImplemented then this might be libedit
+          Readline.emacs_editing_mode
+          false
+        rescue NotImplementedError
+          true
+        end
+      end
     end
 
     class CallWrapper
@@ -51,7 +62,7 @@ module Adhearsion
 
       def initialize(call)
         @call = call
-        extend Adhearsion::VoIP::Commands.for('asterisk')
+        extend Adhearsion::Commands.for('asterisk')
       end
     end
   end

data/lib/adhearsion/dialplan_controller.rb

@@ -0,0 +1,9 @@
+module Adhearsion
+  class DialplanController < CallController
+    attr_accessor :dialplan
+
+    def run
+      instance_exec &dialplan
+    end
+  end
+end

data/lib/adhearsion/events.rb

@@ -0,0 +1,84 @@
+module Adhearsion
+  class Events
+
+    include HasGuardedHandlers
+
+    Message = Struct.new :type, :object
+
+    class << self
+      def method_missing(method_name, *args, &block)
+        instance.send method_name, *args, &block
+      end
+
+      def respond_to?(method_name)
+        instance.respond_to?(method_name) || super
+      end
+
+      def instance
+        @@instance || refresh!
+      end
+
+      def refresh!
+        @@instance = new
+      end
+    end
+
+    refresh!
+
+    def queue
+      @queue || reinitialize_queue!
+    end
+
+    def trigger(type, object = nil)
+      queue.push_async Message.new(type, object)
+    end
+
+    def trigger_immediately(type, object = nil)
+      queue.push_immediately Message.new(type, object)
+    end
+
+    def reinitialize_queue!
+      GirlFriday.shutdown! if @queue
+      # TODO: Extract number of threads to use from Adhearsion.config
+      @queue = GirlFriday::WorkQueue.new 'main_queue', :error_handler => ErrorHandler do |message|
+        begin
+          handle_message message
+        rescue Exception => e
+          ErrorHandler.new.handle e
+        end
+      end
+    end
+
+    def handle_message(message)
+      trigger_handler message.type, message.object
+    end
+
+    def draw(&block)
+      instance_exec &block
+    end
+
+    def method_missing(method_name, *args, &block)
+      register_handler method_name, *args, &block
+    end
+
+    def respond_to?(method_name)
+      return true if @handlers && @handlers.has_key?(method_name)
+      super
+    end
+
+    alias :register_callback :register_handler
+
+    private
+
+    def call_handler(handler, guards, event)
+      super && throw(:pass)
+    end
+
+    class ErrorHandler
+      def handle(exception)
+        Events.trigger :exception, exception
+      end
+    end
+
+  end
+end