Merge lp:~eday/burrow/openstack_app into lp:~burrow-core/burrow/cactus

[Eric Day]

Per Vish's comment on the last MP, this is more of a FYI, but reviews appreciated if you have time. :) Also doing this so jenkins can merge it.

Adds an openstack application for modules not specific to burrow. So far this includes generic tcp/ssl socket wrapper, server, and HTTP protocol modules.

[OpenStack Infra (hudson-openstack)]

The attempt to merge lp:~eday/burrow/openstack_app into lp:burrow failed. Below is the output from the failed tests.

==> burrow (compile)
Compiled src/burrow.erl
Compiled src/burrow_http.erl
==> openstack (compile)
Compiled src/openstack_socket.erl
Compiled src/openstack.erl
Compiled src/openstack_server.erl
Compiled src/openstack_http.erl
==> rel (compile)
==> tmpDUU9Bk (compile)
==> burrow (eunit)
Compiled src/burrow_http.erl
Compiled src/burrow.erl

=INFO REPORT==== 27-Feb-2011::03:16:23 ===
    application: burrow
    exited: {bad_return,
                {{burrow,start,[normal,[]]},
                 {{listen_failed,eaddrinuse},
                  {child,undefined,
                      {tcp,8080,[]},
                      {proc_lib,start_link,
                          [openstack_server,listen,
                           [{tcp,8080,[]},
                            {state,#Fun<openstack_http.0.62395619>,
                                {state,#Fun<burrow_http.0.98356872>,
                                    undefined,<<"Burrow/2011.2">>,undefined,
                                    undefined}}]]},
                      transient,brutal_kill,worker,
                      [openstack_server]}}}}
    type: temporary
burrow: application_test (module 'burrow')...*failed*
::error:{assertEqual_failed,
          [{module,burrow},
           {line,84},
           {expression,"start ( )"},
           {expected,ok},
           {value,
               {error,
                   {bad_return,
                       {{burrow,start,[normal,[]]},
                        {{listen_failed,eaddrinuse},
                         {child,undefined,...}}}}}}]}
  in function burrow:'-application_test/0-fun-0-'/1
  in call from burrow:application_test/0

=======================================================
  Failed: 1. Skipped: 0. Passed: 0.
Cover analysis: /tmp/tmpDUU9Bk/apps/burrow/.eunit/index.html
ERROR: One or more eunit tests failed.

[OpenStack Infra (hudson-openstack)]

The attempt to merge lp:~eday/burrow/openstack_app into lp:burrow failed. Below is the output from the failed tests.

==> burrow (compile)
Compiled src/burrow.erl
Compiled src/burrow_http.erl
==> openstack (compile)
Compiled src/openstack_server.erl
Compiled src/openstack_socket.erl
Compiled src/openstack.erl
src/openstack_http.erl:225: Warning: variable 'Name' is unused
Compiled src/openstack_http.erl
==> rel (compile)
==> tmpChhJXr (compile)
==> burrow (eunit)
Compiled src/burrow_http.erl
Compiled src/burrow.erl

=INFO REPORT==== 28-Feb-2011::02:51:27 ===
Now listening on port: {tcp,32123,[]}

=INFO REPORT==== 28-Feb-2011::02:51:27 ===
    application: burrow
    exited: stopped
    type: temporary

=INFO REPORT==== 28-Feb-2011::02:51:27 ===
    application: openstack
    exited: stopped
    type: temporary

=INFO REPORT==== 28-Feb-2011::02:51:27 ===
    application: ssl
    exited: stopped
    type: temporary

=INFO REPORT==== 28-Feb-2011::02:51:27 ===
Now listening on port: {tcp,32123,[]}

=INFO REPORT==== 28-Feb-2011::02:51:27 ===
    application: burrow
    exited: stopped
    type: temporary

=INFO REPORT==== 28-Feb-2011::02:51:27 ===
    application: openstack
    exited: stopped
    type: temporary

=INFO REPORT==== 28-Feb-2011::02:51:27 ===
    application: ssl
    exited: stopped
    type: temporary
  Test passed.
Cover analysis: /tmp/tmpChhJXr/apps/burrow/.eunit/index.html
==> openstack (eunit)
Compiled src/openstack_socket.erl
Compiled src/openstack.erl
Compiled src/openstack_server.erl
src/openstack_http.erl:225: Warning: variable 'Name' is unused
src/openstack_http.erl:725: Warning: variable 'Send' is unused
Compiled src/openstack_http.erl

=INFO REPORT==== 28-Feb-2011::02:51:28 ===
    application: openstack
    exited: stopped
    type: temporary

=INFO REPORT==== 28-Feb-2011::02:51:28 ===
    application: ssl
    exited: stopped
    type: temporary

=INFO REPORT==== 28-Feb-2011::02:51:28 ===
    application: openstack
    exited: stopped
    type: temporary

=INFO REPORT==== 28-Feb-2011::02:51:28 ===
    application: ssl
    exited: stopped
    type: temporary

=INFO REPORT==== 28-Feb-2011::02:51:28 ===
Now listening on port: {tcp,32123,[]}

=INFO REPORT==== 28-Feb-2011::02:51:28 ===
    application: openstack
    exited: stopped
    type: temporary

=INFO REPORT==== 28-Feb-2011::02:51:28 ===
    application: ssl
    exited: stopped
    type: temporary

=INFO REPORT==== 28-Feb-2011::02:51:28 ===
Now listening on port: {tcp,32123,[]}

=INFO REPORT==== 28-Feb-2011::02:51:28 ===
    application: openstack
    exited: stopped
    type: temporary

=INFO REPORT==== 28-Feb-2011::02:51:28 ===
    application: ssl
    exited: stopped
    type: temporary

=INFO REPORT==== 28-Feb-2011::02:51:28 ===
Now listening on port: {tcp,32123,[]}

=ERROR REPORT==== 28-Feb-2011::02:51:28 ===
Error during HTTP request: <<"GET * BAD\r\n">>
=INFO REPORT==== 28-Feb-2011::02:51:28 ===
    application: openstack
    exited: stopped
    type: temporary

=INFO REPORT==== 28-Feb-2011::02:51:28 ===
    application: ssl
    exited: stopped
    type: temporary

=INFO REPORT==== 28-Feb-2011::02:51:28 ===
Now listening on port: {tcp,32123,[]}

=INFO REPORT==== ...

[lp:~eday/burrow/openstack_app]

8. By Eric Day on 2011-02-28

Fixed a couple warnings.

9. By Eric Day on 2011-02-28

Fixed a few odd behaviors with SSL application.

=== modified file '.bzrignore'
--- .bzrignore	2011-02-23 01:59:49 +0000
+++ .bzrignore	2011-02-28 07:20:04 +0000
@@ -1,4 +1,4 @@
-apps/burrow/.eunit/
-apps/burrow/doc
-apps/burrow/ebin
+apps/*/.eunit/
+apps/*/doc
+apps/*/ebin
 rel/burrow/

=== modified file 'README'
--- README	2011-02-23 01:59:49 +0000
+++ README	2011-02-28 07:20:04 +0000
@@ -50,3 +50,8 @@
 For information on the mailing list, IRC, and contributing, see:
 
 http://wiki.openstack.org/HowToContribute
+
+For developers, if you would like to see if your binary operations
+are optimized, set the following environment variable and recompile:
+
+export ERL_COMPILER_OPTIONS=bin_opt_info

=== modified file 'apps/burrow/src/burrow.app.src'
--- apps/burrow/src/burrow.app.src	2011-02-23 01:59:49 +0000
+++ apps/burrow/src/burrow.app.src	2011-02-28 07:20:04 +0000
@@ -13,18 +13,16 @@
 % limitations under the License.
 
 {application, burrow, [
-    {description, "Burrow - OpenStack Queue Service"},
+    {description, "Burrow - OpenStack Message Queue"},
     {vsn, "2011.2"},
     {modules, [
         burrow,
-        burrow_app,
-        burrow_sup
-    ]},
+        burrow_http]},
     {applications, [
         kernel,
-        stdlib
-    ]},
+        openstack,
+        stdlib]},
     {registered, []},
-    {mod, {burrow_app, []}},
-    {env, []}
+    {mod, {burrow, []}},
+    {env, [{http_ports, [8080]}]}
 ]}.

=== modified file 'apps/burrow/src/burrow.erl'
--- apps/burrow/src/burrow.erl	2011-02-23 01:59:49 +0000
+++ apps/burrow/src/burrow.erl	2011-02-28 07:20:04 +0000
@@ -12,21 +12,34 @@
 % See the License for the specific language governing permissions and
 % limitations under the License.
 
-% @doc Main functions for Burrow.
+% @doc Main application module for Burrow. This contains callbacks for
+%  both the application and root supervisor behaviours.
 
 -module(burrow).
 
 -export([start/0, stop/0, restart/0]).
 
+-behaviour(application).
+-export([start/2, stop/1]).
+
+-behaviour(supervisor).
+-export([init/1]).
+
 % @doc Start Burrow.
+% @spec () -> ok | {error, Reason}
 start() ->
+    openstack:start(),
     application:start(?MODULE).
 
 % @doc Stop Burrow.
+% @spec () -> ok | {error, Reason}
 stop() ->
-    application:stop(?MODULE).
+    Result = application:stop(?MODULE),
+    openstack:stop(),
+    Result.
 
 % @doc Restart Burrow.
+% @spec () -> ok | {error, Reason}
 restart() ->
     case stop() of
         ok -> start();
@@ -34,6 +47,33 @@
     end.
 
 %
+% Callbacks for the application behaviour.
+%
+
+% @doc Start callback for the application behaviour. This starts the root
+%  supervisor process and all components of the server. See application(3erl)
+%  for more details.
+start(_Type, _Args) ->
+    Supervisor = supervisor:start_link({local, ?MODULE}, ?MODULE, []),
+    burrow_http:start(),
+    Supervisor.
+
+% @doc Stop callback for the application behaviour. See application(3erl)
+%  for more details.
+stop(_State) ->
+    ok.
+
+%
+% Callbacks for the supervisor behaviour.
+%
+
+% @doc Init callback for the supervisor behaviour. See supervisor(3erl)
+%  for more details.
+init(_Args) ->
+    {ok, {{one_for_one, 10, 10}, [
+    ]}}.
+
+%
 % Test functions.
 %
 
@@ -41,6 +81,8 @@
 -include_lib("eunit/include/eunit.hrl").
 
 application_test() ->
+    ?assertEqual(ok, application:load(burrow)),
+    ?assertEqual(ok, application:set_env(burrow, http_ports, [32123])),
     ?assertEqual(ok, start()),
     ?assertEqual(ok, restart()),
     ?assertEqual(ok, stop()),

=== removed file 'apps/burrow/src/burrow_app.erl'
--- apps/burrow/src/burrow_app.erl	2011-02-23 01:59:49 +0000
+++ apps/burrow/src/burrow_app.erl	1970-01-01 00:00:00 +0000
@@ -1,32 +0,0 @@
-% Copyright (C) 2011 OpenStack LLC.
-%
-% Licensed under the Apache License, Version 2.0 (the "License");
-% you may not use this file except in compliance with the License.
-% You may obtain a copy of the License at
-%
-%     http://www.apache.org/licenses/LICENSE-2.0
-%
-% Unless required by applicable law or agreed to in writing, software
-% distributed under the License is distributed on an "AS IS" BASIS,
-% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-% See the License for the specific language governing permissions and
-% limitations under the License.
-
-% @doc Application module for burrow. This contains callbacks for the
-%  application behaviour.
-
--module(burrow_app).
-
--behaviour(application).
--export([start/2, stop/1]).
-
-% @doc Start callback for the application behaviour. This starts the root
-%  supervisor process and all components of the server. See application(3erl)
-%  for more details.
-start(_Type, _Args) ->
-    burrow_sup:start_link().
-
-% @doc Stop callback for the application behaviour. See application(3erl)
-%  for more details.
-stop(_State) ->
-    ok.

=== added file 'apps/burrow/src/burrow_http.erl'
--- apps/burrow/src/burrow_http.erl	1970-01-01 00:00:00 +0000
+++ apps/burrow/src/burrow_http.erl	2011-02-28 07:20:04 +0000
@@ -0,0 +1,38 @@
+% Copyright (C) 2011 OpenStack LLC.
+%
+% Licensed under the Apache License, Version 2.0 (the "License");
+% you may not use this file except in compliance with the License.
+% You may obtain a copy of the License at
+%
+%     http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+% See the License for the specific language governing permissions and
+% limitations under the License.
+
+% @doc This is a HTTP interface into Burrow. This module is built off of
+%  the generic HTTP server provided by openstack_http.
+
+-module(burrow_http).
+
+-export([start/0]).
+
+-include_lib("openstack/include/openstack_http.hrl").
+
+% @doc Start up the HTTP server for the configured ports.
+% @spec () -> {ok, Child} | {error, Reason}
+start() ->
+    {ok, Ports} = application:get_env(burrow, http_ports),
+    {ok, Version} = application:get_key(burrow, vsn),
+    ServerName = <<"Burrow/", (list_to_binary(Version))/binary>>,
+    openstack_http:server(Ports, ServerName, fun handle_request/3, undefined).
+
+% @doc Callback to handle requests from the client.
+% @spec (Request::openstack_http:request(),
+%        Response::openstack_http:response(),
+%        State::term())
+%       -> {Response::openstack_http:response(), State::term()}
+handle_request(_Request, Response, State) ->
+    {Response, State}.

=== removed file 'apps/burrow/src/burrow_sup.erl'
--- apps/burrow/src/burrow_sup.erl	2011-02-23 01:59:49 +0000
+++ apps/burrow/src/burrow_sup.erl	1970-01-01 00:00:00 +0000
@@ -1,32 +0,0 @@
-% Copyright (C) 2011 OpenStack LLC.
-%
-% Licensed under the Apache License, Version 2.0 (the "License");
-% you may not use this file except in compliance with the License.
-% You may obtain a copy of the License at
-%
-%     http://www.apache.org/licenses/LICENSE-2.0
-%
-% Unless required by applicable law or agreed to in writing, software
-% distributed under the License is distributed on an "AS IS" BASIS,
-% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-% See the License for the specific language governing permissions and
-% limitations under the License.
-
-% @doc Supervisor module for burrow. This contains callbacks for the root
-%  supervisor behaviour.
-
--module(burrow_sup).
-
--export([start_link/0]).
-
--behaviour(supervisor).
--export([init/1]).
-
-% @doc Start and link to the supervisor process.
-start_link() ->
-    supervisor:start_link({local, ?MODULE}, ?MODULE, []).
-
-% @doc Callback for the supervisor behaviour. See supervisor(3erl) for
-%  more details.
-init([]) ->
-    {ok, {{one_for_one, 5, 10}, []}}.

=== added directory 'apps/openstack'
=== added file 'apps/openstack/example.com-cert.pem'
--- apps/openstack/example.com-cert.pem	1970-01-01 00:00:00 +0000
+++ apps/openstack/example.com-cert.pem	2011-02-28 07:20:04 +0000
@@ -0,0 +1,15 @@
+-----BEGIN CERTIFICATE-----
+MIICXTCCAcYCCQDKsG7RfKYfUjANBgkqhkiG9w0BAQUFADBzMQswCQYDVQQGEwJV
+UzEPMA0GA1UECBMGT3JlZ29uMREwDwYDVQQHEwhQb3J0bGFuZDEUMBIGA1UEChML
+ZXhhbXBsZS5jb20xFDASBgNVBAsTC2V4YW1wbGUuY29tMRQwEgYDVQQDEwtleGFt
+cGxlLmNvbTAeFw0xMTAyMjQwMjU0MzNaFw0yMTAyMjEwMjU0MzNaMHMxCzAJBgNV
+BAYTAlVTMQ8wDQYDVQQIEwZPcmVnb24xETAPBgNVBAcTCFBvcnRsYW5kMRQwEgYD
+VQQKEwtleGFtcGxlLmNvbTEUMBIGA1UECxMLZXhhbXBsZS5jb20xFDASBgNVBAMT
+C2V4YW1wbGUuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCycD48lZj0
+wzMBZsNT7qzwlKcOiQJaPvaL4kQiL/3SGegnsnjiHscuAe2cQID7aPRTqam0GDbb
+ULLA8c8RIxaK7k8eM0GKFOzmbqtiyPi3H1FaL+2V94tUFrRy/OX9IXbArLWFmlCN
+V3gIhOFT4HH0io2OFzwc62lFYtyoZKQIaQIDAQABMA0GCSqGSIb3DQEBBQUAA4GB
+AKYQNMfbwttDyv3h96SKa6ll0sEHzghO/HwpF0n6iIrly3xvpSoR39ydR2wAmmGH
+33oA5tF51SD7CplQDHyst6QWFjRzmNla5TfUfImJS0VqIQYQTneikpHsBopt5T5f
+MKn4t7AeUVMLGIU1w3DuIMe6OLm08gpwyb6XYqhLMvtp
+-----END CERTIFICATE-----

=== added file 'apps/openstack/example.com-key.pem'
--- apps/openstack/example.com-key.pem	1970-01-01 00:00:00 +0000
+++ apps/openstack/example.com-key.pem	2011-02-28 07:20:04 +0000
@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICWwIBAAKBgQCycD48lZj0wzMBZsNT7qzwlKcOiQJaPvaL4kQiL/3SGegnsnji
+HscuAe2cQID7aPRTqam0GDbbULLA8c8RIxaK7k8eM0GKFOzmbqtiyPi3H1FaL+2V
+94tUFrRy/OX9IXbArLWFmlCNV3gIhOFT4HH0io2OFzwc62lFYtyoZKQIaQIDAQAB
+AoGAG4uyP94EJ7y+cffwLVPKBLWd+GN0JoRTwRJj3Dc2Yqm3KfGmMZn4u4R2rslS
+X/06wnONjAy04zRY8+ogQg/9maCdNYITJTh/hgIwv0p+El1KDRvolRbdKLX+PkB2
+yCgQ2E1yh73sHYZUJP4pmxgMyRqnuxAHI3LTCMjQxyx8z4ECQQDqZx8Eer+b0RDX
+i5vD6p4+9j5bWMvPrDd2BTQJFQSmcnPq5urQcMjJXUpokQ8SBxJjojYtzzCIkiZT
+WGX4uGtZAkEAwuEV8vd+V7BOGE6T2V8MUQYaSbIXeSq0mWxpeG7z54UjYLHaxVKv
+3tuTakKFscBOPURRt+0GczmdOtkaliCzkQJAEduzaEL10Cg4cUOIpX99eOyHyavV
+M0g6nXo+AachSJEVtcLMBv9gvL6nyZmrnUL+qqqUGB9d4jnIQ7dLZYyfWQJAFCw4
+mW4FJg6aBuobY+Ty4XBASGCnDWPeTgNq54yUsuKVRu0iOErW6brRB67bKAtADheE
+XgWrJUJRhEX0+pVoAQJAKFR1XG4VauNlsrxTSlDGEitew1sdw3/uzzsQ/XWxSgYF
+izvmXCV5e8IINSMSicjd+2/IQrCLGXNWA4Tt02bOqA==
+-----END RSA PRIVATE KEY-----

=== added directory 'apps/openstack/include'
=== added file 'apps/openstack/include/openstack_http.hrl'
--- apps/openstack/include/openstack_http.hrl	1970-01-01 00:00:00 +0000
+++ apps/openstack/include/openstack_http.hrl	2011-02-28 07:20:04 +0000
@@ -0,0 +1,125 @@
+% Copyright (C) 2011 OpenStack LLC.
+%
+% Licensed under the Apache License, Version 2.0 (the "License");
+% you may not use this file except in compliance with the License.
+% You may obtain a copy of the License at
+%
+%     http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+% See the License for the specific language governing permissions and
+% limitations under the License.
+
+% Data types used with the openstack_http module.
+
+% @type request() = #request{
+%       method = atom() | binary(),
+%       path = binary(),
+%       parameters = [parameter()],
+%       version = {integer(), integer()},
+%       headers = [request_header()],
+%       connection = undefined | close | keep_alive,
+%       expect = undefined | continue,
+%       length = integer(),
+%       body = undefined | function()}
+% @type parameter() = {Name::binary(), Value::binary()}
+% @type request_header() = {Name::atom() | binary(), Value::binary()}
+-record(request, {
+    method = 'GET',
+    path = <<>>,
+    parameters = [],
+    version = {1, 1},
+    headers = [],
+    connection,
+    expect,
+    length = 0,
+    body}).
+
+% @type response() = #response{
+%       status = integer(),
+%       headers = [response_header()],
+%       connection = undefined | close | keep_alive,
+%       chunked = true | false | allowed,
+%       length = integer(),
+%       body = undefined | binary() | function()}
+% @type response_header() = {
+%       Name::atom() | binary(),
+%       Value::integer() | list() | binary()}
+-record(response, {
+    status = 200,
+    headers = [],
+    connection,
+    chunked = false,
+    length = 0,
+    body}).
+
+% The built-in Erlang packet parser (written in C) parses HTTP natively
+% which is much faster than doing it in Erlang. It optimizes around common
+% method and header names by returning them as atoms instead of strings or
+% binaries. Common headers must be matched using atoms, but custom headers
+% must be matched using binaries. The following lists show what are atoms.
+
+% The following method names will be atoms, all others will be binaries:
+% OPTIONS
+% GET
+% HEAD
+% POST
+% PUT
+% DELETE
+% TRACE
+
+% The following header names will be atoms, all others will be binaries:
+% Cache-Control
+% Connection
+% Date
+% Pragma
+% Transfer-Encoding
+% Upgrade
+% Via
+% Accept
+% Accept-Charset
+% Accept-Encoding
+% Accept-Language
+% Authorization
+% From
+% Host
+% If-Modified-Since
+% If-Match
+% If-None-Match
+% If-Range
+% If-Unmodified-Since
+% Max-Forwards
+% Proxy-Authorization
+% Range
+% Referer
+% User-Agent
+% Age
+% Location
+% Proxy-Authenticate
+% Public
+% Retry-After
+% Server
+% Vary
+% Warning
+% Www-Authenticate
+% Allow
+% Content-Base
+% Content-Encoding
+% Content-Language
+% Content-Length
+% Content-Location
+% Content-Md5
+% Content-Range
+% Content-Type
+% Etag
+% Expires
+% Last-Modified
+% Accept-Ranges
+% Set-Cookie
+% Set-Cookie2
+% X-Forwarded-For
+% Cookie
+% Keep-Alive
+% Proxy-Connection

=== added file 'apps/openstack/include/openstack_logging.hrl'
--- apps/openstack/include/openstack_logging.hrl	1970-01-01 00:00:00 +0000
+++ apps/openstack/include/openstack_logging.hrl	2011-02-28 07:20:04 +0000
@@ -0,0 +1,19 @@
+% Copyright (C) 2011 OpenStack LLC.
+%
+% Licensed under the Apache License, Version 2.0 (the "License");
+% you may not use this file except in compliance with the License.
+% You may obtain a copy of the License at
+%
+%     http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+% See the License for the specific language governing permissions and
+% limitations under the License.
+
+% Logging macros in case we want to switch or wrap these later.
+
+-define(ERROR, error_logger:error_msg).
+-define(WARNING, error_logger:warning_msg).
+-define(INFO, error_logger:info_msg).

=== added directory 'apps/openstack/src'
=== added file 'apps/openstack/src/openstack.app.src'
--- apps/openstack/src/openstack.app.src	1970-01-01 00:00:00 +0000
+++ apps/openstack/src/openstack.app.src	2011-02-28 07:20:04 +0000
@@ -0,0 +1,29 @@
+% Copyright (C) 2011 OpenStack LLC.
+%
+% Licensed under the Apache License, Version 2.0 (the "License");
+% you may not use this file except in compliance with the License.
+% You may obtain a copy of the License at
+%
+%     http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+% See the License for the specific language governing permissions and
+% limitations under the License.
+
+{application, openstack, [
+    {description, "OpenStack - Common OpenStack Modules"},
+    {vsn, "2011.2"},
+    {modules, [
+        openstack,
+        openstack_http,
+        openstack_server,
+        openstack_socket]},
+    {applications, [
+        kernel,
+        stdlib]},
+    {registered, []},
+    {mod, {openstack, []}},
+    {env, []}
+]}.

=== added file 'apps/openstack/src/openstack.erl'
--- apps/openstack/src/openstack.erl	1970-01-01 00:00:00 +0000
+++ apps/openstack/src/openstack.erl	2011-02-28 07:20:04 +0000
@@ -0,0 +1,86 @@
+% Copyright (C) 2011 OpenStack LLC.
+%
+% Licensed under the Apache License, Version 2.0 (the "License");
+% you may not use this file except in compliance with the License.
+% You may obtain a copy of the License at
+%
+%     http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+% See the License for the specific language governing permissions and
+% limitations under the License.
+
+% @doc Main application module for OpenStack. This contains callbacks for
+%  both the application and root supervisor behaviours.
+
+-module(openstack).
+
+-export([start/0, stop/0, restart/0]).
+
+-behaviour(application).
+-export([start/2, stop/1]).
+
+-behaviour(supervisor).
+-export([init/1]).
+
+% @doc Start OpenStack.
+% @spec () -> ok | {error, Reason}
+start() ->
+    ssl:start(),
+    application:start(?MODULE).
+
+% @doc Stop OpenStack.
+% @spec () -> ok | {error, Reason}
+stop() ->
+    application:stop(?MODULE).
+
+% @doc Restart OpenStack.
+% @spec () -> ok | {error, Reason}
+restart() ->
+    case stop() of
+        ok -> start();
+        Error -> Error
+    end.
+
+%
+% Callbacks for the application behaviour.
+%
+
+% @doc Start callback for the application behaviour. This starts the root
+%  supervisor process and all components of the server. See application(3erl)
+%  for more details.
+start(_Type, _Args) ->
+    supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
+% @doc Stop callback for the application behaviour. See application(3erl)
+%  for more details.
+stop(_State) ->
+    ok.
+
+%
+% Callbacks for the supervisor behaviour.
+%
+
+% @doc Init callback for the supervisor behaviour. See supervisor(3erl)
+%  for more details.
+init(_Args) ->
+    {ok, {{one_for_one, 10, 10}, [
+        openstack_server:child_spec()
+    ]}}.
+
+%
+% Test functions.
+%
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+
+application_test() ->
+    ?assertEqual(ok, start()),
+    ?assertEqual(ok, restart()),
+    ?assertEqual(ok, stop()),
+    ?assertEqual({error, {not_started, openstack}}, restart()).
+
+-endif.

=== added file 'apps/openstack/src/openstack_http.erl'
--- apps/openstack/src/openstack_http.erl	1970-01-01 00:00:00 +0000
+++ apps/openstack/src/openstack_http.erl	2011-02-28 07:20:04 +0000
@@ -0,0 +1,763 @@
+% Copyright (C) 2011 OpenStack LLC.
+%
+% Licensed under the Apache License, Version 2.0 (the "License");
+% you may not use this file except in compliance with the License.
+% You may obtain a copy of the License at
+%
+%     http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+% See the License for the specific language governing permissions and
+% limitations under the License.
+
+% @doc HTTP protocol module that allows other modules to easily write
+%  HTTP clients and servers. Currently only server functions are defined,
+%  clients should use the HTTP client module provided by inets(3erl).
+
+-module(openstack_http).
+
+-export([server/4, get_request_header/2, set_response_headers/2]).
+
+% @headerfile "openstack_http.hrl"
+-include("openstack_http.hrl").
+-include("openstack_logging.hrl").
+
+% @type state() = #state{
+%       handle_request = function(),
+%       callback_state = term(),
+%       server_name = binary(),
+%       socket = term()}
+-record(state, {
+    handle_request,
+    callback_state,
+    server_name,
+    socket}).
+
+% @doc Start up HTTP listener sockets for the given ports using the
+%  openstack_server module.
+% @spec (Ports::openstack_server:ports(),
+%        ServerName::binary(),
+%        HandleRequest::function(),
+%        CallbackState::term())
+%       -> {ok, Child} | {error, Reason}
+server(Ports, ServerName, HandleRequest, CallbackState) ->
+    openstack_server:start(Ports, fun accept/2, #state{
+        handle_request = HandleRequest,
+        callback_state = CallbackState,
+        server_name = <<"OpenStack (", ServerName/binary, ")">>}).
+
+% @doc Callback function for when a new client is accepted.
+% @spec (Socket::term(), State::state()) -> ok
+accept(Socket, State) ->
+    start_request(State#state{socket = Socket}).
+
+% @doc Start a new HTTP request.
+% @spec (State::state()) -> ok
+start_request(State = #state{socket = Socket}) ->
+    case recv_request(Socket) of
+        {ok, Request} ->
+            handle_request(Request, State);
+        {error, closed} ->
+            ok;
+        {error, {http_error, Reason}} ->
+            ?WARNING("Error during HTTP request: ~p", [Reason]),
+            openstack_socket:send(Socket, <<
+                "HTTP/1.1 400 Bad Request\r\n"
+                "Date: ",
+                (list_to_binary(httpd_util:rfc1123_date()))/binary, "\r\n"
+                "Server: ", (State#state.server_name)/binary, "\r\n"
+                "Content-Length: 0\r\n"
+                "Connection: close\r\n\r\n">>),
+            ok;
+        Error ->
+            ?WARNING("Error during HTTP request: ~p", [Error]),
+            ok
+    end.
+
+% @doc Pass the request off to the callback function and send the response.
+% @spec (Request::request(), State::state()) -> ok
+handle_request(Request, State = #state{
+        handle_request = HandleRequest,
+        callback_state = CallbackState,
+        server_name = ServerName,
+        socket = Socket}) ->
+    Response = #response{
+        headers = [
+            {'Date', list_to_binary(httpd_util:rfc1123_date())},
+            {'Server', ServerName}],
+        connection = Request#request.connection,
+        chunked = chunked_allowed(Request)},
+    {NewResponse, NewCallbackState} =
+        HandleRequest(Request, Response, CallbackState),
+    case send_response(NewResponse, Socket) of
+        persist ->
+            start_request(State#state{callback_state = NewCallbackState});
+        close ->
+            ok;
+        Error ->
+            ?WARNING("Error during HTTP response: ~p", [Error]),
+            ok
+    end.
+
+% @doc Check to see if chunked transfer encoding is possible.
+% @spec (Request::request()) -> allowed | false
+chunked_allowed(#request{version = {1, 1}}) ->
+    allowed;
+chunked_allowed(_Request) ->
+    false.
+
+% @doc Setup the socket and request record for reading a request.
+% @spec (Socket::term())
+%       -> {ok, Request::request()} | {error | http_error, Reason}
+recv_request(Socket) ->
+    openstack_socket:setopts(Socket, [{packet, http_bin}]),
+    recv_request(Socket, #request{}).
+    
+% @doc Parse the request line and headers for a HTTP request. This uses
+%  the built-in Erlang HTTP parsing that is written in C. For full details
+%  on the packet types, see the decode_packet documentation in erlang(3erl).
+% @spec (Socket::term(), Request::request())
+%       -> {ok, Request::request()} | {error | http_error, Reason}
+recv_request(Socket, Request) ->
+    case openstack_socket:recv(Socket, 0) of
+        {ok, {http_request, Method, URI, Version}} ->
+            {Path, Parameters} = parse_uri(URI),
+            NewRequest = parse_version(Version, Request),
+            recv_request(Socket, NewRequest#request{
+                method = Method,
+                path = Path,
+                parameters = Parameters});
+        {ok, {http_header, _Number, Name, _Reserved, Value}} ->
+            recv_request(Socket, parse_header({Name, Value}, Request));
+        {ok, http_eoh} ->
+            openstack_socket:setopts(Socket, [{packet, raw}]),
+            NewHeaders = lists:reverse(Request#request.headers),
+            {ok, set_recv(Request#request{headers = NewHeaders}, Socket)};
+        Error ->
+            Error
+    end.
+
+% @doc Parse one of the URI formats given by the HTTP packet parsing.
+% @spec (URI::term()) -> {Path::binary, Parameters::[parameter()]}
+parse_uri('*') ->
+    {'*', []};
+parse_uri({abs_path, URI}) ->
+    parse_path(URI, <<>>);
+parse_uri(URI) ->
+    parse_path(URI, <<>>).
+
+% @doc Parse the path portion of the URI.
+% @spec (URI::binary(), Path::binary())
+%       -> {Path::binary, Parameters::[parameter()]}
+parse_path(<<>>, Path) ->
+    {Path, []};
+parse_path(<<$?, URI/binary>>, Path) ->
+    parse_key(URI, Path, [], <<>>);
+parse_path(<<Character, URI/binary>>, Path) ->
+    parse_path(URI, <<Path/binary, Character>>).
+
+% @doc Parse a key in the URI parameter list.
+% @spec (URI::binary(),
+%        Path::binary(),
+%        Parameters::[parameter()],
+%        Key::binary())
+%       -> {Path::binary(), Parameters::[parameter()]}
+parse_key(<<>>, Path, Parameters, <<>>) ->
+    {Path, Parameters};
+parse_key(<<>>, Path, Parameters, Key) ->
+    {Path, lists:reverse([{Key, <<>>} | Parameters])};
+parse_key(<<$&, URI/binary>>, Path, Parameters, <<>>) ->
+    parse_key(URI, Path, Parameters, <<>>);
+parse_key(<<$&, URI/binary>>, Path, Parameters, Key) ->
+    parse_key(URI, Path, [{Key, <<>>} | Parameters], <<>>);
+parse_key(<<$=, URI/binary>>, Path, Parameters, Key) ->
+    parse_value(URI, Path, [{Key, <<>>} | Parameters], <<>>);
+parse_key(<<Character, URI/binary>>, Path, Parameters, Key) ->
+    parse_key(URI, Path, Parameters, <<Key/binary, Character>>).
+
+% @doc Parse a value in the URI parameter list.
+% @spec (URI::binary(),
+%        Path::binary(),
+%        Parameters::[parameter()],
+%        Value::binary())
+%       -> {Path::binary, Parameters::[parameter()]}
+parse_value(<<>>, Path, Parameters, <<>>) ->
+    {Path, Parameters};
+parse_value(<<>>, Path, [{Key, <<>>} | Parameters], Value) ->
+    {Path, lists:reverse([{Key, Value} | Parameters])};
+parse_value(<<$&, URI/binary>>, Path, [{Key, <<>>} | Parameters], Value) ->
+    parse_key(URI, Path, [{Key, Value} | Parameters], <<>>);
+parse_value(<<Character, URI/binary>>, Path, Parameters, Value) ->
+    parse_value(URI, Path, Parameters, <<Value/binary, Character>>).
+
+% @doc Set any request parameters for the version.
+% @spec (Version::term(), Request::request()) -> Request::request()
+parse_version(Version = {1, 0}, Request) ->
+    Request#request{version = Version, connection = close};
+parse_version(Version, Request) ->
+    Request#request{version = Version}.
+
+% @doc Set any request parameters for the header and save the header.
+% @spec (Header::request_header(), Request::request()) -> Request::request()
+parse_header(Header = {'Connection', Value}, Request) ->
+    Connection = case string:to_lower(binary_to_list(Value)) of
+        "close" -> close;
+        "keep-alive" -> keep_alive;
+        _Other -> Request#request.connection
+    end,
+    Request#request{
+        headers = [Header | Request#request.headers],
+        connection = Connection};
+parse_header(Header = {'Content-Length', Value}, Request) ->
+    Request#request{
+        headers = [Header | Request#request.headers],
+        length = list_to_integer(binary_to_list(Value))};
+parse_header({<<"Expect">>, Value}, Request) ->
+    Expect = case string:to_lower(binary_to_list(Value)) of
+        "100-continue" -> continue;
+        _Other -> Request#request.expect
+    end,
+    Request#request{
+        headers = [{<<"expect">>, Value} | Request#request.headers],
+        expect = Expect};
+parse_header(Header, Request) ->
+    Request#request{headers = [Header | Request#request.headers]}.
+
+% @doc Set the body receive callback in a request record if needed.
+% @spec (Request::request(), Socket::term()) -> Request::request()
+set_recv(Request = #request{expect = Expect, length = Length}, Socket)
+        when Length > 0 ->
+    Request#request{body = fun(L) -> recv(L, Expect, Socket) end};
+set_recv(Request, _Socket) ->
+    Request.
+
+% @doc Receive a chunk of the request body.
+% @spec (Length::integer(), Expect::undefined | continue, Socket::term())
+%       -> {ok, Buffer, Recv} | {error, Reason}
+recv(Length, continue, Socket) ->
+    case openstack_socket:send(Socket, "HTTP/1.1 100 Continue\r\n\r\n") of
+        ok -> recv(Length, undefined, Socket);
+        Error -> Error
+    end;
+recv(Length, _Expect, Socket) ->
+    case openstack_socket:recv(Socket, Length) of
+        {ok, Buffer} -> {ok, Buffer, fun(L) -> recv(L, false, Socket) end};
+        Error -> Error
+    end.
+
+% @doc Get a header value in a list of headers from a request record.
+% @spec (Name::atom() | binary(), Requst::request()) -> Value::binary()
+get_request_header(Name, #request{headers = Headers}) ->
+    get_header(Name, Headers).
+
+% @doc Get a header value in a list of headers.
+% @spec (Name::atom() | binary(), Headers::[request_header()])
+%       -> Value::binary()
+get_header(_Name, []) ->
+    undefined;
+get_header(Name, [{Name, Value} | _Headers]) ->
+    Value;
+get_header(Name, [{Name2, Value} | Headers])
+        when is_binary(Name), is_binary(Name2) ->
+    LowerName = string:to_lower(binary_to_list(Name)),
+    LowerName2 = string:to_lower(binary_to_list(Name2)),
+    case LowerName of
+        LowerName2 -> Value;
+        _Other -> get_header(LowerName, Headers)
+    end;
+get_header(Name, [_Header | Headers]) ->
+    get_header(Name, Headers).
+
+% @doc Add or replace a header in the response record.
+% @spec (Headers::[response_header()], Response::response())
+%       -> Response::response()
+set_response_headers([], Response) ->
+    Response;
+set_response_headers([Header | Headers],
+        Response = #response{headers = OldHeaders}) ->
+    set_response_headers(Headers,
+        Response#response{headers = set_header(Header, OldHeaders, [])}).
+
+% @doc Add or replace a header in the header list.
+% @spec (Header::response_header(),
+%        Headers::[response_header()],
+%        Skipped::[response_header()])
+%       -> Headers::[response_header()]
+set_header(Header, [], Skipped) ->
+    lists:reverse(Skipped) ++ [Header];
+set_header({Name, Value}, [{Name, _OldValue} | Headers], Skipped) ->
+    lists:reverse(Skipped) ++ [{Name, Value}] ++ Headers;
+set_header(Header, [Skip | Headers], Skipped) ->
+    set_header(Header, Headers, [Skip | Skipped]).
+
+% @doc Send a response based on the response record details.
+% @spec (Response::response(), Socket::term())
+%       -> persist | close | {error, Reason}
+send_response(Response = #response{status = Status}, Socket) ->
+    pack_headers(<<"HTTP/1.1 ", (status_name(Status))/binary, "\r\n">>,
+        Response#response.headers,
+        Response,
+        Socket).
+
+% @doc Pack all headers into the buffer.
+% @spec (Buffer::binary(),
+%        Headers::[response_header()],
+%        Response::response(),
+%        Socket::term())
+%       -> persist | close | {error, Reason}
+pack_headers(Buffer, [], Response, Socket) ->
+    pack_content_headers(Buffer, Response, Socket);
+pack_headers(Buffer, [Header | Headers], Response, Socket) ->
+    pack_headers(pack_header(Buffer, Header), Headers, Response, Socket).
+
+% @doc Pack the header into the buffer, converting types as needed.
+% @spec (Buffer::binary(), Header::response_header()) -> Buffer::binary()
+pack_header(Buffer, {Name, Value}) when is_atom(Name) ->
+    pack_header(Buffer, {atom_to_list(Name), Value});
+pack_header(Buffer, {Name, Value}) when is_list(Name) ->
+    pack_header(Buffer, {list_to_binary(Name), Value});
+pack_header(Buffer, {Name, Value}) when is_integer(Value) ->
+    pack_header(Buffer, {Name, integer_to_list(Value)});
+pack_header(Buffer, {Name, Value}) when is_list(Value) ->
+    pack_header(Buffer, {Name, list_to_binary(Value)});
+pack_header(Buffer, {Name, Value}) ->
+    <<Buffer/binary, Name/binary, ": ", Value/binary, "\r\n">>.
+
+% @doc Pack headers related to the response content. Specifically, this is
+%  used to set the content-length or transfer-encoding headers. The order
+%  of the clauses matter and is used to set priority of response options.
+% @spec (Buffer::binary(), Response::response(), Socket::term())
+%       -> persist | close | {error, Reason}
+pack_content_headers(Buffer, Response = #response{body = Body}, Socket)
+        when is_binary(Body) ->
+    pack_length_header(Buffer, Response#response{length = byte_size(Body)},
+        Socket);
+pack_content_headers(Buffer, Response = #response{length = Length}, Socket)
+        when Length > 0 ->
+    pack_length_header(Buffer, Response, Socket);
+pack_content_headers(Buffer,
+        Response = #response{body = Body, chunked = allowed},
+        Socket)
+        when is_function(Body) ->
+    pack_connection_header(<<Buffer/binary, "Transfer-Encoding: chunked\r\n">>,
+        Response#response{chunked = true}, Socket);
+pack_content_headers(Buffer,
+        Response = #response{body = Body, chunked = false},
+        Socket)
+        when is_function(Body) ->
+    pack_connection_header(Buffer, Response#response{connection = close},
+        Socket);
+pack_content_headers(Buffer, Response, Socket) ->
+    pack_length_header(Buffer, Response, Socket).
+
+% @doc Send a length header.
+% @spec (Buffer::binary(), Response::response(), Socket::term())
+%       -> persist | close | {error, Reason}
+pack_length_header(Buffer, Response = #response{length = Length}, Socket) ->
+    pack_connection_header(<<Buffer/binary, "Content-Length: ",
+        (list_to_binary(integer_to_list(Length)))/binary, "\r\n">>,
+        Response, Socket).
+
+% @doc Send a connection header if needed.
+% @spec (Buffer::binary(), Response::response(), Socket::term())
+%       -> persist | close | {error, Reason}
+pack_connection_header(Buffer, Response = #response{connection = close},
+        Socket) ->
+    send_body(<<Buffer/binary, "Connection: close\r\n">>, Response, Socket);
+pack_connection_header(Buffer, Response = #response{connection = keep_alive},
+        Socket) ->
+    send_body(<<Buffer/binary, "Connection: Keep-Alive\r\n">>, Response,
+        Socket);
+pack_connection_header(Buffer, Response, Socket) ->
+    send_body(Buffer, Response, Socket).
+
+% @doc Send the headers and body, streaming from a callback if needed.
+% @spec (Headers::binary(), Response::response(), Socket::term())
+%       -> persist | close | {error, Reason}
+send_body(Headers, Response = #response{body = undefined}, Socket) ->
+    end_response(<<Headers/binary, "\r\n">>, Response, Socket);
+send_body(Headers, Response = #response{body = Body}, Socket)
+        when is_binary(Body) ->
+    end_response(<<Headers/binary, "\r\n", Body/binary>>, Response, Socket);
+send_body(Headers, Response = #response{chunked = Chunked, body = Body}, Socket)
+        when is_function(Body) ->
+    case openstack_socket:send(Socket, <<Headers/binary, "\r\n">>) of
+        ok ->
+            case Body(fun (Buffer) -> send(Buffer, Chunked, Socket) end) of
+                ok -> end_response(Response, Socket);
+                Error -> Error
+            end;
+        Error ->
+            Error
+    end.
+
+% @doc Callback function for other modules to send a chunk of the body.
+% @spec (Buffer::binary(), Chunked::true | false | allowed, Socket::term())
+%       -> ok | {error, Reason}
+send(Buffer, _Chunked, _Socket) when byte_size(Buffer) == 0 ->
+    ok;
+send(Buffer, true, Socket) ->
+    openstack_socket:send(Socket, [
+        io_lib:format("~.16b\r\n", [byte_size(Buffer)]),
+        Buffer,
+        <<"\r\n">>]);
+send(Buffer, _Chunked, Socket) ->
+    openstack_socket:send(Socket, Buffer).
+
+% @doc Write the buffer and end the response.
+% @spec (Buffer::binary(), Response::response(), Socket::term())
+%       -> persist | close | {error, Reason}
+end_response(Buffer, Response, Socket) ->
+    case openstack_socket:send(Socket, Buffer) of
+        ok -> end_response(Response);
+        Error -> Error
+    end.
+
+% @doc Write the last chunk if needed and end the response.
+% @spec (Response::response(), Socket::term())
+%       -> persist | close | {error, Reason}
+end_response(Response = #response{chunked = true}, Socket) ->
+    case openstack_socket:send(Socket, <<"0\r\n\r\n">>) of
+        ok -> end_response(Response);
+        Error -> Error
+    end;
+end_response(Response, _Socket) ->
+    end_response(Response).
+
+% @doc End the response.
+% @spec (Response::response()) -> persist | close
+end_response(#response{connection = close}) ->
+    close;
+end_response(_Response) ->
+    persist.
+
+% @doc Get the status name for a status code.
+% @spec (Statue::integer()) -> StatusName::binary()
+status_name(100) -> <<"100 Continue">>;
+status_name(101) -> <<"101 Switching Protocols">>;
+status_name(200) -> <<"200 OK">>;
+status_name(201) -> <<"201 Created">>;
+status_name(202) -> <<"202 Accepted">>;
+status_name(203) -> <<"203 Non-Authoritative Information">>;
+status_name(204) -> <<"204 No Content">>;
+status_name(205) -> <<"205 Reset Content">>;
+status_name(206) -> <<"206 Partial Content">>;
+status_name(300) -> <<"300 Multiple Choices">>;
+status_name(301) -> <<"301 Moved Permanently">>;
+status_name(302) -> <<"302 Found">>;
+status_name(303) -> <<"303 See Other">>;
+status_name(304) -> <<"304 Not Modified">>;
+status_name(305) -> <<"305 Use Proxy">>;
+status_name(307) -> <<"307 Temporary Redirect">>;
+status_name(400) -> <<"400 Bad Request">>;
+status_name(401) -> <<"401 Unauthorized">>;
+status_name(402) -> <<"402 Payment Required">>;
+status_name(403) -> <<"403 Forbidden">>;
+status_name(404) -> <<"404 Not Found">>;
+status_name(405) -> <<"405 Method Not Allowed">>;
+status_name(406) -> <<"406 Not Acceptable">>;
+status_name(407) -> <<"407 Proxy Authentication Required">>;
+status_name(408) -> <<"408 Request Timeout">>;
+status_name(409) -> <<"409 Conflict">>;
+status_name(410) -> <<"410 Gone">>;
+status_name(411) -> <<"411 Length Required">>;
+status_name(412) -> <<"412 Precondition Failed">>;
+status_name(413) -> <<"413 Request Entity Too Large">>;
+status_name(414) -> <<"414 Request-URI Too Long">>;
+status_name(415) -> <<"415 Unsupported Media Type">>;
+status_name(416) -> <<"416 Requested Range Not Satisfiable">>;
+status_name(417) -> <<"417 Expectation Failed">>;
+status_name(500) -> <<"500 Internal Server Error">>;
+status_name(501) -> <<"501 Not Implemented">>;
+status_name(502) -> <<"502 Bad Gateway">>;
+status_name(503) -> <<"503 Service Unavailable">>;
+status_name(504) -> <<"504 Gateway Timeout">>;
+status_name(505) -> <<"505 HTTP Version Not Supported">>;
+status_name(Status) -> <<(list_to_binary(integer_to_list(Status)))/binary,
+    " Unknown">>.
+
+%
+% Test functions.
+%
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+
+server_test_socket() ->
+    Options = [binary, {active, false}, {nodelay, true}],
+    {ok, Socket} = openstack_socket:connect(tcp, "localhost", 32123, Options),
+    Socket.
+
+server_test_request(Socket, Request, Length) ->
+    ?assertEqual(ok, openstack_socket:send(Socket, Request)),
+    case openstack_socket:recv(Socket, Length) of
+        {ok, Response} -> Response;
+        Error -> Error
+    end.
+
+-define(assertRequest(Socket, Request, Response),
+    ?assertEqual(Response,
+        server_test_request(Socket, Request, byte_size(Response)))).
+
+server_basic_test() ->
+    ?assertEqual(ok, openstack:start()),
+    ?assertEqual(ok,
+        server([32123], <<"test">>, fun server_basic_handle/3, undefined)),
+    Socket = server_test_socket(),
+    <<"HTTP/1.1 200 OK\r\n"
+      "Date: ", _Date:29/binary, "\r\n"
+      "Server: OpenStack (test)\r\n"
+      "Content-Length: 0\r\n"
+      "Connection: close\r\n\r\n">> =
+        server_test_request(Socket, <<"GET / HTTP/1.0\r\n\r\n">>, 0),
+    ?assertEqual({error, closed}, openstack_socket:recv(Socket, 0)),
+    ?assertEqual(ok, openstack:stop()).
+
+server_basic_handle(_Request, Response, State) ->
+    {Response, State}.
+
+server_connection_test() ->
+    ?assertEqual(ok, openstack:start()),
+    ?assertEqual(ok,
+        server([32123], <<"test">>, fun server_connection_handle/3, undefined)),
+    Socket = server_test_socket(),
+    ?assertRequest(Socket,
+      <<"GET / HTTP/1.1\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Content-Length: 0\r\n\r\n">>),
+    ?assertRequest(Socket,
+      <<"GET / HTTP/1.1\r\n"
+        "Connection: keep-alive\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Content-Length: 0\r\n"
+        "Connection: Keep-Alive\r\n\r\n">>),
+    ?assertRequest(Socket,
+      <<"GET / HTTP/1.1\r\n"
+        "Connection: other\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Content-Length: 0\r\n\r\n">>),
+    ?assertRequest(Socket,
+      <<"GET / HTTP/1.1\r\n"
+        "Connection: close\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Content-Length: 0\r\n"
+        "Connection: close\r\n\r\n">>),
+    ?assertEqual({error, closed}, openstack_socket:recv(Socket, 0)),
+    Socket2 = server_test_socket(),
+    ?assertRequest(Socket2,
+      <<"GET / HTTP/1.0\r\n"
+        "Connection: Keep-Alive\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Content-Length: 0\r\n"
+        "Connection: Keep-Alive\r\n\r\n">>),
+    ?assertRequest(Socket2,
+      <<"GET / HTTP/1.0\r\n"
+        "Connection: close\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Content-Length: 0\r\n"
+        "Connection: close\r\n\r\n">>),
+    ?assertEqual({error, closed}, openstack_socket:recv(Socket2, 0)),
+    Socket3 = server_test_socket(),
+    ?assertRequest(Socket3,
+      <<"GET / HTTP/1.0\r\n"
+        "Connection: other\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Content-Length: 0\r\n"
+        "Connection: close\r\n\r\n">>),
+    ?assertEqual({error, closed}, openstack_socket:recv(Socket3, 0)),
+    ?assertEqual(ok, openstack:stop()).
+
+server_connection_handle(_Request, Response, State) ->
+    {Response#response{headers = []}, State}.
+
+server_error_test() ->
+    ?assertEqual(ok, openstack:start()),
+    ?assertEqual(ok,
+        server([32123], <<"test">>, fun server_connection_handle/3, undefined)),
+    Socket = server_test_socket(),
+    ?assertEqual(ok, openstack_socket:send(Socket, <<"GET * BAD\r\n">>)),
+    {ok, <<
+      "HTTP/1.1 400 Bad Request\r\n"
+      "Date: ", _Date:29/binary, "\r\n"
+      "Server: OpenStack (test)\r\n"
+      "Content-Length: 0\r\n"
+      "Connection: close\r\n\r\n">>} = openstack_socket:recv(Socket, 0),
+    openstack_socket:close(server_test_socket()),
+    ?assertEqual(ok, openstack:stop()).
+    
+server_uri_test() ->
+    ?assertEqual(ok, openstack:start()),
+    ?assertEqual(ok,
+        server([32123], <<"test">>, fun server_connection_handle/3, undefined)),
+    Socket = server_test_socket(),
+    ?assertRequest(Socket,
+      <<"GET / HTTP/1.1\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Content-Length: 0\r\n\r\n">>),
+    ?assertRequest(Socket,
+      <<"GET test HTTP/1.1\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Content-Length: 0\r\n\r\n">>),
+    ?assertRequest(Socket,
+      <<"GET * HTTP/1.1\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Content-Length: 0\r\n\r\n">>),
+    ?assertEqual(ok, openstack:stop()).
+
+server_header_test() ->
+    ?assertEqual(ok, openstack:start()),
+    ?assertEqual(ok,
+        server([32123], <<"test">>, fun server_header_handle/3, undefined)),
+    ?assertRequest(server_test_socket(),
+      <<"GET / HTTP/1.0\r\n"
+        "Host: localhost\r\n"
+        "X-Test: test\r\n"
+        "Expect: other\r\n"
+        "Content-Length: 0\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Date: x\r\n"
+        "Server: 1\r\n"
+        "X-Test: value\r\n"
+        "Content-Length: 0\r\n"
+        "Connection: close\r\n\r\n">>),
+    ?assertEqual(ok, openstack:stop()).
+
+server_header_handle(Request, Response, State) ->
+    <<"test">> = get_request_header(<<"X-Test">>, Request),
+    <<"test">> = get_request_header(<<"x-test">>, Request),
+    undefined = get_request_header(<<"x-notfound">>, Request),
+    {set_response_headers([
+        {'Date', <<"x">>},
+        {'Server', 1},
+        {"X-Test", "value"}],
+        Response), State}.
+
+server_request_body_test() ->
+    ?assertEqual(ok, openstack:start()),
+    ?assertEqual(ok,
+        server([32123], <<"test">>, fun server_request_body_handle/3, 0)),
+    Socket = server_test_socket(),
+    ?assertRequest(Socket,
+      <<"GET / HTTP/1.1\r\n"
+        "Content-Length: 4\r\n\r\n"
+        "body">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "X-Body: body\r\n"
+        "Content-Length: 0\r\n\r\n">>),
+    ?assertRequest(Socket,
+      <<"GET / HTTP/1.1\r\n"
+        "Expect: 100-continue\r\n"
+        "Content-Length: 4\r\n\r\n">>,
+      <<"HTTP/1.1 100 Continue\r\n\r\n">>),
+    ?assertRequest(Socket,
+      <<"body">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "X-Body: body\r\n"
+        "Content-Length: 0\r\n\r\n">>),
+    ?assertEqual(ok, openstack:stop()).
+
+server_request_body_handle(#request{length = Length, body = Body}, Response,
+        State) ->
+    {ok, Buffer, _Body} = Body(Length),
+    {Response#response{headers = [{<<"X-Body">>, Buffer}]}, State}.
+
+server_response_body_test() ->
+    ?assertEqual(ok, openstack:start()),
+    ?assertEqual(ok,
+        server([32123], <<"test">>, fun server_response_body_handle/3, 0)),
+    Socket = server_test_socket(),
+    ?assertRequest(Socket,
+      <<"GET / HTTP/1.1\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Content-Length: 4\r\n\r\n"
+        "body">>),
+    ?assertRequest(Socket,
+      <<"GET / HTTP/1.1\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Content-Length: 4\r\n\r\n"
+        "body">>),
+    ?assertRequest(Socket,
+      <<"GET / HTTP/1.0\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Connection: close\r\n\r\n"
+        "body">>),
+    ?assertEqual(ok, openstack:stop()).
+
+server_response_body_handle(_Request, Response, 0) ->
+    {Response#response{headers = [], body = <<"body">>}, 1};
+server_response_body_handle(_Request, Response, 1) ->
+    {Response#response{
+        headers = [],
+        length = 4,
+        body = fun(Send) -> Send(<<"body">>), Send(<<>>) end}, 2};
+server_response_body_handle(_Request, Response, State) ->
+    {Response#response{
+        headers = [],
+        body = fun(Send) -> Send(<<"body">>), Send(<<>>) end}, State}.
+
+server_response_chunked_test() ->
+    ?assertEqual(ok, openstack:start()),
+    ?assertEqual(ok,
+        server([32123], <<"test">>, fun server_response_chunked_handle/3, 0)),
+    Socket = server_test_socket(),
+    ?assertRequest(Socket,
+      <<"GET / HTTP/1.1\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Transfer-Encoding: chunked\r\n\r\n"
+        "0\r\n\r\n">>),
+    ?assertRequest(Socket,
+      <<"GET / HTTP/1.1\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Transfer-Encoding: chunked\r\n\r\n"
+        "4\r\nbody\r\n0\r\n\r\n">>),
+    ?assertRequest(Socket,
+      <<"GET / HTTP/1.1\r\n\r\n">>,
+      <<"HTTP/1.1 200 OK\r\n"
+        "Transfer-Encoding: chunked\r\n\r\n"
+        "3\r\none\r\n3\r\ntwo\r\n0\r\n\r\n">>),
+    ?assertEqual(ok, openstack:stop()).
+
+server_response_chunked_handle(_Request, Response, 0) ->
+    {Response#response{
+        headers = [],
+        body = fun(_Send) -> ok end}, 1};
+server_response_chunked_handle(_Request, Response, 1) ->
+    {Response#response{
+        headers = [],
+        body = fun(Send) -> Send(<<"body">>), Send(<<>>) end}, 2};
+server_response_chunked_handle(_Request, Response, State) ->
+    {Response#response{
+        headers = [],
+        body = fun(Send) -> Send(<<"one">>), Send(<<"two">>) end}, State}.
+
+parse_uri_test() ->
+    ?assertEqual({'*', []}, parse_uri('*')),
+    ?assertEqual({<<"*">>, []}, parse_uri(<<"*">>)),
+    ?assertEqual({<<"/">>, []}, parse_uri(<<"/">>)),
+    ?assertEqual({<<"/a/b/c">>, []}, parse_uri(<<"/a/b/c">>)),
+    ?assertEqual({<<"/a/b/c">>, [{<<"d">>, <<"e">>}, {<<"f">>, <<>>}]},
+        parse_uri(<<"/a/b/c?d=e&f">>)),
+    ?assertEqual({<<"/">>, [{<<"a">>, <<>>}]}, parse_uri(<<"/?&&a&&">>)),
+    ?assertEqual({<<"/">>, [{<<"a">>, <<>>}]}, parse_uri(<<"/?a=">>)),
+    ?assertEqual({<<"/">>, [{<<"a">>, <<"1">>}]}, parse_uri(<<"/?a=1">>)),
+    ?assertEqual({<<"">>, []}, parse_uri(<<"?">>)),
+    ?assertEqual({<<"&">>, []}, parse_uri(<<"&">>)).
+
+status_name_test() ->
+    status_name_scan(0).
+
+status_name_scan(StatusCode = 600) ->
+    ?assertEqual(<<"600 Unknown">>, status_name(StatusCode));
+status_name_scan(StatusCode = 200) ->
+    ?assertEqual(<<"200 OK">>, status_name(StatusCode)),
+    status_name_scan(StatusCode + 1);
+status_name_scan(StatusCode = 404) ->
+    ?assertEqual(<<"404 Not Found">>, status_name(StatusCode)),
+    status_name_scan(StatusCode + 1);
+status_name_scan(StatusCode) ->
+    status_name(StatusCode),
+    status_name_scan(StatusCode + 1).
+
+-endif.

=== added file 'apps/openstack/src/openstack_server.erl'
--- apps/openstack/src/openstack_server.erl	1970-01-01 00:00:00 +0000
+++ apps/openstack/src/openstack_server.erl	2011-02-28 07:20:04 +0000
@@ -0,0 +1,221 @@
+% Copyright (C) 2011 OpenStack LLC.
+%
+% Licensed under the Apache License, Version 2.0 (the "License");
+% you may not use this file except in compliance with the License.
+% You may obtain a copy of the License at
+%
+%     http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+% See the License for the specific language governing permissions and
+% limitations under the License.
+
+% @doc Generic server module to help in building more specific servers. This
+%  module has a supervisor process and adds one child process to that
+%  supervisor for each listener socket created.
+
+-module(openstack_server).
+
+-export([start/3, listen/2, accept/2, set_options/2]).
+
+-behaviour(supervisor).
+-export([child_spec/0, init/1]).
+
+-include("openstack_logging.hrl").
+
+% @type state() = #state{accept = function(), callback_state = term()}
+-record(state, {accept, callback_state}).
+
+% @doc Start up listener sockets on the given ports. This starts a new
+%  process for each port in the list and attaches them to the supervisor
+%  process.
+% @spec (Ports::ports(), Accept::function(), CallbackState::term())
+%       -> ok | {error, Reason}
+% @type ports() = [
+%       Port::integer() |
+%       {Type::port_type(), Port::integer()} |
+%       normalized_port()]
+% @type normalized_port() =
+%       {Type::port_type(), Port::integer(), Options::[option()]}
+% @type port_type() = tcp | ssl
+% @type option() = [{atom(), term()}]
+% @type normalized_ports() = [normalized_port()]
+start(Ports, Accept, CallbackState) ->
+    start_port(normalize_ports(Ports, []), #state{
+        accept = Accept,
+        callback_state = CallbackState}).
+
+% @doc Start a new listener process for the first port in the list, then
+%  loop to the next.
+% @spec (Ports::normalized_ports(), State::state()) -> ok
+start_port([Port | Ports], State) ->
+    ChildSpec = {
+        Port,
+        {proc_lib, start_link, [?MODULE, listen, [Port, State]]},
+        transient,
+        brutal_kill,
+        worker,
+        [?MODULE]},
+    case supervisor:start_child(?MODULE, ChildSpec) of
+        {ok, _Pid} ->
+            start_port(Ports, State);
+        {error, Reason} ->
+            throw(Reason)
+    end;
+start_port([], _State) ->
+    ok.
+
+% @doc Bind a listening socket and enter the accept loop.
+% @spec (Port::normalized_port(), State::state()) -> none()
+listen(Port, State) ->
+    Listener = try_listen(Port, 10),
+    proc_lib:init_ack({ok, self()}),
+    ?INFO("Now listening on port: ~p~n", [Port]),
+    spawn(?MODULE, accept, [Listener, State]),
+    % Wait forever to keep the listener socket open.
+    receive
+    after infinity ->
+        ok
+    end.
+
+% @doc Try listening on a socket, retrying every 100ms for the number of
+%  retry times given.
+% @spec (Port::normalized_port(), Retries::integer()) -> Listener::term()
+try_listen(_Port, 0) ->
+    throw({listen_failed, eaddrinuse});
+try_listen({Type, Port, Options}, Retries) ->
+    NewOptions = set_options(Options, [
+        binary,
+        {active, false},
+        {backlog, 1024},
+        {nodelay, true},
+        {reuseaddr, true}]),
+    case openstack_socket:listen(Type, Port, NewOptions) of
+        {ok, Listener} ->
+            Listener;
+        {error, eaddrinuse} ->
+            timer:sleep(100),
+            try_listen({Type, Port, Options}, Retries - 1);
+        {error, Reason} ->
+            throw({listen_failed, Reason})
+    end.
+
+% @doc Accept a new connection and spawn a process for the next one.
+% @spec (Listener::term(), State::state()) -> none()
+accept(Listener, State = #state{
+        accept = Accept,
+        callback_state = CallbackState}) ->
+    case openstack_socket:accept(Listener) of
+        {ok, Socket} ->
+            spawn(?MODULE, accept, [Listener, State]),
+            openstack_socket:setopts(Socket, [{buffer, 8192}, {nodelay, true}]),
+            Accept(Socket, CallbackState),
+            openstack_socket:close(Socket);
+        {error, closed} ->
+            ok;
+        {error, Reason} ->
+            spawn(?MODULE, accept, [Listener, State]),
+            ?WARNING("Error accepting socket: ~p~n", [Reason])
+    end.
+
+% @doc Merge listen options.
+% @spec (Options::[option()], Result::[option()]) -> Result::[option()]
+set_options([], Result) ->
+    Result;
+set_options([{Key, Value} | Options], Result) ->
+    set_options(Options, [{Key, Value} | proplists:delete(Key, Result)]);
+set_options([Key | Options], Result) ->
+    set_options(Options, [Key | proplists:delete(Key, Result)]).
+
+% @doc Normalize a list of mixed types representing port descriptions.
+% @spec (Ports::ports(), Result::normalized_ports())
+%       -> Result::normalized_ports()
+normalize_ports([], Result) ->
+    lists:reverse(Result);
+normalize_ports([{Type, Port, Options} | Ports], Result) ->
+    normalize_ports(Ports, [{Type, Port, Options} | Result]);
+normalize_ports([{Type, Port} | Ports], Result) ->
+    normalize_ports([{Type, Port, []} | Ports], Result);
+normalize_ports([Port | Ports], Result) when is_integer(Port) ->
+    normalize_ports(Ports, [{tcp, Port, []} | Result]);
+normalize_ports([Port | _Ports], _Result) ->
+    throw({bad_port_type, Port});
+normalize_ports(Ports, _Result) ->
+    throw({bad_port_list, Ports}).
+
+%
+% Callbacks for the supervisor behaviour.
+%
+
+% @doc Get the child_spec for the supervisor process. See supervisor(3erl)
+%  for a description of the child_spec() type.
+% @spec () -> child_spec()
+child_spec() ->
+    {?MODULE,
+     {supervisor, start_link, [{local, ?MODULE}, ?MODULE, []]},
+     permanent,
+     infinity,
+     supervisor,
+     [?MODULE]}.
+
+% @doc Init callback for the supervisor behaviour. This doesn't specify
+%  any child processes, they are added later when the servers are started
+%  in start(). See supervisor(3erl) for more details.
+init(_Args) ->
+    {ok, {{one_for_one, 10, 10}, []}}.
+
+%
+% Test functions.
+%
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+
+start_test() ->
+    ?assertEqual(ok, openstack:start()),
+    ?assertEqual(ok,
+        start([{tcp, 32123, [binary, {nodelay, true}]}], fun test_accept/2,
+            undefined)),
+    Options = [binary, {active, false}, {nodelay, true}],
+    {ok, Socket} = openstack_socket:connect(tcp, "localhost", 32123, Options),
+    ?assertEqual({ok, <<"test">>}, openstack_socket:recv(Socket, 0)),
+    {ok, Socket2} =
+        openstack_socket:connect(tcp, "localhost", 32123, Options, 5),
+    ?assertEqual({ok, <<"test">>}, openstack_socket:recv(Socket2, 0, 5)),
+    ?assertEqual(ok, openstack:stop()).
+
+ssl_start_test() ->
+    ?assertEqual(ok, openstack:start()),
+    ?assertEqual(ok,
+        start([{ssl, 32123, [
+            {certfile, "../example.com-cert.pem"},
+            {keyfile, "../example.com-key.pem"}]}],
+            fun test_accept/2, undefined)),
+    Options = [binary, {active, false}, {nodelay, true}],
+    {ok, Socket} = openstack_socket:connect(ssl, "localhost", 32123, Options),
+    ?assertEqual({ok, <<"test">>}, openstack_socket:recv(Socket, 0)),
+    {ok, Socket2} =
+        openstack_socket:connect(ssl, "localhost", 32123, Options, 5),
+    ?assertEqual({ok, <<"test">>}, openstack_socket:recv(Socket2, 0, 5)),
+    ?assertEqual(ok, openstack:stop()).
+
+test_accept(Socket, _State) ->
+    ?assertEqual({ok, [{active, false}]},
+        openstack_socket:getopts(Socket, [active])),
+    {ok, {Address, 32123}} = openstack_socket:sockname(Socket),
+    {ok, {Address, _Port}} = openstack_socket:peername(Socket),
+    ?assertEqual(ok, openstack_socket:send(Socket, <<"test">>)).
+
+normalize_ports_test_() -> [
+    ?_assertEqual([], normalize_ports([], [])),
+    ?_assertEqual([{tcp, 1, []}, {tcp, 2, []}, {tcp, 3, []}],
+                  normalize_ports([1, {tcp, 2}, {tcp, 3, []}], [])),
+    ?_assertEqual([{ssl, 1, []}, {ssl, 2, []}],
+                  normalize_ports([{ssl, 1}, {ssl, 2, []}], [])),
+    ?_assertException(throw, {bad_port_type, <<0>>},
+                      normalize_ports([<<0>>], [])),
+    ?_assertException(throw, {bad_port_list, 1}, normalize_ports(1, []))].
+
+-endif.

=== added file 'apps/openstack/src/openstack_socket.erl'
--- apps/openstack/src/openstack_socket.erl	1970-01-01 00:00:00 +0000
+++ apps/openstack/src/openstack_socket.erl	2011-02-28 07:20:04 +0000
@@ -0,0 +1,127 @@
+% Copyright (C) 2011 OpenStack LLC.
+%
+% Licensed under the Apache License, Version 2.0 (the "License");
+% you may not use this file except in compliance with the License.
+% You may obtain a copy of the License at
+%
+%     http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+% See the License for the specific language governing permissions and
+% limitations under the License.
+
+% @doc Wrapper for socket functions to abstract away TCP and SSL
+%  differences. See the gen_tcp, inet, and ssl module documentation for
+%  details.
+
+-module(openstack_socket).
+
+-export([connect/4, connect/5, listen/3, accept/1, peername/1, sockname/1,
+    getopts/2, setopts/2, recv/2, recv/3, send/2, close/1]).
+
+connect(ssl, Address, Port, Options) ->
+    case ssl:connect(Address, Port, Options) of
+        {ok, Socket} ->
+            {ok, {ssl, Socket}};
+        Error ->
+            Error
+    end;
+connect(tcp, Address, Port, Options) ->
+    case gen_tcp:connect(Address, Port, Options) of
+        {ok, Socket} ->
+            {ok, {tcp, Socket}};
+        Error ->
+            Error
+    end.
+
+connect(ssl, Address, Port, Options, Timeout) ->
+    case ssl:connect(Address, Port, Options, Timeout) of
+        {ok, Socket} ->
+            {ok, {ssl, Socket}};
+        Error ->
+            Error
+    end;
+connect(tcp, Address, Port, Options, Timeout) ->
+    case gen_tcp:connect(Address, Port, Options, Timeout) of
+        {ok, Socket} ->
+            {ok, {tcp, Socket}};
+        Error ->
+            Error
+    end.
+
+listen(ssl, Port, Options) ->
+    case ssl:listen(Port, Options) of
+        {ok, Listener} ->
+            {ok, {ssl, Listener}};
+        Error ->
+            Error
+    end;
+listen(tcp, Port, Options) ->
+    case gen_tcp:listen(Port, Options) of
+        {ok, Listener} ->
+            {ok, {tcp, Listener}};
+        Error ->
+            Error
+    end.
+
+accept({ssl, Listener}) ->
+    case ssl:transport_accept(Listener) of
+        {ok, Socket} ->
+            case ssl:ssl_accept(Socket) of
+                ok ->
+                    {ok, {ssl, Socket}};
+                Error ->
+                    Error
+            end;
+        Error ->
+            Error
+    end;
+accept({tcp, Listener}) ->
+    case gen_tcp:accept(Listener) of
+        {ok, Socket} ->
+            {ok, {tcp, Socket}};
+        Error ->
+            Error
+    end.
+
+peername({ssl, Socket}) ->
+    ssl:peername(Socket);
+peername({tcp, Socket}) ->
+    inet:peername(Socket).
+
+sockname({ssl, Socket}) ->
+    ssl:sockname(Socket);
+sockname({tcp, Socket}) ->
+    inet:sockname(Socket).
+
+getopts({ssl, Socket}, Options) ->
+    ssl:getopts(Socket, Options);
+getopts({tcp, Socket}, Options) ->
+    inet:getopts(Socket, Options).
+
+setopts({ssl, Socket}, Options) ->
+    ssl:setopts(Socket, Options);
+setopts({tcp, Socket}, Options) ->
+    inet:setopts(Socket, Options).
+
+recv({ssl, Socket}, Length) ->
+    ssl:recv(Socket, Length);
+recv({tcp, Socket}, Length) ->
+    gen_tcp:recv(Socket, Length).
+
+recv({ssl, Socket}, Length, Timeout) ->
+    ssl:recv(Socket, Length, Timeout);
+recv({tcp, Socket}, Length, Timeout) ->
+    gen_tcp:recv(Socket, Length, Timeout).
+
+send({ssl, Socket}, Data) ->
+    ssl:send(Socket, Data);
+send({tcp, Socket}, Data) ->
+    gen_tcp:send(Socket, Data).
+
+close({ssl, Socket}) ->
+    ssl:close(Socket);
+close({tcp, Socket}) ->
+    gen_tcp:close(Socket).

=== modified file 'rebar.config'
--- rebar.config	2011-02-23 01:59:49 +0000
+++ rebar.config	2011-02-28 07:20:04 +0000
@@ -14,7 +14,11 @@
 
 {sub_dirs, [
     "apps/burrow",
-    "rel"
-]}.
+    "apps/openstack",
+    "rel"]}.
 
 {cover_enabled, true}.
+
+{edoc_opts, [{private, true}]}.
+
+{erl_opts, [{i, "../"}]}.

=== modified file 'rel/reltool.config'
--- rel/reltool.config	2011-02-23 01:59:49 +0000
+++ rel/reltool.config	2011-02-28 07:20:04 +0000
@@ -17,20 +17,19 @@
     {rel, "burrow", "2011.2", [
         burrow,
         kernel,
+        openstack,
         stdlib,
-        sasl
-    ]},
+        sasl]},
     {rel, "start_clean", "", [
         kernel,
-        stdlib
-    ]},
+        stdlib]},
     {boot_rel, "burrow"},
     {profile, embedded},
     {excl_sys_filters, [
         "^bin/.*",
-        "^erts.*/bin/(dialyzer|typer)"
-    ]},
+        "^erts.*/bin/(dialyzer|typer)"]},
     {app, burrow, [{incl_cond, include}]},
+    {app, openstack, [{incl_cond, include}]},
     {app, sasl, [{incl_cond, include}]}
 ]}.
 
@@ -42,5 +41,4 @@
     {copy, "files/nodetool", "{{erts_vsn}}/bin/nodetool"},
     {copy, "files/burrow", "bin/burrow"},
     {copy, "files/app.config", "etc/app.config"},
-    {copy, "files/vm.args", "etc/vm.args"}
-]}.
+    {copy, "files/vm.args", "etc/vm.args"}]}.

=== modified file 'start'
--- start	2011-02-23 01:59:49 +0000
+++ start	2011-02-28 07:20:04 +0000
@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-erl -pa apps/burrow/ebin -s burrow start
+erl -pa apps/*/ebin -s burrow start $*