rene-adhearsion 0.8.6

data/bin/jahn

@@ -0,0 +1,42 @@
+#!/usr/bin/env jruby
+
+# This "jahn" script is "ahn" for JRUBY!
+
+# Adhearsion, open source collaboration framework
+# Copyright (C) 2006,2007,2008 Jay Phillips
+#
+# This library is free software; you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation; either version 2.1 of the License, or (at your option)
+# any later version.
+#
+# This library is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with this library; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require 'rubygems'
+require 'adhearsion'
+require 'adhearsion/cli'
+
+# jahn will soon have JRuby-specific behavior such as creating a compiled .jar
+# file from an app.
+# require 'adhearsion/jruby'
+
+abort(<<-MESSAGE) unless RUBY_PLATFORM =~ /java/
+You must use jahn with JRuby! Are you running this script after installing Adhearsion with non-JRuby RubyGems?
+
+If you don't want to install Adhearsion with the JRuby version of RubyGems, try running jahn directly with an absolute path:
+
+#{File.expand_path(__FILE__)} start your_app_name
+
+Note: You must have the jruby executable in your $PATH and $JRUBY_HOME set.
+MESSAGE
+
+Adhearsion::CLI::AhnCommand.execute!

data/examples/asterisk_manager_interface/standalone.rb

@@ -0,0 +1,51 @@
+# This is a file which shows you how to use the Asterisk Manager Interface library in a standalone Ruby script.
+
+PATH_TO_ADHEARSION = File.join(File.dirname(__FILE__), "/../..")
+
+MANAGER_CONNECTION_INFORMATION = {
+  :host     => "10.0.1.97",
+  :username => "jicksta",
+  :password => "roflcopter",
+  :events   => true
+}
+
+require 'rubygems'
+begin
+  require 'adhearsion'
+rescue LoadError
+  begin
+    require File.join(PATH_TO_ADHEARSION, "/lib/adhearsion")
+  rescue LoadError
+    abort "Could not find Adhearsion! Please update the PATH_TO_ADHEARSION constant in this file"
+  end
+end
+
+require 'adhearsion/voip/asterisk/manager_interface'
+
+# If you'd like to see the AMI protocol data, change this to :debug
+Adhearsion::Logging.logging_level = :warn
+
+# This makes addressing the ManagerInterface class a little cleaner
+include Adhearsion::VoIP::Asterisk::Manager
+
+# Let's instantiate a new ManagerInterface object and have it automatically connect using the Hash we defined above.
+interface = ManagerInterface.connect MANAGER_CONNECTION_INFORMATION
+
+# Send an AMI action with our new ManagerInterface object. This will return an Array of SIPPeer events.
+sip_peers = interface.send_action "SIPPeers"
+
+# Pretty-print the SIP peers on the server
+
+if sip_peers.any?
+  sip_peers.each do |peer|
+    # Uncomment the following line to view all the headers for each peer.
+    # p peer.headers
+
+    peer_name   = peer.headers["ObjectName"]
+    peer_status = peer.headers["Status"]
+
+    puts "#{peer_name}: #{peer_status}"
+  end
+else
+  puts "This Asterisk server has no SIP peers!"
+end

data/lib/adhearsion.rb

@@ -0,0 +1,45 @@
+# Check the Ruby version
+STDERR.puts "WARNING: You are running Adhearsion in an unsupported
+version of Ruby (Ruby #{RUBY_VERSION} #{RUBY_RELEASE_DATE})!
+Please upgrade to at least Ruby v1.8.5." if RUBY_VERSION < "1.8.5"
+
+$: << File.expand_path(File.dirname(__FILE__))
+
+require 'rubygems'
+
+require 'adhearsion/version'
+require 'adhearsion/voip/call'
+require 'adhearsion/voip/dial_plan'
+require 'adhearsion/voip/asterisk/special_dial_plan_managers'
+require 'adhearsion/foundation/all'
+require 'adhearsion/events_support'
+require 'adhearsion/logging'
+require 'adhearsion/component_manager'
+require 'adhearsion/initializer/configuration'
+require 'adhearsion/initializer'
+require 'adhearsion/voip/dsl/numerical_string'
+require 'adhearsion/voip/dsl/dialplan/parser'
+require 'adhearsion/voip/commands'
+require 'adhearsion/voip/asterisk/commands'
+require 'adhearsion/voip/dsl/dialing_dsl'
+require 'adhearsion/voip/call_routing'
+
+begin
+  # Try ActiveSupport >= 2.3.0
+  require 'active_support/all'
+rescue LoadError
+  # Assume ActiveSupport < 2.3.0
+  require 'active_support'
+end
+
+module Adhearsion
+  # Sets up the Gem require path.
+  AHN_INSTALL_DIR = File.expand_path(File.dirname(__FILE__) + "/..")
+  AHN_CONFIG = Configuration.new
+
+  ##
+  # This Array holds all the Threads whose life matters. Adhearsion will not exit until all of these have died.
+  #
+  IMPORTANT_THREADS = []
+
+end

data/lib/adhearsion/cli.rb

@@ -0,0 +1,228 @@
+require 'fileutils'
+
+module Adhearsion
+  module CLI
+    module AhnCommand
+      USAGE = <<USAGE
+Usage:
+   ahn create /path/to/directory
+   ahn start [daemon] [/path/to/directory]
+   ahn version|-v|--v|-version|--version
+   ahn help|-h|--h|--help|-help
+
+   ahn  enable component COMPONENT_NAME
+   ahn disable component COMPONENT_NAME
+   ahn  create component COMPONENT_NAME
+USAGE
+
+      def self.execute!
+        CommandHandler.send(*parse_arguments)
+      rescue CommandHandler::CLIException => error
+        fail_and_print_usage error
+      end
+
+      ##
+      # Provides a small abstraction of Kernel::abort().
+      #
+      def self.fail_and_print_usage(error)
+        Kernel.abort "#{error.message}\n\n#{USAGE}"
+      end
+
+      def self.parse_arguments(args=ARGV.clone)
+        action = args.shift
+        case action
+          when /^-?-?h(elp)?$/, nil   then [:help]
+          when /^-?-?v(ersion)?$/     then [:version]
+          when "create"
+            [:create, *args]
+          when 'start'
+            pid_file_regexp = /^--pid-file=(.+)$/
+            if args.size > 3
+              fail_and_print_usage "Too many arguments supplied!" if args.size > 3
+            elsif args.size == 3
+              fail_and_print_usage "Unrecognized final argument #{args.last}" unless args.last =~ pid_file_regexp
+              pid_file = args.pop[pid_file_regexp, 1]
+            else
+              pid_file = nil
+            end
+
+            if args.first == 'daemon' && args.size == 2
+              path   = args.last
+              daemon = true
+            elsif args.size == 1
+              path, daemon = args.first, false
+            else
+              fail_and_print_usage "Invalid format for the start CLI command!"
+            end
+            [:start, path, daemon, pid_file]
+          when '-'
+            [:start, Dir.pwd]
+          when "enable", "disable"
+            if args.size == 1
+              raise CommandHandler::UnknownCommand, "Must supply an argument for what you wish to #{action}"
+            elsif args.size == 2
+              [action, *args]
+            else
+              raise CommandHandler::UnknownCommand, "Too many arguments supplied!"
+            end
+          else
+            [action, *args]
+        end
+      end
+
+      module CommandHandler
+        class << self
+
+          def create(*args)
+            if args.size.zero?
+              raise CommandHandler::UnknownCommand.new("Must specify something to create!")
+            elsif args.size == 1
+              # We're creating a project
+              path = args.first
+              require 'rubigen'
+              require 'rubigen/scripts/generate'
+              source = RubiGen::PathSource.new(:application,
+                File.join(File.dirname(__FILE__), "../../app_generators"))
+              RubiGen::Base.reset_sources
+              RubiGen::Base.append_sources source
+              RubiGen::Scripts::Generate.new.run([path], :generator => 'ahn')
+            elsif args.size == 2
+              # We're creating a feature (e.g. a component)
+              feature_type, component_name = args
+
+              if feature_type != "component"
+                # At the moment, only components can be created.
+                raise CommandHandler::UnknownCommand.new("Don't know how to create '#{feature_type}'")
+              end
+
+              if component_name !~ /^[a-z][\w_]+$/
+                raise CommandHandler::ComponentError.new("Component name must be lowercase alphanumeric characters " +
+                    "and begin with a character")
+              end
+
+              app_path = PathString.from_application_subdirectory Dir.pwd
+
+              raise PathInvalid.new(Dir.pwd) if app_path.nil?
+
+              new_component_dir = app_path + "/components/#{component_name}"
+              raise ComponentError.new("Component #{component_name} already exists!") if File.exists?(new_component_dir)
+
+              # Everything's good. Let's create the component
+              Dir.mkdir new_component_dir
+              File.open(new_component_dir + "/#{component_name}.rb","w") do |file|
+                file.puts <<-RUBY
+# See http://docs.adhearsion.com for more information on how to write components or
+# look at the examples in newly-created projects.
+                RUBY
+              end
+              File.open(new_component_dir + "/#{component_name}.yml","w") do |file|
+                file.puts '# You can use this file for component-specific configuration.'
+              end
+              puts "Created blank component '#{component_name}' at components/#{component_name}"
+            else
+              raise CommandHandler::UnknownCommand.new("Provided too many arguments to 'create'")
+            end
+          end
+
+          def start(path, daemon=false, pid_file=nil)
+            raise PathInvalid, path unless File.exists? path + "/.ahnrc"
+            Adhearsion::Initializer.start path, :daemon => daemon, :pid_file => pid_file
+          end
+
+          def version
+            puts "Adhearsion v#{Adhearsion::VERSION::STRING}"
+          end
+
+          def help
+            puts USAGE
+          end
+
+          def enable(type, name)
+            case type
+              when "component"
+                app_path = PathString.from_application_subdirectory Dir.pwd
+                if app_path
+                  disabled_component_path = File.join app_path, "components", "disabled", name
+                  disabled_components_path = File.join app_path, "components", "disabled"
+                  enabled_component_path  = File.join app_path, "components", name
+                  if File.directory? disabled_component_path
+                    FileUtils.mv disabled_component_path, enabled_component_path
+                    puts "Enabled component #{name}"
+                  elsif File.directory? enabled_component_path
+                    raise ComponentError.new("This component is already enabled.")
+                  elsif !File.directory? disabled_components_path
+                    raise ComponentError.new("There is no components/disabled directory!")
+                  else
+                    raise ComponentError.new("The requested component was not found.")
+                  end
+                else
+                  raise PathInvalid.new(Dir.pwd)
+                end
+              else
+                raise UnknownCommand.new("enable #{type}")
+            end
+          end
+
+          def disable(type, name)
+            case type
+              when "component"
+                app_path = PathString.from_application_subdirectory Dir.pwd
+                if app_path
+                  disabled_dir = File.join app_path, "components", "disabled"
+
+                  disabled_component_path = File.join disabled_dir, name
+                  enabled_component_path  = File.join app_path, "components", name
+
+                  Dir.mkdir disabled_dir unless File.directory?(disabled_dir)
+
+                  if File.directory? enabled_component_path
+                    if File.directory?(disabled_component_path)
+                      raise ComponentError.new("There is already a disabled component at #{disabled_component_path}")
+                    else
+                      FileUtils.mv enabled_component_path, disabled_component_path
+                      puts "Disabled component #{name}"
+                    end
+                  else
+                    raise ComponentError.new("Could not find component #{name} at #{enabled_component_path} !")
+                  end
+                else
+                  raise PathInvalid.new(Dir.pwd)
+                end
+              else
+                raise UnknownCommand.new("disable #{type}")
+            end
+          end
+
+          def method_missing(action, *args)
+            raise UnknownCommand, [action, *args] * " "
+          end
+
+          private
+
+        end
+
+        class CLIException < StandardError; end
+
+        class UnknownCommand < CLIException
+          def initialize(cmd)
+            super "Unknown command: #{cmd}"
+          end
+        end
+
+        class ComponentError < CLIException; end
+
+        class UnknownProject < CLIException
+          def initialize(project)
+            super "Application #{project} does not exist! Have you installed it?"
+          end
+        end
+
+        class PathInvalid < CLIException
+          def initialize(path)
+            super "Directory #{path} does not belong to an Adhearsion project!"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/component_manager.rb

@@ -0,0 +1,272 @@
+module Adhearsion
+  module Components
+
+    mattr_accessor :component_manager
+
+    class ConfigurationError < Exception; end
+
+    class ComponentManager
+
+      class << self
+
+        def scopes_valid?(*scopes)
+          unrecognized_scopes = (scopes.flatten - SCOPE_NAMES).map(&:inspect)
+          raise ArgumentError, "Unrecognized scopes #{unrecognized_scopes.to_sentence}" if unrecognized_scopes.any?
+          true
+        end
+
+      end
+
+      SCOPE_NAMES = [:dialplan, :events, :generators, :rpc, :global]
+
+      attr_reader :scopes, :lazy_config_loader
+      def initialize(path_to_container_directory)
+        @path_to_container_directory = path_to_container_directory
+        @scopes = SCOPE_NAMES.inject({}) do |scopes, name|
+          scopes[name] = Module.new
+          scopes
+        end
+        @lazy_config_loader = LazyConfigLoader.new(self)
+      end
+
+      ##
+      # Includes the anonymous Module created for the :global scope in Object, making its methods globally accessible.
+      #
+      def globalize_global_scope!
+        Object.send :include, @scopes[:global]
+      end
+
+      def load_components
+        components = Dir.glob(File.join(@path_to_container_directory + "/*")).select do |path|
+          File.directory?(path)
+        end
+        components.map! { |path| File.basename path }
+        components.each do |component|
+          next if component == "disabled"
+          component_file = File.join(@path_to_container_directory, component, 'lib', component + ".rb")
+          if File.exists? component_file
+            load_file component_file
+            next
+          end
+
+          # Try the old-style components/<component>/<component>.rb
+          component_file = File.join(@path_to_container_directory, component, component + ".rb")
+          if File.exists? component_file
+            load_file component_file
+          else
+            ahn_log.warn "Component directory does not contain a matching .rb file! Was expecting #{component_file.inspect}"
+          end
+        end
+
+        # Load configured system- or gem-provided components
+        AHN_CONFIG.components_to_load.each do |component|
+          require component
+        end
+
+      end
+
+      ##
+      # Loads the configuration file for a given component name.
+      #
+      # @return [Hash] The loaded YAML for the given component name. An empty Hash if no YAML file exists.
+      #
+      def configuration_for_component_named(component_name)
+        # Look for configuration in #{AHN_ROOT}/config/components first
+        if File.exists?("#{AHN_ROOT}/config/components/#{component_name}.yml")
+          return YAML.load_file "#{AHN_ROOT}/config/components/#{component_name}.yml"
+        end
+
+        # Next try the local app component directory
+        component_dir = File.join(@path_to_container_directory, component_name)
+        config_file = File.join component_dir, "#{component_name}.yml"
+        if File.exists?(config_file)
+          YAML.load_file config_file
+        else
+          # Nothing found? Return an empty hash
+          ahn_log.warn "No configuration found for requested component #{component_name}"
+          return {}
+        end
+      end
+
+      def extend_object_with(object, *scopes)
+        raise ArgumentError, "Must supply at least one scope!" if scopes.empty?
+
+        self.class.scopes_valid? scopes
+
+        scopes.each do |scope|
+          methods = @scopes[scope]
+          if object.kind_of?(Module)
+            object.send :include, methods
+          else
+            object.extend methods
+          end
+        end
+        object
+      end
+
+      def load_code(code)
+        load_container ComponentDefinitionContainer.load_code(code)
+      end
+
+      def load_file(filename)
+        load_container ComponentDefinitionContainer.load_file(filename)
+      end
+
+      def require(filename)
+        load_container ComponentDefinitionContainer.require(filename)
+      end
+
+      protected
+
+      def load_container(container)
+        container.constants.each do |constant_name|
+          constant_value = container.const_get(constant_name)
+          Object.const_set(constant_name, constant_value)
+        end
+        metadata = container.metaclass.send(:instance_variable_get, :@metadata)
+        metadata[:initialization_block].call if metadata[:initialization_block]
+
+        self.class.scopes_valid? metadata[:scopes].keys
+
+        metadata[:scopes].each_pair do |scope, method_definition_blocks|
+          method_definition_blocks.each do |method_definition_block|
+            @scopes[scope].module_eval(&method_definition_block)
+          end
+        end
+        container
+      end
+
+      class ComponentDefinitionContainer < Module
+
+        class << self
+          def load_code(code)
+            new.tap do |instance|
+              instance.module_eval code
+            end
+          end
+
+          def load_file(filename)
+            new.tap do |instance|
+              instance.module_eval File.read(filename), filename
+            end
+          end
+
+          def require(filename)
+            filename = filename + ".rb" if !(filename =~ /\.rb$/)
+            begin
+              # Try loading the exact filename first
+              load_file(filename)
+            rescue LoadError, Errno::ENOENT
+            end
+
+            # Next try Rubygems
+            filepath = get_gem_path_for(filename)
+            return load_file(filepath) if !filepath.nil?
+
+            # Finally try the system search path
+            filepath = get_system_path_for(filename)
+            return load_file(filepath) if !filepath.nil?
+
+            # Raise a LoadError exception if the file is still not found
+            raise LoadError "File not found: #{filename}"
+          end
+
+        end
+
+        def initialize(&block)
+          # Hide our instance variables in the singleton class
+          metadata = {}
+          metaclass.send(:instance_variable_set, :@metadata, metadata)
+
+          metadata[:scopes] = ComponentManager::SCOPE_NAMES.inject({}) do |scopes, name|
+            scopes[name] = []
+            scopes
+          end
+
+          super
+
+          meta_def(:initialize) { raise "This object has already been instantiated. Are you sure you didn't mean initialization()?" }
+        end
+
+        def methods_for(*scopes, &block)
+          raise ArgumentError if scopes.empty?
+
+          ComponentManager.scopes_valid? scopes
+
+          metadata = metaclass.send(:instance_variable_get, :@metadata)
+          scopes.each { |scope| metadata[:scopes][scope] << block }
+        end
+
+        def initialization(&block)
+          # Raise an exception if the initialization block has already been set
+          metadata = metaclass.send(:instance_variable_get, :@metadata)
+          if metadata[:initialization_block]
+            raise "You should only have one initialization() block!"
+          else
+            metadata[:initialization_block] = block
+          end
+        end
+        alias initialisation initialization
+
+        protected
+
+        class << self
+          def self.method_added(method_name)
+            @methods ||= []
+            @methods << method_name
+          end
+
+          def get_gem_path_for(filename)
+            # Look for component files provided by rubygems
+            spec = Gem.searcher.find(filename)
+            return nil if spec.nil?
+            File.join(spec.full_gem_path, spec.require_path, filename)
+          rescue NameError
+            # In case Rubygems are not available
+            nil
+          end
+
+          def get_system_path_for(filename)
+            $:.each do |path|
+              filepath = File.join(path, filename)
+              return filepath if File.exists?(filepath)
+            end
+
+            # Not found? Return nil
+            return nil
+          end
+        end
+
+      end
+
+      class ComponentMethodDefinitionContainer < Module
+        class << self
+          def method_added(method_name)
+            @methods ||= []
+            @methods << method_name
+          end
+        end
+
+        attr_reader :scopes
+        def initialize(*scopes, &block)
+          @scopes = []
+          super(&block)
+        end
+
+      end
+
+      class LazyConfigLoader
+        def initialize(component_manager)
+          @component_manager = component_manager
+        end
+
+        def method_missing(component_name)
+          config = @component_manager.configuration_for_component_named(component_name.to_s)
+          (class << self; self; end).send(:define_method, component_name) { config }
+          config
+        end
+      end
+
+    end
+  end
+end