adhearsion-cw 1.0.2.1

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,251 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+Bundler.require
+
+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

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

@@ -0,0 +1,104 @@
+require 'md5'
+require 'open-uri'
+
+SANDBOX_VERSION = 1.0
+
+initialization do
+  # We shouldn't start initializing until after the AGI server has initialized.
+  Events.register_callback(:after_initialized) do
+
+    config = if COMPONENTS.sandbox.has_key? "connect_to"
+      {"connect_to" => COMPONENTS.sandbox["connect_to"]}
+    else
+      begin
+        yaml_data = open("http://sandbox.adhearsion.com/component/#{SANDBOX_VERSION}").read
+        YAML.load yaml_data
+      rescue SocketError
+        ahn_log.sandbox.error "Could not connect to the sandbox server! Skipping sandbox initialization!"
+        next
+      rescue => e
+        ahn_log.sandbox.error "COULD NOT RETRIEVE SANDBOX CONNECTION INFORMATION! Not initializing sandbox component!"
+        next
+      end
+    end
+
+    begin
+      # The "connect_to" key is what this version supports
+      if config.kind_of?(Hash) && config.has_key?("connect_to")
+        config = config['connect_to']
+
+        host, port = config.values_at "host", "port"
+
+        username, password = COMPONENTS.sandbox["username"].to_s, COMPONENTS.sandbox["password"].to_s
+
+        if username.blank? || password.blank? || username == "user123"
+          ahn_log.sandbox.error "You must specify your username and password in this component's config file!"
+          next
+        end
+
+        # Part of the AGI-superset protocol we use to log in.
+        identifying_hash = MD5.md5(username + ":" + password).to_s
+
+        if host.nil? || port.nil?
+          ahn_log.sandbox.error "Invalid YAML returned from server! Skipping sandbox initialization!"
+          next
+        end
+
+        Thread.new do
+          loop do
+            begin
+              ahn_log.sandbox.debug "Establishing outbound AGI socket"
+              socket = TCPSocket.new(host, port)
+              socket.puts identifying_hash
+              response = socket.gets
+              unless response
+                next
+              end
+              response.chomp!
+              case response
+                when "authentication accepted"
+                  ahn_log.sandbox "Authentication accepted"
+
+                  start_signal = socket.gets
+                  next unless start_signal
+                  start_signal.chomp!
+
+                  if start_signal
+                    ahn_log.sandbox "Incoming call from remote sandbox server!"
+                    begin
+                      Adhearsion::Initializer::AsteriskInitializer.agi_server.server.serve(socket)
+                    rescue => e
+                      ahn_log.error "Non-fatal exception in the AGI server: #{e.inspect} \n" + e.backtrace.join("\n")
+                    ensure
+                      socket.close rescue nil
+                    end
+                    ahn_log.sandbox "AGI server finished serving call. Reconnecting to sandbox."
+                  else
+                    ahn_log.sandbox "Remote Asterisk server received no call. Reconnecting..."
+                  end
+                when "authentication failed"
+                  ahn_log.sandbox.error "Your username or password is invalid! Skipping sandbox initialization..."
+                  break
+                when /^wait (\d+)$/
+                  sleep response[/^wait (\d+)$/,1].to_i
+                else
+                  ahn_log.sandbox.error "Invalid login acknowledgement! Skipping sandbox initialization!"
+                  break
+              end
+            rescue Errno::ECONNREFUSED
+              ahn_log.sandbox.error "Could not connect to the sandbox server! Sandbox component stopping..."
+              break
+            rescue => e
+              ahn_log.error "Unrecognized error: #{e.inspect} \n" + e.backtrace.join("\n")
+            end
+          end
+        end
+
+      else
+        ahn_log.sandbox.error "COULD NOT RETRIEVE SANDBOX CONNECTION INFORMATION! Not initializing sandbox component!"
+      end
+    rescue => e
+      ahn_log.sandbox.error "Encountered an error when connecting to the sandbox! #{e.message}\n" + e.backtrace.join("\n")
+    end
+  end
+end

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

@@ -0,0 +1,2 @@
+username: user123
+password: pass123

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

@@ -0,0 +1,47 @@
+What is Stomp?
+==============
+
+Stomp is a very simple message-queue protocol with which two separate systems can communicate. Because the protocol is so simple, there are many Stomp server implementations from which you can choose. Some of these include
+
+ - ActiveMQ (http://activemq.com)
+ - Ruby "stompserver" gem (gem install stompserver)
+ - RabbitMQ (http://rabbitmq.com)
+
+If you wish to get up and running with a development environment, the Ruby stompserver gem is a fantastic starting point. For a critical production system, ActiveMQ should probably be used but it bears the cumbersome paradigm of many "enterprisey" Java applications.
+
+How does it work?
+=================
+
+Stomp is used when certain processes have defined responsibilities. For example, your Adhearsion application's responsibility is to communicate with your Asterisk machine. Other processes (e.g. a Rails web application) will probably need to instruct Adhearsion to do something. Instructions may include
+
+ - Start a new call between two given phone numbers
+ - Have a particular call do something based on a new event
+ - Hangup a call
+
+Below is a diagram which should give you a better idea of how it works.
+
+    Process  Process  Process (e.g. Rails)
+         \      |      /
+          \     |     /
+           Stomp Server       (e.g. ActiveMQ)
+                |
+                |
+             Process          (e.g. Adhearsion)
+
+Note: Adhearsion could also be the sender of messages through the Stomp server which are consumed by a number of handlers.
+
+Setting up a Ruby Stomp server
+==============================
+
+Install the pure-Ruby Stomp server by doing "gem install stompserver". This will add the "stompserver" command to your system. When running it without any parameters, it starts without requiring authentication. If you're wanting to get a quick experiment running, I recommend simply doing that.
+
+Open the `stomp_gateway.yml` file in the stomp_gateway component folder. Comment out the four settings at the top of the file named "user", "pass", "host" and "port" by prepending a "#" to their line. This will cause the component to choose defaults for those properties. The component's defaults will match the expected credentials for the experimental stompserver you're already running on your computer.
+
+You also need specify a subscription name in
+
+    events.stomp.start_call.each do |event|
+      # The "event" variable holds a Stomp::Message object.
+      name = event.headers
+    end
+
+You a

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

@@ -0,0 +1,34 @@
+require 'stomp'
+
+# TODO: Recover from a disconnect!
+
+initialization do
+  user = COMPONENTS.stomp_gateway[:user] || ""
+  pass = COMPONENTS.stomp_gateway[:pass] || ""
+  host = COMPONENTS.stomp_gateway[:host] || "localhost"
+  port = COMPONENTS.stomp_gateway[:port] || 61613
+
+  ::StompGatewayConnection = Stomp::Client.open(user, pass, host, port)
+
+  subscriptions = COMPONENTS.stomp_gateway["subscriptions"]
+
+  ahn_log.stomp_gateway "Connection established. Subscriptions: #{subscriptions.inspect}"
+
+  Events.register_namespace_name "/stomp"
+
+  subscriptions.each do |subscription|
+    Events.register_namespace_name "/stomp/#{subscription}"
+    ::StompGatewayConnection.subscribe subscription do |event|
+      Adhearsion::Events.trigger ["stomp", subscription], event
+    end
+  end
+
+end
+
+methods_for :global do
+  def send_stomp(destination, message, headers={})
+    ::StompGatewayConnection.send(destination, message, headers)
+  end
+end
+
+# In the future, I may add a methods_for(:events) method which allows synchronous messaging.

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

@@ -0,0 +1,12 @@
+# Comment out any of these properties to use a default.
+
+user: stomp_user
+pass: secret_password
+host: localhost
+port: 61613
+
+### Add your list of subscriptions below that this gateway should proxy to events.rb
+
+# subscriptions:
+#   - start_call
+#   - hungup_call

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

@@ -0,0 +1,3 @@
+In order to use this component, you must have an XMPP connection enabled in config/startup.rb. It is recommended this be done as an XMPP component rather than a standard client.
+
+You can use all elements of the Blather DSL scoped to XMPP::Connection

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

@@ -0,0 +1,11 @@
+initialization do
+  
+  XMPP::Connection.message :body do |m|
+    XMPP::Connection.say m.from, "You said: #{m.body}"
+  end
+  
+  XMPP::Connection.subscription :request? do |s|
+    XMPP::Connection.write_to_stream s.approve!
+  end
+
+end

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

@@ -0,0 +1,56 @@
+methods_for :dialplan do
+  def simon_game
+    SimonGame.new(self).start
+  end
+end
+
+class SimonGame
+
+  def initialize(call)
+    @call = call
+    reset
+  end
+
+  def start
+    loop do
+      say_number
+      collect_attempt
+      verify_attempt
+    end
+  end
+
+  def random_number
+    rand(10).to_s
+  end
+
+  def update_number
+    @number << random_number
+  end
+
+  def say_number
+    update_number
+    @call.say_digits @number
+  end
+
+  def collect_attempt
+    @attempt = @call.input @number.length
+  end
+
+  def verify_attempt
+    if attempt_correct?
+      @call.play 'good'
+    else
+      @call.play %W[#{@number.length-1} times wrong-try-again-smarty]
+      reset
+    end
+  end
+
+  def attempt_correct?
+    @attempt == @number
+  end
+
+  def reset
+    @attempt, @number = '', ''
+  end
+
+end

data/app_generators/ahn/templates/config/startup.rb

@@ -0,0 +1,74 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+Bundler.require
+
+Adhearsion::Configuration.configure do |config|
+
+  # Components to load from the system.
+  # All components that are activated in components/ will be automatically
+  # loaded and made available.
+  # This configuration option allows you to load components provided by gems.
+  # List the gem names here:
+  # config.add_component "ahn_test_component"
+
+  # Supported levels (in increasing severity) -- :debug < :info < :warn < :error < :fatal
+  config.logging :level => :info
+
+  # Whether incoming calls be automatically answered. Defaults to true.
+  # config.automatically_answer_incoming_calls = false
+
+  # Whether the other end hanging up should end the call immediately. Defaults to true.
+  # config.end_call_on_hangup = false
+
+  # Whether to end the call immediately if an unrescued exception is caught. Defaults to true.
+  # config.end_call_on_error = false
+
+  # NOTE: Pay special attention to the argument_delimiter field below:
+  # For Asterisk <= 1.4, use "|" (default)
+  # For Asterisk >= 1.6, use ","
+  # The delimiter can also be specified in Asterisk's asterisk.conf.
+  # This setting applies only to AGI.  The AMI delimiter is auto-detected.
+  config.enable_asterisk :argument_delimiter => '|'
+  # config.asterisk.enable_ami :host => "127.0.0.1", :username => "admin", :password => "password", :events => true
+
+  # config.enable_drb
+
+  # Streamlined Rails integration! The first argument should be a relative or absolute path to
+  # the Rails app folder with which you're integrating. The second argument must be one of the
+  # the following: :development, :production, or :test.
+
+  # config.enable_rails :path => 'gui', :env => :development
+
+  # Note: You CANNOT do enable_rails and enable_database at the same time. When you enable Rails,
+  # it will automatically connect to same database Rails does and load the Rails app's models.
+
+  # Configure a database to use ActiveRecord-backed models. See ActiveRecord::Base.establish_connection
+  # for the appropriate settings here.
+  # You can also override the default log destination by supplying an alternate
+  # logging object with :logger.  The default is ahn_log.db.
+  # config.enable_database :adapter  => 'mysql',
+  #                        :username => 'joe',
+  #                        :password => 'secret',
+  #                        :host     => 'db.example.org'
+
+  # Configure an LDAP connection using ActiveLdap.  See ActiveLdap::Base.establish_connect
+  # for the appropriate settings here.
+  # config.enable_ldap :host => 'ldap.dataspill.org',
+  #                    :port => 389,
+  #                    :base => 'dc=dataspill,dc=org',
+  #                    :logger => ahn_log.ldap,
+  #                    :bind_dn => "uid=drewry,ou=People,dc=dataspill,dc=org",
+  #                    :password => 'password12345',
+  #                    :allow_anonymous => false,
+  #                    :try_sasl => false
+
+  # Configure XMPP call controller
+  # config.enable_xmpp :jid => 'active-calls.xmpp.example.com',
+  #                    :password => 'passwd',
+  #                    :server => 'xmpp.example.com',
+  #                    :port => 5347
+
+end
+
+Adhearsion::Initializer.start_from_init_file(__FILE__, File.dirname(__FILE__) + "/..")

data/app_generators/ahn/templates/dialplan.rb

@@ -0,0 +1,3 @@
+adhearsion {
+  simon_game
+}

data/app_generators/ahn/templates/events.rb

@@ -0,0 +1,32 @@
+##
+# In this file you can define callbacks for different aspects of the framework. Below is an example:
+##
+#
+# events.asterisk.before_call.each do |call|
+#   # This simply logs the extension for all calls going through this Adhearsion app.
+#   extension = call.variables[:extension]
+#   ahn_log "Got a new call with extension #{extension}"
+# end
+#
+##
+# Asterisk Manager Interface example:
+#
+# events.asterisk.manager_interface.each do |event|
+#   ahn_log.events event.inspect
+# end
+#
+# This assumes you gave :events => true to the config.asterisk.enable_ami method in config/startup.rb
+#
+##
+# Here is a list of the events included by default:
+#
+# - events.asterisk.manager_interface
+# - events.after_initialized
+# - events.shutdown
+# - events.asterisk.before_call
+# - events.asterisk.failed_call
+# - events.asterisk.hungup_call
+#
+#
+# Note: events are mostly for components to register and expose to you.
+##