rene-adhearsion 0.8.6

data/app_generators/ahn/templates/Rakefile

@@ -0,0 +1,25 @@
+# This file is for the "rake" tool which automates project-related tasks. If you need to automate things, you can create
+# a new Rake task here. See http://rake.rubyforge.org for more info.
+require 'rubygems'
+
+begin
+  require 'adhearsion'
+  require 'adhearsion/tasks'
+rescue LoadError
+  STDERR.puts "\nCannot load Adhearsion! Not all Rake tasks will be loaded!\n\n"
+end
+
+desc "Writes a .gitignore file that ignores certain SCM annoyances such as log files"
+task :gitignore do
+  ignore_file = "#{Dir.pwd}/.gitignore"
+  if File.exists? ignore_file
+    STDERR.puts "File #{ignore_file} already exists!"
+  else
+    File.open ignore_file, 'w' do |file|
+      # Add other files to the Array below
+      %w[ log ].each do |pattern|
+        file.puts pattern
+      end
+    end
+  end
+end

data/app_generators/ahn/templates/components/ami_remote/ami_remote.rb

@@ -0,0 +1,15 @@
+methods_for :rpc do
+
+  # Simply create proxy methods for the high-level AMI methods
+
+  [:send_action, :introduce, :originate, :call_into_context, :call_and_exec, :ping].each do |method_name|
+    define_method(method_name) do |*args|
+      if VoIP::Asterisk.manager_interface
+        VoIP::Asterisk.manager_interface.send(method_name, *args)
+      else
+        ahn_log.ami_remote.error "AMI has not been enabled in startup.rb!"
+      end
+    end
+  end
+
+end

data/app_generators/ahn/templates/components/disabled/HOW_TO_ENABLE

@@ -0,0 +1,7 @@
+Type "ahn enable component COMPONENT_NAME_FROM_DISABLED_FOLDER
+
+For example:
+
+~/Desktop $ ahn create myapp
+~/Desktop $ cd myapp
+~/Desktop/myapp $ ahn enable component stomp_gateway

data/app_generators/ahn/templates/components/disabled/restful_rpc/README.markdown

@@ -0,0 +1,11 @@
+Adhearsion RESTful RPC Component
+================================
+
+This is a component for people want to integrate their telephony systems with non-Ruby systems. When enabled, this component
+will start up a HTTP server within the Adhearsion process and accept POST requests to invoke Ruby methods shared in the
+`methods_for(:rpc)` context.
+
+Protocol Notes
+--------------
+
+When POSTing your data to.

data/app_generators/ahn/templates/components/disabled/restful_rpc/example-client.rb

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rest_client'
+require 'json'
+
+# You must have the "rest-client" and "json" gems installed for this file to work.
+
+class RESTfulAdhearsion
+
+  DEFAULT_OPTIONS = {
+    # Note: :user and :password are non-existent by default
+    :host => "localhost",
+    :port => "5000",
+    :path_nesting => "/"
+  }
+
+  def initialize(options={})
+    @options = DEFAULT_OPTIONS.merge options
+
+    @path_nesting = @options.delete :path_nesting
+    @host = @options.delete :host
+    @port = @options.delete :port
+
+    @url_beginning = "http://#{@host}:#{@port}#{@path_nesting}"
+  end
+
+  def method_missing(method_name, *args)
+    JSON.parse RestClient::Resource.new(@url_beginning + method_name.to_s, @options).post(args.to_json)
+  end
+
+end
+
+Adhearsion = RESTfulAdhearsion.new :host => "localhost", :port => 5000, :user => "jicksta", :password => "roflcopterz"
+
+# ### Sample component code. Try doing "ahn create component testing123" and pasting this code in.
+#
+# methods_for :rpc do
+#   def i_like_hashes(options={})
+#     options.has_key?(:foo)
+#   end
+#   def i_like_arrays(*args)
+#     args.reverse
+#   end
+# end
+
+# Note: everything returned will be wrapped in an Array
+
+p Adhearsion.i_like_hashes(:foo => "bar")
+p Adhearsion.i_like_arrays(1,2,3,4,5)

data/app_generators/ahn/templates/components/disabled/restful_rpc/restful_rpc.rb

@@ -0,0 +1,91 @@
+begin
+  require 'rack'
+  require 'json'
+rescue LoadError
+  abort "ERROR: restful_rpc requires the 'rack' and 'json' gems"
+end
+
+# Don't you love regular expressions? Matches only 0-255 octets. Recognizes "*" as an octet wildcard.
+VALID_IP_ADDRESS = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|\*)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|\*)$/
+
+def ip_allowed?(ip)
+  raise ArgumentError, "#{ip.inspect} is not a valid IP address!" unless ip.kind_of?(String) && ip =~ VALID_IP_ADDRESS
+
+  octets = ip.split "."
+
+  case COMPONENTS.restful_rpc["access"]
+    when "everyone"
+      true
+    when "whitelist"
+      whitelist = COMPONENTS.restful_rpc["whitelist"]
+      !! whitelist.find do |pattern|
+        pattern_octets = pattern.split "."
+        # Traverse both arrays in parallel
+        octets.zip(pattern_octets).map do |octet, octet_pattern|
+          octet_pattern == "*" ? true : (octet == octet_pattern)
+        end == [true, true, true, true]
+      end
+    when "blacklist"
+      blacklist = COMPONENTS.restful_rpc["blacklist"]
+      ! blacklist.find do |pattern|
+        pattern_octets = pattern.split "."
+        # Traverse both arrays in parallel
+        octets.zip(pattern_octets).map do |octet, octet_pattern|
+          octet_pattern == "*" ? true : (octet == octet_pattern)
+        end == [true, true, true, true]
+      end
+    else
+      raise Adhearsion::Components::ConfigurationError, 'Unrecognized "access" configuration value!'
+  end
+end
+
+RESTFUL_API_HANDLER = lambda do |env|
+  json = env["rack.input"].read
+
+  # Return "Bad Request" HTTP error if the client forgot
+  return [400, {}, "You must POST a valid JSON object!"] if json.blank?
+
+  json = JSON.parse json
+
+  nesting = COMPONENTS.restful_rpc["path_nesting"]
+  path = env["PATH_INFO"]
+
+  return [404, {}, "This resource does not respond to #{path.inspect}"] unless path[0...nesting.size] == nesting
+
+  path = path[nesting.size..-1]
+
+  return [404, {"Content-Type" => "application/json"}, "You cannot nest method names!"] if path.include?("/")
+
+  rpc_object = Adhearsion::Components.component_manager.extend_object_with(Object.new, :rpc)
+
+  # TODO: set the content-type and other HTTP headers
+  response_object = rpc_object.send(path, *json)
+  [200, {"Content-Type" => "application/json"}, response_object.to_json]
+
+end
+
+initialization do
+  config = COMPONENTS.restful_rpc
+
+  api = RESTFUL_API_HANDLER
+
+  port            = config["port"] || 5000
+  authentication  = config["authentication"]
+  show_exceptions = config["show_exceptions"]
+  handler         = Rack::Handler.const_get(config["handler"] || "Mongrel")
+
+  if authentication
+    api = Rack::Auth::Basic.new(api) do |username, password|
+      authentication[username] == password
+    end
+    api.realm = "Adhearsion API"
+  end
+
+  if show_exceptions
+    api = Rack::ShowStatus.new(Rack::ShowExceptions.new(api))
+  end
+
+  Thread.new do
+    handler.run api, :Port => port
+  end
+end

data/app_generators/ahn/templates/components/disabled/restful_rpc/restful_rpc.yml

@@ -0,0 +1,34 @@
+# Use path_nesting to specify an arbitrarily nested. Could be used for additional security or in HTTP reverse proxy server.
+path_nesting: /
+
+port: 5000
+
+# The "handler" option here can be any valid Rack::Handler constant name.
+# Other options: WEBrick, EventedMongrel.
+# If you don't know the differences between these, "Mongrel" is definitely a good choice.
+handler: Mongrel
+
+# In a production system, you should make this "false" since
+show_exceptions: true
+
+# The "authentication" config option can either be "false" or key/value pairs representing allowed usernames and passwords.
+
+#authentication: false
+authentication:
+  jicksta: roflcopterz
+  foo: bar6213671682
+
+access: everyone   # When allowing "everyone" access, no IPs are blocked.
+#access: whitelist # When using a whitelist, the "whitelist" data below will be used.
+#access: blacklist # When using a blacklist, the "blacklist" data below will be used.
+
+# This is a list of IPs which are exclusively allowed to call this web service.
+# Note: whitelists are far more secure than blacklists.
+whitelist:
+  - 127.0.0.1
+  - 192.168.*.*
+
+# This is a list of the IPs which are explicitly NOT allowed to call this web service. This will only be used if "access" is
+# set to "blacklist" above.
+blacklist:
+  - 100.200.100.200

data/app_generators/ahn/templates/components/disabled/restful_rpc/spec/restful_rpc_spec.rb

@@ -0,0 +1,263 @@
+unless defined? Adhearsion
+  if File.exists? File.dirname(__FILE__) + "/../../../adhearsion/lib/adhearsion.rb"
+    # If you wish to freeze a copy of Adhearsion to this app, simply place a copy of Adhearsion
+    # into a folder named "adhearsion" within this app's main directory.
+    require File.dirname(__FILE__) + "/../../../adhearsion/lib/adhearsion.rb"
+  elsif File.exists? File.dirname(__FILE__) + "/../../../../../../lib/adhearsion.rb"
+    # This file may be ran from the within the Adhearsion framework code (before a project has been generated)
+    require File.dirname(__FILE__) + "/../../../../../../lib/adhearsion.rb"
+  else
+    require 'rubygems'
+    gem 'adhearsion', '>= 0.7.999'
+    require 'adhearsion'
+  end
+end
+
+require 'adhearsion/component_manager/spec_framework'
+
+RESTFUL_RPC = ComponentTester.new("restful_rpc", File.dirname(__FILE__) + "/../..")
+
+##### This is here for a reference
+#{"CONTENT_LENGTH"       => "12",
+# "CONTENT_TYPE"         => "application/x-www-form-urlencoded",
+# "GATEWAY_INTERFACE"    => "CGI/1.1",
+# "HTTP_ACCEPT"          => "application/xml",
+# "HTTP_ACCEPT_ENCODING" => "gzip, deflate",
+# "HTTP_AUTHORIZATION"   => "Basic amlja3N0YTpyb2ZsY29wdGVyeg==",
+# "HTTP_HOST"            => "localhost:5000",
+# "HTTP_VERSION"         => "HTTP/1.1",
+# "PATH_INFO"            => "/rofl",
+# "QUERY_STRING"         => "",
+# "rack.errors"          => StringIO.new(""),
+# "rack.input"           => StringIO.new('["o","hai!"]'),
+# "rack.multiprocess"    => false,
+# "rack.multithread"     => true,
+# "rack.run_once"        => false,
+# "rack.url_scheme"      => "http",
+# "rack.version"         => [0, 1],
+# "REMOTE_ADDR"          => "::1",
+# "REMOTE_HOST"          => "localhost",
+# "REMOTE_USER"          => "jicksta",
+# "REQUEST_METHOD"       => "POST"
+# "REQUEST_PATH"         => "/",
+# "REQUEST_URI"          => "http://localhost:5000/rofl",
+# "SCRIPT_NAME"          => "",
+# "SERVER_NAME"          => "localhost",
+# "SERVER_PORT"          => "5000",
+# "SERVER_PROTOCOL"      => "HTTP/1.1",
+# "SERVER_SOFTWARE"      => "WEBrick/1.3.1 (Ruby/1.8.6/2008-03-03)"}
+
+
+
+describe "The VALID_IP_ADDRESS regular expression" do
+
+  it "should match only valid IP addresses" do
+    valid_ip_addresses   = ["192.168.1.98", "10.0.1.200", "255.255.255.0", "123.*.4.*"]
+    invalid_ip_addresses = ["10.0.1.1 foo", "bar 255.255.255.0", "0*0*0*0", "1234"]
+
+    valid_ip_addresses.  each { |ip| RESTFUL_RPC::VALID_IP_ADDRESS.should =~ ip }
+    invalid_ip_addresses.each { |ip| RESTFUL_RPC::VALID_IP_ADDRESS.should_not =~ ip }
+  end
+end
+
+describe "The initialization block" do
+
+  it "should create a new Thread" do
+    mock_component_config_with :restful_rpc => {}
+    mock(Thread).new { nil }
+    RESTFUL_RPC.initialize!
+  end
+
+  it "should run the Rack adapter specified in the configuration" do
+    mock(Thread).new.yields
+    mock_component_config_with :restful_rpc => {"adapter" => "Mongrel"}
+    mock(Rack::Handler::Mongrel).run is_a(Proc), :Port => 5000
+    RESTFUL_RPC.initialize!
+  end
+
+  it "should wrap the RESTFUL_API_HANDLER in an Rack::Auth::Basic object if authentication is enabled" do
+    mock(Thread).new.yields
+    mock_component_config_with :restful_rpc => {"authentication" => {"foo" => "bar"}}
+
+    proper_authenticator = lambda do |obj|
+      request = OpenStruct.new :credentials => ["foo", "bar"]
+      obj.is_a?(Rack::Auth::Basic) && obj.send(:valid?, request)
+    end
+
+    mock(Rack::Handler::Mongrel).run(satisfy(&proper_authenticator), :Port => 5000)
+    RESTFUL_RPC.initialize!
+  end
+
+  it 'should wrap the RESTFUL_API_HANDLER in ShowStatus and ShowExceptions objects when show_exceptions is enabled' do
+    mock(Thread).new.yields
+    mock_component_config_with :restful_rpc => {"show_exceptions" => true}
+
+    mock.proxy(Rack::ShowExceptions).new(is_a(Proc))
+    mock.proxy(Rack::ShowStatus).new is_a(Rack::ShowExceptions)
+
+    mock(Rack::Handler::Mongrel).run is_a(Rack::ShowStatus), :Port => 5000
+    RESTFUL_RPC.initialize!
+  end
+
+end
+
+describe 'Private helper methods' do
+
+  describe "the RESTFUL_API_HANDLER lambda" do
+
+    it "should return a 200 for requests which execute a method that has been defined in the methods_for(:rpc) context" do
+      component_manager = Adhearsion::Components::ComponentManager.new('/path/shouldnt/matter')
+
+      mock(Adhearsion::Components).component_manager { component_manager }
+      component_manager.load_code <<-RUBY
+        methods_for(:rpc) do
+          def testing_123456(one,two)
+            [two.reverse, one.reverse]
+          end
+        end
+      RUBY
+
+      input = StringIO.new %w[jay phillips].to_json
+
+      mock_component_config_with :restful_rpc => {"path_nesting" => "/"}
+
+      env = {"PATH_INFO" => "/testing_123456", "rack.input" => input}
+
+      response = RESTFUL_RPC::RESTFUL_API_HANDLER.call(env)
+      response.should be_kind_of(Array)
+      response.should have(3).items
+      response.first.should equal(200)
+      JSON.parse(response.last).should eql(%w[jay phillips].map(&:reverse).reverse)
+    end
+
+    it "should return a 400 when no data is POSTed" do
+      env = {"rack.input" => StringIO.new(""), "REQUEST_URI" => "/foobar"}
+      RESTFUL_RPC::RESTFUL_API_HANDLER.call(env).first.should equal(400)
+    end
+
+    it "should work with a high level test of a successful method invocation" do
+
+      component_manager = Adhearsion::Components::ComponentManager.new('/path/shouldnt/matter')
+
+      mock(Adhearsion::Components).component_manager { component_manager }
+
+      component_manager.load_code '
+        methods_for(:rpc) do
+          def rofl(one,two)
+            "Hai! #{one} #{two}"
+          end
+        end'
+
+      env = {
+        "CONTENT_LENGTH"       => "12",
+        "CONTENT_TYPE"         => "application/x-www-form-urlencoded",
+        "GATEWAY_INTERFACE"    => "CGI/1.1",
+        "HTTP_ACCEPT"          => "application/xml",
+        "HTTP_ACCEPT_ENCODING" => "gzip, deflate",
+        "HTTP_AUTHORIZATION"   => "Basic amlja3N0YTpyb2ZsY29wdGVyeg==",
+        "HTTP_HOST"            => "localhost:5000",
+        "HTTP_VERSION"         => "HTTP/1.1",
+        "PATH_INFO"            => "/rofl",
+        "QUERY_STRING"         => "",
+        "rack.errors"          => StringIO.new(""),
+        "rack.input"           => StringIO.new('["o","hai!"]'),
+        "rack.multiprocess"    => false,
+        "rack.multithread"     => true,
+        "rack.run_once"        => false,
+        "rack.url_scheme"      => "http",
+        "rack.version"         => [0, 1],
+        "REMOTE_ADDR"          => "::1",
+        "REMOTE_HOST"          => "localhost",
+        "REMOTE_USER"          => "jicksta",
+        "REQUEST_METHOD"       => "POST",
+        "REQUEST_PATH"         => "/",
+        "REQUEST_URI"          => "http://localhost:5000/rofl",
+        "SCRIPT_NAME"          => "",
+        "SERVER_NAME"          => "localhost",
+        "SERVER_PORT"          => "5000",
+        "SERVER_PROTOCOL"      => "HTTP/1.1",
+        "SERVER_SOFTWARE"      => "WEBrick/1.3.1 (Ruby/1.8.6/2008-03-03)" }
+
+      response = RESTFUL_RPC::RESTFUL_API_HANDLER.call(env)
+      JSON.parse(response.last).should == ["Hai! o hai!"]
+
+    end
+
+    it "should contain backtrace information when show_errors is enabled and an exception occurs" do
+      mock_component_config_with :restful_api => {"show_errors" => true}
+      pending
+    end
+
+  end
+
+  describe 'the ip_allowed?() method' do
+
+    before :each do
+      @method = RESTFUL_RPC.helper_method :ip_allowed?
+    end
+
+    it 'should raise a ConfigurationError if "access" is not one of "everyone", "whitelist" or "blacklist"' do
+      good_access_values = %w[everyone whitelist blacklist]
+      bad_access_values  = %w[foo bar qaz qwerty everone blaclist whitlist]
+
+      good_access_values.each do |access_value|
+        mock_component_config_with :restful_rpc => {"access" => access_value, "whitelist" => [], "blacklist" => []}
+        lambda { @method.call("10.0.0.1") }.should_not raise_error
+      end
+
+      bad_access_values.each do |access_value|
+        mock_component_config_with :restful_rpc => {"access" => access_value, "authentication" => false}
+        lambda { @method.call("10.0.0.1") }.should raise_error(Adhearsion::Components::ConfigurationError)
+      end
+    end
+
+    describe 'whitelists' do
+
+      it "should parse *'s as wildcards" do
+        mock_component_config_with :restful_rpc => {"access" => "whitelist", "whitelist" => ["10.*.*.*"]}
+        @method.call("10.1.2.3").should be_true
+      end
+
+      it "should allow IPs which are explictly specified" do
+        mock_component_config_with :restful_rpc => {"access" => "whitelist", "whitelist" => ["4.3.2.1"]}
+        @method.call("4.3.2.1").should be_true
+      end
+
+      it "should not allow IPs which are not explicitly specified" do
+        mock_component_config_with :restful_rpc => {"access" => "whitelist", "whitelist" => %w[ 1.2.3.4 4.3.2.1]}
+        @method.call("2.2.2.2").should be_false
+      end
+
+    end
+
+    describe 'blacklists' do
+
+      it "should parse *'s as wildcards" do
+        mock_component_config_with :restful_rpc => {"access" => "blacklist", "blacklist" => ["10.*.*.*"]}
+        @method.call("10.1.2.3").should be_false
+      end
+
+      it "should not allow IPs which are explicitly specified" do
+        mock_component_config_with :restful_rpc => {"access" => "blacklist", "blacklist" => ["9.8.7.6", "9.8.7.5"]}
+        @method.call("9.8.7.5").should be_false
+      end
+
+      it "should allow IPs which are not explicitly specified" do
+        mock_component_config_with :restful_rpc => {"access" => "blacklist", "blacklist" => ["10.20.30.40"]}
+        @method.call("1.1.1.1").should be_true
+      end
+
+    end
+
+    describe '"everyone" access' do
+      it "should return true for any IP given, irrespective of the configuration" do
+        ip_addresses = %w[100.200.100.200 0.0.0.0 *.0.0.*]
+        ip_addresses.each do |address|
+          RESTFUL_RPC.helper_method(:ip_allowed?).call(address).should equal(true)
+        end
+      end
+    end
+
+  end
+
+end