AdhearsionConf was a HUGE success!  Approximately 30 people attended the first Voxeo Labs’ sponsored AdhearsionConf event last week in San Francisco (in person and on the stream).

During Jay Phillip’s (@Jicksta) Adhersion keynote, he suggested that we needed an easier way for the Adhearsion community to find and share components (plug-ins).  Fifteen minutes later @ChrisMatthieu registered and contributed the domain AhnHub.com.  Fifteen more minutes went by and a starter AhnHub.com website was written in Ruby on Rails and deployed to Heroku.

By the end of the event, AhnHub was receiving automatic component repository listings and commit updates from GitHub.  All the component author has to do to share their components with AhnHub is add http://ahnhub.com to their repository’s post-receive hooks as illustrated in the example below:

AhnHub automatically lists all known Adhearsion components on the home page.  Additional components can be added to the directory by updating the GitHub post-receive hook on the component’s repository.  A record of each commit update is also logged in the directory so that others can see the dates of the updates and corresponding links and messages associated with the commit.

The component directory is currently sorted in descending order by number of watchers per repository.  You can also link out to the home page of the component and quickly note whether the repository is private or public and view the number of watchers and forks on the repository.

Future enhancements will include GitHub OAuth authorization, tagging, and better search capabilities.  This is a great example of how a community with a variety of skills can contribute to various open source projects.  If you would like to get involved in this project, please notify Chris Matthieu to be added as a Collaborator on AhnHub.com.

The first ever AdhearsionConf is gearing up to start on Saturday! The advance team is already in San Francisco ensuring the venue is ready and all of the logistical planning is complete. So, without further adéu here is the agenda and additional details:

See everyone there!

The first AdhearsionConf will be held in San Francisco on the weekend of August 14-15, 2010.

Jay Phillips, the creator of Adhearsion, will be joining us for two days of talks, discussions, hacking and pair programming on all things Adhearsion.

What is Adhearson?
Adhearsion is the first fully-featured open source Ruby framework for Asterisk and an easy way to write voice-enabled applications. In the age of the social web, what other technologies are more social than voice?  Adhearsion empowers your code to handle and route inbound and outbound phone, VoIP, and Skype calls automatically, just like it handles normal web traffic.

Who should attend AdhearsionConf 2010?
Ruby developers who are already using Adhearsion or Asterisk or ANY Web 2.0 developers who would like to better understand how they can use Adhearsion to open up their applications to a whole new audience of VoIP, Skype and phone-based users.

If you’re not familiar with Jay (and/or Adhearsion), here’s a video interview from InfoQ where Jay Phillips explains what Adhearsion is.  We’ll also have other folks on deck that will be sharing their innovative uses of Adhearsion.

Additional speakers and sponsors are still being hashed out, but we’ll post the agenda and exact location as soon as we have them all solidified.  All you have to do is REGISTER EARLY and get yourself to San Francisco in August.

And, yes, there will be free food and possibly free kitten mittens.

We would like to announce the first AdhearsionConf to be held in San Francisco from August 14th to the 15th. Jay Phillips, the creator of Adhearsion, will be joining us for two days of talks, discussions, hacking and pair programming on all things Adhearsion. We also have other folks on deck that will be sharing their innovative uses of Adhearsion.

This event is sponsored by Voxeo Labs, so there will be no charge for the event itself. The final schedule and venue will be published soon. So mark your calendars and see you all in San Francisco in August!

After a long time coming I would like to announce the release of Adhearsion v0.8.4! Adhearsion was originally created by Jay Phillips (@jicksta) in 2006. Since that time it has evolved to become one of the most complete and widely adopted development frameworks for the Asterisk open-source telephony engine.

This release marks the continuation of the platform with some major enhancements and bugfixes:

• Support for Asterisk 1.6 (continued backward compatibility with Asterisk 1.4)
• Added support for ActiveLDAP
• ActiveRecord now works properly with Adhearsion components
• Daemonizing of Adhearsion no longer truncates log files
• Escape commands sent to Asterisk via AGI
• Asterisk Manager Interface (AMI) events now work when daemonized
• Various enhancements for improved Asterisk 1.6 support
• Various bugfixes

(For more details you may see the CHANGELOG and Lighthouse tickets.)

I would like to thank Ben Klang (@bklang), Troy Davis (@troyd), Eric Lindvall (@lindvall), Michel Villancourt (@jkl5group), Wayne Walker and so many others in the community that continue to support and move this project forward. There are more things in the works, so stay tuned for additional announcements coming soon.

For those of you new to Adhearsion you may install with ’sudo gem install adhearsion’. The source code is available on Github and the gem is on Rubygems.org.

I would like to welcome Ben Klang (@bklang) as a core contributor to the Adhearsion project. Ben has been active in the Adhearsion community for sometime, contributing patches, helping out on the Google Group and keeping the momentum of the community going.

Our first order of business with Ben now on board will be to release Adhearsion v0.8.4. The key focus of this release will be:

• Asterisk v1.6 Support
• DRb/ActiveRecord/Components Bugfix
• General Bugfixes off of Lighthouse

There is much more to come and we welcome all input from the community as we build our priorities. Thanks for all of the great support from Ben and everyone else so far!

There is much more we are preparing on the Adhearsion front, so stay tuned.

We have been busy working on our new Moho project over the last year, and are now in the process of doing lots of exciting new things with it. A plan has been in the work for some time to port Adhearsion onto Moho, so that it may run both on Asterisk and a deploy ready cloud like Tropo, all with minimal impact to Adhearsion applications already written.

With this, we have moved the official project of Adhearsion to Github. You may now find the official source code repository at http://github.com/adhearsion/adhearsion. The website will continue to be at Adhearsion.com where we have now begun monitoring the services from our 7×24 network operations center.

Stay tuned for more on the Adhearsion front.

Welcome to the new look of “Voxeo Labs”! After our announcement of Voxeo Labs last July, the domain “labs.voxeo.com” simply went to a static web page on our site with some basic information about Labs activities. While that was perhaps fine as the team started up, we decided with 2010 that we needed to more easily provide more dynamic content and get you information about all the cool things we’re cooking up in the Labs. So this new redesign is a start… this now combines our static content with the Voxeo Labs blog… and then will have individual pages for each of the projects associated with Voxeo Labs… like, oh, this one! We’re still building those pages out and you can see more soon.

That’s the news… we’ve got a spiffy new WordPress theme, new logos and more… we’d love to hear what you think about it – and do let us know if you see any funky in the display of content. Thanks!

Now that Tropo offers transcriptions, I would like to provide another example of using cloud services to manage your transcription results. In this case we will use Google AppEngine’s (GAE) Java implementation by deploying with JRuby, leveraging a similar architecture to what we use on Tropo for hosting our scripting languages.

I have created another Sinatra application (tropo-transcriptions) that provides an HTTP REST API for receiving POSTs of transcriptions from the Tropo cloud. The same application then allows you to get those results, either by fetching all or a single transcription. The app takes advantage of Google’s BigTable on GAE, storing all of the transcriptions right in the cloud in a schemaless data store. Using the unofficial Ruby/JRuby Google library, appengine-jruby, I have already created everything you need to simply download and deploy the application. This means that it already has JRuby and all of the Ruby gems baked into the app, so you get running with minimal fuss.

The first step is to install the google-appengine gem and download the tropo-transcriptions source code (you may do a Git clone or download from Github):

After having signed up for Google AppEngine and creating an application, then you need to make one configuration change to your application you just downloaded. Editing the file tropo-transcriptions/config.ru, make the following change to line 3:

:application => 'tropo-transcriptions'

becomes:

:application => 'your-app-name'

Then the last step is to deploy your application to Google AppEngine. To do this simply cd into your application’s directory and enter:

  appcfg.rb update .

You will be prompted for your GAE username and password and you should then see:

Thats it, you are now up and running. There are now three resources available on your new HTTP web services app:

1. POST to receive transcriptions

  http://your-app-name.appspot.com/receive_transcription

2. GET to fetch all transcriptions

  http://your-app-name.appspot.com/transcriptions

3. GET to fetch a single transcription based on GUID

  http://your-app-name.appspot.com/transcription?guid=5fad8750-7316-012c-00bd-0400580fde23

Now, you may start using your new server to store your transcription results. Simply use the first URL in the transcriptionOutURI portion of your recording request of your Tropo script:

  answer
  say 'Welcome to ruby recording test'

  event = record('Say something after the beep.',
                           { :repeat              => 0,
                             :bargein             => true,
                             :beep                => true,
                             :silenceTimeout      => 2,
                             :maxTime             => 30,
                             :timeout             => 4,
                             :recordURI           => 'http://tropo.to-a-domain.com/post_audio?filename=file123456.wav',
                             :transcriptionOutURI => 'http://your-app-name.appspot.com/receive_transcription',
                             :transcriptionID     => '123456' })

  log 'Recorded file: ' + event.recordURI
  say 'Thanks for your testing ruby on Tropo platform'
  hangup

Make a few calls and you should see this when you put the second URL above in your browser:

There is more to come…

At Voxeo Labs we clearly have an affinity for clouds. Now that we provide the ability to easily push recorded audio files out of the Tropo cloud, we would like to provide an example of how to receive and post these files using other great clouds.

For this example we are going to use Sinatra to create a REST web service application. This application will then be deployed to Heroku where it will receive and then push the recorded audio files from Tropo up to an Amazon S3 account.

First, Sinatra provides a simple domain specific language in Ruby for creating REST web services, or whole web sites if you choose to. In this case we are using Sinatra to write our REST API to receive and then process the audio file. Creating an HTTP resource with Sinatra is as simple as this:

  get '/pizza' do
    order params['toppings']
    # Do some more stuff
  end

To get this resource you would then put this in your web browser:

  http://www.yourhost.com/pizza?toppings=pepperoni

If we take this a step further, writing the code to receive an audio file and post to Amazon S3 is not much harder:

  post '/post_audio_to_s3' do
    AWS::S3::S3Object.store(params['filename'][:filename],
                            File.open(params['filename'][:tempfile].path),
                            AWS_CONFIG['bucket_name'])
  end

In your Tropo app you may then write a script to record and send an audio file:

  answer
  say 'Welcome to the recording application'
  startCallRecording 'http://www.yourhost.com/post_audio_to_s3?filename=myfilename.wav'
  ask 'Do you like chocolate?', { :choices => 'yes, no' }
  stopCallRecording
  hangup

Now we have our web service, but where to run it? This is where Heroku comes in. Heroku is an ‘instant Ruby platform’ that allows you to deploy an application, via Git, and have it up and running on a scalable infrastructure in minutes. Lucky for us, Heroku excels at running Sinatra apps, and they even have the AWS-S3 library built in. All you need is a Heroku account, which is free to get started with a Blossom, and you are ready to start running your web service.

Last but not least, you will need an Amazon S3 account to store your files. Thats it, you may now start moving your files through the clouds to Amazon, or use this as an example to store them wherever you choose. The full application ready to deploy locally or to Heroku is available at Github here.