aeolus

Friday I flew out to Mountain View, CA to attend the Google Summer of Code Mentors Summit hosted at the Googleplex, Google's worldwide headquarters. Every year, two mentors from every organization are sponsored by google to attend the summit and I was offered the extra slot by Buddhike, the Fedora summer of code admin.

After the inevitable hubub w/ delayed flights and such (surprisingly my stow-away bag actually made it!), I arrived at the hotel on Friday night intime for the pre-summit dinner. On Saturday shuttles were available to transport us from the hotel to the Googleplex which I have to say in quite impressive. From architecture of the buildings, to the modern artwork scattered around the complex, to the meals/beverages/snacks, and even random bicyles available for any employee to just pickup and use, the complex lives up to the legend! (hover over images for descriptions, click for full sizes)

The summit was very much developer centric which I very much enjoyed, as most of the other conferences I attended included a mix of sys-admin and developer tracks. Obviously the driving event was a summer of _code_, so many of the attendees were software engineers themselves, mentoring students doing the development. Some projects were bigger than others, some well established, some not, but it was a great mix of contributors from across the industry working on many cool things.

Among the best of the presentations I attended included roundtable discussions on the latest languages and language features being used in the industry, different collaboration tools that the projects are using and their thoughts on them, and one on developing tools to quantify and measure community metrics and individual contributions. During the lightning talks (one minute a piece), I showed off Zuhao's isitfedoraruby project, and extensively promoted his work, as well as Sammy's and Nitesh's contributions to Aeolus throughout the entire conference.

I also held an impromptu session on the JSON-RPC protocol during the afternoon which was a last minute thing, but was able to leverage my presentation and demo of rjr in Brno from a few months back. This led to an good discussion with some interesting ideas emerging from it and even a couple adopters!

Saturday night was the Summit Dinner Party at the hotel, italian food, good mingling, and even a dip in the pool and hottub! This morning I checked out of the hotel and attended more sessions before wrapping up the trip (I am currently blogging this from SFO prior to catching my red-eye home).

I have to say this might just be the best conference I've been to so far. The talks and presenters were phenomenal. Even the attendees were constituted of some of the brightest of the industry, so many conversations lead to insightful perspectives and different conclusions than I hadn't come upon so far. I hope to be able to participate in the GSoC and maybe attend the summit again next year. Until next time, happy coding!

Be sure to see the first three parts in this series which contains the complete overview of my demo for the conference. I also have a minimal set of slides which I've uploaded here (original showoff source and commands).

And thats about it! I head out in a short bit for my 7hr drive there (stopping in Buffalo) and back on Sunday. On Friday, I'm scheduled to present in the first slot at the 'Build A Cloud' Day, and then on saturday my OLF talk is at 3pm in room C110-112. Everyone who can make it is welcome to attend, and I'll try to take some photos and post from the conference but there is always a million things going on so no promises! :-)

Take care!

See my first article in the series to set up cloud providers, and my second article on using the core Aeolus components.

Web interface

To setup the full Aeolus suite, simply:

  yum install aeolus-all
  aeolus-configure

Open a web browser and navigate to http://localhost/conductor to access the conductor web interface.

Login w/ the default credentials ('admin' / 'password').

To manage cloud provider, click 'admin' and 'providers':

Add a new provider and provider account, specifying the type and location
of the provider, access credentials, and uri of the deltacloud instance
through which to connect to it.

Manage cloud hardware and realms:

Manage pools of providers and environment which instances run in:

Manager users and rights:

Build images and start instances themselves on providers according
to any number of metrics:

CLI

To connect via the command line, setup a ~/.aeolus-cli file containing the credentials which to use to connect to conductor:

   :conductor:
     :url: https://localhost/conductor/api
     :username: admin
     :password: password

Yum install the command line utility:

   # yum install aeolus-cli

All operations available via the web interface are also available from the command line:

   $ aeolus --help
 
   $  aeolus hwp list
 
   $  aeolus hwp create --name demo
 
   $  aeolus image --help

</presentation>

That about wraps up the presentation content that I had prepared, besides a small / minimal set of slides that I will be posting shortly. I have also downloaded a few screencasts off our youtube channel as a backup plan incase things go awry with one of my machines (there is a nice / short one on the Audrey config server that I'll probably end up showing anyways to demo that component).

Stay tuned for my final post in this series!

To setup a few cloud providers to use against Aeolus, see my first blog post in this series.

deltacloud

To install, the core Aeolus component, deltacloud and the drivers for oVirt (RHEV) and OpenStack:

  # yum install deltacloud-core deltacloud-core-rhevm deltacloud-core-openstack

Deltacloud comes with a RESTful server, a command line client, and various programatic interfaces including C and Ruby. We'll start a few instances of deltacloud to serve requests to the various providers and connect to them via IRB / Ruby. A single deltacloud server can dispatch requests to as many cloud providers as desired, provided the correct HTTP headers are set such that deltacloud can resolve the remote provider entry point. But for this demo, to make it especially clear what is going on, two deltacloud instances are used:

  # API_PROVIDER='https://ovirt:8443/api'  /usr/bin/ruby /usr/bin/deltacloudd -i rhevm -e production --port 3004 --host localhost -u nobody -g nobody
  # API_PROVIDER='https://openstack:5000/v2.0'  /usr/bin/ruby /usr/bin/deltacloudd -i openstack  -e production --port 3005 --host localhost -u nobody -g nobody

Pop open an irb session and connect oVirt

  $ irb
  > require 'deltacloud'
  > c = DeltaCloud.new('admin@internal', 'cloudpass', 'http://localhost:3004/api')
  => <DeltaCloud::API:0x00000002d75968 @password="cloudpass", @username="admin@internal",
                                        @api_uri=#<URI::HTTP:0x00000002d75580 URL:http://localhost:3004/api>,
                                        @entry_points={:instances=>"http://localhost:3004/api/instances",
                                                       :images=>"http://localhost:3004/api/images",
                                                       :drivers=>"http://localhost:3004/api/drivers",
                                                       :instance_states=>"http://localhost:3004/api/instance_states",
                                                       :storage_volumes=>"http://localhost:3004/api/storage_volumes",
                                                       :realms=>"http://localhost:3004/api/realms",
                                                       :hardware_profiles=>"http://localhost:3004/api/hardware_profiles"},
                                        @features={:instances=>[:user_name, :user_data]},
                                        @verbose=false, @driver_name="rhevm", @api_version="1.0.0">
 
  > c.instances.collect { |i| [i.id, i.name] }
  => [["8b347be3-0a76-4c84-aa79-c017557540f5", "demo6"],        ["894fb094-c75d-49a8-b49d-5523346b46a3", "demo7"],
      ["98511559-46a3-4eb2-aba2-4c81c4e0d5b5", "i-1347974040"], ["29c4d6ae-87ab-46cd-8424-af05b96b1d91", "i-1348008963"],
      ["c1844032-45d4-4b17-9405-224b4942ace7", "i-1348425727"], ["12f8c82e-2837-49e0-8d41-745aa208021a", "i-1348516821"],
      ["9f3e115f-e097-4fdc-bfa3-5d634141c38a", "i-1348586396"], ["76b5bc43-6bc5-4c06-a92a-c86595bfc303", "inst1"]]
 
  > c.images.collect { |i| [i.id, i.name] }
  => [["00000000-0000-0000-0000-000000000000", "Blank"], ["d0a8df2e-1563-470e-bfd7-8384a400380f", "e3280dab-e719-4e6e-b954-55578acfe4b7"]]
 
  > i = c.create_instance("00000000-0000-0000-0000-000000000000")
  => <DeltaCloud::API::Stateful::Instance:0x000000025ddb60 @base_name="instance", @client=<DeltaCloud::API:0x00000002d75968 ...>,
                                                            @url="http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4",
                                                            @id="d637ee52-787d-48de-a6c4-a92b854677b4",
                                                            @objects=[{:method_name=>"stopped?", :type=>:state, :state=>"STOPPED"},
                                                                      {:method_name=>"running?", :type=>:state, :state=>"RUNNING"},
                                                                      {:method_name=>"pending?", :type=>:state, :state=>"PENDING"},
                                                                      {:method_name=>"shutting_down?", :type=>:state, :state=>"SHUTTING_DOWN"},
                                                                      {:type=>:text, :method_name=>"name", :value=>"i-1348597714"},
                                                                      {:type=>:text, :method_name=>"owner_id", :value=>"admin@internal"},
                                                                      {:type=>:link, :method_name=>"image", :id=>"00000000-0000-0000-0000-000000000000"},
                                                                      {:type=>:text, :method_name=>"image_id", :value=>"00000000-0000-0000-0000-000000000000"},
                                                                      {:type=>:link, :method_name=>"realm", :id=>"99408929-82cf-4dc7-a532-9d998063fa95"},
                                                                      {:type=>:text, :method_name=>"realm_id", :value=>"99408929-82cf-4dc7-a532-9d998063fa95"},
                                                                      {:type=>:text, :method_name=>"state", :value=>"STOPPED"},
                                                                      {:type=>:link, :method_name=>"hardware_profile", :id=>"DESKTOP"},
                                                                      {:type=>:text, :method_name=>"hardware_profile_id", :value=>"DESKTOP"},
                                                                      {:type=>:action_link, :method_name=>"start!",
                                                                       :id=>"d637ee52-787d-48de-a6c4-a92b854677b4",
                                                                       :href=>"http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4/start",
                                                                       :rel=>"start", :method=>"post"},
                                                                      {:type=>:action_link, :method_name=>"destroy!",
                                                                       :id=>"d637ee52-787d-48de-a6c4-a92b854677b4",
                                                                       :href=>"http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4",
                                                                       :rel=>"destroy", :method=>"delete"},
                                                                      {:type=>:action_link, :method_name=>"create_image!",
                                                                       :id=>"d637ee52-787d-48de-a6c4-a92b854677b4",
                                                                       :href=>"http://localhost:3004/api/create_image;instance_id=d637ee52-787d-48de-a6c4-a92b854677b4",
                                                                       :rel=>"create_image", :method=>"post"},
                                                                      {:type=>:collection, :method_name=>"public_addresses",
                                                                       :values=>[{:address=>"127.0.0.1", :type=>"vnc"}]},
                                                                                 {:type=>:collection, :method_name=>"private_addresses", :values=>[]},
                                                                                 {:type=>:text, :method_name=>"storage_volumes", :value=>""}],
                                                            @action_urls=["http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4/start",
                                                                          "http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4",
                                                                          "http://localhost:3004/api/create_image;instance_id=d637ee52-787d-48de-a6c4-a92b854677b4"],
                                                            @actions=[["start", "http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4/start"],
                                                                      ["destroy", "http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4"],
                                                                      ["create_image", "http://localhost:3004/api/create_image;instance_id=d637ee52-787d-48de-a6c4-a92b854677b4"]],
                                                            @state="STOPPED">
 
  > i.actions
  => [["start",        "http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4/start"],
      ["destroy",      "http://localhost:3004/api/instances/d637ee52-787d-48de-a6c4-a92b854677b4"],
      ["create_image", "http://localhost:3004/api/create_image;instance_id=d637ee52-787d-48de-a6c4-a92b854677b4"]]
 
  > i.state
  => "STOPPED"
 
  > i.start!
  > i.state
  => "PENDING"
 
  # and after a little while
  > i.state
  => "RUNNING"

Now you can use the same API to connect to and control openstack:

  $ irb
  > require 'deltacloud'
 
  > c = DeltaCloud.new('admin+admin', 'cloudpass', 'http://localhost:3005/api')
  => <DeltaCloud::API:0x0000000149fc90 @password="cloudpass", @username="admin+admin",
                                        @api_uri=#<URI::HTTP:0x000000014a7530 URL:http://localhost:3005/api>,
                                        @entry_points={:instances=>"http://localhost:3005/api/instances",
                                                       :buckets=>"http://localhost:3005/api/buckets",
                                                       :images=>"http://localhost:3005/api/images",
                                                       :drivers=>"http://localhost:3005/api/drivers",
                                                       :instance_states=>"http://localhost:3005/api/instance_states",
                                                       :realms=>"http://localhost:3005/api/realms",
                                                       :hardware_profiles=>"http://localhost:3005/api/hardware_profiles"},
                                        @features={:instances=>[:user_name, :user_files, :authentication_password]},
                                        @verbose=false, @driver_name="openstack", @api_version="1.0.0">
 
  > c.instances.collect { |i| [i.id, i.name] }
  => [["f6915123-c3de-4a3c-bb0e-e88143ea838f", "2012-09-25 11:32:43 -0400"]]
 
  > c.images.collect { |i| [i.id, i.name] }
  => [["a4180f79-c4bf-4d61-a801-b5990b590fb0", "f16-jeos"]]
 
  > i = c.create_instance('a4180f79-c4bf-4d61-a801-b5990b590fb0')
  => <DeltaCloud::API::Stateful::Instance:0x000000014fe1a0 @base_name="instance", @client=#<DeltaCloud::API:0x0000000149fc90 ...>,
                                                            @url="http://localhost:3005/api/instances/c32688e4-eeb0-468f-a08f-cdf047d36b45",
                                                            @id="c32688e4-eeb0-468f-a08f-cdf047d36b45",
                                                            @objects=[{:method_name=>"stopped?", :type=>:state, :state=>"STOPPED"},
                                                                      {:method_name=>"running?", :type=>:state, :state=>"RUNNING"},
                                                                      {:method_name=>"pending?", :type=>:state, :state=>"PENDING"},
                                                                      {:method_name=>"shutting_down?", :type=>:state, :state=>"SHUTTING_DOWN"},
                                                                      {:type=>:text, :method_name=>"name", :value=>"2012-09-25 14:39:31 -0400"},
                                                                      {:type=>:text, :method_name=>"owner_id", :value=>"admin"},
                                                                      {:type=>:link, :method_name=>"image", :id=>"a4180f79-c4bf-4d61-a801-b5990b590fb0"},
                                                                      {:type=>:text, :method_name=>"image_id", :value=>"a4180f79-c4bf-4d61-a801-b5990b590fb0"},
                                                                      {:type=>:link, :method_name=>"realm", :id=>"default"},
                                                                      {:type=>:text, :method_name=>"realm_id", :value=>"default"},
                                                                      {:type=>:text, :method_name=>"state", :value=>"PENDING"},
                                                                      {:type=>:link, :method_name=>"hardware_profile", :id=>"1"},
                                                                      {:type=>:text, :method_name=>"hardware_profile_id", :value=>"1"},
                                                                      {:type=>:collection, :method_name=>"public_addresses", :values=>[]},
                                                                      {:type=>:collection, :method_name=>"private_addresses", :values=>[]},
                                                                      {:type=>:text, :method_name=>"storage_volumes", :value=>""},
                                                                      {:type=>:collection, :method_name=>"authentication", :values=>{:username=>"removed"}}],
                                                            @action_urls=[],
                                                            @actions=[],
                                                            @state="PENDING">
  irb(main):006:0> i.state
  => "PENDING"
 
  > c.instances.collect { |i| [i.id, i.name] }
  => [["c32688e4-eeb0-468f-a08f-cdf047d36b45", "2012-09-25 14:39:31 -0400"],
      ["f6915123-c3de-4a3c-bb0e-e88143ea838f", "2012-09-25 11:32:43 -0400"]]
 
  # openstack instances autostart
  > c.instances.first.state
  => "RUNNING"

The same API can be used to control ec2, vsphere, gogrid and many others.

imagefactory

To install imagefactory, the core component used to build and push cloud images, simply:

  # yum install imagefactory

You may want to checkout / build the latest imagefactory from source to get all the latest updates:

  # yum install git
  $ git clone git://github.com/aeolusproject/imagefactory.git
  $ cd imagefactory
  $ make rpms
  $ cd imagefactory-plugins
  $ make rpms
  $ rpm -ivh <imagefactory.rpm> <imagefactory-plugins.rpm>

The latest imagefactory also leverages the oVirt SDK to build images:

  $ rpmbuild --rebuild http://repos.fedorapeople.org/repos/aeolus/imagefactory/testing/latest_bindings/ovirt-engine-sdk-3.1.0.3-1.fc14.src.rpm
  $ rpm -ivh <ovirt-engine-sdk.rpm>

To push images to oVirt, mount the NFS export domain you had previous setup.

  $ mount ovirt:/ext/ovirt31export /mnt/ovirt

Two configuration files are read in by imagefactory, one describing the provider which to build images for and the other the credentials to use to push an image to it. For example the rhev provider json & credentials xml files would look like:

  $ cat rhevm.json 
      {"nfs-dir": "/mnt/ovirt", "nfs-path": "/ext/ovirt31export",
       "nfs-host": "ovirt", "cluster": "_any_",
       "api-url": "http://ovirt/api", "timeout": 1800 }
 
  $ cat rhevm.xml 
      <provider_credentials><rhevm_credentials><username>admin@internal</username><password>cloudpass</password></rhevm_credentials></provider_credentials>

And the openstack config files:

  $ cat openstack.json 
    {"glance-host": "openstack", "glance-port": 9292 }
 
  $ cat openstack.xml 
    <provider_credentials><openstack_credentials><username>admin</username><tenant>admin</tenant><password>cloudpass</password><strategy>keystone</strategy><auth_url>http://openstack:5000/v2.0</auth_url></openstack_credentials></provider_credentials>

Setup a template containing the description of the image you would like to build. You may download many useful ones from the Aeolus Templates Repo. There are ones to setup httpd, mysqld and more.

Import the template into imagefactory like so:

  $ sudo imagefactory base_image template.xml

Build the image for a particular cloud provider like so (target image is from last step):

  $ sudo imagefactory --debug target_image --id b55b42f1-aa2d-418f-b635-252e5f343209 rhevm

Push the image to the specified provider like so (image id from last step):

  $ sudo imagefactory --debug provider_image --id "2492c8c2-ada4-4325-a783-da3c37871ba7" --target rhevm rhevm.json rhevm.xml

other components

Aeolus consists of many components which can be used individually or together for a seamless cross-cloud experience. Imagefactory uses one of the most popular components Oz behind the scenes, to install a bare-bones operating system with Just-Enough-OS (JEOS) to bootstrap further installation mechanisms using the tooling native to the local environment. This allows us to generate minimalistic cloud images that are as portable as possible. The Audrey config server is used to orchestrate cross-cloud services and configurations and I have previously posted about snap which uses native tooling to take portable snapshots of cloud instances. Ontop of everything the Conductor RESTful API and Web application is used to manage all this, and configure various components to work with each other with users and an extensive permission schema. Infront of this is a the aeolus-cli which provides a rich command line cloud management interface.

Stay tuned for my next post in the series which will be on the Conductor Web UI and aeolus-cli.

This weekend I head out to Columbus, OH for the Ohio LinuxFest where I will be presenting Aeolus. This is one of the largest community run Linux conferences in the states, and should be my biggest presentation audience yet, so I'm really looking forward to going. The presentation leans heavily on a live demonstration of the software, with a minimal introduction to the topic and architecture at the beginning. This week a few of us in the Aeolus community are going to be blogging / tweeting / etc to try and drive a bit of buzz around our recent work which includes support for more cloud providers (prominently openstack!), various command line utilities and migration tooling, and our community efforts.

The demo consists of two machines, my desktop workstation acting as an 'external' cloud provider, and my laptop running a vm w/ the Aeolus suite on it. Network resources are always unreliable at conferences, so I'm not planning on deploying to ec2 or similar, but rather I have setup OpenStack and oVirt (RHEV) on my desktop, each bonded to their own management network interface, through which they will be controlled via my laptop. The exact same commands and setup I will be demoing works with any cloud provider supported by the Aeolus suite (which is the most comprehensive IaaS cloud management suite to date).

The demo will be run on freshly installed Fedora 17 systems with components from the Fedora package repositories. In retrospect the hardest part of setting everything up was setting up the cloud providers themselves, after which Aeolus was a cinch. It is no surprise through, a Cloud-based computational environment is a very complicated thing, and involves orchestrating many disparate components, each of which may be complicated in its own right. This reinforces the need for a technology such as Aeolus, as even with open frameworks such as oVirt and OpenStack, the end user is often adopting one particular way of doing things, which entails certain benefits and drawbacks. By adopting open standards 100% centred around portability, one is freeing themselves from being tied to a specific implementation and may choose at any point to adopt alternate solutions with minimal effort.

Attached below is my guide on setting up oVirt and OpenStack on a fresh F17 box (after the jump). I plan on posting an Aeolus overview later to demo interaction with the providers setup below.

A few months back I wrote about a few projects which I am mentoring for Fedora as part of the Google Summer of Code '12. Now that the summer is about 1/2 way over, I'm pleased to share the progress on the projects, as well as all the hard work that the students' have put into them.

First off Sammy who is working on an interface to deploy to the cloud via specified deployment criteria has made great headway expanding the central Aeolus API to support hardware profiles and instance management. Sammy has also expanded the command line client and utility to support these new capabilities and will be basing the remainder of the work this summer on using these features to deploy to the cheapest and quickest cloud providers.

Nitesh (who has been graciously volunteering his own time outside the GSoC) has been working on building a graphical (QT based) desktop client for Aeolus, which he is hosting on his github repo. The application is looking great, modules have already been completed for provider and instance management from the desktop, and he is looking to continue expanding functionality for end-to-end cloud instance management.

Finaly Zuhao who has been working hard on the isitfedoraruby project has also made great headway, implementing Rake tasks allowing us to import gems and rpms into the database, as well as various frontend interfaces which to display and cross-reference the gem and rpm metadata and other info. Various other features are in progress including the ability to comment and rate specific packages, a section highlighting various projects based on the Fedora / Ruby stack, and a mechanism to more closely integrate w/ rubygems as gems are pushed. You may find the code in Zuhao's github repo, and I've hosted the website on a temp subdomain for demoing purposes. Towards he end of the summer we'll update the site with the latest developments, reserve the is-it-fedora-ruby (or other) domain, and point that at my server.

Any comments, feedback, patches, or feature requests to any of these projects would be more than appreciated. Be sure to stay tuned for more updates as these projects evolve as additional features are added.

As some of you may know, Fedora was recently accepted, as a participating organization into the Google Summer of Code. Shortly after this was announced, Buddhika (our Fedora GSoC Admin and Coordinator) circulated a RFC for projects to improve the Fedora distribution as part of this effort. I submitted a few proposals to mentor myself, and am pleased to say there quite a bit of interest by various students, a few of which are now officially working on the various topics.

Specifically Samridh Srinath will be working on improving the Aeolus user experience on Fedora, implementing various aspect of the command line interface and core API features needed to drive it, and Zuhao Wan will be working on a site to highlight and promote the Fedora / Ruby experience, providing a simple one-stop-shop to query for Ruby related packages in Fedora and to assist in the migration process.

Unfortunately, not all of the students who applied were able to be accepted into the GSoC due to the limited number of slots we had available. Both Nitesh Narayan and Furhan Shabir are talented students who submitted strong proposals to work on Aeolus but weren't able to secure the official sponsorship. That being said, both have graciously volunteered to donate some time to assist with the project for which I would like to thank them greatly for.

All in all, I'm looking forward to working with these talented students over the course of the summer and beyond. Stay tuned for more updates as the projects progress and the proposals are implemented.

Until next time, happy hacking!

Just got back from Fudcon Blacksburg. As always, it was a great time. Arrived after driving down (10 hrs) Thursday evening and crashed quickly after checking into my accommodations (The Inn at Virginia Tech). Friday, the first day, was hackfests, I attended the Fedora Infrastructure meeting and held a few sessions around Aeolus where I talked with passer by's about the project, my Snap subproject and what people were looking for out of an open source IaaS cloud abstraction platform. Specifically at FUDCon I aimed to find out how people wanted to interface w/ the cloud on the Fedora desktop and how they wanted to use the Aeolus stack. We ended up modifying Snap a little to add some command line options and began
messing around w/ mycloud a c level cloud computing API I started throwing together to meet people's needs. Dinner that night was at a good indian place.

The second day was the barcamp sessions, I volunteered to do another session on Aeolus, which went well, there were plenty of newcomers interested in the projects and I was able to share what was in development and upcoming things on the platform. After lunch several of us from the ruby-sig met to hold the now traditional ruby-sig meeting at FUDCon (we held one in Toronto, one was held in Milan, and now this was the third at Blacksburg). We got alot done including:

• tested out the new Ruby 1.9.3 repository (messed around w/ getting Aeolus working on MRI 1.9.3)
• discussed updates to the new packaging guidelines, and updates to the the ruby stack
• looked into possibly using macros to assist w/ building gems for multiple ruby interpreters on Fedora (jeroen volunteered to start investigating thing one, this would be a feature coming furthur down the pipeline)
• discussed the rvm / bundler ecosystems, and again how to drive and market the Fedora philosophy of a single supported stack while delivering the ultimate development platform for the ruby-community
• looked into continuing building tools and applications which to enhance the Ruby experience on Fedora, I volunteered to build a isitfedoraruby website (akin to itisruby19.org) to demo and highlight fedora on ruby and to start reaching out to the cloud-sig and other Fedora communities to promote and highlight the product/platform.
• continuing to extend / expand / improve gem2rpm, polisher, and other gem/rpm interoperability tools

Next I attended the session on OpenStack, a popular build-your-own-cloud platform (one of the platforms supported by deltacloud) and learned a bit more about the internals and how it is constructed. Finally the lightning talks session was the last on Saturday, and a must for any FUDCon attendee. There were many pitches, including several for new fedora components including hosted instances of mock infra apps, a discussion on what motivates and how to drive open source contributions, a demonstration on how to inject code into running Python processes using "parasite" by lmacken, an overview of foss@rit by remmy dekaukusburg and the narcissus web visualizations by ralph bean. I ended up pitching mycloud and snap again as well as my own Nethack Encyclopedia project, inviting fellow explorers of the mazes of menace to bring the guide :-)

FUDPub was fun, as always a good time, featuring bowling and lots of tastey food and held at the Blacksburg student center this time around.

I'm writing this from my hotel room Sunday morning as I pack up and prepare for the 10hr drive hack. Overall a great time, have plenty to keep me busy going forward, and am looking forward to the next FUDCon!

For those who missed it, be sure to checkout the Aeolus Project youtube channel which contains several screencasts around current usage of Aeolus including topics such as:

I had such a great time at the last FUDCon I attended, Toronto '09 that I decided to return for Blacksburg '12 this upcoming January 13th-15th in Blacksburg, Virgina. Some of you may recall, during the last FUDCon, I gave a presentation on deltacloud, the core component of Aeolus the Open Source Cloud Computing API.

Alot of great work has went into the project over the last couple of years, and I've decided to submit a few hackfest proposals around using some of the tooling in unique ways. With the first proposal, I aim to go over the various projects that exist under the Aeolus umbrella, and use them to build some simple tools to deploy and monitor cloud provider instances in interesting ways. With my second proposal, I intend to take my subproject Snap (the modular system snapshotter for Fedora/Ubuntu/Windows/etc) and expand it with more custom snapshot targets. I have a bunch in mind, but I'm more than eager to help anyone write a plugin to take a snapshot of their own custom software (these are very easy to write and integrate into the project).

In any case, the conference should be a really fun time as always, and I'm really looking forward to it! Hope to see you all there!