Merge lp:~raxnetworking/nova/melange into lp:~hudson-openstack/nova/trunk

[Trey Morris]

adds melange to nova

melange is currently an IP or L3 management service, but will probably expand into more of a "network identifier" management service which may include L2 data in the future.

[lp:~raxnetworking/nova/melange]

1339. By Trey Morris on 2011-08-17

moved double author to .mailmap

[Sandy Walsh (sandy-walsh)]

Getting some errors http://paste.openstack.org/show/2187/
(are you running novaclient 2.6.1?)

review: Needs Information

[Josh Kearney (jk0)]

> Getting some errors http://paste.openstack.org/show/2187/
> (are you running novaclient 2.6.1?)

That's odd. All tests pass for me running the latest novaclient.

[Vish Ishaya (vishvananda)]

This is looking good guys. First impression is that the code is pretty clean and well laid out. Quick nits in my first glance at the code:

Not sure about the changes to bzrignore. Why remove the ignores for logs and sqlite dbs?

3320 +required_dbs=['mysql','postgres','sqllite']
extra l in sqlite.

Are there some tests as well? I see reference to melage/tests/unit in a couple places, but no actual code

review: Needs Information

[Sandy Walsh (sandy-walsh)]

ok, got the tests running again. Was running an older eventlet and the easy_install and pip were conflicting with two versions.

But melange tests are failing

http://paste.openstack.org/show/2188/

review: Needs Fixing

[lp:~raxnetworking/nova/melange]

1340. By Trey Morris on 2011-08-17

alphabetized melange imports

1341. By Trey Morris on 2011-08-17

correct copyright

[Sandy Walsh (sandy-walsh)]

unit tests pass, but functional tests won't run
http://paste.openstack.org/show/2189/

review: Needs Fixing

[Trey Morris (tr3buchet)]

Vish, there are tests, this diff is truncated, yay launchpad. You'll have to use commandline diffs.

The tests are located in melange/tests/.

sqllite -> sqlite

As for the bzrignore changes:
*.DS_Store, .project, and .pydevproject
were simply moved, no harm no foul i guess

run_tests.err.log
run_tests.log
are replaced with *.log

nova.sqlite
clean.sqlite
tests.sqlite
are replaced with *.sqlite

[lp:~raxnetworking/nova/melange]

1342. By Trey Morris on 2011-08-17

fixed extra l in sqlite

[Sandy Walsh (sandy-walsh)]

There is *so* much copy-paste from nova in here I feel dirty pressing Approve.

Why not just make it a proper Nova service under the network service and do it right?

review: Needs Information

[Sandy Walsh (sandy-walsh)]

For unit tests we shouldn't have to create a db or copy/move a .conf file. Maybe for functional tests.

[Josh Kearney (jk0)]

> For unit tests we shouldn't have to create a db or copy/move a .conf file.
> Maybe for functional tests.

Hm, I never had to do that. Does it say that somewhere?

[Jay Pipes (jaypipes)]

Some notes...

1) I probably missed a discussion somewhere, but weren't we planning on having melange as a completely separate service?

2) I don't think it's a good idea to have tools like bin/melange accessing or configuring the db API manually... this should be done through a client class only, and bin/melange shouldn't be configuring any database at all.

3) The bin/melange-manage has copyright headers having to do with Django's interactive shell, but I see no evidence of django interactive shell stuff being used there.

4) Agree with Vishy on some of the bzrignore stuff... for instance, what is this:

 34 +.ropeproject

?

5) Executables like bin/melange-delete-deallocated-ips should a) be combined into a single melange-manage tool, and b) Should not directly access db models or API... these should be client commands. These tools look like they were written assuming someone would always be logged into the box running the melange server; this should not be the case. An admin should be able to run bin/melange-manage and similar tools from anywhere, and a Melange client class should send HTTP commands to the Melange server, not directly interact with the underlying database...

6) Pretty much all of the code in bin/melange-manage should be in a melange.Client class, with the melange-manage executable being a simple CLI wrapper around the client calls, instead of being direct HTTP calls.

7)

1364 +def integer(value):
1365 + return int(value)

Really?

8) I would recommend removing all of the "extensions" code in /melange/extensions/. IMO, YAGNI, and it just makes things overly complicated.

9) Nobody is upgrading melange yet, so not sure any of the db-migrate scripts are necessary

Cheers,
jay

review: Needs Fixing

[Sandy Walsh (sandy-walsh)]

+1 to Jay's feedback.

This should really be our motivation to push on openstack-common.

[Jay Pipes (jaypipes)]

Where we are putting common code (that will eventually become openstack.common...)

https://github.com/openstack/openstack-skeleton/

[Rick Harris (rconradharris)]

+1 on Jay's comments

Some other minor nits:

> 268 +from gettext import gettext as _

Nova uses this pattern for importing gettext (might be a good idea to match):

    import gettext
    gettext.install('melange', unicode=1)

> 1005 + def do_request(self, method, path, body=None, headers={}, params={}):

Usually not a good idea to use mutable types as default arguments since the
default is shared across invocations which can lead to some very strange bugs.
A better approach is usually to do something like:

    def do_request(self, method, path, body=None, headers=None, params=None):
        headers = headers or {}
        params = params or {}

        # OR

        if not headers:
            headers = {}

> 1384 +def boolean(subject):

Nova already has a pretty well tested boolean to string method
`utils.bool_from_str`. It would probably be a good idea to use that if
possible.

> === added file 'melange/common/utils.py'
>

Pertains to all of melange/common/ really:

Since melange resides in the same source tree as Nova, it would probably be a
good idea to pull as much as this as possible from nova.utils directly (rather than duplicate it).

As mentioned above, an even better solution is to have openstack.common as an external dependency (at some point).

review: Needs Fixing

[Sandy Walsh (sandy-walsh)]

+1 to Rick's suggestion of, at least, fixing the imports to use nova's existing code base.

[lp:~raxnetworking/nova/melange]

1343. By Santhosh Kumar Muniraj on 2011-08-19

Santhosh/Deepak | Fixed bug where tenant_id was not being passed for allocating Ipv6 addresses through network controller.

1344. By Rajaram Mallya on 2011-08-22

Rajaram/Vinkesh|merge from nova

1345. By Rajaram Mallya on 2011-08-22

Rajaram/Vinkesh|used common framework code that exists in the openstack-common project

1346. By Rajaram Mallya on 2011-08-22

Rajaram/Vinkesh|some more misc cleanup to use openstack-common project

1347. By Rajaram Mallya on 2011-08-23

Rajaram/Vinkesh | Renamed melange-manage to melange-client. Added db sync, upgrade and downgrade commands in melange-manage

1348. By Rajaram Mallya on 2011-08-23

Rajaram/Vinkesh | Fixed some pep8 errors

1349. By Rajaram Mallya on 2011-08-23

Vinkesh/Rajaram|fixed gettext to work like in nova as per Rick Harris' suggestion

1350. By Rajaram Mallya on 2011-08-23

Rajaram/Vinkesh | Removed usages of mutable default arguments

1351. By Rajaram Mallya on 2011-08-23

Rajaram/Vinkesh | moved common/data_types.py to Converter class in models.py to remove confusion caused by the Integer and Boolean methods

1352. By Rajaram Mallya on 2011-08-24

Rajaram/Vinkesh | extracted melange client code from CLI to ipam/client. Removed unnecessary bzrignore.

1353. By Rajaram Mallya on 2011-08-24

Rajaram/Vinkesh | Simplified models mapping in db api

1354. By Rajaram Mallya on 2011-08-24

Rajaram/Vinkesh | Renamed utils.Method to utils.MethodInspector. Removed unecessary bzrignore entries

1355. By Rajaram Mallya on 2011-08-25

Rajaram/Vinkesh | Switched to sqlite for tests. Cleaned up migration scripts.

1356. By Rajaram Mallya on 2011-08-25

Rajaram/Vinkesh|moved extensions folder inside melange

1357. By Rajaram Mallya on 2011-08-25

merge from nova

1358. By Rajaram Mallya on 2011-08-26

Rajaram/Vinkesh| updated readme file

1359. By Rajaram Mallya on 2011-08-30

Rajaram/Vinkesh| used wsgi.resource from openstack.common

1360. By Rajaram Mallya on 2011-08-30

merge from nova trunk

1361. By Rajaram Mallya on 2011-09-02

Rajaram| Newline between imports and copyright header, imports only import modules, doc strings as per HACKING guide

1362. By Rajaram Mallya on 2011-09-02

Rajaram|missed a couple of pep8 voilations

1363. By Rajaram Mallya on 2011-09-05

Vinkesh/Rajaram| Fixes as per Brain's comments:
1. :moved gettext.install to melange/__init__
2. melange-client raises errros only on option.verbose
3. Used urlparse.urljoin where applicable
4. Fixed version in bin/melange* scripts
and other misc fixes according to HACKING or style recomendations

1364. By Rajaram Mallya on 2011-09-05

Rajaram/Vinkesh|fixed more imports to import only modules and misc style improvements

1365. By Rajaram Mallya on 2011-09-06

Rajaram/Vinkesh | Changed openstack.common imports in melange common to module level labels

1366. By Rajaram Mallya on 2011-09-06

Rajaram/Vinkesh | Made MelangeError a subclass of openstack common's OpenstackException, removed usages of merge_dicts

1367. By Rajaram Mallya on 2011-09-06

Vinkesh\Rajaram|made keystone auth optional in melange-client

1368. By Rajaram Mallya on 2011-09-07

Vinkesh/Rajaram|changed wsgi in melange.common to use serializers from openstack.common

1369. By Vinkesh Banka on 2011-09-07

Vinkesh/Rajaram| Added tests for melange-manage db_sync and db_upgrade commands

1370. By Rajaram Mallya on 2011-09-08

Rajaram/Vinkesh | Removed overridden get_content_type in wsgi.Request class

1371. By Rajaram Mallya on 2011-09-09

Vinkesh/Rajaram|Removed extensions code and started using openstack common's extension code

1372. By Rajaram Mallya on 2011-09-09

Rajaram/Vinkesh|ipaddress now stores used_by_tenant to denote tenant using the ipaddress and used_by_device for the instance on which the ip_address is allocated

1373. By Rajaram Mallya on 2011-09-12

Vinkesh/Rajaram|Removed non tenanted resources from api

1374. By Rajaram Mallya on 2011-09-12

Vinkesh/Rajaram|Removed admin actions as after removing non tenant scoped resources, we dont have any admin actions

1375. By Rajaram Mallya on 2011-09-12

Merged from nova trunk

1376. By Rajaram Mallya on 2011-09-12

Rajaram/Vinkesh|nat resources in api are tenant scoped

1377. By Rajaram Mallya on 2011-09-13

Rajaram/Vinkesh | Non Tenanted resources can only be accessed by admins

1378. By Rajaram Mallya on 2011-09-13

Rajaram/Vinkesh| mandated PasteDeploy>=1.5 in pip_requires since melange uses call URI scheme from PasteDeploy 1.5

1379. By Rajaram Mallya on 2011-09-13

Rajaram/Vinkesh|added route to search for allocated ip addresses

1380. By Rajaram Mallya on 2011-09-13

Rajaram/Vinkesh | Added CLI commands for ip_address

1381. By Rajaram Mallya on 2011-09-14

Rajaram/Vinkesh | Removed some unused code. Added few tests. Miscellaneous small refactoring

1382. By Rajaram Mallya on 2011-09-14

Merged from nova trunk

1383. By Rajaram Mallya on 2011-09-15

Rajaram/Vinkesh | Cleaned up the code a bit. Small style fixes

1384. By Rajaram Mallya on 2011-09-20

Rajaram/Vinkesh| fixed bug in melange-delete-deallocated-ips where it wasnt loading the config file

1385. By Vinkesh Banka on 2011-09-22

Rajaram/Vinkesh | Consolidated migrations. Removed soft delete

1386. By Vinkesh Banka on 2011-09-23

Rajaram/Vinkesh | Added retries while allocating ips to fix concurrency problem

1387. By Vinkesh Banka on 2011-09-26

Rajaram/Vinkesh | AllocatedIps index now does not show deallocated IPs

1388. By Vinkesh Banka on 2011-09-28

Rajaram/Vinkesh | Added IpRoute model. Started using melange.conf.sample for tests

1389. By Vinkesh Banka on 2011-09-28

Rajaram/Vinkesh | Exposed CRUD APIs for ip_routes

1390. By Vinkesh Banka on 2011-09-29

Rajaram/Vinkesh | Added CLI for IpRoute

1391. By Vinkesh Banka on 2011-09-29

Rajaram/Vinkesh | Added ip_routes in ip_allocations' payload

1392. By Vinkesh Banka on 2011-09-30

Vinkesh | Validating gateway address is a valid address before IpBlock create/update

1393. By Vinkesh Banka on 2011-09-30

Vinkesh | Displaying an error message which asks users to provide a tenant_id in CLI if needed

1394. By Rajaram Mallya on 2011-10-05

Rajaram/Vinkesh|Changed ip allocation algo to not load all allocated ips at once

1395. By Rajaram Mallya on 2011-10-05

Vinkesh/Rajaram|moved ipv4 generation algo to a plugable module

Unmerged revisions

1395. By Rajaram Mallya on 2011-10-05

Vinkesh/Rajaram|moved ipv4 generation algo to a plugable module

1394. By Rajaram Mallya on 2011-10-05

Rajaram/Vinkesh|Changed ip allocation algo to not load all allocated ips at once

1393. By Vinkesh Banka on 2011-09-30

Vinkesh | Displaying an error message which asks users to provide a tenant_id in CLI if needed

1392. By Vinkesh Banka on 2011-09-30

Vinkesh | Validating gateway address is a valid address before IpBlock create/update

1391. By Vinkesh Banka on 2011-09-29

Rajaram/Vinkesh | Added ip_routes in ip_allocations' payload

1390. By Vinkesh Banka on 2011-09-29

Rajaram/Vinkesh | Added CLI for IpRoute

1389. By Vinkesh Banka on 2011-09-28

Rajaram/Vinkesh | Exposed CRUD APIs for ip_routes

1388. By Vinkesh Banka on 2011-09-28

Rajaram/Vinkesh | Added IpRoute model. Started using melange.conf.sample for tests

1387. By Vinkesh Banka on 2011-09-26

Rajaram/Vinkesh | AllocatedIps index now does not show deallocated IPs

1386. By Vinkesh Banka on 2011-09-23

Rajaram/Vinkesh | Added retries while allocating ips to fix concurrency problem

=== modified file '.bzrignore'
--- .bzrignore	2011-07-26 05:50:05 +0000
+++ .bzrignore	2011-08-25 11:33:54 +0000
@@ -1,19 +1,16 @@
-run_tests.err.log
+*.log
+*.sqlite
+*.DS_Store
+.project
+.pydevproject
 .nova-venv
+.coverage
 ChangeLog
 _trial_temp
 keys
 networks
-nova.sqlite
 CA
 nova/vcsversion.py
-*.DS_Store
-.project
-.pydevproject
-clean.sqlite
-run_tests.log
-tests.sqlite
 nova/tests/instance-*
 tags
-.coverage
 covhtml

=== modified file '.mailmap'
--- .mailmap	2011-08-09 21:45:31 +0000
+++ .mailmap	2011-08-25 11:33:54 +0000
@@ -55,3 +55,4 @@
 <[e-mail]> <[e-mail]>
 <[e-mail]> <[e-mail]>
 <[e-mail]> <[e-mail]>
+<[e-mail]> <[e-mail]>

=== modified file 'Authors'
--- Authors	2011-08-23 18:16:04 +0000
+++ Authors	2011-08-25 11:33:54 +0000
@@ -26,6 +26,7 @@
 Dave Walker <[e-mail]>
 David Pravec <[e-mail]>
 Dean Troyer <[e-mail]>
+Deepak N <[e-mail]>
 Devendra Modium <[e-mail]>
 Devin Carlen <[e-mail]>
 Donal Lafferty <[e-mail]>
@@ -85,6 +86,7 @@
 Nikolay Sokolov <[e-mail]>
 Nirmal Ranganathan <[e-mail]>
 Paul Voccio <[e-mail]>
+Rajaram Mallya <[e-mail]>
 Renuka Apte <[e-mail]>
 Ricardo Carrillo Cruz <[e-mail]>
 Rick Clark <[e-mail]>
@@ -95,6 +97,7 @@
 Ryu Ishimoto <[e-mail]>
 Salvatore Orlando <[e-mail]>
 Sandy Walsh <[e-mail]>
+Santhosh Kumar Muniraj <[e-mail]>
 Sateesh Chodapuneedi <[e-mail]>
 Scott Moser <[e-mail]>
 Soren Hansen <[e-mail]>
@@ -106,6 +109,7 @@
 Troy Toman <[e-mail]>
 Tushar Patil <[e-mail]>
 Vasiliy Shlykov <[e-mail]>
+Vinkesh Banka <[e-mail]>
 Vishvananda Ishaya <[e-mail]>
 Vivek Y S <[e-mail]>
 Vladimir Popovski <[e-mail]>

=== added file 'bin/melange'
--- bin/melange	1970-01-01 00:00:00 +0000
+++ bin/melange	2011-08-25 11:33:54 +0000
@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+import gettext
+import optparse
+import os
+import re
+import sys
+import time
+
+# If ../melange/__init__.py exists, add ../ to Python search path, so that
+# it will override what happens to be installed in /usr/(local/)lib/python...
+possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
+                                   os.pardir,
+                                   os.pardir))
+if os.path.exists(os.path.join(possible_topdir, 'melange', '__init__.py')):
+    sys.path.insert(0, possible_topdir)
+
+gettext.install('melange', unicode=1)
+
+from melange.common import config
+from melange.common import wsgi
+from melange.db import db_api
+
+
+def create_options(parser):
+    """
+    Sets up the CLI and config-file options that may be
+    parsed and program commands.
+    :param parser: The option parser
+    """
+    parser.add_option('-p', '--port', dest="port", metavar="PORT",
+                      type=int, default=9898,
+                      help="Port the Melange API host listens on. "
+                      "Default: %default")
+    config.add_common_options(parser)
+    config.add_log_options(parser)
+
+
+if __name__ == '__main__':
+    oparser = optparse.OptionParser(version='%%prog VERSION')
+    create_options(oparser)
+    (options, args) = config.parse_options(oparser)
+    try:
+        conf, app = config.load_paste_app('melange', options, args)
+        db_api.configure_db(conf)
+        server = wsgi.Server()
+        server.start(app, options.get('port', conf['bind_port']),
+                     conf['bind_host'])
+        server.wait()
+    except RuntimeError, e:
+        sys.exit("ERROR: %s" % e)

=== added file 'bin/melange-client'
--- bin/melange-client	1970-01-01 00:00:00 +0000
+++ bin/melange-client	2011-08-25 11:33:54 +0000
@@ -0,0 +1,183 @@
+#!/usr/bin/env python
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+"""
+  CLI interface for IPAM.
+"""
+import gettext
+import optparse
+import os
+from os import environ as env
+import sys
+
+# If ../melange/__init__.py exists, add ../ to Python search path, so that
+# it will override what happens to be installed in /usr/(local/)lib/python...
+possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
+                                   os.pardir,
+                                   os.pardir))
+if os.path.exists(os.path.join(possible_topdir, 'melange', '__init__.py')):
+    sys.path.insert(0, possible_topdir)
+
+gettext.install("melange", unicode=1)
+
+from melange import version
+from melange.common.auth import KeystoneClient
+from melange.common.client import HTTPClient
+from melange.common.utils import MethodInspector
+from melange.ipam.client import (IpBlockClient, SubnetClient, PolicyClient,
+                                 UnusableIpOctetsClient,
+                                 UnusableIpRangesClient)
+
+
+def create_options(parser):
+    """
+    Sets up the CLI and config-file options that may be
+    parsed and program commands.
+
+    :param parser: The option parser
+    """
+    parser.add_option('-v', '--verbose', default=False, action="store_true",
+                      help="Print more verbose output")
+    parser.add_option('-H', '--host', metavar="ADDRESS", default="0.0.0.0",
+                      help="Address of Melange API host. "
+                           "Default: %default")
+    parser.add_option('-p', '--port', dest="port", metavar="PORT",
+                      type=int, default=9898,
+                      help="Port the Melange API host listens on. "
+                           "Default: %default")
+    parser.add_option('-t', '--tenant', dest="tenant", metavar="TENANT",
+                      type=str, help="tenant id in case of tenant resources")
+    parser.add_option('--auth-token', dest="auth_token",
+                      metavar="MELANGE_AUTH_TOKEN",
+                      default=env.get('MELANGE_AUTH_TOKEN', None),
+                      type=str, help="Auth token received from keystone")
+    parser.add_option('-u', '--username', dest="username",
+                      metavar="MELANGE_USERNAME",
+                      default=env.get('MELANGE_USERNAME', None),
+                      type=str, help="Melange user name")
+    parser.add_option('-k', '--api-key', dest="api_key",
+                      metavar="MELANGE_API_KEY",
+                      default=env.get('MELANGE_API_KEY', None),
+                      type=str, help="Melange access key")
+    parser.add_option('-a', '--auth-url', dest="auth_url",
+                      metavar="MELANGE_AUTH_URL", type=str,
+                      default=env.get('MELANGE_AUTH_URL', None),
+                      help="Url of keystone service")
+    parser.add_option('--timeout', dest="timeout",
+                      metavar="MELANGE_TIME_OUT", type=int,
+                      default=env.get('MELANGE_TIME_OUT', None),
+                      help="timeout for melange client operations")
+
+
+def parse_options(parser, cli_args):
+    """
+    Returns the parsed CLI options, command to run and its arguments, merged
+    with any same-named options found in a configuration file
+
+    :param parser: The option parser
+    """
+    (options, args) = parser.parse_args(cli_args)
+    if not args:
+        parser.print_usage()
+        sys.exit(2)
+    return (options, args)
+
+
+def usage():
+    usage = """
+%prog category action [args] [options]"
+
+Available categories:
+
+    """
+    for k, _v in categories.iteritems():
+        usage = usage + ("\t%s\n" % k)
+    return usage
+
+
+categories = dict(ip_block=IpBlockClient, subnet=SubnetClient,
+                 policy=PolicyClient, unusable_ip_range=UnusableIpRangesClient,
+                 unusable_ip_octet=UnusableIpOctetsClient)
+
+
+def lookup(name, hash):
+    result = hash.get(name, None)
+    if not result:
+        print "%s does not match any options:" % name
+        print_keys(hash)
+        sys.exit(2)
+
+    return result
+
+
+def print_keys(hash):
+    for k, _v in hash.iteritems():
+        print "\t%s" % k
+
+
+def methods_of(obj):
+    """Get all callable methods of an object that don't start with underscore
+    returns a list of tuples of the form (method_name, method)"""
+
+    def is_public_method(attr):
+        return callable(getattr(obj, attr)) and not attr.startswith('_')
+
+    return dict((attr, getattr(obj, attr)) for attr in dir(obj)
+              if is_public_method(attr))
+
+
+def main():
+    oparser = optparse.OptionParser(version='%%prog %s'
+                                    % version.version_string(),
+                                    usage=usage().strip())
+    create_options(oparser)
+    (options, args) = parse_options(oparser, sys.argv[1:])
+
+    script_name = os.path.basename(sys.argv[0])
+    category = args.pop(0)
+    http_client = HTTPClient(options.host, options.port, options.timeout)
+    auth_client = KeystoneClient(options.auth_url, options.username,
+                                      options.api_key, options.auth_token)
+
+    category_client_class = lookup(category, categories)
+    client = category_client_class(http_client, auth_client, options.tenant)
+    client_actions = methods_of(client)
+    if len(args) < 1:
+        print "Usage: " + script_name + " category action [<args>]"
+        print _("Available actions for %s category:") % category
+        print_keys(client_actions)
+        sys.exit(2)
+    action = args.pop(0)
+    fn = lookup(action, client_actions)
+
+    # call the action with the remaining arguments
+    try:
+        print fn(*args)
+        sys.exit(0)
+    except TypeError:
+        print _("Possible wrong number of arguments supplied")
+        print "Usage: %s %s %s" % (script_name, category, MethodInspector(fn))
+        if options.verbose:
+            raise
+        sys.exit(2)
+    except Exception:
+        print _("Command failed, please check log for more info")
+        raise
+
+
+if __name__ == '__main__':
+    main()

=== added file 'bin/melange-delete-deallocated-ips'
--- bin/melange-delete-deallocated-ips	1970-01-01 00:00:00 +0000
+++ bin/melange-delete-deallocated-ips	2011-08-25 11:33:54 +0000
@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+import gettext
+import logging
+import optparse
+import os
+import sys
+
+# If ../melange/__init__.py exists, add ../ to Python search path, so that
+# it will override what happens to be installed in /usr/(local/)lib/python...
+possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
+                                   os.pardir,
+                                   os.pardir))
+if os.path.exists(os.path.join(possible_topdir, 'melange', '__init__.py')):
+    sys.path.insert(0, possible_topdir)
+
+gettext.install('melange', unicode=1)
+
+from melange.db import db_api
+from melange.common import config
+from melange.ipam.models import IpBlock
+
+
+def _configure_db_session(conf):
+    db_api.configure_db(conf)
+
+
+def _load_app_environment():
+    oparser = optparse.OptionParser()
+    config.add_log_options(oparser)
+    (options, args) = config.parse_options(oparser)
+    conf_file, conf = config.load_paste_config('melange', options, args)
+    config.setup_logging(options=options, conf=conf)
+    _configure_db_session(conf)
+
+
+if __name__ == '__main__':
+    try:
+        _load_app_environment()
+        IpBlock.delete_all_deallocated_ips()
+    except RuntimeError, e:
+        sys.exit("ERROR: %s" % e)

=== added file 'bin/melange-manage'
--- bin/melange-manage	1970-01-01 00:00:00 +0000
+++ bin/melange-manage	2011-08-25 11:33:54 +0000
@@ -0,0 +1,125 @@
+#!/usr/bin/env python
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+import gettext
+import optparse
+import os
+import re
+import sys
+import time
+
+# If ../melange/__init__.py exists, add ../ to Python search path, so that
+# it will override what happens to be installed in /usr/(local/)lib/python...
+possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
+                                   os.pardir,
+                                   os.pardir))
+if os.path.exists(os.path.join(possible_topdir, 'melange', '__init__.py')):
+    sys.path.insert(0, possible_topdir)
+
+gettext.install('melange', unicode=1)
+
+
+from melange.common import config
+from melange.common import wsgi
+from melange.common.utils import MethodInspector
+from melange.db import db_api
+
+
+def create_options(parser):
+    """
+    Sets up the CLI and config-file options that may be
+    parsed and program commands.
+    :param parser: The option parser
+    """
+    parser.add_option('-p', '--port', dest="port", metavar="PORT",
+                      type=int, default=9898,
+                      help="Port the Melange API host listens on. "
+                      "Default: %default")
+    config.add_common_options(parser)
+    config.add_log_options(parser)
+
+
+class Commands(object):
+
+    def __init__(self, conf):
+        self.conf = conf
+
+    def db_sync(self):
+        print self.conf
+        db_api.db_sync(self.conf)
+
+    def db_upgrade(self, version=None):
+        db_api.db_upgrade(self.conf, version)
+
+    def db_downgrade(self, version):
+        db_api.db_downgrade(self.conf, version)
+
+    def execute(self, command_name, *args):
+        if self.has(command_name):
+            return getattr(self, command_name)(*args)
+
+    _commands = ['db_sync', 'db_upgrade', 'db_downgrade']
+
+    @classmethod
+    def has(cls, command_name):
+        return (command_name in cls._commands)
+
+    @classmethod
+    def all(cls):
+        return cls._commands
+
+    def params_of(self, command_name):
+        if Commands.has(command_name):
+            return MethodInspector(getattr(self, command_name))
+
+
+def usage():
+    usage = """
+%prog action [args] [options]
+
+Available actions:
+
+    """
+    for action in Commands.all():
+        usage = usage + ("\t%s\n" % action)
+    return usage
+
+
+if __name__ == '__main__':
+    oparser = optparse.OptionParser(version='%%prog VERSION', usage=usage())
+    create_options(oparser)
+    (options, args) = config.parse_options(oparser)
+
+    if len(args) < 1 or not Commands.has(args[0]):
+        oparser.print_usage()
+        sys.exit(2)
+
+    try:
+        conf_file, conf = config.load_paste_config('melange', options, args)
+        config.setup_logging(options, conf)
+
+        command_name = args.pop(0)
+        Commands(conf).execute(command_name, *args)
+        sys.exit(0)
+    except TypeError as e:
+        print _("Possible wrong number of arguments supplied")
+        command_params = Commands(conf).params_of(command_name)
+        print "Usage: melange-manage %s" % command_params
+        sys.exit(2)
+    except Exception as e:
+        print _("Command failed, please check log for more info")
+        raise

=== modified file 'bin/nova-manage'
--- bin/nova-manage	2011-08-24 21:01:33 +0000
+++ bin/nova-manage	2011-08-25 11:33:54 +0000
@@ -58,11 +58,11 @@
 import json
 import math
 import netaddr
+from optparse import OptionParser
 import os
 import sys
 import time
 
-from optparse import OptionParser
 
 # If ../nova/__init__.py exists, add ../ to Python search path, so that
 # it will override what happens to be installed in /usr/(local/)lib/python...

=== added directory 'etc/melange'
=== added file 'etc/melange/melange.conf.sample'
--- etc/melange/melange.conf.sample	1970-01-01 00:00:00 +0000
+++ etc/melange/melange.conf.sample	2011-08-25 11:33:54 +0000
@@ -0,0 +1,77 @@
+[DEFAULT]
+# Show more verbose log output (sets INFO log level output)
+verbose = True
+
+# Show debugging output in logs (sets DEBUG log level output)
+debug = True
+
+# Address to bind the API server
+bind_host = 0.0.0.0
+
+# Port the bind the API server to
+bind_port = 9898
+
+# SQLAlchemy connection string for the reference implementation
+# registry server. Any valid SQLAlchemy connection string is fine.
+# See: http://www.sqlalchemy.org/docs/05/reference/sqlalchemy/connections.html#sqlalchemy.create_engine
+sql_connection = sqlite:///melange.sqlite
+
+# Period in seconds after which SQLAlchemy should reestablish its connection
+# to the database.
+#
+# MySQL uses a default `wait_timeout` of 8 hours, after which it will drop
+# idle connections. This can result in 'MySQL Gone Away' exceptions. If you
+# notice this, you can lower this value to ensure that SQLAlchemy reconnects
+# before MySQL can drop the connection.
+sql_idle_timeout = 3600
+
+#DB Api Implementation
+db_api_implementation = "melange.db.sqlalchemy.api"
+
+# Path to the extensions
+api_extensions_path = melange/extensions
+
+# Cidr used for auto creating private ip block in a network
+default_cidr = 10.0.0.0/24
+
+#IPV6 Generator Factory
+#ipv6_generator=melange.ipv6.tenant_based_generator.TenantBasedIpV6Generator
+
+#DNS info for a data_center
+dns1 = "ns1.example.com"
+dns2 = "ns2.example.com"
+
+[composite:melange]
+use = call:melange.common.wsgi:versioned_urlmap
+/: versions
+/v0.1: melangeapi
+
+[app:versions]
+paste.app_factory = melange.versions:app_factory
+
+[pipeline:melangeapi]
+pipeline = extensions melangeapp
+
+[filter:extensions]
+paste.filter_factory = melange.common.extensions:ExtensionMiddleware.factory
+
+[filter:tokenauth]
+paste.filter_factory = keystone.middleware.auth_token:filter_factory
+service_protocol = http
+service_host = 127.0.0.1
+service_port = 808
+auth_host = 127.0.0.1
+auth_port = 5001
+auth_protocol = http
+admin_token = 999888777666
+
+[filter:authorization]
+paste.filter_factory = melange.common.auth:AuthorizationMiddleware.factory
+url_auth_factory = melange.ipam.service.UrlAuthorizationFactory
+
+[app:melangeapp]
+paste.app_factory = melange.ipam.service:app_factory
+
+#Add this filter to log request and response for debugging
+[filter:debug]
+paste.filter_factory = melange.common.wsgi:Debug.factory

=== added file 'etc/melange/melange.conf.test'
--- etc/melange/melange.conf.test	1970-01-01 00:00:00 +0000
+++ etc/melange/melange.conf.test	2011-08-25 11:33:54 +0000
@@ -0,0 +1,61 @@
+[DEFAULT]
+# Show more verbose log output (sets INFO log level output)
+verbose = False
+
+# Show debugging output in logs (sets DEBUG log level output)
+debug = False
+
+# Path to the extensions
+api_extensions_path = ../../melange/tests/unit/extensions
+
+# Address to bind the API server
+bind_host = 0.0.0.0
+
+# Port the bind the API server to
+bind_port = 9898
+
+# SQLAlchemy connection string for the reference implementation          
+# registry server. Any valid SQLAlchemy connection string is fine. 
+# See: http://www.sqlalchemy.org/docs/05/reference/sqlalchemy/connections.html#sqlalchemy.create_engine
+sql_connection = sqlite:///melange_test.sqlite
+
+# Period in seconds after which SQLAlchemy should reestablish its connection
+# to the database.
+#
+# MySQL uses a default `wait_timeout` of 8 hours, after which it will drop
+# idle connections. This can result in 'MySQL Gone Away' exceptions. If you
+# notice this, you can lower this value to ensure that SQLAlchemy reconnects
+# before MySQL can drop the connection.
+sql_idle_timeout = 3600
+
+#DB Api Implementation
+db_api_implementation = "melange.db.sqlalchemy.api"
+
+# Cidr used for auto creating private ip block in a network
+default_cidr = 10.0.0.0/24
+
+#IPV6 Generator Factory
+#ipv6_generator=melange.ipv6.tenant_based_generator.TenantBasedIpV6Generator
+
+#DNS info for a data_center
+nameserver = "ns.example.com"
+
+[pipeline:extensions_app_with_filter]
+pipeline = extensions extensions_test_app
+
+[filter:extensions]
+paste.filter_factory = melange.common.extensions:ExtensionMiddleware.factory
+
+[app:extensions_test_app]
+paste.app_factory = melange.tests.unit.test_extensions:app_factory
+
+[composite:versioned_melange]
+use = egg:Paste#urlmap
+/: versions
+/v0.1: melange
+
+[app:versions]
+paste.app_factory = melange.versions:app_factory
+
+[app:melange]
+paste.app_factory = melange.ipam.service:app_factory

=== added directory 'melange'
=== added file 'melange/README'
--- melange/README	1970-01-01 00:00:00 +0000
+++ melange/README	2011-08-25 11:33:54 +0000
@@ -0,0 +1,14 @@
+# Running Melange Tests
+Use the run_tests.sh from the root nova folder. It doesnt run Melange tests by default.
+1) Create the required databases:
+>mysql -uroot -p -e "CREATE DATABASE melange_test;CREATE DATABASE melange"
+2) To run melange tests:
+>run_tests.sh melange
+>run_tests.sh melange.tests.unit
+>run_tests.sh melange.tests.functional
+
+# Running Melange App
+>mysql -uroot -p -e "CREATE DATABASE melange"
+>cd <nova_root>
+>cp etc/melange/melange.conf.sample  ~/melange.conf
+>bin/melange

=== added file 'melange/__init__.py'
--- melange/__init__.py	1970-01-01 00:00:00 +0000
+++ melange/__init__.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,29 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+import os
+
+
+def melange_root_path():
+    return os.path.dirname(__file__)
+
+
+def melange_bin_path(filename="."):
+    return os.path.join(melange_root_path(), "..", "bin", filename)
+
+
+def melange_etc_path(filename="."):
+    return os.path.join(melange_root_path(), "..", "etc", "melange", filename)

=== added directory 'melange/common'
=== added file 'melange/common/__init__.py'
--- melange/common/__init__.py	1970-01-01 00:00:00 +0000
+++ melange/common/__init__.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,16 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010-2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.

=== added file 'melange/common/auth.py'
--- melange/common/auth.py	1970-01-01 00:00:00 +0000
+++ melange/common/auth.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,97 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+import httplib2
+import json
+import re
+from webob.exc import HTTPForbidden
+import wsgi
+
+from melange.common.utils import import_class
+
+
+class AuthorizationMiddleware(wsgi.Middleware):
+
+    def __init__(self, application, *auth_providers, **local_config):
+        self.auth_providers = auth_providers
+        super(AuthorizationMiddleware, self).__init__(application,
+                                                      **local_config)
+
+    def process_request(self, request):
+        roles = request.headers.get('X_ROLE', '').split(',')
+        tenant_id = request.headers.get('X_TENANT', None)
+        for provider in self.auth_providers:
+            provider.authorize(request, tenant_id, roles)
+
+    @classmethod
+    def factory(cls, global_config, **local_config):
+        def _factory(app):
+            url_auth_factory = import_class(local_config['url_auth_factory'])
+            return cls(app, url_auth_factory(), TenantBasedAuth(),
+                       **local_config)
+        return _factory
+
+
+class TenantBasedAuth(object):
+    tenant_scoped_url = re.compile(".*/tenants/(?P<tenant_id>.*?)/.*")
+
+    def authorize(self, request, tenant_id, roles):
+        if('Admin' in roles):
+            return True
+        match = self.tenant_scoped_url.match(request.path_info)
+        if match and tenant_id != match.group('tenant_id'):
+            raise HTTPForbidden(_("User with tenant id %s cannot access "
+                                  "this resource") % tenant_id)
+        return True
+
+
+class RoleBasedAuth(object):
+
+    def __init__(self, mapper):
+        self.mapper = mapper
+
+    def authorize(self, request, tenant_id, roles):
+        if('Admin' in roles):
+            return True
+        match = self.mapper.match(request.path_info, request.environ)
+        if match and match['action'] in match['controller'].admin_actions:
+            raise HTTPForbidden(_("User with roles %s cannot access "
+                                "admin actions") % ', '.join(roles))
+        return True
+
+
+class KeystoneClient(httplib2.Http):
+
+    def __init__(self, url, username, access_key, auth_token=None):
+        super(KeystoneClient, self).__init__()
+        self.url = str(url) + "/v2.0/tokens"
+        self.username = username
+        self.access_key = access_key
+        self.auth_token = auth_token
+
+    def get_token(self):
+        if self.auth_token:
+            return self.auth_token
+        headers = {'content-type': 'application/json'}
+        request_body = json.dumps({"passwordCredentials":
+                                       {"username": self.username,
+                                        'password': self.access_key}})
+        res, body = self.request(self.url, "POST", headers=headers,
+                                 body=request_body)
+        if int(res.status) >= 400:
+            raise Exception(_("Error occured while retrieving token : %s")
+                              % body)
+        return json.loads(body)['auth']['token']['id']

=== added file 'melange/common/client.py'
--- melange/common/client.py	1970-01-01 00:00:00 +0000
+++ melange/common/client.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,64 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+import httplib
+import socket
+import urllib
+
+
+class HTTPClient(object):
+
+    def __init__(self, host='localhost', port=8080, use_ssl=False, timeout=60):
+        self.host = host
+        self.port = port
+        self.use_ssl = use_ssl
+        self.timeout = timeout
+
+    def get(self, path, params=None, headers=None):
+        params = params or {}
+        headers = headers or {}
+        return self.do_request("GET", path, params=params, headers=headers)
+
+    def post(self, path, body=None, headers=None):
+        headers = headers or {}
+        return self.do_request("POST", path, body=body, headers=headers)
+
+    def delete(self, path, headers=None):
+        headers = headers or {}
+        return self.do_request("DELETE", path, headers=headers)
+
+    def _get_connection(self):
+        if self.use_ssl:
+            return httplib.HTTPSConnection(self.host, self.port,
+                                           timeout=self.timeout)
+        else:
+            return httplib.HTTPConnection(self.host, self.port,
+                                          timeout=self.timeout)
+
+    def do_request(self, method, path, body=None, headers=None, params=None):
+        params = params or {}
+        headers = headers or {}
+
+        url = path + '?' + urllib.urlencode(params)
+
+        try:
+            connection = self._get_connection()
+            connection.request(method, url, body, headers)
+            response = connection.getresponse()
+            return response
+        except (socket.error, IOError), e:
+            raise Exception(_("Unable to connect to "
+                            "server. Got error: %s") % e)

=== added file 'melange/common/config.py'
--- melange/common/config.py	1970-01-01 00:00:00 +0000
+++ melange/common/config.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+
+"""
+Routines for configuring Melange
+"""
+from openstack.common.config import (parse_options,
+                                     add_log_options,
+                                     add_common_options,
+                                     load_paste_config,
+                                     setup_logging,
+                                     load_paste_app, get_option)
+
+
+class Config(object):
+
+    instance = {}
+
+    @classmethod
+    def get(cls, key, default=None):
+        return cls.instance.get(key, default)

=== added file 'melange/common/exception.py'
--- melange/common/exception.py	1970-01-01 00:00:00 +0000
+++ melange/common/exception.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,34 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+
+"""
+Nova base exception handling, including decorator for re-raising
+Nova-type exceptions. SHOULD include dedicated exception logging.
+"""
+
+from openstack.common.exception import (Error, ProcessExecutionError,
+                                        DatabaseMigrationError,
+                                        InvalidContentType)
+
+
+class MelangeError(Error):
+
+    def __init__(self, message=None):
+        super(MelangeError, self).__init__(message or self._error_message())
+
+    def _error_message(self):
+        pass

=== added file 'melange/common/extensions.py'
--- melange/common/extensions.py	1970-01-01 00:00:00 +0000
+++ melange/common/extensions.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,437 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# Copyright 2011 Justin Santa Barbara
+# All Rights Reserved.
+#
+#    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.
+import imp
+import logging
+import os
+import routes
+import webob.dec
+import webob.exc
+
+from melange.common import exception
+from melange.common import wsgi
+
+
+LOG = logging.getLogger('melange.common.extensions')
+
+
+class ExtensionDescriptor(object):
+    """Base class that defines the contract for extensions.
+
+    Note that you don't have to derive from this class to have a valid
+    extension; it is purely a convenience.
+
+    """
+
+    def get_name(self):
+        """The name of the extension.
+
+        e.g. 'Fox In Socks'
+
+        """
+        raise NotImplementedError()
+
+    def get_alias(self):
+        """The alias for the extension.
+
+        e.g. 'FOXNSOX'
+
+        """
+        raise NotImplementedError()
+
+    def get_description(self):
+        """Friendly description for the extension.
+
+        e.g. 'The Fox In Socks Extension'
+
+        """
+        raise NotImplementedError()
+
+    def get_namespace(self):
+        """The XML namespace for the extension.
+
+        e.g. 'http://www.fox.in.socks/api/ext/pie/v1.0'
+
+        """
+        raise NotImplementedError()
+
+    def get_updated(self):
+        """The timestamp when the extension was last updated.
+
+        e.g. '2011-01-22T13:25:27-06:00'
+
+        """
+        # NOTE(justinsb): Not sure of the purpose of this is, vs the XML NS
+        raise NotImplementedError()
+
+    def get_resources(self):
+        """List of extensions.ResourceExtension extension objects.
+
+        Resources define new nouns, and are accessible through URLs.
+
+        """
+        resources = []
+        return resources
+
+    def get_actions(self):
+        """List of extensions.ActionExtension extension objects.
+
+        Actions are verbs callable from the API.
+
+        """
+        actions = []
+        return actions
+
+    def get_request_extensions(self):
+        """List of extensions.RequestException extension objects.
+
+        Request extensions are used to handle custom request data.
+
+        """
+        request_exts = []
+        return request_exts
+
+
+class ActionExtensionController(wsgi.Controller):
+
+    def __init__(self, application):
+
+        self.application = application
+        self.action_handlers = {}
+
+    def add_action(self, action_name, handler):
+        self.action_handlers[action_name] = handler
+
+    def action(self, request, id):
+
+        input_dict = self._deserialize(request.body,
+                                       request.get_content_type())
+        for action_name, handler in self.action_handlers.iteritems():
+            if action_name in input_dict:
+                return handler(input_dict, request, id)
+        # no action handler found (bump to downstream application)
+        response = self.application
+        return response
+
+
+class RequestExtensionController(wsgi.Controller):
+
+    def __init__(self, application):
+        self.application = application
+        self.handlers = []
+
+    def add_handler(self, handler):
+        self.handlers.append(handler)
+
+    def process(self, request, *args, **kwargs):
+        res = request.get_response(self.application)
+        # currently request handlers are un-ordered
+        for handler in self.handlers:
+            res = handler(request, res)
+        return res
+
+
+class ExtensionController(wsgi.Controller):
+
+    def __init__(self, extension_manager):
+        self.extension_manager = extension_manager
+
+    def _translate(self, ext):
+        ext_data = {}
+        ext_data['name'] = ext.get_name()
+        ext_data['alias'] = ext.get_alias()
+        ext_data['description'] = ext.get_description()
+        ext_data['namespace'] = ext.get_namespace()
+        ext_data['updated'] = ext.get_updated()
+        ext_data['links'] = []  # TODO(dprince): implement extension links
+        return ext_data
+
+    def index(self, request):
+        extensions = []
+        for _alias, ext in self.extension_manager.extensions.iteritems():
+            extensions.append(self._translate(ext))
+        return dict(extensions=extensions)
+
+    def show(self, request, id):
+        # NOTE(dprince): the extensions alias is used as the 'id' for show
+        ext = self.extension_manager.extensions[id]
+        return self._translate(ext)
+
+    def delete(self, request, id):
+        raise webob.exc.HTTPNotFound()
+
+    def create(self, request):
+        raise webob.exc.HTTPNotFound()
+
+
+class ExtensionMiddleware(wsgi.Middleware):
+    """Extensions middleware for WSGI."""
+    @classmethod
+    def factory(cls, global_config, **local_config):
+        """Paste factory."""
+        def _factory(app):
+            return cls(app, global_config, **local_config)
+        return _factory
+
+    def _action_ext_controllers(self, application, ext_mgr, mapper):
+        """Return a dict of ActionExtensionController-s by collection."""
+        action_controllers = {}
+        for action in ext_mgr.get_actions():
+            if not action.collection in action_controllers.keys():
+                controller = ActionExtensionController(application)
+                mapper.connect("/%s/:(id)/action.:(format)" %
+                                action.collection,
+                                action='action',
+                                controller=controller,
+                                conditions=dict(method=['POST']))
+                mapper.connect("/%s/:(id)/action" % action.collection,
+                                action='action',
+                                controller=controller,
+                                conditions=dict(method=['POST']))
+                action_controllers[action.collection] = controller
+
+        return action_controllers
+
+    def _request_ext_controllers(self, application, ext_mgr, mapper):
+        """Returns a dict of RequestExtensionController-s by collection."""
+        request_ext_controllers = {}
+        for req_ext in ext_mgr.get_request_extensions():
+            if not req_ext.key in request_ext_controllers.keys():
+                controller = RequestExtensionController(application)
+                mapper.connect(req_ext.url_route + '.:(format)',
+                                action='process',
+                                controller=controller,
+                                conditions=req_ext.conditions)
+
+                mapper.connect(req_ext.url_route,
+                                action='process',
+                                controller=controller,
+                                conditions=req_ext.conditions)
+                request_ext_controllers[req_ext.key] = controller
+
+        return request_ext_controllers
+
+    def __init__(self, application, config_params,
+                 ext_mgr=None):
+        self.ext_mgr = (ext_mgr
+                   or ExtensionManager(config_params.get('api_extensions_path',
+                                                         '')))
+
+        mapper = routes.Mapper()
+
+        # extended resources
+        for resource in self.ext_mgr.get_resources():
+            LOG.debug(_('Extended resource: %s'),
+                        resource.collection)
+            mapper.resource(resource.collection, resource.collection,
+                            controller=resource.controller,
+                            collection=resource.collection_actions,
+                            member=resource.member_actions,
+                            parent_resource=resource.parent)
+
+        # extended actions
+        action_controllers = self._action_ext_controllers(application,
+                                                          self.ext_mgr, mapper)
+        for action in self.ext_mgr.get_actions():
+            LOG.debug(_('Extended action: %s'), action.action_name)
+            controller = action_controllers[action.collection]
+            controller.add_action(action.action_name, action.handler)
+
+        # extended requests
+        req_controllers = self._request_ext_controllers(application,
+                                                        self.ext_mgr, mapper)
+        for request_ext in self.ext_mgr.get_request_extensions():
+            LOG.debug(_('Extended request: %s'), request_ext.key)
+            controller = req_controllers[request_ext.key]
+            controller.add_handler(request_ext.handler)
+
+        self._router = routes.middleware.RoutesMiddleware(self._dispatch,
+                                                          mapper)
+
+        super(ExtensionMiddleware, self).__init__(application)
+
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
+    def __call__(self, request):
+        """Route the incoming request with router."""
+        request.environ['extended.app'] = self.application
+        return self._router
+
+    @staticmethod
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
+    def _dispatch(request):
+        """Dispatch the request.
+
+        Returns the routed WSGI app's response or defers to the extended
+        application.
+
+        """
+        match = request.environ['wsgiorg.routing_args'][1]
+        if not match:
+            return request.environ['extended.app']
+        app = match['controller']
+        return app
+
+
+class ExtensionManager(object):
+    """Load extensions from the configured extension path.
+
+    See melange/tests/unit/extensions/foxinsocks.py for an
+    example extension implementation.
+
+    """
+
+    def __init__(self, path):
+        LOG.info(_('Initializing extension manager.'))
+
+        self.path = path
+        self.extensions = {}
+        self._load_all_extensions()
+
+    def get_resources(self):
+        """Returns a list of ResourceExtension objects."""
+        resources = []
+        resources.append(ResourceExtension('extensions',
+                                            ExtensionController(self)))
+        for alias, ext in self.extensions.iteritems():
+            try:
+                resources.extend(ext.get_resources())
+            except AttributeError:
+                # NOTE(dprince): Extension aren't required to have resource
+                # extensions
+                pass
+        return resources
+
+    def get_actions(self):
+        """Returns a list of ActionExtension objects."""
+        actions = []
+        for alias, ext in self.extensions.iteritems():
+            try:
+                actions.extend(ext.get_actions())
+            except AttributeError:
+                # NOTE(dprince): Extension aren't required to have action
+                # extensions
+                pass
+        return actions
+
+    def get_request_extensions(self):
+        """Returns a list of RequestExtension objects."""
+        request_exts = []
+        for alias, ext in self.extensions.iteritems():
+            try:
+                request_exts.extend(ext.get_request_extensions())
+            except AttributeError:
+                # NOTE(dprince): Extension aren't required to have request
+                # extensions
+                pass
+        return request_exts
+
+    def _check_extension(self, extension):
+        """Checks for required methods in extension objects."""
+        try:
+            LOG.debug(_('Ext name: %s'), extension.get_name())
+            LOG.debug(_('Ext alias: %s'), extension.get_alias())
+            LOG.debug(_('Ext description: %s'), extension.get_description())
+            LOG.debug(_('Ext namespace: %s'), extension.get_namespace())
+            LOG.debug(_('Ext updated: %s'), extension.get_updated())
+        except AttributeError as ex:
+            LOG.exception(_("Exception loading extension: %s"), unicode(ex))
+
+    def _load_all_extensions(self):
+        """Load extensions from the configured path.
+
+        Load extensions from the configured path. The extension name is
+        constructed from the module_name. If your extension module was named
+        widgets.py the extension class within that module should be
+        'Widgets'.
+
+        In addition, extensions are loaded from the 'contrib' directory.
+
+        See melange/tests/unit/extensions/foxinsocks.py for an example
+        extension implementation.
+
+        """
+        if os.path.exists(self.path):
+            self._load_all_extensions_from_path(self.path)
+
+        contrib_path = os.path.join(os.path.dirname(__file__), "contrib")
+        if os.path.exists(contrib_path):
+            self._load_all_extensions_from_path(contrib_path)
+
+    def _load_all_extensions_from_path(self, path):
+        for f in os.listdir(path):
+            LOG.info(_('Loading extension file: %s'), f)
+            mod_name, file_ext = os.path.splitext(os.path.split(f)[-1])
+            ext_path = os.path.join(path, f)
+            if file_ext.lower() == '.py' and not mod_name.startswith('_'):
+                mod = imp.load_source(mod_name, ext_path)
+                ext_name = mod_name[0].upper() + mod_name[1:]
+                new_ext_class = getattr(mod, ext_name, None)
+                if not new_ext_class:
+                    LOG.warn(_('Did not find expected name '
+                               '"%(ext_name)s" in %(file)s'),
+                             {'ext_name': ext_name,
+                              'file': ext_path})
+                    continue
+                new_ext = new_ext_class()
+                self._check_extension(new_ext)
+                self._add_extension(new_ext)
+
+    def _add_extension(self, ext):
+        alias = ext.get_alias()
+        LOG.info(_('Loaded extension: %s'), alias)
+
+        self._check_extension(ext)
+
+        if alias in self.extensions:
+            raise exception.MelangeError(_("Found duplicate extension: %s")
+                                         % alias)
+        self.extensions[alias] = ext
+
+
+class RequestExtension(object):
+    """Extend requests and responses of core melange OpenStack API controllers.
+
+    Provide a way to add data to responses and handle custom request data
+    that is sent to core melange OpenStack API controllers.
+
+    """
+    def __init__(self, method, url_route, handler):
+        self.url_route = url_route
+        self.handler = handler
+        self.conditions = dict(method=[method])
+        self.key = "%s-%s" % (method, url_route)
+
+
+class ActionExtension(object):
+    """Add custom actions to core melange OpenStack API controllers."""
+
+    def __init__(self, collection, action_name, handler):
+        self.collection = collection
+        self.action_name = action_name
+        self.handler = handler
+
+
+class ResourceExtension(object):
+    """Add top level resources to the OpenStack API in melange."""
+
+    def __init__(self, collection, controller, parent=None,
+                 collection_actions={}, member_actions={}):
+        self.collection = collection
+        self.controller = controller
+        self.parent = parent
+        self.collection_actions = collection_actions
+        self.member_actions = member_actions

=== added file 'melange/common/pagination.py'
--- melange/common/pagination.py	1970-01-01 00:00:00 +0000
+++ melange/common/pagination.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,108 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+import urllib
+import urlparse
+from xml.dom import minidom
+
+from melange.common.utils import merge_dicts
+from melange.common.wsgi import Result
+
+
+class AtomLink(object):
+    """An atom link"""
+
+    def __init__(self, rel, href, link_type=None, hreflang=None, title=None):
+        self.rel = rel
+        self.href = href
+        self.link_type = link_type
+        self.hreflang = hreflang
+        self.title = title
+
+    def to_xml(self):
+        ATOM_NAMESPACE = "http://www.w3.org/2005/Atom"
+        doc = minidom.Document()
+        atom_elem = doc.createElementNS(ATOM_NAMESPACE, "link")
+        if self.link_type:
+            atom_elem.setAttribute("link_type", self.link_type)
+        if self.hreflang:
+            atom_elem.setAttribute("hreflang", self.hreflang)
+        if self.title:
+            atom_elem.setAttribute("title", self.title)
+        atom_elem.setAttribute("rel", self.rel)
+        atom_elem.setAttribute("href", self.href)
+        return atom_elem
+
+
+class PaginatedResult(Result):
+
+    def serialize_data(self, serializer, serialization_type):
+        data = self.data.data_for_json()
+        if serialization_type == "application/xml":
+            data = self.data.data_for_xml()
+        return serializer.serialize(data, serialization_type)
+
+
+class PaginatedDataView(object):
+
+    def __init__(self, collection_type, collection, current_page_url,
+                 next_page_marker=None):
+        self.collection_type = collection_type
+        self.collection = collection
+        self.current_page_url = current_page_url
+        self.next_page_marker = next_page_marker
+
+    def data_for_json(self):
+        links_dict = {}
+        if self._links():
+            links_key = self.collection_type + "_links"
+            links_dict[links_key] = self._links()
+        return merge_dicts({self.collection_type: self.collection}, links_dict)
+
+    def data_for_xml(self):
+        atom_links = [AtomLink(link['rel'], link['href'])
+                           for link in self._links()]
+        return {self.collection_type: self.collection + atom_links}
+
+    def _create_link(self, marker):
+        app_url = AppUrl(self.current_page_url)
+        return str(app_url.change_query_params(marker=marker))
+
+    def _links(self):
+        if not self.next_page_marker:
+            return []
+        next_link = dict(rel='next',
+                         href=self._create_link(self.next_page_marker))
+        return [next_link]
+
+
+class AppUrl(object):
+
+    def __init__(self, url):
+        self.url = url
+
+    def __str__(self):
+        return self.url
+
+    def change_query_params(self, **kwargs):
+        parsed_url = urlparse.urlparse(self.url)
+        query_params = dict(urlparse.parse_qsl(parsed_url.query))
+        new_query_params = urllib.urlencode(merge_dicts(query_params, kwargs))
+        return self.__class__(
+            urlparse.ParseResult(parsed_url.scheme,
+                                 parsed_url.netloc, parsed_url.path,
+                                 parsed_url.params, new_query_params,
+                                 parsed_url.fragment).geturl())

=== added file 'melange/common/utils.py'
--- melange/common/utils.py	1970-01-01 00:00:00 +0000
+++ melange/common/utils.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,171 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+
+"""
+System-level utilities and helper functions.
+"""
+
+import datetime
+import inspect
+import logging
+import os
+import subprocess
+import uuid
+
+from openstack.common.utils import import_class, import_object
+
+from melange.common.exception import ProcessExecutionError
+
+
+def parse_int(subject):
+    try:
+        return int(subject)
+    except (ValueError, TypeError):
+        return None
+
+
+def execute(cmd, process_input=None, addl_env=None, check_exit_code=True):
+    logging.debug("Running cmd: %s", cmd)
+    env = os.environ.copy()
+    if addl_env:
+        env.update(addl_env)
+    obj = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env)
+    result = None
+    if process_input != None:
+        result = obj.communicate(process_input)
+    else:
+        result = obj.communicate()
+    obj.stdin.close()
+    if obj.returncode:
+        logging.debug("Result was %s" % (obj.returncode))
+        if check_exit_code and obj.returncode != 0:
+            (stdout, stderr) = result
+            raise ProcessExecutionError(exit_code=obj.returncode,
+                                        stdout=stdout,
+                                        stderr=stderr,
+                                        cmd=cmd)
+    return result
+
+
+def utcnow():
+    return datetime.datetime.utcnow()
+
+
+def exclude(key_values, *exclude_keys):
+    return dict((key, value) for key, value in key_values.iteritems()
+                if key not in exclude_keys)
+
+
+def filter_dict(key_values, *include_keys):
+    return dict((key, value) for key, value in key_values.iteritems()
+                if key in include_keys)
+
+
+def stringify_keys(dictionary):
+    return dict((str(key), value) for key, value in dictionary.iteritems())
+
+
+def find(predicate, items):
+    for item in items:
+        if predicate(item) is True:
+            return item
+
+
+def merge_dicts(*dictionaries):
+    merged_dict = dict()
+    for dictionary in dictionaries:
+        merged_dict = dict(merged_dict.items() + dictionary.items())
+    return merged_dict
+
+
+def guid():
+    return str(uuid.uuid4())
+
+
+def remove_nones(hash):
+    return dict((key, value)
+               for key, value in hash.iteritems() if value is not None)
+
+
+class cached_property(object):
+    """
+    Taken from : https://github.com/nshah/python-memoize
+    A decorator that converts a function into a lazy property. The
+    function wrapped is called the first time to retrieve the result
+    and than that calculated result is used the next time you access
+    the value::
+
+        class Foo(object):
+
+            @cached_property
+            def bar(self):
+                # calculate something important here
+                return 42
+
+    """
+
+    def __init__(self, func, name=None, doc=None):
+        self.func = func
+        self.__name__ = name or func.__name__
+        self.__doc__ = doc or func.__doc__
+
+    def __get__(self, obj, type=None):
+        if obj is None:
+            return self
+        value = self.func(obj)
+        setattr(obj, self.__name__, value)
+        return value
+
+
+class MethodInspector(object):
+    def __init__(self, func):
+        self._func = func
+
+    @cached_property
+    def required_args(self):
+        return self.args[0:self.required_args_count]
+
+    @cached_property
+    def optional_args(self):
+        keys = self.args[self.required_args_count: len(self.args)]
+        return zip(keys, self.defaults)
+
+    @cached_property
+    def defaults(self):
+        return self.argspec.defaults or ()
+
+    @cached_property
+    def required_args_count(self):
+        return len(self.args) - len(self.defaults)
+
+    @cached_property
+    def args(self):
+        args = self.argspec.args
+        if inspect.ismethod(self._func):
+            args.pop(0)
+        return args
+
+    @cached_property
+    def argspec(self):
+        return inspect.getargspec(self._func)
+
+    def __str__(self):
+        optionals = ["%s=%s" % (k, v) for k, v in self.optional_args]
+        args_str = ' '.join(map(lambda arg: "<%s>" % arg,
+                                self.required_args + optionals))
+        return "%s %s" % (self._func.__name__, args_str)

=== added file 'melange/common/wsgi.py'
--- melange/common/wsgi.py	1970-01-01 00:00:00 +0000
+++ melange/common/wsgi.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,383 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+
+"""
+Utility methods for working with WSGI servers
+"""
+import datetime
+from datetime import timedelta
+import eventlet.wsgi
+import inspect
+import json
+import logging
+import paste.urlmap
+import re
+import traceback
+from webob import Response
+import webob.dec
+import webob.exc
+from webob.exc import HTTPBadRequest
+from webob.exc import HTTPError
+from webob.exc import HTTPInternalServerError
+from webob.exc import HTTPNotAcceptable
+from webob.exc import HTTPNotFound
+from xml.dom import minidom
+
+from openstack.common.wsgi import Router, Server, Middleware
+
+from melange.common.exception import InvalidContentType
+from melange.common.exception import MelangeError
+from melange.common.utils import cached_property
+
+
+eventlet.patcher.monkey_patch(all=False, socket=True)
+
+LOG = logging.getLogger('melange.wsgi')
+
+
+def versioned_urlmap(*args, **kwargs):
+    urlmap = paste.urlmap.urlmap_factory(*args, **kwargs)
+    return VersionedURLMap(urlmap)
+
+
+class VersionedURLMap(object):
+
+    def __init__(self, urlmap):
+        self.urlmap = urlmap
+
+    def __call__(self, environ, start_response):
+        req = Request(environ)
+
+        if req.url_version is None and req.accept_version is not None:
+            version = "/v" + req.accept_version
+            app = self.urlmap.get(
+                version, Fault(HTTPNotAcceptable(_("version not supported"))))
+        else:
+            app = self.urlmap
+
+        return app(environ, start_response)
+
+
+class Request(webob.Request):
+
+    @property
+    def deserialized_params(self):
+        return Serializer().deserialize(self.body, self.get_content_type())
+
+    def best_match_content_type(self):
+        """Determine the most acceptable content-type.
+
+        Based on the query extension then the Accept header.
+
+        """
+        parts = self.path.rsplit('.', 1)
+
+        if len(parts) > 1:
+            format = parts[1]
+            if format in ['json', 'xml']:
+                return 'application/{0}'.format(parts[1])
+
+        ctypes = {'application/vnd.openstack.melange+json': "application/json",
+                  'application/vnd.openstack.melange+xml': "application/xml",
+                  'application/json': "application/json",
+                  'application/xml': "application/xml"}
+
+        bm = self.accept.best_match(ctypes.keys())
+        return ctypes.get(bm, 'application/json')
+
+    def get_content_type(self):
+        allowed_types = ("application/xml", "application/json")
+        self.content_type = self.content_type or "application/json"
+        type = self.content_type
+        if type in allowed_types:
+            return type
+        LOG.debug("Wrong Content-Type: %s" % type)
+        raise webob.exc.HTTPUnsupportedMediaType(
+        _("Content type %s not supported") % type)
+
+    @cached_property
+    def accept_version(self):
+        accept_header = self.headers.get('ACCEPT', "")
+        accept_version_re = re.compile(".*?application/vnd.openstack.melange"
+                                       "(\+.+?)?;"
+                                       "version=(?P<version_no>\d+\.?\d*)")
+
+        match = accept_version_re.search(accept_header)
+        return  match.group("version_no") if match else None
+
+    @cached_property
+    def url_version(self):
+        versioned_url_re = re.compile("/v(?P<version_no>\d+\.?\d*)")
+        match = versioned_url_re.search(self.path)
+        return match.group("version_no") if match else None
+
+
+class Result(object):
+
+    def __init__(self, data, status=200):
+        self.data = data
+        self.status = status
+
+    def response(self, serializer, serialization_type):
+        serialized_data = self.serialize_data(serializer, serialization_type)
+        return Response(body=serialized_data, content_type=serialization_type,
+                        status=self.status)
+
+    def serialize_data(self, serializer, serialization_type):
+        return serializer.serialize(self.data, serialization_type)
+
+
+class Controller(object):
+    """
+    WSGI app that reads routing information supplied by RoutesMiddleware
+    and calls the requested action method upon itself.  All action methods
+    must, in addition to their normal parameters, accept a 'req' argument
+    which is the incoming webob.Request.  They raise a webob.exc exception,
+    or return a dict which will be serialized by requested content type.
+    """
+    exception_map = {}
+    admin_actions = []
+
+    def __init__(self, admin_actions=None):
+        admin_actions = admin_actions or []
+        self.model_exception_map = self._invert_dict_list(self.exception_map)
+        self.admin_actions = admin_actions
+
+    @webob.dec.wsgify(RequestClass=Request)
+    def __call__(self, req):
+        """
+        Call the method specified in req.environ by RoutesMiddleware.
+        """
+        arg_dict = req.environ['wsgiorg.routing_args'][1]
+        action = arg_dict['action']
+        method = getattr(self, action, None)
+        del arg_dict['controller']
+        del arg_dict['action']
+        arg_dict['request'] = req
+
+        result = self._execute_action(method, arg_dict)
+
+        if type(result) is dict:
+            result = Result(result)
+
+        if isinstance(result, Result):
+            return result.response(self._serializer(),
+                               req.best_match_content_type())
+        return result
+
+    def _execute_action(self, method, arg_dict):
+        if method is None:
+            raise HTTPNotFound
+        try:
+            if self._method_doesnt_expect_format_arg(method):
+                arg_dict.pop('format', None)
+            return method(**arg_dict)
+        except MelangeError as e:
+            LOG.debug(traceback.format_exc())
+            httpError = self._get_http_error(e)
+            return Fault(httpError(str(e), request=arg_dict['request']))
+        except HTTPError as e:
+            LOG.debug(traceback.format_exc())
+            return Fault(e)
+        except Exception as e:
+            LOG.exception(e)
+            return Fault(HTTPInternalServerError(e.message,
+                              request=arg_dict['request']))
+
+    def _method_doesnt_expect_format_arg(self, method):
+        return not 'format' in inspect.getargspec(method)[0]
+
+    def _get_http_error(self, error):
+        return self.model_exception_map.get(type(error), HTTPBadRequest)
+
+    def _serializer(self):
+        """
+        Serialize the given dict to the response type requested in request.
+        Uses self._serialization_metadata if it exists, which is a dict mapping
+        MIME types to information needed to serialize to that type.
+        """
+        _metadata = getattr(type(self), "_serialization_metadata", {})
+        return Serializer(_metadata)
+
+    def _deserialize(self, data, content_type):
+        """Deserialize the request body to the specefied content type.
+
+        Uses self._serialization_metadata if it exists, which is a dict mapping
+        MIME types to information needed to serialize to that type.
+
+        """
+        _metadata = getattr(type(self), '_serialization_metadata', {})
+        serializer = Serializer(_metadata)
+        return serializer.deserialize(data, content_type)
+
+    def _invert_dict_list(self, exception_dict):
+        """
+        {'x':[1,2,3],'y':[4,5,6]} converted to
+        {1:'x',2:'x',3:'x',4:'y',5:'y',6:'y'}
+        """
+        inverted_dict = {}
+        for key, value_list in exception_dict.items():
+            for value in value_list:
+                inverted_dict[value] = key
+        return inverted_dict
+
+
+class Serializer(object):
+    """
+    Serializes a dictionary to a Content Type specified by a WSGI environment.
+    """
+
+    def __init__(self, metadata=None):
+        """
+        Create a serializer based on the given WSGI environment.
+        'metadata' is an optional dict mapping MIME types to information
+        needed to serialize a dictionary to that type.
+        """
+        self.metadata = metadata or {}
+        self._methods = {
+            'application/json': self._to_json,
+            'application/xml': self._to_xml}
+
+    def serialize(self, data, content_type):
+        """
+        Serialize a dictionary into a string.  The format of the string
+        will be decided based on the Content Type requested in self.environ:
+        by Accept: header, or by URL suffix.
+        """
+        return self._methods.get(content_type, repr)(data)
+
+    def _to_json(self, data):
+        def sanitizer(obj):
+            if isinstance(obj, datetime.datetime):
+                _dtime = obj - timedelta(microseconds=obj.microsecond)
+                return _dtime.isoformat()
+            return obj
+
+        return json.dumps(data, default=sanitizer)
+
+    def _to_xml(self, data):
+        metadata = self.metadata.get('application/xml', {})
+        # We expect data to contain a single key which is the XML root.
+        root_key = data.keys()[0]
+        doc = minidom.Document()
+        node = self._to_xml_node(doc, metadata, root_key, data[root_key])
+        return node.toprettyxml(indent='    ')
+
+    def _to_xml_node(self, doc, metadata, nodename, data):
+        """Recursive method to convert data members to XML nodes."""
+        if hasattr(data, 'to_xml'):
+            return data.to_xml()
+        result = doc.createElement(nodename)
+        if type(data) is list:
+            singular = metadata.get('plurals', {}).get(nodename, None)
+            if singular is None:
+                if nodename.endswith('s'):
+                    singular = nodename[:-1]
+                else:
+                    singular = 'item'
+            for item in data:
+                node = self._to_xml_node(doc, metadata, singular, item)
+                result.appendChild(node)
+        elif type(data) is dict:
+            attrs = metadata.get('attributes', {}).get(nodename, {})
+            for k, v in data.items():
+                if k in attrs:
+                    result.setAttribute(k, str(v))
+                else:
+                    node = self._to_xml_node(doc, metadata, k, v)
+                    result.appendChild(node)
+        else:  # atom
+            node = doc.createTextNode(str(data))
+            result.appendChild(node)
+        return result
+
+    def deserialize(self, datastring, content_type):
+        """Deserialize a string to a dictionary.
+
+        The string must be in the format of a supported MIME type.
+
+        """
+        return self.get_deserialize_handler(content_type)(datastring)
+
+    def get_deserialize_handler(self, content_type):
+        handlers = {
+            'application/json': self._from_json,
+            'application/xml': self._from_xml,
+        }
+
+        try:
+            return handlers[content_type]
+        except Exception:
+            raise InvalidContentType(content_type=content_type)
+
+    def _from_json(self, datastring):
+        return json.loads(datastring or "{}")
+
+    def _from_xml(self, datastring):
+        xmldata = self.metadata.get('application/xml', {})
+        plurals = set(xmldata.get('plurals', {}))
+        node = minidom.parseString(datastring).childNodes[0]
+        return {node.nodeName: self._from_xml_node(node, plurals)}
+
+    def _from_xml_node(self, node, listnames):
+        """Convert a minidom node to a simple Python type.
+
+        listnames is a collection of names of XML nodes whose subnodes should
+        be considered list items.
+
+        """
+        if len(node.childNodes) == 1 and node.childNodes[0].nodeType == 3:
+            return node.childNodes[0].nodeValue
+        elif node.nodeName in listnames:
+            return [self._from_xml_node(n, listnames) for n in node.childNodes]
+        else:
+            result = dict()
+            for attr in node.attributes.keys():
+                result[attr] = node.attributes[attr].nodeValue
+            for child in node.childNodes:
+                if child.nodeType != node.TEXT_NODE:
+                    result[child.nodeName] = self._from_xml_node(child,
+                                                                 listnames)
+            return result
+
+
+class Fault(webob.exc.HTTPException):
+    """Error codes for API faults"""
+
+    def __init__(self, exception):
+        """Create a Fault for the given webob.exc.exception."""
+        self.wrapped_exc = exception
+
+    @webob.dec.wsgify(RequestClass=Request)
+    def __call__(self, req):
+        """Generate a WSGI response based on the exception passed to ctor."""
+        # Replace the body with fault details.
+        fault_name = self.wrapped_exc.__class__.__name__
+        if(fault_name.startswith("HTTP")):
+            fault_name = fault_name[4:]
+        fault_data = {
+            fault_name: {
+                'code': self.wrapped_exc.status_int,
+                'message': self.wrapped_exc.explanation,
+                'detail': self.wrapped_exc.detail}}
+        # 'code' is an attribute on the fault tag itself
+        metadata = {'application/xml': {'attributes': {fault_name: 'code'}}}
+        serializer = Serializer(metadata)
+        content_type = req.best_match_content_type()
+        self.wrapped_exc.body = serializer.serialize(fault_data, content_type)
+        self.wrapped_exc.content_type = content_type
+        return self.wrapped_exc

=== added directory 'melange/db'
=== added file 'melange/db/__init__.py'
--- melange/db/__init__.py	1970-01-01 00:00:00 +0000
+++ melange/db/__init__.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,43 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010-2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+import optparse
+
+from melange.common import utils
+from melange.common.config import Config
+
+
+db_api = utils.import_object(Config.get("db_api_implementation",
+                                        "melange.db.sqlalchemy.api"))
+
+
+def add_options(parser):
+    """
+    Adds any configuration options that the db layer might have.
+
+    :param parser: An optparse.OptionParser object
+    :retval None
+    """
+    help_text = "The following configuration options are specific to the "\
+                "Melange image registry database."
+
+    group = optparse.OptionGroup(parser, "Registry Database Options",
+                                 help_text)
+    group.add_option('--sql-connection', metavar="CONNECTION",
+                     default=None,
+                     help="A valid SQLAlchemy connection string for the "
+                          "registry database. Default: %default")
+    parser.add_option_group(group)

=== added directory 'melange/db/sqlalchemy'
=== added file 'melange/db/sqlalchemy/__init__.py'
--- melange/db/sqlalchemy/__init__.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/__init__.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,16 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010-2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.

=== added file 'melange/db/sqlalchemy/api.py'
--- melange/db/sqlalchemy/api.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/api.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,213 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy import and_
+from sqlalchemy import or_
+from sqlalchemy.orm import aliased
+
+from melange import ipam
+from melange.common import utils
+from melange.db.sqlalchemy import migration
+from melange.db.sqlalchemy import session
+from melange.db.sqlalchemy.mappers import IpNat
+
+
+def find_all_by(model, **conditions):
+    return _query_by(model, **conditions).all()
+
+
+def find_all_by_limit(model, conditions, limit, marker=None,
+                      marker_column=None):
+    return _limits(model, conditions, limit, marker, marker_column).all()
+
+
+def find_by(model, **kwargs):
+    return _query_by(model, **kwargs).first()
+
+
+def save(model):
+    db_session = session.get_session()
+    model = db_session.merge(model)
+    db_session.flush()
+    return model
+
+
+def delete(model):
+    model.deleted = True
+    save(model)
+
+
+def delete_all(model, **conditions):
+    _delete_all(_query_by(model, **conditions))
+
+
+def update(model, values):
+    for k, v in values.iteritems():
+        model[k] = v
+
+
+def update_all(model, conditions, values):
+    _query_by(model, **conditions).update(values)
+
+
+def find_inside_globals_for(local_address_id, **kwargs):
+    marker_column = IpNat.inside_global_address_id
+    limit = kwargs.pop('limit', 200)
+    marker = kwargs.pop('marker', None)
+
+    kwargs["inside_local_address_id"] = local_address_id
+    query = _limits(IpNat, kwargs,
+                    limit, marker, marker_column)
+    return [nat.inside_global_address for nat in query]
+
+
+def find_inside_locals_for(global_address_id, **kwargs):
+    marker_column = IpNat.inside_local_address_id
+    limit = kwargs.pop('limit', 200)
+    marker = kwargs.pop('marker', None)
+
+    kwargs["inside_global_address_id"] = global_address_id
+    query = _limits(IpNat, kwargs,
+                    limit, marker, marker_column)
+    return [nat.inside_local_address for nat in query]
+
+
+def save_nat_relationships(nat_relationships):
+    ip_nat_table = IpNat
+    for relationship in nat_relationships:
+        ip_nat = ip_nat_table()
+        relationship['id'] = utils.guid()
+        update(ip_nat, relationship)
+        save(ip_nat)
+
+
+def remove_inside_globals(local_address_id,
+                          inside_global_address=None):
+
+    def _filter_inside_global_address(natted_ips, inside_global_address):
+        return natted_ips.\
+            join((ipam.models.IpAddress,
+                 IpNat.inside_global_address_id == ipam.models.IpAddress.id)).\
+                 filter(ipam.models.IpAddress.address == inside_global_address)
+
+    remove_natted_ips(_filter_inside_global_address,
+                      inside_global_address,
+                      inside_local_address_id=local_address_id)
+
+
+def remove_inside_locals(global_address_id,
+                         inside_local_address=None):
+
+    def _filter_inside_local_address(natted_ips, inside_local_address):
+        return natted_ips.\
+            join((ipam.models.IpAddress,
+                  IpNat.inside_local_address_id == ipam.models.IpAddress.id)).\
+                  filter(ipam.models.IpAddress.address == inside_local_address)
+
+    remove_natted_ips(_filter_inside_local_address,
+                          inside_local_address,
+                          inside_global_address_id=global_address_id)
+
+
+def remove_natted_ips(_filter_by_natted_address,
+                      natted_address, **kwargs):
+    natted_ips = find_natted_ips(**kwargs)
+    if natted_address != None:
+        natted_ips = _filter_by_natted_address(natted_ips, natted_address)
+    for ip in natted_ips:
+        delete(ip)
+
+
+def find_natted_ips(**kwargs):
+    return _base_query(IpNat).\
+                 filter_by(**kwargs)
+
+
+def find_all_blocks_with_deallocated_ips():
+    return _base_query(ipam.models.IpBlock).\
+           join(ipam.models.IpAddress).\
+           filter(ipam.models.IpAddress.marked_for_deallocation == True)
+
+
+def delete_deallocated_ips(deallocated_by, **kwargs):
+    return _delete_all(_query_by(ipam.models.IpAddress, **kwargs).\
+           filter_by(marked_for_deallocation=True).\
+           filter(ipam.models.IpAddress.deallocated_at <= deallocated_by))
+
+
+def find_all_top_level_blocks_in_network(network_id):
+    parent_block = aliased(ipam.models.IpBlock, name="parent_block")
+
+    return _base_query(ipam.models.IpBlock).\
+        outerjoin((parent_block,
+                   and_(ipam.models.IpBlock.parent_id == parent_block.id,
+                        parent_block.network_id == network_id))).\
+        filter(ipam.models.IpBlock.network_id == network_id).\
+        filter(parent_block.id == None)
+
+
+def find_all_ips_in_network(network_id, **conditions):
+    return _query_by(ipam.models.IpAddress, **conditions).\
+        join(ipam.models.IpBlock).\
+        filter(ipam.models.IpBlock.network_id == network_id)
+
+
+def configure_db(options):
+    session.configure_db(options)
+
+
+def drop_db(options):
+    session.drop_db(options)
+
+
+def clean_db():
+    session.clean_db()
+
+
+def db_sync(options, version=None):
+    migration.db_sync(options, version)
+
+
+def db_upgrade(options, version=None):
+    migration.upgrade(options, version)
+
+
+def db_downgrade(options, version):
+    migration.downgrade(options, version)
+
+
+def _delete_all(query):
+    query.update({'deleted': True})
+
+
+def _base_query(cls):
+    return session.get_session().query(cls).\
+           filter(or_(cls.deleted == False, cls.deleted == None))
+
+
+def _query_by(cls, **conditions):
+    query = _base_query(cls)
+    if conditions:
+        query = query.filter_by(**conditions)
+    return query
+
+
+def _limits(cls, conditions, limit, marker, marker_column=None):
+    query = _query_by(cls, **conditions)
+    marker_column = marker_column or cls.id
+    if (marker is not None):
+        query = query.filter(marker_column > marker)
+    return query.order_by(marker_column).limit(limit)

=== added file 'melange/db/sqlalchemy/mappers.py'
--- melange/db/sqlalchemy/mappers.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/mappers.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,53 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy import MetaData
+from sqlalchemy import Table
+from sqlalchemy.orm import mapper
+from sqlalchemy.orm import relation
+
+
+def map(engine, models):
+    meta = MetaData()
+    meta.bind = engine
+    ip_nats_table = Table('ip_nats', meta, autoload=True)
+    ip_addresses_table = Table('ip_addresses', meta, autoload=True)
+    policies_table = Table('policies', meta, autoload=True)
+    ip_ranges_table = Table('ip_ranges', meta, autoload=True)
+    ip_octets_table = Table('ip_octets', meta, autoload=True)
+
+    mapper(models["IpBlock"], Table('ip_blocks', meta, autoload=True))
+    mapper(models["IpAddress"], ip_addresses_table)
+    mapper(models["Policy"], policies_table)
+    mapper(models["IpRange"], ip_ranges_table)
+    mapper(models["IpOctet"], ip_octets_table)
+    mapper(IpNat, ip_nats_table,
+           properties={'inside_global_address':
+                       relation(models["IpAddress"],
+                         primaryjoin=ip_nats_table.c.inside_global_address_id \
+                         == ip_addresses_table.c.id),
+                        'inside_local_address': relation(models["IpAddress"],
+                       primaryjoin=ip_nats_table.c.\
+                                     inside_local_address_id == \
+                                            ip_addresses_table.c.id)})
+
+
+class IpNat(object):
+    def __setitem__(self, key, value):
+        setattr(self, key, value)
+
+    def __getitem__(self, key):
+        return getattr(self, key)

=== added directory 'melange/db/sqlalchemy/migrate_repo'
=== added file 'melange/db/sqlalchemy/migrate_repo/README'
--- melange/db/sqlalchemy/migrate_repo/README	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/README	2011-08-25 11:33:54 +0000
@@ -0,0 +1,4 @@
+This is a database migration repository.
+
+More information at
+http://code.google.com/p/sqlalchemy-migrate/

=== added file 'melange/db/sqlalchemy/migrate_repo/__init__.py'
--- melange/db/sqlalchemy/migrate_repo/__init__.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/__init__.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,18 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+
+# template repository default module

=== added file 'melange/db/sqlalchemy/migrate_repo/manage.py'
--- melange/db/sqlalchemy/migrate_repo/manage.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/manage.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from migrate.versioning.shell import main
+
+
+main(debug='False', repository='.')

=== added file 'melange/db/sqlalchemy/migrate_repo/migrate.cfg'
--- melange/db/sqlalchemy/migrate_repo/migrate.cfg	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/migrate.cfg	2011-08-25 11:33:54 +0000
@@ -0,0 +1,20 @@
+[db_settings]
+# Used to identify which repository this database is versioned under.
+# You can use the name of your project.
+repository_id=Melange Migrations
+
+# The name of the database table used to track the schema version.
+# This name shouldn't already be used by your project.
+# If this is changed once a database is under version control, you'll need to
+# change the table name in each database too.
+version_table=migrate_version
+
+# When committing a change script, Migrate will attempt to generate the
+# sql for all supported databases; normally, if one of them fails - probably
+# because you don't have that database installed - it is ignored and the
+# commit continues, perhaps ending successfully.
+# Databases in this list MUST compile successfully during a commit, or the
+# entire commit will fail. List the databases your application will actually
+# be using to ensure your updates to that database work properly.
+# This must be a list; example: ['postgres','sqlite']
+required_dbs=['mysql','postgres','sqlite']

=== added file 'melange/db/sqlalchemy/migrate_repo/schema.py'
--- melange/db/sqlalchemy/migrate_repo/schema.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/schema.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,65 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+
+"""
+Various conveniences used for migration scripts
+"""
+
+import logging
+import sqlalchemy.types
+
+
+logger = logging.getLogger('melange.db.migrate_repo.schema')
+
+
+String = lambda length: sqlalchemy.types.String(
+    length=length, convert_unicode=False, assert_unicode=None,
+    unicode_error=None, _warn_on_bytestring=False)
+
+
+Text = lambda: sqlalchemy.types.Text(
+    length=None, convert_unicode=False, assert_unicode=None,
+    unicode_error=None, _warn_on_bytestring=False)
+
+
+Boolean = lambda: sqlalchemy.types.Boolean(create_constraint=True, name=None)
+
+
+DateTime = lambda: sqlalchemy.types.DateTime(timezone=False)
+
+
+Integer = lambda: sqlalchemy.types.Integer()
+
+
+BigInteger = lambda: sqlalchemy.types.BigInteger()
+
+
+def create_tables(tables):
+    for table in tables:
+        logger.info("creating table %(table)s" % locals())
+        table.create()
+
+
+def drop_tables(tables):
+    for table in tables:
+        logger.info("dropping table %(table)s" % locals())
+        table.drop()
+
+
+def Table(name, metadata, *args, **kwargs):
+    return sqlalchemy.schema.Table(name, metadata, *args,
+                                   mysql_engine='INNODB', **kwargs)

=== added directory 'melange/db/sqlalchemy/migrate_repo/versions'
=== added file 'melange/db/sqlalchemy/migrate_repo/versions/001_add_ip_blocks_table.py'
--- melange/db/sqlalchemy/migrate_repo/versions/001_add_ip_blocks_table.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/001_add_ip_blocks_table.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,48 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import MetaData
+
+from melange.db.sqlalchemy.migrate_repo.schema import create_tables
+from melange.db.sqlalchemy.migrate_repo.schema import DateTime
+from melange.db.sqlalchemy.migrate_repo.schema import drop_tables
+from melange.db.sqlalchemy.migrate_repo.schema import String
+from melange.db.sqlalchemy.migrate_repo.schema import Table
+
+
+def define_ip_blocks_table(meta):
+    ip_blocks = Table('ip_blocks', meta,
+        Column('id', String(36), primary_key=True, nullable=False),
+        Column('network_id', String(255)),
+        Column('cidr', String(255), nullable=False),
+        Column('created_at', DateTime(), nullable=True),
+        Column('updated_at', DateTime()))
+    return ip_blocks
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    tables = [define_ip_blocks_table(meta)]
+    create_tables(tables)
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    tables = [define_ip_blocks_table(meta)]
+    drop_tables(tables)

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/002_add_ip_addresses_table.py'
--- melange/db/sqlalchemy/migrate_repo/versions/002_add_ip_addresses_table.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/002_add_ip_addresses_table.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,54 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import ForeignKey
+from sqlalchemy.schema import MetaData
+
+from melange.db.sqlalchemy.migrate_repo.schema import create_tables
+from melange.db.sqlalchemy.migrate_repo.schema import DateTime
+from melange.db.sqlalchemy.migrate_repo.schema import drop_tables
+from melange.db.sqlalchemy.migrate_repo.schema import String
+from melange.db.sqlalchemy.migrate_repo.schema import Table
+
+
+def define_ip_addresses_table(meta):
+
+    ip_blocks = Table('ip_blocks', meta, autoload=True)
+
+    ip_addresses = Table('ip_addresses', meta,
+        Column('id', String(36), primary_key=True, nullable=False),
+        Column('address', String(255), nullable=False),
+        Column('interface_id', String(255), nullable=True),
+        Column('ip_block_id', String(36), ForeignKey('ip_blocks.id'),
+               nullable=True),
+        Column('created_at', DateTime(), nullable=True),
+        Column('updated_at', DateTime()))
+    return ip_addresses
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    tables = [define_ip_addresses_table(meta)]
+    create_tables(tables)
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    tables = [define_ip_addresses_table(meta)]
+    drop_tables(tables)

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/003_add_type_to_ip_blocks.py'
--- melange/db/sqlalchemy/migrate_repo/versions/003_add_type_to_ip_blocks.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/003_add_type_to_ip_blocks.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,33 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import MetaData
+
+from melange.db.sqlalchemy.migrate_repo.schema import String
+from melange.db.sqlalchemy.migrate_repo.schema import Table
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    Column('type', String(7)).create(Table('ip_blocks', meta))
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    Table('ip_blocks', meta, autoload=True).columns["type"].drop()

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/004_add_ip_nat_table.py'
--- melange/db/sqlalchemy/migrate_repo/versions/004_add_ip_nat_table.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/004_add_ip_nat_table.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,56 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+import datetime
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import ForeignKey
+from sqlalchemy.schema import MetaData
+
+from melange.db.sqlalchemy.migrate_repo.schema import create_tables
+from melange.db.sqlalchemy.migrate_repo.schema import DateTime
+from melange.db.sqlalchemy.migrate_repo.schema import drop_tables
+from melange.db.sqlalchemy.migrate_repo.schema import String
+from melange.db.sqlalchemy.migrate_repo.schema import Table
+
+
+def define_ip_nat_table(meta):
+
+    ip_addresses = Table('ip_addresses', meta, autoload=True)
+
+    ip_nats = Table('ip_nats', meta,
+        Column('id', String(36), primary_key=True, nullable=False),
+        Column('inside_local_address_id', String(36),
+               ForeignKey('ip_addresses.id'), nullable=False),
+        Column('inside_global_address_id', String(36),
+               ForeignKey('ip_addresses.id'), nullable=False),
+        Column('created_at', DateTime(),
+               default=datetime.datetime.utcnow, nullable=True),
+        Column('updated_at', DateTime(), default=datetime.datetime.utcnow))
+    return ip_nats
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    tables = [define_ip_nat_table(meta)]
+    create_tables(tables)
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    tables = [define_ip_nat_table(meta)]
+    drop_tables(tables)

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/005_add_soft_delete_to_blocks_addresses_and_ip_nats.py'
--- melange/db/sqlalchemy/migrate_repo/versions/005_add_soft_delete_to_blocks_addresses_and_ip_nats.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/005_add_soft_delete_to_blocks_addresses_and_ip_nats.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,37 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import MetaData
+from sqlalchemy.schema import Table
+
+from melange.db.sqlalchemy.migrate_repo.schema import Boolean
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    Column('deleted', Boolean()).create(Table('ip_blocks', meta))
+    Column('deleted', Boolean()).create(Table('ip_addresses', meta))
+    Column('deleted', Boolean()).create(Table('ip_nats', meta))
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    Table('ip_nats', meta, autoload=True).columns["deleted"].drop()
+    Table('ip_addresses', meta, autoload=True).columns["deleted"].drop()
+    Table('ip_blocks', meta, autoload=True).columns["deleted"].drop()

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/006_add_deallocated_to_ip_addresses.py'
--- melange/db/sqlalchemy/migrate_repo/versions/006_add_deallocated_to_ip_addresses.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/006_add_deallocated_to_ip_addresses.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,35 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import MetaData
+from sqlalchemy.schema import Table
+
+from melange.db.sqlalchemy.migrate_repo.schema import Boolean
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    Column('marked_for_deallocation', Boolean()).create(\
+                                Table('ip_addresses', meta))
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    Table('ip_addresses', meta,
+          autoload=True).columns["marked_for_deallocation"].drop()

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/007_add_policy_table.py'
--- melange/db/sqlalchemy/migrate_repo/versions/007_add_policy_table.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/007_add_policy_table.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,51 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import MetaData
+
+from melange.db.sqlalchemy.migrate_repo.schema import Boolean
+from melange.db.sqlalchemy.migrate_repo.schema import create_tables
+from melange.db.sqlalchemy.migrate_repo.schema import DateTime
+from melange.db.sqlalchemy.migrate_repo.schema import drop_tables
+from melange.db.sqlalchemy.migrate_repo.schema import String
+from melange.db.sqlalchemy.migrate_repo.schema import Table
+
+
+def define_policy_table(meta):
+
+    policies = Table('policies', meta,
+        Column('id', String(36), primary_key=True, nullable=False),
+        Column('name', String(255), nullable=False),
+        Column('description', String(255), nullable=True),
+        Column('created_at', DateTime(), nullable=True),
+        Column('updated_at', DateTime()),
+        Column('deleted', Boolean(), default=False))
+    return policies
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    tables = [define_policy_table(meta)]
+    create_tables(tables)
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    tables = [define_policy_table(meta)]
+    drop_tables(tables)

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/008_add_ip_ranges_table.py'
--- melange/db/sqlalchemy/migrate_repo/versions/008_add_ip_ranges_table.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/008_add_ip_ranges_table.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,55 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import ForeignKey
+from sqlalchemy.schema import MetaData
+
+from melange.db.sqlalchemy.migrate_repo.schema import Boolean
+from melange.db.sqlalchemy.migrate_repo.schema import create_tables
+from melange.db.sqlalchemy.migrate_repo.schema import DateTime
+from melange.db.sqlalchemy.migrate_repo.schema import drop_tables
+from melange.db.sqlalchemy.migrate_repo.schema import Integer
+from melange.db.sqlalchemy.migrate_repo.schema import String
+from melange.db.sqlalchemy.migrate_repo.schema import Table
+
+
+def define_ip_range_table(meta):
+    policy_table = Table('policies', meta, autoload=True)
+
+    ip_ranges = Table('ip_ranges', meta,
+        Column('id', String(36), primary_key=True, nullable=False),
+        Column('offset', Integer(), nullable=False),
+        Column('length', Integer(), nullable=False),
+        Column('policy_id', String(36), ForeignKey('policies.id')),
+        Column('created_at', DateTime(), nullable=True),
+        Column('updated_at', DateTime()),
+        Column('deleted', Boolean(), default=False))
+    return ip_ranges
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    tables = [define_ip_range_table(meta)]
+    create_tables(tables)
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    tables = [define_ip_range_table(meta)]
+    drop_tables(tables)

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/009_add_policy_id_to_ip_blocks.py'
--- melange/db/sqlalchemy/migrate_repo/versions/009_add_policy_id_to_ip_blocks.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/009_add_policy_id_to_ip_blocks.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,38 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import MetaData
+from sqlalchemy.schema import Table
+from sqlalchemy.schema import ForeignKeyConstraint
+
+from melange.db.sqlalchemy.migrate_repo.schema import String
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+
+    policy_table = Table('policies', meta, autoload=True)
+    ip_block_table = Table('ip_blocks', meta)
+    Column('policy_id', String(36), nullable=True).create(ip_block_table)
+    ForeignKeyConstraint([ip_block_table.c.policy_id], [policy_table.c.id])
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    Table('ip_blocks', meta, autoload=True).columns["policy_id"].drop()

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/010_add_ip_octets_table.py'
--- melange/db/sqlalchemy/migrate_repo/versions/010_add_ip_octets_table.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/010_add_ip_octets_table.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,54 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import ForeignKey
+from sqlalchemy.schema import MetaData
+
+from melange.db.sqlalchemy.migrate_repo.schema import Boolean
+from melange.db.sqlalchemy.migrate_repo.schema import create_tables
+from melange.db.sqlalchemy.migrate_repo.schema import DateTime
+from melange.db.sqlalchemy.migrate_repo.schema import drop_tables
+from melange.db.sqlalchemy.migrate_repo.schema import Integer
+from melange.db.sqlalchemy.migrate_repo.schema import String
+from melange.db.sqlalchemy.migrate_repo.schema import Table
+
+
+def define_ip_octets_table(meta):
+    policy_table = Table('policies', meta, autoload=True)
+
+    ip_octets = Table('ip_octets', meta,
+        Column('id', String(36), primary_key=True, nullable=False),
+        Column('octet', Integer(), nullable=False),
+        Column('policy_id', String(36), ForeignKey('policies.id')),
+        Column('created_at', DateTime(), nullable=True),
+        Column('updated_at', DateTime()),
+        Column('deleted', Boolean(), default=False))
+    return ip_octets
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    tables = [define_ip_octets_table(meta)]
+    create_tables(tables)
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    tables = [define_ip_octets_table(meta)]
+    drop_tables(tables)

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/011_add_tenant_id_to_ip_blocks.py'
--- melange/db/sqlalchemy/migrate_repo/versions/011_add_tenant_id_to_ip_blocks.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/011_add_tenant_id_to_ip_blocks.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,33 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import MetaData
+from sqlalchemy.schema import Table
+
+from melange.db.sqlalchemy.migrate_repo.schema import String
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    Column('tenant_id', String(255)).create(Table('ip_blocks', meta))
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    Table('ip_blocks', meta, autoload=True).columns["tenant_id"].drop()

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/012_add_tenant_id_to_policies.py'
--- melange/db/sqlalchemy/migrate_repo/versions/012_add_tenant_id_to_policies.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/012_add_tenant_id_to_policies.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,33 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import MetaData
+from sqlalchemy.schema import Table
+
+from melange.db.sqlalchemy.migrate_repo.schema import String
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    Column('tenant_id', String(255)).create(Table('policies', meta))
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    Table('policies', meta, autoload=True).columns["tenant_id"].drop()

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/013_add_parent_id_to_ip_blocks.py'
--- melange/db/sqlalchemy/migrate_repo/versions/013_add_parent_id_to_ip_blocks.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/013_add_parent_id_to_ip_blocks.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,36 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import ForeignKeyConstraint
+from sqlalchemy.schema import MetaData
+
+from melange.db.sqlalchemy.migrate_repo.schema import String
+from melange.db.sqlalchemy.migrate_repo.schema import Table
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    ip_blocks_table = Table('ip_blocks', meta, autoload=True)
+    Column('parent_id', String(36), nullable=True).create(ip_blocks_table)
+    ForeignKeyConstraint([ip_blocks_table.c.parent_id], [ip_blocks_table.c.id])
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    Table('ip_blocks', meta, autoload=True).columns["parent_id"].drop()

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/014_add_is_full_to_ip_blocks.py'
--- melange/db/sqlalchemy/migrate_repo/versions/014_add_is_full_to_ip_blocks.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/014_add_is_full_to_ip_blocks.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,35 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import MetaData
+from sqlalchemy.schema import Table
+
+from melange.db.sqlalchemy.migrate_repo.schema import Boolean
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+
+    ip_block_table = Table('ip_blocks', meta)
+    Column('is_full', Boolean()).create(ip_block_table)
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    Table('ip_blocks', meta, autoload=True).columns["is_full"].drop()

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/015_gateway_and_broadcast_addresses_to_ip_block.py'
--- melange/db/sqlalchemy/migrate_repo/versions/015_gateway_and_broadcast_addresses_to_ip_block.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/015_gateway_and_broadcast_addresses_to_ip_block.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,38 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import MetaData
+from sqlalchemy.schema import Table
+
+from melange.db.sqlalchemy.migrate_repo.schema import String
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+
+    ip_block_table = Table('ip_blocks', meta)
+    Column('broadcast_address', String(255)).create(ip_block_table)
+    Column('gateway_address', String(255)).create(ip_block_table)
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    ip_block_table = Table('ip_blocks', meta, autoload=True)
+    ip_block_table.columns["broadcast_address"].drop()
+    ip_block_table.columns["gateway_address"].drop()

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/016_add_deallocated_at_to_ip_addresses.py'
--- melange/db/sqlalchemy/migrate_repo/versions/016_add_deallocated_at_to_ip_addresses.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/016_add_deallocated_at_to_ip_addresses.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,34 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import MetaData
+from sqlalchemy.schema import Table
+
+from melange.db.sqlalchemy.migrate_repo.schema import DateTime
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    Column('deallocated_at', DateTime()).create(\
+                                Table('ip_addresses', meta))
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    Table('ip_addresses', meta, autoload=True).columns["deallocated_at"].drop()

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/017_remove_broadcast_address_and_rename_gateway_address.py'
--- melange/db/sqlalchemy/migrate_repo/versions/017_remove_broadcast_address_and_rename_gateway_address.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/017_remove_broadcast_address_and_rename_gateway_address.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,37 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import MetaData
+from sqlalchemy.schema import Table
+
+from melange.db.sqlalchemy.migrate_repo.schema import String
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    ip_block_table = Table('ip_blocks', meta, autoload=True)
+    ip_block_table.columns["broadcast_address"].drop()
+    ip_block_table.columns["gateway_address"].alter(name="gateway")
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    ip_block_table = Table('ip_blocks', meta, autoload=True)
+    Column('broadcast_address', String(255)).create(ip_block_table)
+    ip_block_table.columns["gateway"].alter(name="gateway_address")

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/018_add_dns_fields_to_ip_blocks.py'
--- melange/db/sqlalchemy/migrate_repo/versions/018_add_dns_fields_to_ip_blocks.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/018_add_dns_fields_to_ip_blocks.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,36 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+from sqlalchemy.schema import Column
+from sqlalchemy.schema import MetaData
+
+from melange.db.sqlalchemy.migrate_repo.schema import String
+from melange.db.sqlalchemy.migrate_repo.schema import Table
+
+
+def upgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    ip_blocks_table = Table('ip_blocks', meta, autoload=True)
+    Column('dns1', String(255), nullable=True).create(ip_blocks_table)
+    Column('dns2', String(255), nullable=True).create(ip_blocks_table)
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+    Table('ip_blocks', meta, autoload=True).columns["dns1"].drop()
+    Table('ip_blocks', meta, autoload=True).columns["dns2"].drop()

=== added file 'melange/db/sqlalchemy/migrate_repo/versions/__init__.py'
--- melange/db/sqlalchemy/migrate_repo/versions/__init__.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migrate_repo/versions/__init__.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,18 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+
+# template repository default versions module

=== added file 'melange/db/sqlalchemy/migration.py'
--- melange/db/sqlalchemy/migration.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/migration.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,124 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+import logging
+import os
+
+from migrate.versioning import api as versioning_api
+# See LP bug #719834. sqlalchemy-migrate changed location of
+# exceptions.py after 0.6.0.
+try:
+    from migrate.versioning import exceptions as versioning_exceptions
+except ImportError:
+    from migrate import exceptions as versioning_exceptions
+
+from melange.common import exception
+
+
+logger = logging.getLogger('melange.db.migration')
+
+
+def db_version(options):
+    """Return the database's current migration number
+
+    :param options: options dict
+    :retval version number
+    """
+    repo_path = get_migrate_repo_path()
+    sql_connection = options['sql_connection']
+    try:
+        return versioning_api.db_version(sql_connection, repo_path)
+    except versioning_exceptions.DatabaseNotControlledError, e:
+        msg = ("database '%(sql_connection)s' is not under migration control"
+               % locals())
+        raise exception.DatabaseMigrationError(msg)
+
+
+def upgrade(options, version=None):
+    """Upgrade the database's current migration level
+
+    :param options: options dict
+    :param version: version to upgrade (defaults to latest)
+    :retval version number
+    """
+    db_version(options)  # Ensure db is under migration control
+    repo_path = get_migrate_repo_path()
+    sql_connection = options['sql_connection']
+    version_str = version or 'latest'
+    logger.info("Upgrading %(sql_connection)s to version %(version_str)s" %
+                locals())
+    return versioning_api.upgrade(sql_connection, repo_path, version)
+
+
+def downgrade(options, version):
+    """Downgrade the database's current migration level
+
+    :param options: options dict
+    :param version: version to downgrade to
+    :retval version number
+    """
+    db_version(options)  # Ensure db is under migration control
+    repo_path = get_migrate_repo_path()
+    sql_connection = options['sql_connection']
+    logger.info("Downgrading %(sql_connection)s to version %(version)s" %
+                locals())
+    return versioning_api.downgrade(sql_connection, repo_path, version)
+
+
+def version_control(options):
+    """Place a database under migration control
+
+    :param options: options dict
+    """
+    sql_connection = options['sql_connection']
+    try:
+        _version_control(options)
+    except versioning_exceptions.DatabaseAlreadyControlledError, e:
+        msg = ("database '%(sql_connection)s' is already under migration "
+               "control" % locals())
+        raise exception.DatabaseMigrationError(msg)
+
+
+def _version_control(options):
+    """Place a database under migration control
+
+    :param options: options dict
+    """
+    repo_path = get_migrate_repo_path()
+    sql_connection = options['sql_connection']
+    return versioning_api.version_control(sql_connection, repo_path)
+
+
+def db_sync(options, version=None):
+    """Place a database under migration control and perform an upgrade
+
+    :param options: options dict
+    :retval version number
+    """
+    try:
+        _version_control(options)
+    except versioning_exceptions.DatabaseAlreadyControlledError, e:
+        pass
+
+    upgrade(options, version=version)
+
+
+def get_migrate_repo_path():
+    """Get the path for the migrate repository."""
+    path = os.path.join(os.path.abspath(os.path.dirname(__file__)),
+                        'migrate_repo')
+    assert os.path.exists(path)
+    return path

=== added file 'melange/db/sqlalchemy/session.py'
--- melange/db/sqlalchemy/session.py	1970-01-01 00:00:00 +0000
+++ melange/db/sqlalchemy/session.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,91 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+
+_ENGINE = None
+_MAKER = None
+
+import contextlib
+import logging
+from sqlalchemy import create_engine
+from sqlalchemy import MetaData
+from sqlalchemy.orm import sessionmaker
+
+from melange import ipam
+from melange.common import config
+from melange.db.sqlalchemy import mappers
+
+
+def configure_db(options):
+    configure_sqlalchemy_log(options)
+    global _ENGINE
+    if not _ENGINE:
+        _ENGINE = _create_engine(options)
+        mappers.map(_ENGINE, ipam.models.persisted_models())
+
+
+def configure_sqlalchemy_log(options):
+    debug = config.get_option(options,
+                              'debug', type='bool', default=False)
+    verbose = config.get_option(options,
+                                'verbose', type='bool', default=False)
+    logger = logging.getLogger('sqlalchemy.engine')
+    if debug:
+        logger.setLevel(logging.DEBUG)
+    elif verbose:
+        logger.setLevel(logging.INFO)
+
+
+def _create_engine(options):
+    timeout = config.get_option(options,
+                                'sql_idle_timeout', type='int', default=3600)
+    return create_engine(options['sql_connection'],
+                                pool_recycle=timeout)
+
+
+def get_session(autocommit=True, expire_on_commit=False):
+    """Helper method to grab session"""
+    global _MAKER, _ENGINE
+    if not _MAKER:
+        assert _ENGINE
+        _MAKER = sessionmaker(bind=_ENGINE,
+                              autocommit=autocommit,
+                              expire_on_commit=expire_on_commit)
+    return _MAKER()
+
+
+def raw_query(model, autocommit=True, expire_on_commit=False):
+    return get_session(autocommit, expire_on_commit).query(model)
+
+
+def clean_db():
+    global _ENGINE
+    meta = MetaData()
+    meta.reflect(bind=_ENGINE)
+    with contextlib.closing(_ENGINE.connect()) as con:
+        trans = con.begin()
+        for table in reversed(meta.sorted_tables):
+            if table.name != "migrate_version":
+                con.execute(table.delete())
+        trans.commit()
+
+
+def drop_db(options):
+    meta = MetaData()
+    engine = _create_engine(options)
+    meta.bind = engine
+    meta.reflect()
+    meta.drop_all()

=== added directory 'melange/extensions'
=== added file 'melange/extensions/__init__.py'
--- melange/extensions/__init__.py	1970-01-01 00:00:00 +0000
+++ melange/extensions/__init__.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,16 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.

=== added directory 'melange/ipam'
=== added file 'melange/ipam/__init__.py'
--- melange/ipam/__init__.py	1970-01-01 00:00:00 +0000
+++ melange/ipam/__init__.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,16 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.

=== added file 'melange/ipam/client.py'
--- melange/ipam/client.py	1970-01-01 00:00:00 +0000
+++ melange/ipam/client.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,178 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+import json
+
+from melange.common.utils import remove_nones
+
+
+class Resource(object):
+
+    def __init__(self, path, name, client, auth_client, tenant_id=None):
+        if tenant_id:
+            path = "tenants/{0}/{1}".format(tenant_id, path)
+        self.path = "/v0.1/ipam/" + path
+        self.name = name
+        self.client = client
+        self.auth_client = auth_client
+
+    def create(self, **kwargs):
+        return self.request("POST", self.path,
+                            body=json.dumps({self.name: kwargs}))
+
+    def update(self, id, **kwargs):
+        return self.request("PUT", self._member_path(id),
+                            body=json.dumps({self.name: remove_nones(kwargs)}))
+
+    def all(self):
+        return self.request("GET", self.path)
+
+    def find(self, id):
+        return self.request("GET", self._member_path(id))
+
+    def delete(self, id):
+        return self.request("DELETE", self._member_path(id))
+
+    def _member_path(self, id):
+        return "{0}/{1}".format(self.path, id)
+
+    def request(self, method, path, body_params=None, **kwargs):
+        kwargs['headers'] = {'X-AUTH-TOKEN': self.auth_client.get_token(),
+                             'Content-Type': "application/json"}
+        response = self.client.do_request(method, path, **kwargs)
+        return response.read()
+
+
+class IpBlockClient(object):
+
+    def __init__(self, client, auth_client, tenant_id=None):
+        self.resource = Resource("ip_blocks", "ip_block",
+                                client, auth_client, tenant_id)
+
+    def create(self, type, cidr, network_id=None, policy_id=None):
+        return self.resource.create(type=type, cidr=cidr,
+                                    network_id=network_id, policy_id=policy_id)
+
+    def list(self):
+        return self.resource.all()
+
+    def show(self, id):
+        return self.resource.find(id)
+
+    def update(self, id, network_id=None, policy_id=None):
+        return self.resource.update(id, network_id=network_id,
+                                 policy_id=policy_id)
+
+    def delete(self, id):
+        return self.resource.delete(id)
+
+
+class SubnetClient(object):
+
+    def __init__(self, client, auth_client, tenant_id=None):
+        self.tenant_id = tenant_id
+        self.client = client
+        self.auth_client = auth_client
+
+    def _resource(self, parent_id):
+        return Resource("ip_blocks/{0}/subnets".format(parent_id), "subnet",
+                        self.client, self.auth_client, self.tenant_id)
+
+    def create(self, parent_id, cidr, network_id=None):
+        return self._resource(parent_id).create(cidr=cidr,
+                                                network_id=network_id)
+
+    def list(self, parent_id):
+        return self._resource(parent_id).all()
+
+
+class PolicyClient(object):
+
+    def __init__(self, client, auth_client, tenant_id=None):
+        self.resource = Resource("policies", "policy", client,
+                                 auth_client, tenant_id)
+
+    def create(self, name, description=None):
+        return self.resource.create(name=name, description=description)
+
+    def update(self, id, name, description=None):
+        return self.resource.update(id, name=name, description=description)
+
+    def list(self):
+        return self.resource.all()
+
+    def show(self, id):
+        return self.resource.find(id)
+
+    def delete(self, id):
+        return self.resource.delete(id)
+
+
+class UnusableIpRangesClient(object):
+
+    def __init__(self, client, auth_client, tenant_id=None):
+        self.client = client
+        self.auth_client = auth_client
+        self.tenant_id = tenant_id
+
+    def _resource(self, policy_id):
+        return Resource("policies/{0}/unusable_ip_ranges".format(policy_id),
+                        "ip_range", self.client, self.auth_client,
+                        self.tenant_id)
+
+    def create(self, policy_id, offset, length):
+        return self._resource(policy_id).create(offset=offset, length=length)
+
+    def update(self, policy_id, id, offset=None, length=None):
+        return self._resource(policy_id).update(id, offset=offset,
+                                                length=length)
+
+    def list(self, policy_id):
+        return self._resource(policy_id).all()
+
+    def show(self, policy_id, id):
+        return self. _resource(policy_id).find(id)
+
+    def delete(self, policy_id, id):
+        return self._resource(policy_id).delete(id)
+
+
+class UnusableIpOctetsClient(object):
+
+    def __init__(self, client, auth_client, tenant_id=None):
+        self.client = client
+        self.auth_client = auth_client
+        self.tenant_id = tenant_id
+
+    def _resource(self, policy_id):
+        return Resource("policies/{0}/unusable_ip_octets".format(policy_id),
+                        "ip_octet", self.client, self.auth_client,
+                        self.tenant_id)
+
+    def create(self, policy_id, octet):
+        return self._resource(policy_id).create(octet=octet)
+
+    def update(self, policy_id, id, octet=None):
+        return self._resource(policy_id).update(id, octet=octet)
+
+    def list(self, policy_id):
+        return self._resource(policy_id).all()
+
+    def show(self, policy_id, id):
+        return self._resource(policy_id).find(id)
+
+    def delete(self, policy_id, id):
+        return self._resource(policy_id).delete(id)

=== added file 'melange/ipam/models.py'
--- melange/ipam/models.py	1970-01-01 00:00:00 +0000
+++ melange/ipam/models.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,820 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010-2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+
+"""
+SQLAlchemy models for Melange data
+"""
+
+import netaddr
+from datetime import timedelta
+from netaddr.strategy.ipv6 import ipv6_verbose
+from openstack.common.utils import bool_from_string
+
+from melange.common import utils
+from melange.common.config import Config
+from melange.common.exception import MelangeError
+from melange.common.utils import cached_property
+from melange.common.utils import exclude
+from melange.common.utils import find
+from melange.db import db_api
+
+
+class Query(object):
+
+    def __init__(self, model, **conditions):
+        self._model = model
+        self._conditions = conditions
+
+    def all(self):
+        return db_api.find_all_by(self._model, **self._conditions)
+
+    def __iter__(self):
+        return iter(self.all())
+
+    def update(self, **values):
+        db_api.update_all(self._model, self._conditions, values)
+
+    def delete(self):
+        db_api.delete_all(self._model, **self._conditions)
+
+    def limit(self, limit=200, marker=None, marker_column=None):
+        return db_api.find_all_by_limit(self._model, self._conditions,
+                                        limit=limit, marker=marker,
+                                        marker_column=marker_column)
+
+    def paginated_collection(self, limit=200, marker=None, marker_column=None):
+        collection = self.limit(int(limit) + 1, marker, marker_column)
+        if len(collection) > int(limit):
+            return (collection[0:-1], collection[-2]['id'])
+        return (collection, None)
+
+
+class Converter(object):
+    data_type_converters = {'integer': lambda x: int(x),
+                            'boolean': lambda value: bool_from_string(value)}
+
+    def __init__(self, data_type):
+        self.data_type = data_type
+
+    def convert(self, value):
+        return self.data_type_converters[self.data_type](value)
+
+
+class ModelBase(object):
+    _columns = {}
+    _auto_generated_attrs = ["id", "created_at", "updated_at"]
+    _data_fields = []
+
+    @classmethod
+    def create(cls, **values):
+        values['id'] = utils.guid()
+        values['created_at'] = utils.utcnow()
+        instance = cls(**values)
+        return instance.save()
+
+    def save(self):
+        if not self.is_valid():
+            raise InvalidModelError(self.errors)
+        self._convert_columns_to_proper_type()
+        self._before_save()
+        self['updated_at'] = utils.utcnow()
+        return db_api.save(self)
+
+    def delete(self):
+        db_api.delete(self)
+
+    def __init__(self, **kwargs):
+        self.merge_attributes(kwargs)
+
+    def _validate_columns_type(self):
+        for column_name, data_type in self._columns.iteritems():
+            try:
+                Converter(data_type).convert(self[column_name])
+            except (TypeError, ValueError):
+                self._add_error(column_name,
+                       _("%(column_name)s should be of type %(data_type)s")
+                         % locals())
+
+    def _validate(self):
+        pass
+
+    def _before_validate(self):
+        pass
+
+    def _before_save(self):
+        pass
+
+    def _convert_columns_to_proper_type(self):
+        for column_name, data_type in self._columns.iteritems():
+            self[column_name] = Converter(data_type).convert(self[column_name])
+
+    def is_valid(self):
+        self.errors = {}
+        self._validate_columns_type()
+        self._before_validate()
+        self._validate()
+        return self.errors == {}
+
+    def _validate_presence_of(self, attribute_name):
+        if (self[attribute_name] in [None, ""]):
+            self._add_error(attribute_name,
+                            _("%(attribute_name)s should be present")
+                              % locals())
+
+    def _validate_existence_of(self, attribute, model_class, **conditions):
+        model_id = self[attribute]
+        conditions['id'] = model_id
+        if model_id is not None and model_class.get_by(**conditions) is None:
+            conditions_str = ", ".join(["{0} = {1}".format(key, repr(value))
+                                     for key, value in conditions.iteritems()])
+            model_class_name = model_class.__name__
+            self._add_error(attribute,
+                            _("%(model_class_name)s with %(conditions_str)s"
+                              " doesn't exist") % locals())
+
+    @classmethod
+    def find(cls, id):
+        return cls.find_by(id=id)
+
+    @classmethod
+    def get(cls, id):
+        return cls.get_by(id=id)
+
+    @classmethod
+    def find_by(cls, **conditions):
+        model = cls.get_by(**conditions)
+        if model == None:
+            raise ModelNotFoundError(_("%s Not Found") % cls.__name__)
+        return model
+
+    @classmethod
+    def get_by(cls, **kwargs):
+        return db_api.find_by(cls, **cls._get_conditions(kwargs))
+
+    @classmethod
+    def _get_conditions(cls, raw_conditions):
+        return raw_conditions
+
+    @classmethod
+    def find_all(cls, **kwargs):
+        return Query(cls, **cls._get_conditions(kwargs))
+
+    def merge_attributes(self, values):
+        """dict.update() behaviour."""
+        for k, v in values.iteritems():
+            self[k] = v
+
+    def update(self, **values):
+        attrs = exclude(values, *self._auto_generated_attrs)
+        self.merge_attributes(attrs)
+        return self.save()
+
+    def __setitem__(self, key, value):
+        setattr(self, key, value)
+
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+    def __iter__(self):
+        self._i = iter(db_api.columns_of(self))
+        return self
+
+    def __eq__(self, other):
+        if not hasattr(other, 'id'):
+            return False
+        return type(other) == type(self) and other.id == self.id
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __hash__(self):
+        return id.__hash__()
+
+    def next(self):
+        n = self._i.next().name
+        return n, getattr(self, n)
+
+    def keys(self):
+        return self.__dict__.keys()
+
+    def values(self):
+        return self.__dict__.values()
+
+    def items(self):
+        return self.__dict__.items()
+
+    def to_dict(self):
+        return self.__dict__()
+
+    def data(self, **options):
+        data_fields = self._data_fields + self._auto_generated_attrs
+        return dict([(field, self[field])
+                    for field in data_fields])
+
+    def _validate_positive_integer(self, attribute_name):
+        if(utils.parse_int(self[attribute_name]) < 0):
+            self._add_error(attribute_name,
+                            _("%s should be a positive integer")
+                              % attribute_name)
+
+    def _add_error(self, attribute_name, error_message):
+        self.errors[attribute_name] = self.errors.get(attribute_name, [])
+        self.errors[attribute_name].append(error_message)
+
+    def _has_error_on(self, attribute):
+        return self.errors.get(attribute, None) is not None
+
+
+def ipv6_address_generator_factory(cidr, **kwargs):
+    default_generator = "melange.ipv6.tenant_based_generator."\
+                        "TenantBasedIpV6Generator"
+    ip_generator_class_name = Config.get("ipv6_generator", default_generator)
+    ip_generator = utils.import_class(ip_generator_class_name)
+    required_params = ip_generator.required_params\
+        if hasattr(ip_generator, "required_params") else []
+    missing_params = set(required_params) - set(kwargs.keys())
+    if missing_params:
+        raise DataMissingError(_("Required params are missing: %s")
+                                 % (', '.join(missing_params)))
+    return ip_generator(cidr, **kwargs)
+
+
+class IpAddressIterator(object):
+
+    def __init__(self, generator):
+        self.generator = generator
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        return self.generator.next_ip()
+
+
+class IpBlock(ModelBase):
+
+    _allowed_types = ["private", "public"]
+    _data_fields = ['cidr', 'network_id', 'policy_id', 'tenant_id', 'gateway',
+                    'parent_id', 'type', 'dns1', 'dns2',
+                    'broadcast', 'netmask']
+
+    @classmethod
+    def find_or_allocate_ip(cls, ip_block_id, address):
+        block = IpBlock.find(ip_block_id)
+        allocated_ip = IpAddress.get_by(ip_block_id=block.id, address=address)
+
+        if allocated_ip and allocated_ip.locked():
+            raise AddressLockedError()
+
+        return (allocated_ip or block.allocate_ip(address=address))
+
+    @classmethod
+    def find_all_by_policy(cls, policy_id):
+        return cls.find_all(policy_id=policy_id)
+
+    @classmethod
+    def allowed_by_policy(cls, ip_block, policy, address):
+        return policy == None or policy.allows(ip_block.cidr, address)
+
+    @classmethod
+    def delete_all_deallocated_ips(cls):
+        for block in db_api.find_all_blocks_with_deallocated_ips():
+            block.update(is_full=False)
+            block.delete_deallocated_ips()
+
+    @property
+    def broadcast(self):
+        return str(netaddr.IPNetwork(self.cidr).broadcast)
+
+    @property
+    def netmask(self):
+        return str(netaddr.IPNetwork(self.cidr).netmask)
+
+    def is_ipv6(self):
+        return netaddr.IPNetwork(self.cidr).version == 6
+
+    def subnets(self):
+        return IpBlock.find_all(parent_id=self.id).all()
+
+    def siblings(self):
+        if not self.parent:
+            return []
+        return filter(lambda block: block != self, self.parent.subnets())
+
+    def delete(self):
+        for block in self.subnets():
+            block.delete()
+        IpAddress.find_all(ip_block_id=self.id).delete()
+        super(IpBlock, self).delete()
+
+    def policy(self):
+        return Policy.get(self.policy_id)
+
+    def get_address(self, address):
+        return IpAddress.get_by(ip_block_id=self.id, address=address)
+
+    def addresses(self):
+        return IpAddress.find_all(ip_block_id=self.id).all()
+
+    @cached_property
+    def parent(self):
+        return IpBlock.get(self.parent_id)
+
+    def allocate_ip(self, interface_id=None, address=None, **kwargs):
+        tenant_id = kwargs.get('tenant_id', None)
+        if self.tenant_id and tenant_id and self.tenant_id != tenant_id:
+            raise InvalidTenantError(_("Cannot allocate ip address "
+                                            "from differnt tenant's block"))
+        if self.subnets():
+            raise IpAllocationNotAllowedError(
+                _("Non Leaf block can not allocate IPAddress"))
+        if self.is_full:
+            raise NoMoreAddressesError(_("IpBlock is full"))
+
+        if address is None:
+            address = self._generate_ip_address(**kwargs)
+        else:
+            self._validate_address(address)
+
+        if not address:
+            self.update(is_full=True)
+            raise NoMoreAddressesError(_("IpBlock is full"))
+
+        return IpAddress.create(address=address, interface_id=interface_id,
+                                ip_block_id=self.id)
+
+    def _generate_ip_address(self, **kwargs):
+        if(self.is_ipv6()):
+            address_generator = ipv6_address_generator_factory(self.cidr,
+                                                               **kwargs)
+
+            return find(lambda address: self.get_address(address) is None,
+                                IpAddressIterator(address_generator))
+        else:
+            #TODO: very inefficient way to generate ips,
+            #will look at better algos for this
+            allocated_addresses = [ip.address for ip in self.addresses()]
+            unavailable_addresses = allocated_addresses + [self.gateway,
+                                                           self.broadcast]
+            policy = self.policy()
+            for ip in netaddr.IPNetwork(self.cidr):
+                if (IpBlock.allowed_by_policy(self, policy, str(ip))
+                    and (str(ip) not in unavailable_addresses)):
+                    return str(ip)
+            return None
+
+    def _validate_address(self, address):
+
+        if (address in [self.broadcast, self.gateway]
+            or (self.get_address(address) is not None)):
+            raise DuplicateAddressError()
+
+        if not self.contains(address):
+            raise AddressDoesNotBelongError(
+                _("Address does not belong to IpBlock"))
+
+        policy = self.policy()
+        if not IpBlock.allowed_by_policy(self, policy, address):
+            raise AddressDisallowedByPolicyError(
+                _("Block policy does not allow this address"))
+
+    def contains(self, address):
+        return netaddr.IPAddress(address) in netaddr.IPNetwork(self.cidr)
+
+    def _overlaps(self, other_block):
+        network = netaddr.IPNetwork(self.cidr)
+        other_network = netaddr.IPNetwork(other_block.cidr)
+        return network in other_network or other_network in network
+
+    def find_allocated_ip(self, address):
+        ip_address = IpAddress.find_by(ip_block_id=self.id, address=address)
+        if ip_address == None:
+            raise ModelNotFoundError(_("IpAddress Not Found"))
+        return ip_address
+
+    def deallocate_ip(self, address):
+        ip_address = IpAddress.find_by(ip_block_id=self.id, address=address)
+        if ip_address != None:
+            ip_address.deallocate()
+
+    def delete_deallocated_ips(self):
+        db_api.delete_deallocated_ips(
+            deallocated_by=self._deallocated_by_date(), ip_block_id=self.id)
+
+    def _deallocated_by_date(self):
+        days_to_keep_ips = Config.get('keep_deallocated_ips_for_days', 2)
+        return utils.utcnow() - timedelta(days=days_to_keep_ips)
+
+    def subnet(self, cidr, network_id=None, tenant_id=None):
+        network_id = network_id or self.network_id
+        tenant_id = tenant_id or self.tenant_id
+        return IpBlock.create(cidr=cidr, network_id=network_id,
+                              parent_id=self.id, type=self.type,
+                              tenant_id=tenant_id)
+
+    def _validate_cidr_format(self):
+        if not self._has_valid_cidr():
+            self._add_error('cidr', _("cidr is invalid"))
+
+    def _has_valid_cidr(self):
+        try:
+            netaddr.IPNetwork(self.cidr)
+            return True
+        except Exception:
+            return False
+
+    def _validate_cidr_is_within_parent_block_cidr(self):
+        parent = self.parent
+        if (parent and netaddr.IPNetwork(self.cidr) not in
+            netaddr.IPNetwork(parent.cidr)):
+            self._add_error('cidr',
+                            _("cidr should be within parent block's cidr"))
+
+    def _validate_type(self):
+        if not (self.type in self._allowed_types):
+            self._add_error('type', _("type should be one among %s") %
+                            ", ".join(self._allowed_types))
+
+    def _validate_cidr(self):
+        self._validate_cidr_format()
+        if not self._has_valid_cidr():
+            return
+        self._validate_cidr_doesnt_overlap_for_root_public_ip_blocks()
+        self._validate_cidr_is_within_parent_block_cidr()
+        self._validate_cidr_does_not_overlap_with_siblings()
+        if self._is_top_level_block_in_network():
+            self._validate_cidr_doesnt_overlap_with_networked_toplevel_blocks()
+
+    def _validate_cidr_doesnt_overlap_for_root_public_ip_blocks(self):
+        if self.type != 'public':
+            return
+        for block in IpBlock.find_all(type='public', parent_id=None):
+            if  self != block and self._overlaps(block):
+                msg = _("cidr overlaps with public block %s") % block.cidr
+                self._add_error('cidr', msg)
+                break
+
+    def _validate_cidr_does_not_overlap_with_siblings(self):
+        for sibling in self.siblings():
+            if self._overlaps(sibling):
+                msg = _("cidr overlaps with sibling %s") % sibling.cidr
+                self._add_error('cidr', msg)
+                break
+
+    def networked_top_level_blocks(self):
+        if not self.network_id:
+            return []
+        blocks = db_api.find_all_top_level_blocks_in_network(self.network_id)
+        return filter(lambda block: block != self and block != self.parent,
+                      blocks)
+
+    def _is_top_level_block_in_network(self):
+        return not self.parent or self.network_id != self.parent.network_id
+
+    def _validate_cidr_doesnt_overlap_with_networked_toplevel_blocks(self):
+        for block in self.networked_top_level_blocks():
+            if self._overlaps(block):
+                self._add_error('cidr', _("cidr overlaps with block %s"
+                                          " in same network") % block.cidr)
+                break
+
+    def _validate_belongs_to_supernet_network(self):
+        if(self.parent and self.parent.network_id and
+           self.parent.network_id != self.network_id):
+            self._add_error('network_id',
+                            _("network_id should be same as that of parent"))
+
+    def _validate_belongs_to_supernet_tenant(self):
+        if(self.parent and self.parent.tenant_id and
+           self.parent.tenant_id != self.tenant_id):
+            self._add_error('tenant_id',
+                            _("tenant_id should be same as that of parent"))
+
+    def _validate_parent_is_subnettable(self):
+        if (self.parent and self.parent.addresses()):
+            msg = _("parent is not subnettable since it has allocated ips")
+            self._add_error('parent_id', msg)
+
+    def _validate_type_is_same_within_network(self):
+        block = IpBlock.get_by(network_id=self.network_id)
+        if(block and block.type != self.type):
+            self._add_error('type', _("type should be same within a network"))
+
+    def _validate(self):
+        self._validate_type()
+        self._validate_cidr()
+        self._validate_existence_of('parent_id', IpBlock, type=self.type)
+        self._validate_belongs_to_supernet_network()
+        self._validate_belongs_to_supernet_tenant()
+        self._validate_parent_is_subnettable()
+        self._validate_existence_of('policy_id', Policy)
+        self._validate_type_is_same_within_network()
+
+    def _convert_cidr_to_lowest_address(self):
+        if self._has_valid_cidr():
+            self.cidr = str(netaddr.IPNetwork(self.cidr).cidr)
+
+    def _before_validate(self):
+        self._convert_cidr_to_lowest_address()
+
+    def _before_save(self):
+        self.gateway = self.gateway or str(netaddr.IPNetwork(self.cidr)[1])
+        self.dns1 = self.dns1 or Config.get("dns1")
+        self.dns2 = self.dns2 or Config.get("dns2")
+
+
+class IpAddress(ModelBase):
+
+    _data_fields = ['ip_block_id', 'address', 'interface_id', 'version']
+
+    @classmethod
+    def _get_conditions(cls, raw_conditions):
+        conditions = raw_conditions.copy()
+        if 'address' in conditions:
+            conditions['address'] = cls._formatted(conditions['address'])
+        return conditions
+
+    @classmethod
+    def _formatted(cls, address):
+        return netaddr.IPAddress(address).format(dialect=ipv6_verbose)
+
+    @classmethod
+    def find_all_by_network(cls, network_id, **conditions):
+        return db_api.find_all_ips_in_network(network_id, **conditions)
+
+    def _before_save(self):
+        self.address = self._formatted(self.address)
+
+    def ip_block(self):
+        return IpBlock.get(self.ip_block_id)
+
+    def add_inside_locals(self, ip_addresses):
+        db_api.save_nat_relationships([
+            {'inside_global_address_id': self.id,
+             'inside_local_address_id': local_address.id}
+            for local_address in ip_addresses])
+
+    def deallocate(self):
+        return self.update(marked_for_deallocation=True,
+                           deallocated_at=utils.utcnow())
+
+    def restore(self):
+        self.update(marked_for_deallocation=False, deallocated_at=None)
+
+    def inside_globals(self, **kwargs):
+        return db_api.find_inside_globals_for(self.id, **kwargs)
+
+    def add_inside_globals(self, ip_addresses):
+        return db_api.save_nat_relationships([
+            {'inside_global_address_id': global_address.id,
+             'inside_local_address_id': self.id}
+            for global_address in ip_addresses])
+
+    def inside_locals(self, **kwargs):
+        return db_api.find_inside_locals_for(self.id, **kwargs)
+
+    def remove_inside_globals(self, inside_global_address=None):
+        return db_api.remove_inside_globals(self.id, inside_global_address)
+
+    def remove_inside_locals(self, inside_local_address=None):
+        return db_api.remove_inside_locals(self.id, inside_local_address)
+
+    def locked(self):
+        return self.marked_for_deallocation
+
+    @property
+    def version(self):
+        return netaddr.IPAddress(self.address).version
+
+    def data(self, **options):
+        data = super(IpAddress, self).data(**options)
+        if options.get('with_ip_block', False):
+            data['ip_block'] = self.ip_block().data()
+        return data
+
+    def __str__(self):
+        return self.address
+
+
+class Policy(ModelBase):
+
+    _data_fields = ['name', 'description', 'tenant_id']
+
+    def _validate(self):
+        self._validate_presence_of('name')
+
+    def delete(self):
+        IpRange.find_all(policy_id=self.id).delete()
+        IpOctet.find_all(policy_id=self.id).delete()
+        IpBlock.find_all(policy_id=self.id).update(policy_id=None)
+        super(Policy, self).delete()
+
+    def create_unusable_range(self, **attributes):
+        attributes['policy_id'] = self.id
+        return IpRange.create(**attributes)
+
+    def create_unusable_ip_octet(self, **attributes):
+        attributes['policy_id'] = self.id
+        return IpOctet.create(**attributes)
+
+    @cached_property
+    def unusable_ip_ranges(self):
+        return IpRange.find_all(policy_id=self.id).all()
+
+    @cached_property
+    def unusable_ip_octets(self):
+        return IpOctet.find_all(policy_id=self.id).all()
+
+    def allows(self, cidr, address):
+        if (any(ip_octet.applies_to(address)
+                       for ip_octet in self.unusable_ip_octets)):
+            return False
+        return not any(ip_range.contains(cidr, address)
+                       for ip_range in self.unusable_ip_ranges)
+
+    def find_ip_range(self, ip_range_id):
+        return IpRange.find_by(id=ip_range_id, policy_id=self.id)
+
+    def find_ip_octet(self, ip_octet_id):
+        return IpOctet.find_by(id=ip_octet_id, policy_id=self.id)
+
+
+class IpRange(ModelBase):
+
+    _columns = {'offset': 'integer', 'length': 'integer'}
+    _data_fields = ['offset', 'length', 'policy_id']
+
+    def contains(self, cidr, address):
+        end_index = self.offset + self.length
+        end_index_overshoots_length_for_negative_offset = (self.offset < 0
+                                                           and end_index >= 0)
+        if end_index_overshoots_length_for_negative_offset:
+            end_index = None
+        return (netaddr.IPAddress(address) in
+                netaddr.IPNetwork(cidr)[self.offset:end_index])
+
+    def _validate(self):
+        self._validate_positive_integer('length')
+
+
+class IpOctet(ModelBase):
+
+    _columns = {'octet': 'integer'}
+    _data_fields = ['octet', 'policy_id']
+
+    @classmethod
+    def find_all_by_policy(cls, policy_id):
+        return cls.find_all(policy_id=policy_id)
+
+    def applies_to(self, address):
+        return self.octet == netaddr.IPAddress(address).words[-1]
+
+
+class Network(ModelBase):
+
+    @classmethod
+    def find_by(cls, id, tenant_id=None):
+        ip_blocks = IpBlock.find_all(network_id=id, tenant_id=tenant_id).all()
+        if(len(ip_blocks) == 0):
+            raise ModelNotFoundError(_("Network %s not found") % id)
+        return cls(id=id, ip_blocks=ip_blocks)
+
+    @classmethod
+    def find_or_create_by(cls, id, tenant_id=None):
+        try:
+            return cls.find_by(id=id, tenant_id=tenant_id)
+        except ModelNotFoundError:
+            ip_block = IpBlock.create(cidr=Config.get('default_cidr'),
+                                      network_id=id, tenant_id=tenant_id,
+                                      type="private")
+            return cls(id=id, ip_blocks=[ip_block])
+
+    def allocate_ips(self, addresses=None, **kwargs):
+        if addresses:
+            return filter(None, [self._allocate_specific_ip(address, **kwargs)
+                    for address in addresses])
+
+        ips = [self._allocate_first_free_ip(blocks, **kwargs)
+               for blocks in self._block_partitions()]
+
+        if not any(ips):
+            raise NoMoreAddressesError(_("ip blocks in this network are full"))
+
+        return filter(None, ips)
+
+    def deallocate_ips(self, interface_id):
+        ips = IpAddress.find_all_by_network(self.id, interface_id=interface_id)
+        for ip in ips:
+            ip.deallocate()
+
+    def _block_partitions(self):
+        return [[block for block in self.ip_blocks
+                 if not block.is_ipv6()],
+                [block for block in self.ip_blocks
+                 if block.is_ipv6()]]
+
+    def _allocate_specific_ip(self, address, **kwargs):
+        ip_block = utils.find(lambda ip_block: ip_block.contains(address),
+                              self.ip_blocks)
+        if(ip_block is not None):
+            try:
+                return ip_block.allocate_ip(address=address, **kwargs)
+            except DuplicateAddressError:
+                pass
+
+    def _allocate_first_free_ip(self, ip_blocks, **kwargs):
+        for ip_block in ip_blocks:
+            try:
+                return ip_block.allocate_ip(**kwargs)
+            except NoMoreAddressesError:
+                pass
+
+
+def persisted_models():
+    return {'IpBlock': IpBlock, 'IpAddress': IpAddress, 'Policy': Policy,
+            'IpRange': IpRange, 'IpOctet': IpOctet}
+
+
+class NoMoreAddressesError(MelangeError):
+
+    def _error_message(self):
+        return _("no more addresses")
+
+
+class DuplicateAddressError(MelangeError):
+
+    def _error_message(self):
+        return _("Address is already allocated")
+
+
+class AddressDoesNotBelongError(MelangeError):
+
+    def _error_message(self):
+        return _("Address does not belong here")
+
+
+class AddressLockedError(MelangeError):
+
+    def _error_message(self):
+        return _("Address is locked")
+
+
+class ModelNotFoundError(MelangeError):
+
+    def _error_message(self):
+        return _("Not Found")
+
+
+class DataMissingError(MelangeError):
+
+    def _error_message(self):
+        return _("Data Missing")
+
+
+class AddressDisallowedByPolicyError(MelangeError):
+
+    def _error_message(self):
+        return _("Policy does not allow this address")
+
+
+class IpAllocationNotAllowedError(MelangeError):
+
+    def _error_message(self):
+        return _("Ip Block can not allocate address")
+
+
+class InvalidTenantError(MelangeError):
+
+    def _error_message(self):
+        return _("Cannot access other tenant's block")
+
+
+class InvalidModelError(MelangeError):
+
+    def __init__(self, errors, message=None):
+        self.errors = errors
+        super(InvalidModelError, self).__init__(message)
+
+    def __str__(self):
+        return _("The following values are invalid: %s") % str(self.errors)
+
+    def _error_message(self):
+        return str(self)
+
+
+def sort(iterable):
+    return sorted(iterable, key=lambda model: model.id)

=== added file 'melange/ipam/service.py'
--- melange/ipam/service.py	1970-01-01 00:00:00 +0000
+++ melange/ipam/service.py	2011-08-25 11:33:54 +0000
@@ -0,0 +1,426 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    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.
+import json
+import routes
+from webob.exc import HTTPBadRequest
+from webob.exc import HTTPConflict
+from webob.exc import HTTPNotFound
+from webob.exc import HTTPUnprocessableEntity
+
+from melange.common import wsgi
+from melange.common.auth import RoleBasedAuth
+from melange.common.config import Config
+from melange.common.pagination import PaginatedDataView
+from melange.common.pagination import PaginatedResult
+from melange.common.utils import exclude
+from melange.common.utils import filter_dict
+from melange.common.utils import stringify_keys
+from melange.common.wsgi import Result
+from melange.ipam import models
+from melange.ipam.models import IpAddress
+from melange.ipam.models import IpBlock
+from melange.ipam.models import IpOctet
+from melange.ipam.models import IpRange
+from melange.ipam.models import Network
+from melange.ipam.models import Policy
+
+
+class BaseController(wsgi.Controller):
+    exclude_attr = []
+    exception_map = {HTTPUnprocessableEntity:
+                     [models.NoMoreAddressesError,
+                      models.AddressDoesNotBelongError,
+                      models.AddressLockedError],
+                     HTTPBadRequest: [models.InvalidModelError,
+                                      models.DataMissingError],
+                     HTTPNotFound: [models.ModelNotFoundError],
+                     HTTPConflict: [models.DuplicateAddressError]}
+
+    def _extract_required_params(self, request, model_name):
+        model_params = request.deserialized_params.get(model_name, {})
+        return stringify_keys(exclude(model_params, *self.exclude_attr))
+
+    def _extract_limits(self, params):
+        return dict([(key, params[key]) for key in params.keys()
+                     if key in ["limit", "marker"]])
+
+    def _parse_ips(self, addresses):
+        return [IpBlock.find_or_allocate_ip(address["ip_block_id"],
+                                                 address["ip_address"])
+                     for address in json.loads(addresses)]
+
+    def _get_addresses(self, ips):
+        return dict(ip_addresses=[ip_address.data() for ip_address in ips])
+
+    def _paginated_response(self, collection_type, collection_query, request):
+        elements, next_marker = collection_query.paginated_collection(
+            **self._extract_limits(request.params))
+        collection = [element.data() for element in elements]
+
+        return PaginatedResult(PaginatedDataView(collection_type, collection,
+                                                 request.url, next_marker))
+
+
+class IpBlockController(BaseController):
+
+    exclude_attr = ['tenant_id', 'parent_id']
+
+    def _find_block(self, **kwargs):
+        return IpBlock.find_by(**kwargs)
+
+    def index(self, request, tenant_id=None):
+        type_dict = filter_dict(request.params, 'type')
+        all_blocks = IpBlock.find_all(tenant_id=tenant_id, **type_dict)
+        return self._paginated_response('ip_blocks', all_blocks, request)
+
+    def create(self, request, tenant_id=None):
+        params = self._extract_required_params(request, 'ip_block')
+        block = IpBlock.create(tenant_id=tenant_id, **params)
+        return Result(dict(ip_block=block.data()), 201)
+
+    def update(self, request, id, tenant_id=None):
+        ip_block = self._find_block(id=id, tenant_id=tenant_id)
+        params = self._extract_required_params(request, 'ip_block')
+        ip_block.update(**exclude(params, 'cidr', 'type'))
+        return Result(dict(ip_block=ip_block.data()), 200)
+
+    def show(self, request, id, tenant_id=None):
+        ip_block = self._find_block(id=id, tenant_id=tenant_id)
+        return dict(ip_block=ip_block.data())
+
+    def delete(self, request, id, tenant_id=None):
+        self._find_block(id=id, tenant_id=tenant_id).delete()
+
+
+class SubnetController(BaseController):
+
+    def _find_block(self, id, tenant_id):
+        return IpBlock.find_by(id=id, tenant_id=tenant_id)
+
+    def index(self, request, ip_block_id, tenant_id=None):
+        ip_block = self._find_block(id=ip_block_id, tenant_id=tenant_id)
+        return dict(subnets=[subnet.data() for subnet in ip_block.subnets()])
+
+    def create(self, request, ip_block_id, tenant_id=None):
+        ip_block = self._find_block(id=ip_block_id, tenant_id=tenant_id)
+        params = self._extract_required_params(request, 'subnet')
+        subnet = ip_block.subnet(**filter_dict(params, 'cidr', 'network_id',
+                                               'tenant_id'))
+        return Result(dict(subnet=subnet.data()), 201)
+
+
+class IpAddressController(BaseController):
+
+    def _find_block(self, id, tenant_id):
+        return IpBlock.find_by(id=id, tenant_id=tenant_id)
+
+    def index(self, request, ip_block_id, tenant_id=None):
+        ip_block = self._find_block(id=ip_block_id, tenant_id=tenant_id)
+        addresses = IpAddress.find_all(ip_block_id=ip_block.id)
+        return self._paginated_response('ip_addresses', addresses, request)
+
+    def show(self, request, address, ip_block_id, tenant_id=None):
+        ip_block = self._find_block(id=ip_block_id, tenant_id=tenant_id)
+        return dict(ip_address=ip_block.find_allocated_ip(address).data())
+
+    def delete(self, request, address, ip_block_id, tenant_id=None):
+        self._find_block(id=ip_block_id,
+                        tenant_id=tenant_id).deallocate_ip(address)
+
+    def create(self, request, ip_block_id, tenant_id=None):
+        ip_block = self._find_block(id=ip_block_id, tenant_id=tenant_id)
+        params = self._extract_required_params(request, 'ip_address')
+        params['tenant_id'] = tenant_id or params.get('tenant_id', None)
+        ip_address = ip_block.allocate_ip(**params)
+        return Result(dict(ip_address=ip_address.data()), 201)
+
+    def restore(self, request, ip_block_id, address, tenant_id=None):
+        ip_address = self._find_block(id=ip_block_id, tenant_id=tenant_id).\
+                             find_allocated_ip(address)
+        ip_address.restore()
+
+
+class InsideGlobalsController(BaseController):
+
+    def create(self, request, ip_block_id, address):
+        local_ip = IpBlock.find_or_allocate_ip(ip_block_id, address)
+        global_ips = self._parse_ips(request.params["ip_addresses"])
+        local_ip.add_inside_globals(global_ips)
+
+    def index(self, request, ip_block_id, address):
+        ip = IpBlock.find(ip_block_id).find_allocated_ip(address)
+        return self._get_addresses(ip.inside_globals(
+                                      **self._extract_limits(request.params)))
+
+    def delete(self, request, ip_block_id, address,
+               inside_globals_address=None):
+        local_ip = IpBlock.find(ip_block_id).find_allocated_ip(address)
+        local_ip.remove_inside_globals(inside_globals_address)
+
+
+class InsideLocalsController(BaseController):
+
+    def create(self, request, ip_block_id, address):
+        global_ip = IpBlock.find_or_allocate_ip(ip_block_id, address)
+        local_ips = self._parse_ips(request.params["ip_addresses"])
+        global_ip.add_inside_locals(local_ips)
+
+    def index(self, request, ip_block_id, address):
+        ip = IpBlock.find(ip_block_id).find_allocated_ip(address)
+        return self._get_addresses(ip.inside_locals(
+                                    **self._extract_limits(request.params)))
+
+    def delete(self, request, ip_block_id, address,
+               inside_locals_address=None):
+        global_ip = IpBlock.find(ip_block_id).find_allocated_ip(address)
+        global_ip.remove_inside_locals(inside_locals_address)
+
+
+class UnusableIpRangesController(BaseController):
+
+    def create(self, request, policy_id, tenant_id=None):
+        policy = Policy.find_by(id=policy_id, tenant_id=tenant_id)
+        params = self._extract_required_params(request, 'ip_range')
+        ip_range = policy.create_unusable_range(**params)
+        return Result(dict(ip_range=ip_range.data()), 201)
+
+    def show(self, request, policy_id, id, tenant_id=None):
+        ip_range = Policy.find_by(id=policy_id,
+                                  tenant_id=tenant_id).find_ip_range(id)
+        return dict(ip_range=ip_range.data())
+
+    def index(self, request, policy_id, tenant_id=None):
+        policy = Policy.find_by(id=policy_id,
+                                      tenant_id=tenant_id)
+        ip_ranges = IpRange.find_all(policy_id=policy.id)
+        return self._paginated_response('ip_ranges', ip_ranges, request)
+
+    def update(self, request, policy_id, id, tenant_id=None):
+        ip_range = Policy.find_by(id=policy_id,
+                                  tenant_id=tenant_id).find_ip_range(id)
+        params = self._extract_required_params(request, 'ip_range')
+        ip_range.update(**exclude(params, 'policy_id'))
+        return dict(ip_range=ip_range.data())
+
+    def delete(self, request, policy_id, id, tenant_id=None):
+        ip_range = Policy.find_by(id=policy_id,
+                                  tenant_id=tenant_id).find_ip_range(id)
+        ip_range.delete()
+