From 39dae5cc1f8e960f63da8711b453f90071f450ca Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Wed, 2 Feb 2011 10:49:02 -0600
Subject: [PATCH 01/77] Casting to the scheduler

---
 nova/rpc.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/rpc.py b/nova/rpc.py
index 01fc6d44..c4c938f4 100644
--- a/nova/rpc.py
+++ b/nova/rpc.py
@@ -119,7 +119,7 @@ class Consumer(messaging.Consumer):
                 LOG.error(_("Reconnected to queue"))
                 self.failed_connection = False
         # NOTE(vish): This is catching all errors because we really don't
-        #             exceptions to be logged 10 times a second if some
+        #             want exceptions to be logged 10 times a second if some
         #             persistent failure occurs.
         except Exception:  # pylint: disable-msg=W0703
             if not self.failed_connection:

From 873ebc36b127c922b294c885ecba5c678b8dc629 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Tue, 15 Feb 2011 11:15:59 -0800
Subject: [PATCH 03/77] zone/info works

---
 bin/nova-combined | 4 ++--
 nova/flags.py     | 5 +++++
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/bin/nova-combined b/bin/nova-combined
index 913c866b..a0f552d6 100755
--- a/bin/nova-combined
+++ b/bin/nova-combined
@@ -53,11 +53,11 @@ if __name__ == '__main__':
 
     compute = service.Service.create(binary='nova-compute')
     network = service.Service.create(binary='nova-network')
-    volume = service.Service.create(binary='nova-volume')
+    #volume = service.Service.create(binary='nova-volume')
     scheduler = service.Service.create(binary='nova-scheduler')
     #objectstore = service.Service.create(binary='nova-objectstore')
 
-    service.serve(compute, network, volume, scheduler)
+    service.serve(compute, network, scheduler)
 
     apps = []
     paste_config_file = wsgi.paste_config_file('nova-api.conf')
diff --git a/nova/flags.py b/nova/flags.py
index 3ba3fe6f..0a45499f 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -312,3 +312,8 @@ DEFINE_string('host', socket.gethostname(),
 
 DEFINE_string('node_availability_zone', 'nova',
               'availability zone of this node')
+
+DEFINE_string('zone_name', 'nova', 'name of this zone')
+DEFINE_string('zone_capabilities', 'xen, linux', 
+              'comma-delimited list of tags which represent boolean'
+              ' capabilities of this zone')

From 05bfa83249b603fbb8896916adb2bc474fd33d42 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Feb 2011 11:05:03 -0800
Subject: [PATCH 04/77] novatools call to child zones done

---
 nova/scheduler/zone_manager.py | 126 +++++++++++++++++++++++++++++++++
 1 file changed, 126 insertions(+)
 create mode 100644 nova/scheduler/zone_manager.py

diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
new file mode 100644
index 00000000..dd910eb0
--- /dev/null
+++ b/nova/scheduler/zone_manager.py
@@ -0,0 +1,126 @@
+# Copyright (c) 2010 Openstack, LLC.
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+
+"""
+ZoneManager oversees all communications with child Zones.
+"""
+
+import novatools
+import thread
+
+from datetime import datetime
+from eventlet.greenpool import GreenPool
+
+from nova import db
+from nova import flags
+from nova import log as logging
+
+FLAGS = flags.FLAGS
+flags.DEFINE_integer('zone_db_check_interval', 60,
+                    'Seconds between getting fresh zone info from db.')
+flags.DEFINE_integer('zone_failures_to_offline', 3,
+             'Number of consecutive errors before marking zone offline')
+
+
+class ZoneState(object):
+    """Holds the state of all connected child zones."""
+    def __init__(self):
+        self.is_active = True
+        self.name = None
+        self.capabilities = None
+        self.attempt = 0
+        self.last_seen = datetime.min
+        self.last_exception = None
+        self.last_exception_time = None
+ 
+    def update_credentials(self, zone):
+        """Update zone credentials from db"""
+        self.zone_id = zone.id
+        self.api_url = zone.api_url
+        self.username = zone.username
+        self.password = zone.password
+ 
+    def update_metadata(self, zone_metadata):
+        """Update zone metadata after successful communications with
+           child zone."""
+        self.last_seen = datetime.now()
+        self.attempt = 0
+        self.name = zone_metadata["name"]
+        self.capabilities = zone_metadata["capabilities"]
+        self.is_active = True
+
+    def log_error(self, exception):
+        """Something went wrong. Check to see if zone should be
+           marked as offline."""
+        self.last_exception = exception
+        self.last_exception_time = datetime.now()
+        logging.warning(_("%s error talking to zone %s") % (exception,
+            zone.api_url, FLAGS.zone_failures_to_offline))
+
+       self.attempt += 1
+        if self.attempt >= FLAGS.zone_failures_to_offline:
+           self.is_active = False
+           logging.error(_("No answer from zone %s after %d "
+               "attempts. Marking inactive.") % (zone.api_url,
+               FLAGS.zone_failures_to_offline))
+
+def _poll_zone(zone):
+    """Eventlet worker to poll a zone."""
+    logging.debug("_POLL_ZONE: STARTING")
+    os = novatools.OpenStack(zone.username, zone.password, zone.api_url)
+    try:
+        zone.update_metadata(os.zones.info()._info)
+    except Exception, e:
+        zone.log_error(e)
+
+class ZoneManager(object):
+    """Keeps the zone states updated."""
+    def __init__(self):
+        self.last_zone_db_check = datetime.min
+        self.zone_states = {}
+
+    def _refresh_from_db(self, context):
+        """Make our zone state map match the db."""
+        # Add/update existing zones ...
+        zones = db.zone_get_all(context)
+        existing = self.zone_states.keys()
+        db_keys = []
+        for zone in zones:
+            db_keys.append(zone.id)
+            if zone.id not in existing:
+                self.zone_states[zone.id] = ZoneState()
+            self.zone_states[zone.id].update_credentials(zone)
+
+        # Cleanup zones removed from db ...
+        for zone_id in self.zone_states.keys():
+            if zone_id not in db_keys:
+                del self.zone_states[zone_id]
+ 
+    def _poll_zones(self, context):
+        """Try to connect to each child zone and get update."""
+        green_pool = GreenPool()
+        green_pool.imap(_poll_zone, self.zone_states.values())
+
+    def ping(self, context=None):
+        """Ping should be called periodically to update zone status."""
+        logging.debug("ZoneManager PING")
+        diff = datetime.now() - self.last_zone_db_check
+        if diff.seconds >=  FLAGS.zone_db_check_interval:
+            logging.debug("ZoneManager RECHECKING DB ")
+            self.last_zone_db_check = datetime.now()
+            self._refresh_from_db(context)
+        self._poll_zones(context)

From 422fefc6792807560c48e4e5a322739ef97ea186 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Feb 2011 13:17:42 -0800
Subject: [PATCH 05/77] zone manager tests

---
 nova/scheduler/zone_manager.py |   2 +-
 nova/tests/test_zones.py       | 132 +++++++++++++++++++++++++++++++++
 2 files changed, 133 insertions(+), 1 deletion(-)
 create mode 100644 nova/tests/test_zones.py

diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index dd910eb0..0974f271 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -71,7 +71,7 @@ class ZoneState(object):
         logging.warning(_("%s error talking to zone %s") % (exception,
             zone.api_url, FLAGS.zone_failures_to_offline))
 
-       self.attempt += 1
+        self.attempt += 1
         if self.attempt >= FLAGS.zone_failures_to_offline:
            self.is_active = False
            logging.error(_("No answer from zone %s after %d "
diff --git a/nova/tests/test_zones.py b/nova/tests/test_zones.py
new file mode 100644
index 00000000..b4c8815d
--- /dev/null
+++ b/nova/tests/test_zones.py
@@ -0,0 +1,132 @@
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+"""
+Tests For ZoneManager
+"""
+
+import datetime
+import mox
+
+from nova import context
+from nova import db
+from nova import flags
+from nova import service
+from nova import test
+from nova import rpc
+from nova import utils
+from nova.auth import manager as auth_manager
+from nova.scheduler import zone_manager
+
+
+class FakeZone:
+    """Represents a fake zone from the db"""
+    def __init__(self, *args, **kwargs):
+        for k, v in kwargs.iteritems():
+            setattr(self, k, v)
+
+
+class ZoneManagerTestCase(test.TestCase):
+    """Test case for zone manager"""
+    def test_ping(self):
+        zm = zone_manager.ZoneManager()
+        self.mox.StubOutWithMock(zm, '_refresh_from_db')
+        self.mox.StubOutWithMock(zm, '_poll_zones')
+        zm._refresh_from_db(mox.IgnoreArg())
+        zm._poll_zones(mox.IgnoreArg())
+
+        self.mox.ReplayAll()
+        zm.ping(None)
+        self.mox.VerifyAll()
+
+    def test_refresh_from_db_new(self):
+        zm = zone_manager.ZoneManager()
+
+        self.mox.StubOutWithMock(db, 'zone_get_all')
+        db.zone_get_all(mox.IgnoreArg()).AndReturn([
+               FakeZone(id=1, api_url='http://foo.com', username='user1',
+                    password='pass1'),
+            ])
+        
+        self.assertEquals(len(zm.zone_states), 0)
+
+        self.mox.ReplayAll()
+        zm._refresh_from_db(None)
+        self.mox.VerifyAll()
+
+        self.assertEquals(len(zm.zone_states), 1)
+        self.assertEquals(zm.zone_states[1].username, 'user1')
+
+    def test_refresh_from_db_replace_existing(self):
+        zm = zone_manager.ZoneManager()
+        zone_state = zone_manager.ZoneState()
+        zone_state.update_credentials(FakeZone(id=1, api_url='http://foo.com',
+                        username='user1', password='pass1'))
+        zm.zone_states[1] = zone_state
+
+        self.mox.StubOutWithMock(db, 'zone_get_all')
+        db.zone_get_all(mox.IgnoreArg()).AndReturn([
+               FakeZone(id=1, api_url='http://foo.com', username='user2',
+                    password='pass2'),
+            ])
+        
+        self.assertEquals(len(zm.zone_states), 1)
+
+        self.mox.ReplayAll()
+        zm._refresh_from_db(None)
+        self.mox.VerifyAll()
+
+        self.assertEquals(len(zm.zone_states), 1)
+        self.assertEquals(zm.zone_states[1].username, 'user2')
+
+    def test_refresh_from_db_missing(self):
+        zm = zone_manager.ZoneManager()
+        zone_state = zone_manager.ZoneState()
+        zone_state.update_credentials(FakeZone(id=1, api_url='http://foo.com',
+                        username='user1', password='pass1'))
+        zm.zone_states[1] = zone_state
+
+        self.mox.StubOutWithMock(db, 'zone_get_all')
+        db.zone_get_all(mox.IgnoreArg()).AndReturn([ ])
+        
+        self.assertEquals(len(zm.zone_states), 1)
+
+        self.mox.ReplayAll()
+        zm._refresh_from_db(None)
+        self.mox.VerifyAll()
+
+        self.assertEquals(len(zm.zone_states), 0)
+
+    def test_refresh_from_db_add_and_delete(self):
+        zm = zone_manager.ZoneManager()
+        zone_state = zone_manager.ZoneState()
+        zone_state.update_credentials(FakeZone(id=1, api_url='http://foo.com',
+                        username='user1', password='pass1'))
+        zm.zone_states[1] = zone_state
+
+        self.mox.StubOutWithMock(db, 'zone_get_all')
+        
+        db.zone_get_all(mox.IgnoreArg()).AndReturn([
+               FakeZone(id=2, api_url='http://foo.com', username='user2',
+                    password='pass2'),
+            ])
+        self.assertEquals(len(zm.zone_states), 1)
+
+        self.mox.ReplayAll()
+        zm._refresh_from_db(None)
+        self.mox.VerifyAll()
+
+        self.assertEquals(len(zm.zone_states), 1)
+        self.assertEquals(zm.zone_states[2].username, 'user2')

From 87e42ad8148bdf9dfe6bc1fa6c4a7bb5eecff021 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Feb 2011 18:30:56 -0800
Subject: [PATCH 06/77] polling tests

---
 nova/scheduler/zone_manager.py | 15 ++++++++-----
 nova/tests/test_zones.py       | 41 ++++++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+), 5 deletions(-)

diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index 0974f271..a6bbc2eb 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -68,22 +68,27 @@ class ZoneState(object):
            marked as offline."""
         self.last_exception = exception
         self.last_exception_time = datetime.now()
-        logging.warning(_("%s error talking to zone %s") % (exception,
-            zone.api_url, FLAGS.zone_failures_to_offline))
+        logging.warning(_("'%s' error talking to zone %s") % (exception,
+            self.api_url))
 
         self.attempt += 1
         if self.attempt >= FLAGS.zone_failures_to_offline:
            self.is_active = False
            logging.error(_("No answer from zone %s after %d "
-               "attempts. Marking inactive.") % (zone.api_url,
+               "attempts. Marking inactive.") % (self.api_url,
                FLAGS.zone_failures_to_offline))
 
+
+def _call_novatools(zone):
+    """Call novatools. Broken out for testing purposes."""
+    os = novatools.OpenStack(zone.username, zone.password, zone.api_url)
+    return os.zones.info()._info
+
 def _poll_zone(zone):
     """Eventlet worker to poll a zone."""
     logging.debug("_POLL_ZONE: STARTING")
-    os = novatools.OpenStack(zone.username, zone.password, zone.api_url)
     try:
-        zone.update_metadata(os.zones.info()._info)
+        zone.update_metadata(_call_novatools(zone))
     except Exception, e:
         zone.log_error(e)
 
diff --git a/nova/tests/test_zones.py b/nova/tests/test_zones.py
index b4c8815d..2cb070ac 100644
--- a/nova/tests/test_zones.py
+++ b/nova/tests/test_zones.py
@@ -19,6 +19,7 @@ Tests For ZoneManager
 
 import datetime
 import mox
+import novatools
 
 from nova import context
 from nova import db
@@ -30,6 +31,8 @@ from nova import utils
 from nova.auth import manager as auth_manager
 from nova.scheduler import zone_manager
 
+FLAGS = flags.FLAGS
+
 
 class FakeZone:
     """Represents a fake zone from the db"""
@@ -38,6 +41,11 @@ class FakeZone:
             setattr(self, k, v)
 
 
+def exploding_novatools(zone):
+    """Used when we want to simulate a novatools call failing."""
+    raise Exception("kaboom")
+
+
 class ZoneManagerTestCase(test.TestCase):
     """Test case for zone manager"""
     def test_ping(self):
@@ -130,3 +138,36 @@ class ZoneManagerTestCase(test.TestCase):
 
         self.assertEquals(len(zm.zone_states), 1)
         self.assertEquals(zm.zone_states[2].username, 'user2')
+
+    def test_poll_zone(self):
+        self.mox.StubOutWithMock(zone_manager, '_call_novatools')
+        zone_manager._call_novatools(mox.IgnoreArg()).AndReturn(
+                        dict(name='zohan', capabilities='hairdresser'))
+
+        zone_state = zone_manager.ZoneState()
+        zone_state.update_credentials(FakeZone(id=2,
+                       api_url='http://foo.com', username='user2',
+                       password='pass2'))
+        zone_state.attempt = 1
+
+        self.mox.ReplayAll()
+        zone_manager._poll_zone(zone_state)
+        self.mox.VerifyAll()
+        self.assertEquals(zone_state.attempt, 0)
+        self.assertEquals(zone_state.name, 'zohan')
+
+    def test_poll_zone_fails(self):
+        self.stubs.Set(zone_manager, "_call_novatools", exploding_novatools)
+
+        zone_state = zone_manager.ZoneState()
+        zone_state.update_credentials(FakeZone(id=2,
+                       api_url='http://foo.com', username='user2',
+                       password='pass2'))
+        zone_state.attempt = FLAGS.zone_failures_to_offline - 1
+
+        self.mox.ReplayAll()
+        zone_manager._poll_zone(zone_state)
+        self.mox.VerifyAll()
+        self.assertEquals(zone_state.attempt, 3)
+        self.assertFalse(zone_state.is_active)
+        self.assertEquals(zone_state.name, None)

From 7f2bf2dd717f08cce60ce0db87c719aeb3104031 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 16 Feb 2011 18:35:43 -0800
Subject: [PATCH 07/77] style cleanup

---
 nova/scheduler/zone_manager.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index a6bbc2eb..a35acb00 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -84,14 +84,16 @@ def _call_novatools(zone):
     os = novatools.OpenStack(zone.username, zone.password, zone.api_url)
     return os.zones.info()._info
 
+
 def _poll_zone(zone):
     """Eventlet worker to poll a zone."""
-    logging.debug("_POLL_ZONE: STARTING")
+    logging.debug(_("Polling zone: %s") % zone.api_url)
     try:
         zone.update_metadata(_call_novatools(zone))
     except Exception, e:
         zone.log_error(e)
 
+
 class ZoneManager(object):
     """Keeps the zone states updated."""
     def __init__(self):
@@ -122,10 +124,9 @@ class ZoneManager(object):
 
     def ping(self, context=None):
         """Ping should be called periodically to update zone status."""
-        logging.debug("ZoneManager PING")
         diff = datetime.now() - self.last_zone_db_check
         if diff.seconds >=  FLAGS.zone_db_check_interval:
-            logging.debug("ZoneManager RECHECKING DB ")
+            logging.debug("Updating zone cache from db.")
             self.last_zone_db_check = datetime.now()
             self._refresh_from_db(context)
         self._poll_zones(context)

From 258916bbe5356c2658ff1e8a452e324c753f02b4 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 17 Feb 2011 12:12:19 -0800
Subject: [PATCH 08/77] zone list now comes from scheduler zonemanager

---
 nova/scheduler/zone_manager.py | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index a35acb00..4fa52897 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -21,6 +21,7 @@ ZoneManager oversees all communications with child Zones.
 
 import novatools
 import thread
+import traceback
 
 from datetime import datetime
 from eventlet.greenpool import GreenPool
@@ -63,6 +64,11 @@ class ZoneState(object):
         self.capabilities = zone_metadata["capabilities"]
         self.is_active = True
 
+    def to_dict(self):
+        return dict(name=self.name, capabilities=self.capabilities,
+                    is_active=self.is_active, api_url=self.api_url,
+                    id=self.zone_id)
+
     def log_error(self, exception):
         """Something went wrong. Check to see if zone should be
            marked as offline."""
@@ -91,7 +97,7 @@ def _poll_zone(zone):
     try:
         zone.update_metadata(_call_novatools(zone))
     except Exception, e:
-        zone.log_error(e)
+        zone.log_error(traceback.format_exc())
 
 
 class ZoneManager(object):
@@ -100,6 +106,9 @@ class ZoneManager(object):
         self.last_zone_db_check = datetime.min
         self.zone_states = {}
 
+    def get_zone_list(self):
+        return [ zone.to_dict() for zone in self.zone_states.values() ]
+
     def _refresh_from_db(self, context):
         """Make our zone state map match the db."""
         # Add/update existing zones ...

From ad006c20e0f5db31df11bd8a6a50c5e0d54623c2 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 17 Feb 2011 16:18:03 -0400
Subject: [PATCH 09/77] fixup

---
 bin/nova-combined              |  4 ++--
 nova/flags.py                  |  2 +-
 nova/scheduler/zone_manager.py | 18 +++++++++---------
 nova/tests/test_zones.py       | 10 +++++-----
 4 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/bin/nova-combined b/bin/nova-combined
index a0f552d6..913c866b 100755
--- a/bin/nova-combined
+++ b/bin/nova-combined
@@ -53,11 +53,11 @@ if __name__ == '__main__':
 
     compute = service.Service.create(binary='nova-compute')
     network = service.Service.create(binary='nova-network')
-    #volume = service.Service.create(binary='nova-volume')
+    volume = service.Service.create(binary='nova-volume')
     scheduler = service.Service.create(binary='nova-scheduler')
     #objectstore = service.Service.create(binary='nova-objectstore')
 
-    service.serve(compute, network, scheduler)
+    service.serve(compute, network, volume, scheduler)
 
     apps = []
     paste_config_file = wsgi.paste_config_file('nova-api.conf')
diff --git a/nova/flags.py b/nova/flags.py
index 0a45499f..60d7cdd0 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -314,6 +314,6 @@ DEFINE_string('node_availability_zone', 'nova',
               'availability zone of this node')
 
 DEFINE_string('zone_name', 'nova', 'name of this zone')
-DEFINE_string('zone_capabilities', 'xen, linux', 
+DEFINE_string('zone_capabilities', 'xen, linux',
               'comma-delimited list of tags which represent boolean'
               ' capabilities of this zone')
diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index 4fa52897..e7c37a9a 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -47,14 +47,14 @@ class ZoneState(object):
         self.last_seen = datetime.min
         self.last_exception = None
         self.last_exception_time = None
- 
+
     def update_credentials(self, zone):
         """Update zone credentials from db"""
         self.zone_id = zone.id
         self.api_url = zone.api_url
         self.username = zone.username
         self.password = zone.password
- 
+
     def update_metadata(self, zone_metadata):
         """Update zone metadata after successful communications with
            child zone."""
@@ -79,10 +79,10 @@ class ZoneState(object):
 
         self.attempt += 1
         if self.attempt >= FLAGS.zone_failures_to_offline:
-           self.is_active = False
-           logging.error(_("No answer from zone %s after %d "
-               "attempts. Marking inactive.") % (self.api_url,
-               FLAGS.zone_failures_to_offline))
+            self.is_active = False
+            logging.error(_("No answer from zone %s after %d "
+                "attempts. Marking inactive.") % (self.api_url,
+                FLAGS.zone_failures_to_offline))
 
 
 def _call_novatools(zone):
@@ -107,7 +107,7 @@ class ZoneManager(object):
         self.zone_states = {}
 
     def get_zone_list(self):
-        return [ zone.to_dict() for zone in self.zone_states.values() ]
+        return [zone.to_dict() for zone in self.zone_states.values()]
 
     def _refresh_from_db(self, context):
         """Make our zone state map match the db."""
@@ -125,7 +125,7 @@ class ZoneManager(object):
         for zone_id in self.zone_states.keys():
             if zone_id not in db_keys:
                 del self.zone_states[zone_id]
- 
+
     def _poll_zones(self, context):
         """Try to connect to each child zone and get update."""
         green_pool = GreenPool()
@@ -134,7 +134,7 @@ class ZoneManager(object):
     def ping(self, context=None):
         """Ping should be called periodically to update zone status."""
         diff = datetime.now() - self.last_zone_db_check
-        if diff.seconds >=  FLAGS.zone_db_check_interval:
+        if diff.seconds >= FLAGS.zone_db_check_interval:
             logging.debug("Updating zone cache from db.")
             self.last_zone_db_check = datetime.now()
             self._refresh_from_db(context)
diff --git a/nova/tests/test_zones.py b/nova/tests/test_zones.py
index 2cb070ac..7036ebe5 100644
--- a/nova/tests/test_zones.py
+++ b/nova/tests/test_zones.py
@@ -67,7 +67,7 @@ class ZoneManagerTestCase(test.TestCase):
                FakeZone(id=1, api_url='http://foo.com', username='user1',
                     password='pass1'),
             ])
-        
+
         self.assertEquals(len(zm.zone_states), 0)
 
         self.mox.ReplayAll()
@@ -89,7 +89,7 @@ class ZoneManagerTestCase(test.TestCase):
                FakeZone(id=1, api_url='http://foo.com', username='user2',
                     password='pass2'),
             ])
-        
+
         self.assertEquals(len(zm.zone_states), 1)
 
         self.mox.ReplayAll()
@@ -107,8 +107,8 @@ class ZoneManagerTestCase(test.TestCase):
         zm.zone_states[1] = zone_state
 
         self.mox.StubOutWithMock(db, 'zone_get_all')
-        db.zone_get_all(mox.IgnoreArg()).AndReturn([ ])
-        
+        db.zone_get_all(mox.IgnoreArg()).AndReturn([])
+
         self.assertEquals(len(zm.zone_states), 1)
 
         self.mox.ReplayAll()
@@ -125,7 +125,7 @@ class ZoneManagerTestCase(test.TestCase):
         zm.zone_states[1] = zone_state
 
         self.mox.StubOutWithMock(db, 'zone_get_all')
-        
+
         db.zone_get_all(mox.IgnoreArg()).AndReturn([
                FakeZone(id=2, api_url='http://foo.com', username='user2',
                     password='pass2'),

From c1e9865d4e573ea8d66bbf221d89ea6c22f892a2 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 17 Feb 2011 13:23:56 -0800
Subject: [PATCH 10/77] multi positional string fix

---
 nova/scheduler/zone_manager.py | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index e7c37a9a..af0b90f9 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -74,15 +74,17 @@ class ZoneState(object):
            marked as offline."""
         self.last_exception = exception
         self.last_exception_time = datetime.now()
-        logging.warning(_("'%s' error talking to zone %s") % (exception,
-            self.api_url))
+        api_url = self.api_url
+        logging.warning(_("'%(exception)s' error talking to "
+                          "zone %(api_url)s") % locals())
 
+        max_errors = FLAGS.zone_failures_to_offline:
         self.attempt += 1
-        if self.attempt >= FLAGS.zone_failures_to_offline:
+        if self.attempt >= max_errors:
             self.is_active = False
-            logging.error(_("No answer from zone %s after %d "
-                "attempts. Marking inactive.") % (self.api_url,
-                FLAGS.zone_failures_to_offline))
+            logging.error(_("No answer from zone %(api_url)s "
+                            "after %(max_errors)d "
+                            "attempts. Marking inactive.") % locals())
 
 
 def _call_novatools(zone):

From f8331adfce4f370608ea2c9ef451461099fde5d3 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 17 Feb 2011 13:29:19 -0800
Subject: [PATCH 11/77] fixed strings

---
 nova/scheduler/zone_manager.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index af0b90f9..4bf6e36c 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -78,7 +78,7 @@ class ZoneState(object):
         logging.warning(_("'%(exception)s' error talking to "
                           "zone %(api_url)s") % locals())
 
-        max_errors = FLAGS.zone_failures_to_offline:
+        max_errors = FLAGS.zone_failures_to_offline
         self.attempt += 1
         if self.attempt >= max_errors:
             self.is_active = False

From d0d933708b9bec232f023f3bc9615f751541002d Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 17 Feb 2011 18:49:30 -0400
Subject: [PATCH 12/77] missing docstring and fixed copyrights

---
 nova/scheduler/zone_manager.py | 3 +--
 nova/tests/test_zones.py       | 1 -
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index 4bf6e36c..3e7c1eba 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -1,6 +1,4 @@
 # Copyright (c) 2010 Openstack, LLC.
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -109,6 +107,7 @@ class ZoneManager(object):
         self.zone_states = {}
 
     def get_zone_list(self):
+        """Return the list of zones we know about."""
         return [zone.to_dict() for zone in self.zone_states.values()]
 
     def _refresh_from_db(self, context):
diff --git a/nova/tests/test_zones.py b/nova/tests/test_zones.py
index 7036ebe5..c273230a 100644
--- a/nova/tests/test_zones.py
+++ b/nova/tests/test_zones.py
@@ -1,5 +1,4 @@
 # Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may

From 821abd0f60cd696bfaab42aece65790f7b3ff12e Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Thu, 17 Feb 2011 23:09:06 -0600
Subject: [PATCH 13/77] Tests

---
 nova/tests/test_compute.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 2aa0690e..e27e0882 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -258,3 +258,10 @@ class ComputeTestCase(test.TestCase):
         self.assertEqual(ret_val, None)
 
         self.compute.terminate_instance(self.context, instance_id)
+
+    def test_resize_instance(self):
+        """Ensure instance can be migrated/resized"""
+        instance_id = self._create_instance()
+        self.compute.run_instnce(self.context, instance_id)
+        self.compute.prep_resize(self.context, instance_id)
+

From fd7cdf3763d19f6cf1749fbe543569adf87d412c Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Fri, 18 Feb 2011 06:03:15 +0000
Subject: [PATCH 14/77] Resize compute tests

---
 nova/tests/test_compute.py | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index e27e0882..3f2e64c8 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -56,7 +56,7 @@ class ComputeTestCase(test.TestCase):
         self.manager.delete_project(self.project)
         super(ComputeTestCase, self).tearDown()
 
-    def _create_instance(self):
+    def _create_instance(self, params={}):
         """Create a test instance"""
         inst = {}
         inst['image_id'] = 'ami-test'
@@ -67,6 +67,7 @@ class ComputeTestCase(test.TestCase):
         inst['instance_type'] = 'm1.tiny'
         inst['mac_address'] = utils.generate_mac()
         inst['ami_launch_index'] = 0
+        inst.update(params)
         return db.instance_create(self.context, inst)['id']
 
     def _create_group(self):
@@ -262,6 +263,23 @@ class ComputeTestCase(test.TestCase):
     def test_resize_instance(self):
         """Ensure instance can be migrated/resized"""
         instance_id = self._create_instance()
-        self.compute.run_instnce(self.context, instance_id)
-        self.compute.prep_resize(self.context, instance_id)
+        context = self.context.elevated()
+        self.compute.run_instance(self.context, instance_id)
+        db.instance_update(self.context, instance_id, {'host':'foo'})
 
+        self.compute.prep_resize(context, instance_id)
+        migration_ref = db.migration_get_by_instance_and_status(context,
+                instance_id, 'pre-migrating')
+        self.compute.resize_instance(context, instance_id,
+                migration_ref['id'])
+        self.compute.terminate_instance(context, instance_id)
+
+    def test_resize_same_source_fails(self):
+        """Ensure instance fails to migrate when source and destination are
+        the same host"""
+        instance_id = self._create_instance()
+        self.compute.run_instance(self.context, instance_id)
+        self.assertRaises(exception.Error, self.compute.prep_resize, 
+                self.context, instance_id)
+
+        self.compute.terminate_instance(self.context, instance_id)

From f4397b0b9409d8c32fd454f1a3cf538e0af1d9dc Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Fri, 18 Feb 2011 12:08:35 -0400
Subject: [PATCH 15/77] fixups backed on merge comments

---
 nova/flags.py                  |  5 ++--
 nova/scheduler/api.py          | 49 ++++++++++++++++++++++++++++++++++
 nova/scheduler/zone_manager.py | 15 ++++++-----
 3 files changed, 59 insertions(+), 10 deletions(-)
 create mode 100644 nova/scheduler/api.py

diff --git a/nova/flags.py b/nova/flags.py
index 7e4919d6..41f01fcd 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -316,6 +316,5 @@ DEFINE_string('node_availability_zone', 'nova',
               'availability zone of this node')
 
 DEFINE_string('zone_name', 'nova', 'name of this zone')
-DEFINE_string('zone_capabilities', 'xen, linux',
-              'comma-delimited list of tags which represent boolean'
-              ' capabilities of this zone')
+DEFINE_string('zone_capabilities', 'kypervisor:xenserver;os:linux',
+              'Key/Value tags which represent capabilities of this zone')
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
new file mode 100644
index 00000000..8491bf3a
--- /dev/null
+++ b/nova/scheduler/api.py
@@ -0,0 +1,49 @@
+# Copyright (c) 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.
+
+"""
+Handles all requests relating to schedulers.
+"""
+
+from nova import flags
+from nova import log as logging
+from nova import rpc
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.scheduler.api')
+
+
+class API:
+    """API for interacting with the scheduler."""
+
+    def _call_scheduler(self, method, context, params=None):
+        """Generic handler for RPC calls to the scheduler.
+
+        :param params: Optional dictionary of arguments to be passed to the
+                       scheduler worker
+
+        :retval: Result returned by scheduler worker
+        """
+        if not params:
+            params = {}
+        queue = FLAGS.scheduler_topic
+        kwargs = {'method': method, 'args': params}
+        return rpc.call(context, queue, kwargs)
+
+    def get_zone_list(self, context):
+        items = self._call_scheduler('get_zone_list', context)
+        for item in items:
+            item['api_url'] = item['api_url'].replace('\\/', '/')
+        return items
diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index 3e7c1eba..783783d0 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2010 Openstack, LLC.
+# Copyright (c) 2011 Openstack, LLC.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -87,8 +87,8 @@ class ZoneState(object):
 
 def _call_novatools(zone):
     """Call novatools. Broken out for testing purposes."""
-    os = novatools.OpenStack(zone.username, zone.password, zone.api_url)
-    return os.zones.info()._info
+    client = novatools.OpenStack(zone.username, zone.password, zone.api_url)
+    return client.zones.info()._info
 
 
 def _poll_zone(zone):
@@ -105,6 +105,7 @@ class ZoneManager(object):
     def __init__(self):
         self.last_zone_db_check = datetime.min
         self.zone_states = {}
+        self.green_pool = GreenPool()
 
     def get_zone_list(self):
         """Return the list of zones we know about."""
@@ -123,20 +124,20 @@ class ZoneManager(object):
             self.zone_states[zone.id].update_credentials(zone)
 
         # Cleanup zones removed from db ...
-        for zone_id in self.zone_states.keys():
+        keys = self.zone_states.keys()  # since we're deleting
+        for zone_id in keys:
             if zone_id not in db_keys:
                 del self.zone_states[zone_id]
 
     def _poll_zones(self, context):
         """Try to connect to each child zone and get update."""
-        green_pool = GreenPool()
-        green_pool.imap(_poll_zone, self.zone_states.values())
+        self.green_pool.imap(_poll_zone, self.zone_states.values())
 
     def ping(self, context=None):
         """Ping should be called periodically to update zone status."""
         diff = datetime.now() - self.last_zone_db_check
         if diff.seconds >= FLAGS.zone_db_check_interval:
-            logging.debug("Updating zone cache from db.")
+            logging.debug(_("Updating zone cache from db."))
             self.last_zone_db_check = datetime.now()
             self._refresh_from_db(context)
         self._poll_zones(context)

From 5afc241262a64a14d88077f685531bdca73f6c84 Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Fri, 18 Feb 2011 19:04:57 +0000
Subject: [PATCH 16/77] Resize compute tests

---
 nova/tests/test_xenapi.py  | 34 ++++++++++++++++++++++++++++++++++
 nova/tests/xenapi/stubs.py | 25 +++++++++++++++++++++++--
 2 files changed, 57 insertions(+), 2 deletions(-)

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 6b8efc9d..ee4c68e6 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -336,3 +336,37 @@ class XenAPIDiffieHellmanTestCase(test.TestCase):
 
     def tearDown(self):
         super(XenAPIDiffieHellmanTestCase, self).tearDown()
+
+class XenAPIMigrateInstance(test.TestCase):
+    """
+    Unit test for verifying migration-related actions
+    """
+    def setUp(self):
+        super(XenAPIMigrateInstance, self).setUp()
+        self.stubs = stubout.StubOutForTesting()
+        FLAGS.target_host = '127.0.0.1'
+        FLAGS.xenapi_connection_url = 'test_url'
+        FLAGS.xenapi_connection_password = 'test_pass'
+        db_fakes.stub_out_db_instance_api(self.stubs)
+        stubs.stub_out_get_target(self.stubs)
+        xenapi_fake.reset()
+        self.values = {'name': 1, 'id': 1,
+                  'project_id': 'fake',
+                  'user_id': 'fake',
+                  'image_id': 1,
+                  'kernel_id': 2,
+                  'ramdisk_id': 3,
+                  'instance_type': 'm1.large',
+                  'mac_address': 'aa:bb:cc:dd:ee:ff',
+                  }
+        stubs.stub_out_migration_methods(self.stubs)
+
+    def test_migrate_disk_and_power_off(self):
+        FLAGS.target_host = '127.0.0.1'
+        FLAGS.xenapi_connection_url = 'test_url'
+        FLAGS.xenapi_connection_password = 'test_pass'   
+        destination = '127.0.0.1'
+        instance = db.instance_create(self.values)
+        stubs.stubout_session(self.stubs, stubs.FakeSessionForMigrationTests)
+        conn = xenapi_conn.get_connection(False)
+        conn.migrate_disk_and_power_off(instance, destination)
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 624995ad..d1c36747 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -20,6 +20,7 @@ from nova.virt import xenapi_conn
 from nova.virt.xenapi import fake
 from nova.virt.xenapi import volume_utils
 from nova.virt.xenapi import vm_utils
+from nova.virt.xenapi import vmops
 
 
 def stubout_instance_snapshot(stubs):
@@ -170,8 +171,8 @@ class FakeSessionForVMTests(fake.SessionBase):
 
     def VM_destroy(self, session_ref, vm_ref):
         fake.destroy_vm(vm_ref)
-
-
+    
+    
 class FakeSessionForVolumeTests(fake.SessionBase):
     """ Stubs out a XenAPISession for Volume tests """
     def __init__(self, uri):
@@ -205,3 +206,23 @@ class FakeSessionForVolumeFailedTests(FakeSessionForVolumeTests):
 
     def SR_forget(self, _1, ref):
         pass
+
+class FakeSessionForMigrationTests(fake.SessionBase):
+    """ Stubs out a XenAPISession for Migration tests """
+    def __init__(self, uri):
+        super(FakeSessionForMigrationTests, self).__init__(uri)
+
+
+class FakeSnapshot(vmops.VMOps):
+    def __getattr__(self, key):
+        return 'fake'
+
+    def __exit__(self, type, value, traceback)
+        pass
+
+def fake_get_snapshot(self, instance):
+     return FakeSnapshot()
+
+def stub_out_migration_methods(stubs):
+    stubs.Set(vmops.VMOps, '_get_snapshot', 
+            fake_get_snapshot)

From 1a9942fcb1fecd2b73a9d7174f2463d141c228ae Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Fri, 18 Feb 2011 22:10:06 +0100
Subject: [PATCH 17/77] Introduce IptablesManager in linux_net. Port every use
 of iptables in linux_net to it.

---
 nova/tests/test_network.py | 59 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index 00f9323f..b28d6424 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -29,11 +29,70 @@ from nova import log as logging
 from nova import test
 from nova import utils
 from nova.auth import manager
+from nova.network import linux_net
 
 FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.tests.network')
 
 
+class IptablesManagerTestCase(test.TestCase):
+    sample_filter = """# Completed on Fri Feb 18 15:17:05 2011
+# Generated by iptables-save v1.4.10 on Fri Feb 18 15:17:05 2011
+*filter
+:INPUT ACCEPT [2223527:305688874]
+:FORWARD ACCEPT [0:0]
+:OUTPUT ACCEPT [2172501:140856656]
+-A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT 
+-A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT 
+-A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT 
+-A INPUT -i virbr0 -p tcp -m tcp --dport 67 -j ACCEPT 
+-A FORWARD -d 192.168.122.0/24 -o virbr0 -m state --state RELATED,ESTABLISHED -j ACCEPT 
+-A FORWARD -s 192.168.122.0/24 -i virbr0 -j ACCEPT 
+-A FORWARD -i virbr0 -o virbr0 -j ACCEPT 
+-A FORWARD -o virbr0 -j REJECT --reject-with icmp-port-unreachable 
+-A FORWARD -i virbr0 -j REJECT --reject-with icmp-port-unreachable 
+COMMIT
+# Completed on Fri Feb 18 15:17:05 2011"""
+
+    def setUp(self):
+        super(IptablesManagerTestCase, self).setUp()
+        self.manager = linux_net.IptablesManager()
+
+    def test_rules_are_wrapped(self):
+        current_lines = self.sample_filter.split('\n')
+
+        table = self.manager.ipv4['filter']
+        table.add_rule('FORWARD', '-s 1.2.3.4/5 -j DROP')
+        new_lines = self.manager.modify_rules(current_lines, table)
+        self.assertTrue('-A run_tests.py-FORWARD '
+                        '-s 1.2.3.4/5 -j DROP' in new_lines)
+
+        table.remove_rule('FORWARD', '-s 1.2.3.4/5 -j DROP')
+        new_lines = self.manager.modify_rules(current_lines, table)
+        self.assertTrue('-A run_tests.py-FORWARD '
+                        '-s 1.2.3.4/5 -j DROP' not in new_lines)
+
+    def test_wrapper_rules_in_place(self):
+        current_lines = self.sample_filter.split('\n')
+
+        # TODO(soren): Add stuff for ipv6
+        check_matrix = {4: {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
+                            'nat': ['PREROUTING', 'INPUT',
+                                    'OUTPUT', 'POSTROUTING']} }
+
+        for ip_version in check_matrix:
+            ip = getattr(self.manager, 'ipv%d' % ip_version)
+            for table_name in ip:
+                table = ip[table_name]
+                new_lines = self.manager.modify_rules(current_lines, table)
+                for chain in check_matrix[ip_version][table_name]:
+                    self.assertTrue(':run_tests.py-%s - [0:0]' % \
+                                    (chain,) in new_lines)
+                    self.assertTrue('-A %s -j run_tests.py-%s' % \
+                                    (chain, chain) in new_lines)
+                print '\n'.join(new_lines)
+
+
 class NetworkTestCase(test.TestCase):
     """Test cases for network code"""
     def setUp(self):

From 38954dbd1056fd9bd2f9369cb2cc33e4dd919b70 Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Fri, 18 Feb 2011 21:37:57 +0000
Subject: [PATCH 18/77] XenAPI tests

---
 nova/tests/test_xenapi.py  | 12 +++++++-----
 nova/tests/xenapi/stubs.py | 38 +++++++++++++++++++++++++++++---------
 2 files changed, 36 insertions(+), 14 deletions(-)

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index ee4c68e6..3cbc01e5 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -362,11 +362,13 @@ class XenAPIMigrateInstance(test.TestCase):
         stubs.stub_out_migration_methods(self.stubs)
 
     def test_migrate_disk_and_power_off(self):
-        FLAGS.target_host = '127.0.0.1'
-        FLAGS.xenapi_connection_url = 'test_url'
-        FLAGS.xenapi_connection_password = 'test_pass'   
-        destination = '127.0.0.1'
         instance = db.instance_create(self.values)
         stubs.stubout_session(self.stubs, stubs.FakeSessionForMigrationTests)
         conn = xenapi_conn.get_connection(False)
-        conn.migrate_disk_and_power_off(instance, destination)
+        conn.migrate_disk_and_power_off(instance, '127.0.0.1')
+
+    def test_attach_disk(self):
+        instance = db.instance_create(self.values)
+        stubs.stubout_session(self.stubs, stubs.FakeSessionForMigrationTests)
+        conn = xenapi_conn.get_connection(False)
+        conn.attach_disk(instance, {'base_copy': 'hurr', 'cow': 'durr'})
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index d1c36747..054fc434 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -213,16 +213,36 @@ class FakeSessionForMigrationTests(fake.SessionBase):
         super(FakeSessionForMigrationTests, self).__init__(uri)
 
 
-class FakeSnapshot(vmops.VMOps):
-    def __getattr__(self, key):
-        return 'fake'
+def stub_out_migration_methods(stubs):
+    class FakeSnapshot(object):
+        def __getattr__(self, key):
+            return str(key)
 
-    def __exit__(self, type, value, traceback)
+        def __enter__(self):
+            return self
+
+        def __exit__(self, type, value, traceback):
+            pass
+
+    def fake_get_snapshot(self, instance):
+        return FakeSnapshot()
+
+    @classmethod
+    def fake_get_vdi(cls, session, vm_ref):
+        vdi_ref = fake.create_vdi(name_label='derp', read_only=False,
+                             sr_ref='herp', sharable=False)
+        vdi_rec = session.get_xenapi().VDI.get_record(vdi_ref)
+        return vdi_ref, {'uuid': vdi_rec['uuid']}
+    
+    def fake_shutdown(self, inst, vm, method='clean'):
         pass
 
-def fake_get_snapshot(self, instance):
-     return FakeSnapshot()
+    @classmethod
+    def fake_scan_sr(cls, session):
+        pass
 
-def stub_out_migration_methods(stubs):
-    stubs.Set(vmops.VMOps, '_get_snapshot', 
-            fake_get_snapshot)
+    stubs.Set(vm_utils.VMHelper, 'scan_sr', fake_scan_sr)
+    stubs.Set(vmops.VMOps, '_get_snapshot', fake_get_snapshot)
+    stubs.Set(vm_utils.VMHelper, 'get_vdi_for_vm_safely', fake_get_vdi)
+    stubs.Set(xenapi_conn.XenAPISession, 'wait_for_task', lambda x,y,z: None)
+    stubs.Set(vmops.VMOps, '_shutdown', fake_shutdown)

From e0e1022f91d94648f3ef54efab61b023587bb086 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Fri, 18 Feb 2011 17:45:57 -0400
Subject: [PATCH 19/77] sandy y u no read hacking guide and import classes?

---
 nova/scheduler/zone_manager.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/nova/scheduler/zone_manager.py b/nova/scheduler/zone_manager.py
index 783783d0..758c5e3d 100644
--- a/nova/scheduler/zone_manager.py
+++ b/nova/scheduler/zone_manager.py
@@ -22,7 +22,7 @@ import thread
 import traceback
 
 from datetime import datetime
-from eventlet.greenpool import GreenPool
+from eventlet import greenpool
 
 from nova import db
 from nova import flags
@@ -105,7 +105,7 @@ class ZoneManager(object):
     def __init__(self):
         self.last_zone_db_check = datetime.min
         self.zone_states = {}
-        self.green_pool = GreenPool()
+        self.green_pool = greenpool.GreenPool()
 
     def get_zone_list(self):
         """Return the list of zones we know about."""

From bff1383ba6c1008186192a971704e0e235406f5e Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Fri, 18 Feb 2011 16:13:34 -0600
Subject: [PATCH 20/77] Pep8 cleanup

---
 nova/tests/test_compute.py |  6 ++----
 nova/tests/test_xenapi.py  |  1 +
 nova/tests/xenapi/stubs.py | 11 ++++++-----
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 3f2e64c8..5fd1ddae 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -265,8 +265,7 @@ class ComputeTestCase(test.TestCase):
         instance_id = self._create_instance()
         context = self.context.elevated()
         self.compute.run_instance(self.context, instance_id)
-        db.instance_update(self.context, instance_id, {'host':'foo'})
-
+        db.instance_update(self.context, instance_id, {'host': 'foo'})
         self.compute.prep_resize(context, instance_id)
         migration_ref = db.migration_get_by_instance_and_status(context,
                 instance_id, 'pre-migrating')
@@ -279,7 +278,6 @@ class ComputeTestCase(test.TestCase):
         the same host"""
         instance_id = self._create_instance()
         self.compute.run_instance(self.context, instance_id)
-        self.assertRaises(exception.Error, self.compute.prep_resize, 
+        self.assertRaises(exception.Error, self.compute.prep_resize,
                 self.context, instance_id)
-
         self.compute.terminate_instance(self.context, instance_id)
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 3cbc01e5..cb9b6620 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -337,6 +337,7 @@ class XenAPIDiffieHellmanTestCase(test.TestCase):
     def tearDown(self):
         super(XenAPIDiffieHellmanTestCase, self).tearDown()
 
+
 class XenAPIMigrateInstance(test.TestCase):
     """
     Unit test for verifying migration-related actions
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 054fc434..303c37eb 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -171,8 +171,8 @@ class FakeSessionForVMTests(fake.SessionBase):
 
     def VM_destroy(self, session_ref, vm_ref):
         fake.destroy_vm(vm_ref)
-    
-    
+
+
 class FakeSessionForVolumeTests(fake.SessionBase):
     """ Stubs out a XenAPISession for Volume tests """
     def __init__(self, uri):
@@ -207,6 +207,7 @@ class FakeSessionForVolumeFailedTests(FakeSessionForVolumeTests):
     def SR_forget(self, _1, ref):
         pass
 
+
 class FakeSessionForMigrationTests(fake.SessionBase):
     """ Stubs out a XenAPISession for Migration tests """
     def __init__(self, uri):
@@ -232,8 +233,8 @@ def stub_out_migration_methods(stubs):
         vdi_ref = fake.create_vdi(name_label='derp', read_only=False,
                              sr_ref='herp', sharable=False)
         vdi_rec = session.get_xenapi().VDI.get_record(vdi_ref)
-        return vdi_ref, {'uuid': vdi_rec['uuid']}
-    
+        return vdi_ref, {'uuid': vdi_rec['uuid'], }
+
     def fake_shutdown(self, inst, vm, method='clean'):
         pass
 
@@ -244,5 +245,5 @@ def stub_out_migration_methods(stubs):
     stubs.Set(vm_utils.VMHelper, 'scan_sr', fake_scan_sr)
     stubs.Set(vmops.VMOps, '_get_snapshot', fake_get_snapshot)
     stubs.Set(vm_utils.VMHelper, 'get_vdi_for_vm_safely', fake_get_vdi)
-    stubs.Set(xenapi_conn.XenAPISession, 'wait_for_task', lambda x,y,z: None)
+    stubs.Set(xenapi_conn.XenAPISession, 'wait_for_task', lambda x, y, z: None)
     stubs.Set(vmops.VMOps, '_shutdown', fake_shutdown)

From d216d49dcba1581c6b64e1c95baa271c8d65074c Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Sat, 19 Feb 2011 00:14:08 +0100
Subject: [PATCH 21/77] Port libvirt_conn.IptablesDriver over to use
 linux_net.IptablesManager

---
 nova/tests/test_virt.py | 55 +++++++++++++++++++++++++++--------------
 1 file changed, 36 insertions(+), 19 deletions(-)

diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index 6e5a0114..a88e0181 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -14,6 +14,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import re
 from xml.etree.ElementTree import fromstring as xml_to_tree
 from xml.dom.minidom import parseString as xml_to_dom
 
@@ -233,16 +234,22 @@ class IptablesFirewallTestCase(test.TestCase):
         self.manager.delete_user(self.user)
         super(IptablesFirewallTestCase, self).tearDown()
 
-    in_rules = [
+    in_nat_rules = [
+      '# Generated by iptables-save v1.4.10 on Sat Feb 19 00:03:19 2011',
+      '*nat',
+      ':PREROUTING ACCEPT [1170:189210]',
+      ':INPUT ACCEPT [844:71028]',
+      ':OUTPUT ACCEPT [5149:405186]',
+      ':POSTROUTING ACCEPT [5063:386098]'
+    ]
+
+    in_filter_rules = [
       '# Generated by iptables-save v1.4.4 on Mon Dec  6 11:54:13 2010',
       '*filter',
       ':INPUT ACCEPT [969615:281627771]',
       ':FORWARD ACCEPT [0:0]',
       ':OUTPUT ACCEPT [915599:63811649]',
       ':nova-block-ipv4 - [0:0]',
-      '-A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT ',
-      '-A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT ',
-      '-A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT ',
       '-A INPUT -i virbr0 -p tcp -m tcp --dport 67 -j ACCEPT ',
       '-A FORWARD -d 192.168.122.0/24 -o virbr0 -m state --state RELATED'
       ',ESTABLISHED -j ACCEPT ',
@@ -254,7 +261,7 @@ class IptablesFirewallTestCase(test.TestCase):
       '# Completed on Mon Dec  6 11:54:13 2010',
     ]
 
-    in6_rules = [
+    in6_filter_rules = [
       '# Generated by ip6tables-save v1.4.4 on Tue Jan 18 23:47:56 2011',
       '*filter',
       ':INPUT ACCEPT [349155:75810423]',
@@ -314,23 +321,31 @@ class IptablesFirewallTestCase(test.TestCase):
         instance_ref = db.instance_get(admin_ctxt, instance_ref['id'])
 
 #        self.fw.add_instance(instance_ref)
-        def fake_iptables_execute(cmd, process_input=None):
+        def fake_iptables_execute(cmd, process_input=None, attempts=5):
             if cmd == 'sudo ip6tables-save -t filter':
-                return '\n'.join(self.in6_rules), None
+                return '\n'.join(self.in6_filter_rules), None
             if cmd == 'sudo iptables-save -t filter':
-                return '\n'.join(self.in_rules), None
+                return '\n'.join(self.in_filter_rules), None
+            if cmd == 'sudo iptables-save -t nat':
+                return '\n'.join(self.in_nat_rules), None
             if cmd == 'sudo iptables-restore':
-                self.out_rules = process_input.split('\n')
+                lines = process_input.split('\n')
+                if '*filter' in lines:
+                    self.out_rules = lines
                 return '', ''
             if cmd == 'sudo ip6tables-restore':
-                self.out6_rules = process_input.split('\n')
+                lines = process_input.split('\n')
+                if '*filter' in lines:
+                    self.out6_rules = lines
                 return '', ''
-        self.fw.execute = fake_iptables_execute
+
+        from nova.network import linux_net
+        linux_net.iptables_manager.execute = fake_iptables_execute
 
         self.fw.prepare_instance_filter(instance_ref)
         self.fw.apply_instance_filter(instance_ref)
 
-        in_rules = filter(lambda l: not l.startswith('#'), self.in_rules)
+        in_rules = filter(lambda l: not l.startswith('#'), self.in_filter_rules)
         for rule in in_rules:
             if not 'nova' in rule:
                 self.assertTrue(rule in self.out_rules,
@@ -338,6 +353,7 @@ class IptablesFirewallTestCase(test.TestCase):
 
         instance_chain = None
         for rule in self.out_rules:
+            print rule
             # This is pretty crude, but it'll do for now
             if '-d 10.11.12.13 -j' in rule:
                 instance_chain = rule.split(' ')[-1]
@@ -353,17 +369,18 @@ class IptablesFirewallTestCase(test.TestCase):
         self.assertTrue(security_group_chain,
                         "The security group chain wasn't added")
 
-        self.assertTrue('-A %s -p icmp -s 192.168.11.0/24 -j ACCEPT' % \
-                               security_group_chain in self.out_rules,
+        regex = re.compile('-A .* -p icmp -s 192.168.11.0/24 -j ACCEPT')
+        self.assertTrue(len(filter(regex.match, self.out_rules)) > 0,
                         "ICMP acceptance rule wasn't added")
 
-        self.assertTrue('-A %s -p icmp -s 192.168.11.0/24 -m icmp --icmp-type '
-                        '8 -j ACCEPT' % security_group_chain in self.out_rules,
+        regex = re.compile('-A .* -p icmp -s 192.168.11.0/24 -m icmp '
+                           '--icmp-type 8 -j ACCEPT')
+        self.assertTrue(len(filter(regex.match, self.out_rules)) > 0,
                         "ICMP Echo Request acceptance rule wasn't added")
 
-        self.assertTrue('-A %s -p tcp -s 192.168.10.0/24 -m multiport '
-                        '--dports 80:81 -j ACCEPT' % security_group_chain \
-                            in self.out_rules,
+        regex = re.compile('-A .* -p tcp -s 192.168.10.0/24 -m multiport '
+                           '--dports 80:81 -j ACCEPT')
+        self.assertTrue(len(filter(regex.match, self.out_rules)) > 0,
                         "TCP port 80/81 acceptance rule wasn't added")
 
 

From dfb531f8367d24af4d119ba5b17d6929db1e9261 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 21 Feb 2011 14:16:42 +0100
Subject: [PATCH 22/77] PEP-8 fixes

---
 nova/tests/test_network.py | 21 +++++++++------------
 nova/tests/test_virt.py    |  3 ++-
 2 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index b28d6424..c9a62a39 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -42,15 +42,14 @@ class IptablesManagerTestCase(test.TestCase):
 :INPUT ACCEPT [2223527:305688874]
 :FORWARD ACCEPT [0:0]
 :OUTPUT ACCEPT [2172501:140856656]
--A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT 
--A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT 
--A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT 
--A INPUT -i virbr0 -p tcp -m tcp --dport 67 -j ACCEPT 
--A FORWARD -d 192.168.122.0/24 -o virbr0 -m state --state RELATED,ESTABLISHED -j ACCEPT 
--A FORWARD -s 192.168.122.0/24 -i virbr0 -j ACCEPT 
--A FORWARD -i virbr0 -o virbr0 -j ACCEPT 
--A FORWARD -o virbr0 -j REJECT --reject-with icmp-port-unreachable 
--A FORWARD -i virbr0 -j REJECT --reject-with icmp-port-unreachable 
+-A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT
+-A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT
+-A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT
+-A INPUT -i virbr0 -p tcp -m tcp --dport 67 -j ACCEPT
+-A FORWARD -s 192.168.122.0/24 -i virbr0 -j ACCEPT
+-A FORWARD -i virbr0 -o virbr0 -j ACCEPT
+-A FORWARD -o virbr0 -j REJECT --reject-with icmp-port-unreachable
+-A FORWARD -i virbr0 -j REJECT --reject-with icmp-port-unreachable
 COMMIT
 # Completed on Fri Feb 18 15:17:05 2011"""
 
@@ -77,8 +76,7 @@ COMMIT
 
         # TODO(soren): Add stuff for ipv6
         check_matrix = {4: {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
-                            'nat': ['PREROUTING', 'INPUT',
-                                    'OUTPUT', 'POSTROUTING']} }
+                            'nat': ['PREROUTING', 'OUTPUT', 'POSTROUTING']}}
 
         for ip_version in check_matrix:
             ip = getattr(self.manager, 'ipv%d' % ip_version)
@@ -90,7 +88,6 @@ COMMIT
                                     (chain,) in new_lines)
                     self.assertTrue('-A %s -j run_tests.py-%s' % \
                                     (chain, chain) in new_lines)
-                print '\n'.join(new_lines)
 
 
 class NetworkTestCase(test.TestCase):
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index a88e0181..11201788 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -345,7 +345,8 @@ class IptablesFirewallTestCase(test.TestCase):
         self.fw.prepare_instance_filter(instance_ref)
         self.fw.apply_instance_filter(instance_ref)
 
-        in_rules = filter(lambda l: not l.startswith('#'), self.in_filter_rules)
+        in_rules = filter(lambda l: not l.startswith('#'),
+                          self.in_filter_rules)
         for rule in in_rules:
             if not 'nova' in rule:
                 self.assertTrue(rule in self.out_rules,

From f8ae315d71279fc26dae3fd8ae1dd3bd734ce13d Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 21 Feb 2011 14:39:02 +0100
Subject: [PATCH 23/77] Wrap ipv6 rules, too

---
 nova/tests/test_network.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index c9a62a39..f1d4fe13 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -76,7 +76,8 @@ COMMIT
 
         # TODO(soren): Add stuff for ipv6
         check_matrix = {4: {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
-                            'nat': ['PREROUTING', 'OUTPUT', 'POSTROUTING']}}
+                            'nat': ['PREROUTING', 'OUTPUT', 'POSTROUTING']},
+                        6: {'filter': ['INPUT', 'OUTPUT', 'FORWARD']}}
 
         for ip_version in check_matrix:
             ip = getattr(self.manager, 'ipv%d' % ip_version)

From 487ef09a17ec9979e1d39b5e979ff1c70d7e015e Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Feb 2011 09:00:29 +0100
Subject: [PATCH 24/77] Address some review comments.

---
 nova/tests/test_virt.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index 11201788..c2c7c833 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -354,7 +354,6 @@ class IptablesFirewallTestCase(test.TestCase):
 
         instance_chain = None
         for rule in self.out_rules:
-            print rule
             # This is pretty crude, but it'll do for now
             if '-d 10.11.12.13 -j' in rule:
                 instance_chain = rule.split(' ')[-1]

From 64cfdd1e23d68f2afb502c64c7c5c72c3a01e8d1 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Feb 2011 11:29:58 +0100
Subject: [PATCH 25/77] Add a bunch of tests for everything.

Add a 'head' kwarg to add_rule that lets the rule bubble to the top. This is needed for nova-filter-top to end up at the top.
---
 nova/tests/test_network.py | 124 +++++++++++++++++++++++++++++++------
 1 file changed, 104 insertions(+), 20 deletions(-)

diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index f1d4fe13..afd38272 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -36,12 +36,22 @@ LOG = logging.getLogger('nova.tests.network')
 
 
 class IptablesManagerTestCase(test.TestCase):
-    sample_filter = """# Completed on Fri Feb 18 15:17:05 2011
-# Generated by iptables-save v1.4.10 on Fri Feb 18 15:17:05 2011
+    sample_filter = """# Generated by iptables-save on Fri Feb 18 15:17:05 2011
 *filter
 :INPUT ACCEPT [2223527:305688874]
 :FORWARD ACCEPT [0:0]
 :OUTPUT ACCEPT [2172501:140856656]
+:nova-compute-FORWARD - [0:0]
+:nova-compute-INPUT - [0:0]
+:nova-compute-local - [0:0]
+:nova-compute-OUTPUT - [0:0]
+:nova-filter-top - [0:0]
+-A FORWARD -j nova-filter-top
+-A OUTPUT -j nova-filter-top
+-A nova-filter-top -j nova-compute-local
+-A INPUT -j nova-compute-INPUT
+-A OUTPUT -j nova-compute-OUTPUT
+-A FORWARD -j nova-compute-FORWARD
 -A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT
 -A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT
 -A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT
@@ -53,42 +63,116 @@ class IptablesManagerTestCase(test.TestCase):
 COMMIT
 # Completed on Fri Feb 18 15:17:05 2011"""
 
+    sample_nat = """# Generated by iptables-save on Fri Feb 18 15:17:05 2011
+*nat
+:PREROUTING ACCEPT [3936:762355]
+:INPUT ACCEPT [2447:225266]
+:OUTPUT ACCEPT [63491:4191863]
+:POSTROUTING ACCEPT [63112:4108641]
+:nova-compute-OUTPUT - [0:0]
+:nova-compute-floating-ip-snat - [0:0]
+:nova-compute-SNATTING - [0:0]
+:nova-compute-PREROUTING - [0:0]
+:nova-compute-POSTROUTING - [0:0]
+:nova-postrouting-bottom - [0:0]
+-A PREROUTING -j nova-compute-PREROUTING
+-A OUTPUT -j nova-compute-OUTPUT
+-A POSTROUTING -j nova-compute-POSTROUTING
+-A POSTROUTING -j nova-postrouting-bottom
+-A nova-postrouting-bottom -j nova-compute-SNATTING
+-A nova-compute-SNATTING -j nova-compute-floating-ip-snat
+COMMIT
+# Completed on Fri Feb 18 15:17:05 2011
+"""
+
     def setUp(self):
         super(IptablesManagerTestCase, self).setUp()
         self.manager = linux_net.IptablesManager()
 
-    def test_rules_are_wrapped(self):
+        
+    def test_filter_rules_are_wrapped(self):
         current_lines = self.sample_filter.split('\n')
 
         table = self.manager.ipv4['filter']
         table.add_rule('FORWARD', '-s 1.2.3.4/5 -j DROP')
-        new_lines = self.manager.modify_rules(current_lines, table)
+        new_lines = self.manager._modify_rules(current_lines, table)
         self.assertTrue('-A run_tests.py-FORWARD '
                         '-s 1.2.3.4/5 -j DROP' in new_lines)
 
         table.remove_rule('FORWARD', '-s 1.2.3.4/5 -j DROP')
-        new_lines = self.manager.modify_rules(current_lines, table)
+        new_lines = self.manager._modify_rules(current_lines, table)
         self.assertTrue('-A run_tests.py-FORWARD '
                         '-s 1.2.3.4/5 -j DROP' not in new_lines)
 
-    def test_wrapper_rules_in_place(self):
+    def test_nat_rules(self):
+        current_lines = self.sample_nat.split('\n')
+        new_lines = self.manager._modify_rules(current_lines,
+                                               self.manager.ipv4['nat'])
+
+        for line in [':nova-compute-OUTPUT - [0:0]',
+                     ':nova-compute-floating-ip-snat - [0:0]',
+                     ':nova-compute-SNATTING - [0:0]',
+                     ':nova-compute-PREROUTING - [0:0]',
+                     ':nova-compute-POSTROUTING - [0:0]']:
+             self.assertTrue(line in new_lines, "One of nova-compute's chains "
+                                                "went missing.")
+
+        seen_lines = set()
+        for line in new_lines:
+            self.assertTrue(line not in seen_lines,
+                            "Duplicate line: %s" % line)
+            seen_lines.add(line)
+
+        last_postrouting_line = ''
+
+        for line in new_lines:
+            if line.startswith('-A POSTROUTING'):
+                last_postrouting_line = line
+
+        self.assertTrue('-j nova-postrouting-bottom' in last_postrouting_line,
+                        "Last POSTROUTING rule does not jump to "
+                        "nova-postouting-bottom: %s" % last_postrouting_line)
+
+        for chain in ['POSTROUTING', 'PREROUTING', 'OUTPUT']:
+            self.assertTrue('-A %s -j run_tests.py-%s' \
+                            % (chain, chain) in new_lines,
+                            "Built-in chain %s not wrapped" % (chain,))
+
+
+    def test_filter_rules(self):
         current_lines = self.sample_filter.split('\n')
+        new_lines = self.manager._modify_rules(current_lines,
+                                               self.manager.ipv4['filter'])
 
-        # TODO(soren): Add stuff for ipv6
-        check_matrix = {4: {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
-                            'nat': ['PREROUTING', 'OUTPUT', 'POSTROUTING']},
-                        6: {'filter': ['INPUT', 'OUTPUT', 'FORWARD']}}
+        for line in [':nova-compute-FORWARD - [0:0]',
+                     ':nova-compute-INPUT - [0:0]',
+                     ':nova-compute-local - [0:0]',
+                     ':nova-compute-OUTPUT - [0:0]']:
+             self.assertTrue(line in new_lines, "One of nova-compute's chains"
+                                                " went missing.")
 
-        for ip_version in check_matrix:
-            ip = getattr(self.manager, 'ipv%d' % ip_version)
-            for table_name in ip:
-                table = ip[table_name]
-                new_lines = self.manager.modify_rules(current_lines, table)
-                for chain in check_matrix[ip_version][table_name]:
-                    self.assertTrue(':run_tests.py-%s - [0:0]' % \
-                                    (chain,) in new_lines)
-                    self.assertTrue('-A %s -j run_tests.py-%s' % \
-                                    (chain, chain) in new_lines)
+        seen_lines = set()
+        for line in new_lines:
+            self.assertTrue(line not in seen_lines,
+                            "Duplicate line: %s" % line)
+            seen_lines.add(line)
+
+        for chain in ['FORWARD', 'OUTPUT']:
+            for line in new_lines:
+                if line.startswith('-A %s' % chain):
+                    self.assertTrue('-j nova-filter-top' in line,
+                                    "First %s rule does not "
+                                    "jump to nova-filter-top" % chain)
+                    break
+
+        self.assertTrue('-A nova-filter-top '
+                        '-j run_tests.py-local' in new_lines,
+                        "nova-filter-top does not jump to wrapped local chain")
+
+        for chain in ['INPUT', 'OUTPUT', 'FORWARD']:
+            self.assertTrue('-A %s -j run_tests.py-%s' \
+                            % (chain, chain) in new_lines,
+                            "Built-in chain %s not wrapped" % (chain,))
 
 
 class NetworkTestCase(test.TestCase):

From e8f18a2380cb6cc142bc701c23427c5de792f5b8 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Feb 2011 12:21:29 +0100
Subject: [PATCH 26/77] PEP8 adjustments.

---
 nova/tests/test_network.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index afd38272..2bdf3709 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -89,7 +89,6 @@ COMMIT
         super(IptablesManagerTestCase, self).setUp()
         self.manager = linux_net.IptablesManager()
 
-        
     def test_filter_rules_are_wrapped(self):
         current_lines = self.sample_filter.split('\n')
 
@@ -114,8 +113,8 @@ COMMIT
                      ':nova-compute-SNATTING - [0:0]',
                      ':nova-compute-PREROUTING - [0:0]',
                      ':nova-compute-POSTROUTING - [0:0]']:
-             self.assertTrue(line in new_lines, "One of nova-compute's chains "
-                                                "went missing.")
+            self.assertTrue(line in new_lines, "One of nova-compute's chains "
+                                               "went missing.")
 
         seen_lines = set()
         for line in new_lines:
@@ -138,7 +137,6 @@ COMMIT
                             % (chain, chain) in new_lines,
                             "Built-in chain %s not wrapped" % (chain,))
 
-
     def test_filter_rules(self):
         current_lines = self.sample_filter.split('\n')
         new_lines = self.manager._modify_rules(current_lines,
@@ -148,8 +146,8 @@ COMMIT
                      ':nova-compute-INPUT - [0:0]',
                      ':nova-compute-local - [0:0]',
                      ':nova-compute-OUTPUT - [0:0]']:
-             self.assertTrue(line in new_lines, "One of nova-compute's chains"
-                                                " went missing.")
+            self.assertTrue(line in new_lines, "One of nova-compute's chains"
+                                               " went missing.")
 
         seen_lines = set()
         for line in new_lines:

From 96c43b0d24dc5e14dfceb355fba6158991e64c8b Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Feb 2011 14:32:20 +0100
Subject: [PATCH 27/77] Account for the fact that iptables-save outputs rules
 with a space at the end. Reverse the rule deduplication so that the last one
 takes precedence.

---
 nova/tests/test_network.py | 42 ++++++++++++++++++++------------------
 1 file changed, 22 insertions(+), 20 deletions(-)

diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index 2bdf3709..b1d70e32 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -46,20 +46,20 @@ class IptablesManagerTestCase(test.TestCase):
 :nova-compute-local - [0:0]
 :nova-compute-OUTPUT - [0:0]
 :nova-filter-top - [0:0]
--A FORWARD -j nova-filter-top
--A OUTPUT -j nova-filter-top
--A nova-filter-top -j nova-compute-local
--A INPUT -j nova-compute-INPUT
--A OUTPUT -j nova-compute-OUTPUT
--A FORWARD -j nova-compute-FORWARD
--A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT
--A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT
--A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT
--A INPUT -i virbr0 -p tcp -m tcp --dport 67 -j ACCEPT
--A FORWARD -s 192.168.122.0/24 -i virbr0 -j ACCEPT
--A FORWARD -i virbr0 -o virbr0 -j ACCEPT
--A FORWARD -o virbr0 -j REJECT --reject-with icmp-port-unreachable
--A FORWARD -i virbr0 -j REJECT --reject-with icmp-port-unreachable
+-A FORWARD -j nova-filter-top 
+-A OUTPUT -j nova-filter-top 
+-A nova-filter-top -j nova-compute-local 
+-A INPUT -j nova-compute-INPUT 
+-A OUTPUT -j nova-compute-OUTPUT 
+-A FORWARD -j nova-compute-FORWARD 
+-A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT 
+-A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT 
+-A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT 
+-A INPUT -i virbr0 -p tcp -m tcp --dport 67 -j ACCEPT 
+-A FORWARD -s 192.168.122.0/24 -i virbr0 -j ACCEPT 
+-A FORWARD -i virbr0 -o virbr0 -j ACCEPT 
+-A FORWARD -o virbr0 -j REJECT --reject-with icmp-port-unreachable 
+-A FORWARD -i virbr0 -j REJECT --reject-with icmp-port-unreachable 
 COMMIT
 # Completed on Fri Feb 18 15:17:05 2011"""
 
@@ -75,12 +75,12 @@ COMMIT
 :nova-compute-PREROUTING - [0:0]
 :nova-compute-POSTROUTING - [0:0]
 :nova-postrouting-bottom - [0:0]
--A PREROUTING -j nova-compute-PREROUTING
--A OUTPUT -j nova-compute-OUTPUT
--A POSTROUTING -j nova-compute-POSTROUTING
--A POSTROUTING -j nova-postrouting-bottom
--A nova-postrouting-bottom -j nova-compute-SNATTING
--A nova-compute-SNATTING -j nova-compute-floating-ip-snat
+-A PREROUTING -j nova-compute-PREROUTING 
+-A OUTPUT -j nova-compute-OUTPUT 
+-A POSTROUTING -j nova-compute-POSTROUTING 
+-A POSTROUTING -j nova-postrouting-bottom 
+-A nova-postrouting-bottom -j nova-compute-SNATTING 
+-A nova-compute-SNATTING -j nova-compute-floating-ip-snat 
 COMMIT
 # Completed on Fri Feb 18 15:17:05 2011
 """
@@ -118,6 +118,7 @@ COMMIT
 
         seen_lines = set()
         for line in new_lines:
+            line = line.strip()
             self.assertTrue(line not in seen_lines,
                             "Duplicate line: %s" % line)
             seen_lines.add(line)
@@ -151,6 +152,7 @@ COMMIT
 
         seen_lines = set()
         for line in new_lines:
+            line = line.strip()
             self.assertTrue(line not in seen_lines,
                             "Duplicate line: %s" % line)
             seen_lines.add(line)

From 1eb5721fe64f31e97016184c197fc70db6ead15e Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 22 Feb 2011 14:40:00 +0100
Subject: [PATCH 28/77] PEP8 again

---
 nova/tests/test_network.py | 101 +++++++++++++++++++------------------
 1 file changed, 51 insertions(+), 50 deletions(-)

diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index b1d70e32..d3a23abf 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -36,61 +36,62 @@ LOG = logging.getLogger('nova.tests.network')
 
 
 class IptablesManagerTestCase(test.TestCase):
-    sample_filter = """# Generated by iptables-save on Fri Feb 18 15:17:05 2011
-*filter
-:INPUT ACCEPT [2223527:305688874]
-:FORWARD ACCEPT [0:0]
-:OUTPUT ACCEPT [2172501:140856656]
-:nova-compute-FORWARD - [0:0]
-:nova-compute-INPUT - [0:0]
-:nova-compute-local - [0:0]
-:nova-compute-OUTPUT - [0:0]
-:nova-filter-top - [0:0]
--A FORWARD -j nova-filter-top 
--A OUTPUT -j nova-filter-top 
--A nova-filter-top -j nova-compute-local 
--A INPUT -j nova-compute-INPUT 
--A OUTPUT -j nova-compute-OUTPUT 
--A FORWARD -j nova-compute-FORWARD 
--A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT 
--A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT 
--A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT 
--A INPUT -i virbr0 -p tcp -m tcp --dport 67 -j ACCEPT 
--A FORWARD -s 192.168.122.0/24 -i virbr0 -j ACCEPT 
--A FORWARD -i virbr0 -o virbr0 -j ACCEPT 
--A FORWARD -o virbr0 -j REJECT --reject-with icmp-port-unreachable 
--A FORWARD -i virbr0 -j REJECT --reject-with icmp-port-unreachable 
-COMMIT
-# Completed on Fri Feb 18 15:17:05 2011"""
+    sample_filter = ['#Generated by iptables-save on Fri Feb 18 15:17:05 2011',
+                     '*filter',
+                     ':INPUT ACCEPT [2223527:305688874]',
+                     ':FORWARD ACCEPT [0:0]',
+                     ':OUTPUT ACCEPT [2172501:140856656]',
+                     ':nova-compute-FORWARD - [0:0]',
+                     ':nova-compute-INPUT - [0:0]',
+                     ':nova-compute-local - [0:0]',
+                     ':nova-compute-OUTPUT - [0:0]',
+                     ':nova-filter-top - [0:0]',
+                     '-A FORWARD -j nova-filter-top ',
+                     '-A OUTPUT -j nova-filter-top ',
+                     '-A nova-filter-top -j nova-compute-local ',
+                     '-A INPUT -j nova-compute-INPUT ',
+                     '-A OUTPUT -j nova-compute-OUTPUT ',
+                     '-A FORWARD -j nova-compute-FORWARD ',
+                     '-A INPUT -i virbr0 -p udp -m udp --dport 53 -j ACCEPT ',
+                     '-A INPUT -i virbr0 -p tcp -m tcp --dport 53 -j ACCEPT ',
+                     '-A INPUT -i virbr0 -p udp -m udp --dport 67 -j ACCEPT ',
+                     '-A INPUT -i virbr0 -p tcp -m tcp --dport 67 -j ACCEPT ',
+                     '-A FORWARD -s 192.168.122.0/24 -i virbr0 -j ACCEPT ',
+                     '-A FORWARD -i virbr0 -o virbr0 -j ACCEPT ',
+                     '-A FORWARD -o virbr0 -j REJECT --reject-with '
+                     'icmp-port-unreachable ',
+                     '-A FORWARD -i virbr0 -j REJECT --reject-with '
+                     'icmp-port-unreachable ',
+                     'COMMIT',
+                     '# Completed on Fri Feb 18 15:17:05 2011']
 
-    sample_nat = """# Generated by iptables-save on Fri Feb 18 15:17:05 2011
-*nat
-:PREROUTING ACCEPT [3936:762355]
-:INPUT ACCEPT [2447:225266]
-:OUTPUT ACCEPT [63491:4191863]
-:POSTROUTING ACCEPT [63112:4108641]
-:nova-compute-OUTPUT - [0:0]
-:nova-compute-floating-ip-snat - [0:0]
-:nova-compute-SNATTING - [0:0]
-:nova-compute-PREROUTING - [0:0]
-:nova-compute-POSTROUTING - [0:0]
-:nova-postrouting-bottom - [0:0]
--A PREROUTING -j nova-compute-PREROUTING 
--A OUTPUT -j nova-compute-OUTPUT 
--A POSTROUTING -j nova-compute-POSTROUTING 
--A POSTROUTING -j nova-postrouting-bottom 
--A nova-postrouting-bottom -j nova-compute-SNATTING 
--A nova-compute-SNATTING -j nova-compute-floating-ip-snat 
-COMMIT
-# Completed on Fri Feb 18 15:17:05 2011
-"""
+    sample_nat = ['# Generated by iptables-save on Fri Feb 18 15:17:05 2011',
+                  '*nat',
+                  ':PREROUTING ACCEPT [3936:762355]',
+                  ':INPUT ACCEPT [2447:225266]',
+                  ':OUTPUT ACCEPT [63491:4191863]',
+                  ':POSTROUTING ACCEPT [63112:4108641]',
+                  ':nova-compute-OUTPUT - [0:0]',
+                  ':nova-compute-floating-ip-snat - [0:0]',
+                  ':nova-compute-SNATTING - [0:0]',
+                  ':nova-compute-PREROUTING - [0:0]',
+                  ':nova-compute-POSTROUTING - [0:0]',
+                  ':nova-postrouting-bottom - [0:0]',
+                  '-A PREROUTING -j nova-compute-PREROUTING ',
+                  '-A OUTPUT -j nova-compute-OUTPUT ',
+                  '-A POSTROUTING -j nova-compute-POSTROUTING ',
+                  '-A POSTROUTING -j nova-postrouting-bottom ',
+                  '-A nova-postrouting-bottom -j nova-compute-SNATTING ',
+                  '-A nova-compute-SNATTING -j nova-compute-floating-ip-snat ',
+                  'COMMIT',
+                  '# Completed on Fri Feb 18 15:17:05 2011']
 
     def setUp(self):
         super(IptablesManagerTestCase, self).setUp()
         self.manager = linux_net.IptablesManager()
 
     def test_filter_rules_are_wrapped(self):
-        current_lines = self.sample_filter.split('\n')
+        current_lines = self.sample_filter
 
         table = self.manager.ipv4['filter']
         table.add_rule('FORWARD', '-s 1.2.3.4/5 -j DROP')
@@ -104,7 +105,7 @@ COMMIT
                         '-s 1.2.3.4/5 -j DROP' not in new_lines)
 
     def test_nat_rules(self):
-        current_lines = self.sample_nat.split('\n')
+        current_lines = self.sample_nat
         new_lines = self.manager._modify_rules(current_lines,
                                                self.manager.ipv4['nat'])
 
@@ -139,7 +140,7 @@ COMMIT
                             "Built-in chain %s not wrapped" % (chain,))
 
     def test_filter_rules(self):
-        current_lines = self.sample_filter.split('\n')
+        current_lines = self.sample_filter
         new_lines = self.manager._modify_rules(current_lines,
                                                self.manager.ipv4['filter'])
 

From 5d79ec726f4e4560d8fd54c2bc6c8fe3a8c81061 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Feb 2011 15:05:48 -0800
Subject: [PATCH 29/77] We're not using prefix matching on AMQP, so fakerabbit
 shouldn't be doing it!

---
 nova/fakerabbit.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/nova/fakerabbit.py b/nova/fakerabbit.py
index dd82a936..a7dee8ca 100644
--- a/nova/fakerabbit.py
+++ b/nova/fakerabbit.py
@@ -48,7 +48,6 @@ class Exchange(object):
         nm = self.name
         LOG.debug(_('(%(nm)s) publish (key: %(routing_key)s)'
                 ' %(message)s') % locals())
-        routing_key = routing_key.split('.')[0]
         if routing_key in self._routes:
             for f in self._routes[routing_key]:
                 LOG.debug(_('Publishing to route %s'), f)

From b7f9513a5f3b3af563d7b4974b69a2b227d0f8df Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Feb 2011 17:45:38 -0800
Subject: [PATCH 30/77] Refactoring nova-api to be a service, so that we can
 reuse it in tests

---
 bin/nova-api       | 50 +++------------------------
 nova/apiservice.py | 85 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 90 insertions(+), 45 deletions(-)
 create mode 100644 nova/apiservice.py

diff --git a/bin/nova-api b/bin/nova-api
index d5efb468..99417e6c 100755
--- a/bin/nova-api
+++ b/bin/nova-api
@@ -36,57 +36,17 @@ gettext.install('nova', unicode=1)
 
 from nova import flags
 from nova import log as logging
-from nova import version
+from nova import apiservice
+from nova import utils
 from nova import wsgi
 
-LOG = logging.getLogger('nova.api')
-
 FLAGS = flags.FLAGS
-flags.DEFINE_string('ec2_listen', "0.0.0.0",
-                    'IP address for EC2 API to listen')
-flags.DEFINE_integer('ec2_listen_port', 8773, 'port for ec2 api to listen')
-flags.DEFINE_string('osapi_listen', "0.0.0.0",
-                    'IP address for OpenStack API to listen')
-flags.DEFINE_integer('osapi_listen_port', 8774, 'port for os api to listen')
-
-API_ENDPOINTS = ['ec2', 'osapi']
-
-
-def run_app(paste_config_file):
-    LOG.debug(_("Using paste.deploy config at: %s"), paste_config_file)
-    apps = []
-    for api in API_ENDPOINTS:
-        config = wsgi.load_paste_configuration(paste_config_file, api)
-        if config is None:
-            LOG.debug(_("No paste configuration for app: %s"), api)
-            continue
-        LOG.debug(_("App Config: %(api)s\n%(config)r") % locals())
-        LOG.info(_("Running %s API"), api)
-        app = wsgi.load_paste_app(paste_config_file, api)
-        apps.append((app, getattr(FLAGS, "%s_listen_port" % api),
-                     getattr(FLAGS, "%s_listen" % api)))
-    if len(apps) == 0:
-        LOG.error(_("No known API applications configured in %s."),
-                  paste_config_file)
-        return
-
-    server = wsgi.Server()
-    for app in apps:
-        server.start(*app)
-    server.wait()
-
 
 if __name__ == '__main__':
     FLAGS(sys.argv)
     logging.setup()
-    LOG.audit(_("Starting nova-api node (version %s)"),
-              version.version_string_with_vcs())
-    LOG.debug(_("Full set of FLAGS:"))
-    for flag in FLAGS:
-        flag_get = FLAGS.get(flag, None)
-        LOG.debug("%(flag)s : %(flag_get)s" % locals())
     conf = wsgi.paste_config_file('nova-api.conf')
-    if conf:
-        run_app(conf)
-    else:
+    if not conf:
         LOG.error(_("No paste configuration found for: %s"), 'nova-api.conf')
+    else:
+        apiservice.serve(conf)
diff --git a/nova/apiservice.py b/nova/apiservice.py
new file mode 100644
index 00000000..7b453e19
--- /dev/null
+++ b/nova/apiservice.py
@@ -0,0 +1,85 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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.
+
+"""
+Wrapper for API service, makes it look more like the non-WSGI services
+"""
+
+from nova import flags
+from nova import log as logging
+from nova import version
+from nova import wsgi
+
+
+LOG = logging.getLogger('nova.api')
+
+FLAGS = flags.FLAGS
+flags.DEFINE_string('ec2_listen', "0.0.0.0",
+                    'IP address for EC2 API to listen')
+flags.DEFINE_integer('ec2_listen_port', 8773, 'port for ec2 api to listen')
+flags.DEFINE_string('osapi_listen', "0.0.0.0",
+                    'IP address for OpenStack API to listen')
+flags.DEFINE_integer('osapi_listen_port', 8774, 'port for os api to listen')
+
+API_ENDPOINTS = ['ec2', 'osapi']
+
+
+def _run_app(paste_config_file):
+    LOG.debug(_("Using paste.deploy config at: %s"), paste_config_file)
+    apps = []
+    for api in API_ENDPOINTS:
+        config = wsgi.load_paste_configuration(paste_config_file, api)
+        if config is None:
+            LOG.debug(_("No paste configuration for app: %s"), api)
+            continue
+        LOG.debug(_("App Config: %(api)s\n%(config)r") % locals())
+        LOG.info(_("Running %s API"), api)
+        app = wsgi.load_paste_app(paste_config_file, api)
+        apps.append((app, getattr(FLAGS, "%s_listen_port" % api),
+                     getattr(FLAGS, "%s_listen" % api)))
+    if len(apps) == 0:
+        LOG.error(_("No known API applications configured in %s."),
+                  paste_config_file)
+        return
+
+    server = wsgi.Server()
+    for app in apps:
+        server.start(*app)
+    server.wait()
+
+
+class ApiService(object):
+    """Base class for workers that run on hosts."""
+
+    def __init__(self, conf):
+        self.conf = conf
+
+    def start(self):
+        _run_app(self.conf)
+
+
+def serve(conf):
+    LOG.audit(_("Starting nova-api node (version %s)"),
+              version.version_string_with_vcs())
+    LOG.debug(_("Full set of FLAGS:"))
+    for flag in FLAGS:
+        flag_get = FLAGS.get(flag, None)
+        LOG.debug("%(flag)s : %(flag_get)s" % locals())
+
+    service = ApiService(conf)
+    service.start()

From c42021d027fcb690e189246ead281e6af89fc38c Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Feb 2011 17:50:26 -0800
Subject: [PATCH 31/77] Added create static method to ApiService

---
 nova/apiservice.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/nova/apiservice.py b/nova/apiservice.py
index 7b453e19..1914b9e5 100644
--- a/nova/apiservice.py
+++ b/nova/apiservice.py
@@ -72,6 +72,11 @@ class ApiService(object):
     def start(self):
         _run_app(self.conf)
 
+    @staticmethod
+    def create():
+        conf = wsgi.paste_config_file('nova-api.conf')
+        return serve(conf)
+
 
 def serve(conf):
     LOG.audit(_("Starting nova-api node (version %s)"),
@@ -83,3 +88,5 @@ def serve(conf):
 
     service = ApiService(conf)
     service.start()
+
+    return service

From c404b9d88f66d27c5bd79cbb02e91b8e0aa9c22b Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Feb 2011 17:58:01 -0800
Subject: [PATCH 32/77] Support service-like wait behaviour for API service

---
 bin/nova-api       | 3 ++-
 nova/apiservice.py | 8 ++++++--
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/bin/nova-api b/bin/nova-api
index 99417e6c..ccb7701a 100755
--- a/bin/nova-api
+++ b/bin/nova-api
@@ -49,4 +49,5 @@ if __name__ == '__main__':
     if not conf:
         LOG.error(_("No paste configuration found for: %s"), 'nova-api.conf')
     else:
-        apiservice.serve(conf)
+        service = apiservice.serve(conf)
+        service.wait()
diff --git a/nova/apiservice.py b/nova/apiservice.py
index 1914b9e5..14239f19 100644
--- a/nova/apiservice.py
+++ b/nova/apiservice.py
@@ -60,7 +60,7 @@ def _run_app(paste_config_file):
     server = wsgi.Server()
     for app in apps:
         server.start(*app)
-    server.wait()
+    return server
 
 
 class ApiService(object):
@@ -68,9 +68,13 @@ class ApiService(object):
 
     def __init__(self, conf):
         self.conf = conf
+        self.wsgi_app = None
 
     def start(self):
-        _run_app(self.conf)
+        self.wsgi_app = _run_app(self.conf)
+
+    def wait(self):
+        self.wsgi_app.wait()
 
     @staticmethod
     def create():

From 092fb67d8cece2ab0c50603e6310eca3c5a6cc28 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Feb 2011 18:15:29 -0800
Subject: [PATCH 33/77] Make static create method behave more like other
 services

---
 nova/apiservice.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/nova/apiservice.py b/nova/apiservice.py
index 14239f19..693bc9a6 100644
--- a/nova/apiservice.py
+++ b/nova/apiservice.py
@@ -79,7 +79,10 @@ class ApiService(object):
     @staticmethod
     def create():
         conf = wsgi.paste_config_file('nova-api.conf')
-        return serve(conf)
+        LOG.audit(_("Starting nova-api node (version %s)"),
+              version.version_string_with_vcs())
+        service = ApiService(conf)
+        return service
 
 
 def serve(conf):

From 2bec3de99a7675913c39b4267552a62f17c7385e Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Feb 2011 18:57:04 -0800
Subject: [PATCH 34/77] Exit with exit code 1 if conf cannot be read

---
 bin/nova-api | 1 +
 1 file changed, 1 insertion(+)

diff --git a/bin/nova-api b/bin/nova-api
index ccb7701a..d03be85e 100755
--- a/bin/nova-api
+++ b/bin/nova-api
@@ -48,6 +48,7 @@ if __name__ == '__main__':
     conf = wsgi.paste_config_file('nova-api.conf')
     if not conf:
         LOG.error(_("No paste configuration found for: %s"), 'nova-api.conf')
+        sys.exit(1)
     else:
         service = apiservice.serve(conf)
         service.wait()

From a79e842fe2e2026ade75959c1f507137e50e549a Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 22 Feb 2011 18:59:23 -0800
Subject: [PATCH 35/77] Removed unused import & formatting cleanups

---
 bin/nova-api       | 1 -
 nova/apiservice.py | 6 +++---
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/bin/nova-api b/bin/nova-api
index d03be85e..96c78462 100755
--- a/bin/nova-api
+++ b/bin/nova-api
@@ -37,7 +37,6 @@ gettext.install('nova', unicode=1)
 from nova import flags
 from nova import log as logging
 from nova import apiservice
-from nova import utils
 from nova import wsgi
 
 FLAGS = flags.FLAGS
diff --git a/nova/apiservice.py b/nova/apiservice.py
index 693bc9a6..6340e9b9 100644
--- a/nova/apiservice.py
+++ b/nova/apiservice.py
@@ -16,9 +16,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-"""
-Wrapper for API service, makes it look more like the non-WSGI services
-"""
+"""Wrapper for API service, makes it look more like the non-WSGI services"""
 
 from nova import flags
 from nova import log as logging
@@ -28,6 +26,7 @@ from nova import wsgi
 
 LOG = logging.getLogger('nova.api')
 
+
 FLAGS = flags.FLAGS
 flags.DEFINE_string('ec2_listen', "0.0.0.0",
                     'IP address for EC2 API to listen')
@@ -36,6 +35,7 @@ flags.DEFINE_string('osapi_listen', "0.0.0.0",
                     'IP address for OpenStack API to listen')
 flags.DEFINE_integer('osapi_listen_port', 8774, 'port for os api to listen')
 
+
 API_ENDPOINTS = ['ec2', 'osapi']
 
 

From 3edfdf2f39a75cedc442a72b685f63dab340e6be Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Wed, 23 Feb 2011 15:17:32 -0800
Subject: [PATCH 36/77] Alphabetize imports

---
 bin/nova-api | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bin/nova-api b/bin/nova-api
index 96c78462..933202dc 100755
--- a/bin/nova-api
+++ b/bin/nova-api
@@ -34,9 +34,9 @@ if os.path.exists(os.path.join(possible_topdir, 'nova', '__init__.py')):
 
 gettext.install('nova', unicode=1)
 
+from nova import apiservice
 from nova import flags
 from nova import log as logging
-from nova import apiservice
 from nova import wsgi
 
 FLAGS = flags.FLAGS

From 395d02aa37923f40e2542aaa1b7b7455c9060f15 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Wed, 23 Feb 2011 15:31:40 -0800
Subject: [PATCH 37/77] Changed create from a @staticmethod to a @classmethod

---
 nova/apiservice.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/nova/apiservice.py b/nova/apiservice.py
index 6340e9b9..03aa781f 100644
--- a/nova/apiservice.py
+++ b/nova/apiservice.py
@@ -76,12 +76,12 @@ class ApiService(object):
     def wait(self):
         self.wsgi_app.wait()
 
-    @staticmethod
-    def create():
+    @classmethod
+    def create(cls):
         conf = wsgi.paste_config_file('nova-api.conf')
         LOG.audit(_("Starting nova-api node (version %s)"),
               version.version_string_with_vcs())
-        service = ApiService(conf)
+        service = cls(conf)
         return service
 
 

From 53fcfc1cc5bc7b647ba8c096f3b7a9cc9527cbc8 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Fri, 25 Feb 2011 13:40:15 -0800
Subject: [PATCH 38/77] API changed to new style class

---
 nova/scheduler/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 8491bf3a..2405f134 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -25,7 +25,7 @@ FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.scheduler.api')
 
 
-class API:
+class API(object):
     """API for interacting with the scheduler."""
 
     def _call_scheduler(self, method, context, params=None):

From 0ec5806365e2b0c4d055d45677c4f83aa0351ab8 Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 28 Feb 2011 12:37:02 +0100
Subject: [PATCH 39/77] Add utils.synchronized decorator to allow for
 synchronising method entrance across multiple workers on the same host.

---
 nova/tests/test_misc.py | 37 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 36 insertions(+), 1 deletion(-)

diff --git a/nova/tests/test_misc.py b/nova/tests/test_misc.py
index e6da6112..154b6fae 100644
--- a/nova/tests/test_misc.py
+++ b/nova/tests/test_misc.py
@@ -14,10 +14,14 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+from datetime import datetime
+import errno
 import os
+import select
+import time
 
 from nova import test
-from nova.utils import parse_mailmap, str_dict_replace
+from nova.utils import parse_mailmap, str_dict_replace, synchronized
 
 
 class ProjectTestCase(test.TestCase):
@@ -55,3 +59,34 @@ class ProjectTestCase(test.TestCase):
                                 '%r not listed in Authors' % missing)
             finally:
                 tree.unlock()
+
+
+class LockTestCase(test.TestCase):
+    def test_synchronized(self):
+        rpipe, wpipe = os.pipe()
+        pid = os.fork()
+        if pid > 0:
+            os.close(wpipe)
+
+            @synchronized('testlock')
+            def f():
+                rfds, _, __ = select.select([rpipe], [], [], 1)
+                self.assertEquals(len(rfds), 0, "The other process, which was"
+                                                " supposed to be locked, "
+                                                "wrote on its end of the "
+                                                "pipe")
+                os.close(rpipe)
+
+            f()
+        else:
+            os.close(rpipe)
+
+            @synchronized('testlock')
+            def g():
+                try:
+                    os.write(wpipe, "foo")
+                except OSError, e:
+                    self.assertEquals(e.errno, errno.EPIPE)
+                    return
+            g()
+            os._exit(0)

From baec3cf72d747c867df1af979f6d347c1862f5d3 Mon Sep 17 00:00:00 2001
From: "Kevin L. Mitchell" <kevin.mitchell@rackspace.com>
Date: Mon, 28 Feb 2011 17:27:19 +0000
Subject: [PATCH 40/77] Suppress stack traces unless --verbose is specified

---
 nova/log.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/nova/log.py b/nova/log.py
index 87a21ddb..d194ab8f 100644
--- a/nova/log.py
+++ b/nova/log.py
@@ -266,7 +266,10 @@ class NovaRootLogger(NovaLogger):
 
 
 def handle_exception(type, value, tb):
-    logging.root.critical(str(value), exc_info=(type, value, tb))
+    extra = {}
+    if FLAGS.verbose:
+        extra['exc_info'] = (type, value, tb)
+    logging.root.critical(str(value), **extra)
 
 
 def reset():

From b4d5650e825f0f0fe98758254ae5f00ee6147b6c Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Mon, 28 Feb 2011 23:31:09 +0100
Subject: [PATCH 41/77] Add a lock_path flag for lock files.

---
 nova/flags.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/nova/flags.py b/nova/flags.py
index 8cf199b2..213d4d4e 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -321,6 +321,8 @@ DEFINE_integer('auth_token_ttl', 3600, 'Seconds for auth tokens to linger')
 
 DEFINE_string('state_path', os.path.join(os.path.dirname(__file__), '../'),
               "Top-level directory for maintaining nova's state")
+DEFINE_string('lock_path', os.path.join(os.path.dirname(__file__), '../'),
+              "Directory for lock files")
 DEFINE_string('logdir', None, 'output to a per-service log file in named '
                               'directory')
 

From 7a6e72eccd51b3910931f086b0ab2c7fc904040b Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Tue, 1 Mar 2011 20:49:46 +0100
Subject: [PATCH 42/77] Use functools.wraps to make sure wrapped method's
 metadata (docstring and name) doesn't get mangled.

---
 nova/tests/test_misc.py | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/nova/tests/test_misc.py b/nova/tests/test_misc.py
index 154b6fae..9f572b58 100644
--- a/nova/tests/test_misc.py
+++ b/nova/tests/test_misc.py
@@ -14,11 +14,9 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from datetime import datetime
 import errno
 import os
 import select
-import time
 
 from nova import test
 from nova.utils import parse_mailmap, str_dict_replace, synchronized
@@ -62,6 +60,16 @@ class ProjectTestCase(test.TestCase):
 
 
 class LockTestCase(test.TestCase):
+    def test_synchronized_wrapped_function_metadata(self):
+        @synchronized('whatever')
+        def foo():
+            """Bar"""
+            pass
+        self.assertEquals(foo.__doc__, 'Bar', "Wrapped function's docstring "
+                                              "got lost")
+        self.assertEquals(foo.__name__, 'foo', "Wrapped function's name "
+                                               "got mangled")
+
     def test_synchronized(self):
         rpipe, wpipe = os.pipe()
         pid = os.fork()

From 836cc550682b104fa51127c1ec53c0213690e7e5 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Thu, 3 Mar 2011 17:21:21 -0500
Subject: [PATCH 43/77] Refactor wsgi.Serializer away from handling Requests
 directly; now require Content-Type in all requests; fix tests according to
 new code

---
 nova/tests/test_direct.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/nova/tests/test_direct.py b/nova/tests/test_direct.py
index b6bfab53..85bfcfd8 100644
--- a/nova/tests/test_direct.py
+++ b/nova/tests/test_direct.py
@@ -59,6 +59,7 @@ class DirectTestCase(test.TestCase):
         req.headers['X-OpenStack-User'] = 'user1'
         req.headers['X-OpenStack-Project'] = 'proj1'
         resp = req.get_response(self.auth_router)
+        self.assertEqual(resp.status_int, 200)
         data = json.loads(resp.body)
         self.assertEqual(data['user'], 'user1')
         self.assertEqual(data['project'], 'proj1')
@@ -69,6 +70,7 @@ class DirectTestCase(test.TestCase):
         req.method = 'POST'
         req.body = 'json=%s' % json.dumps({'data': 'foo'})
         resp = req.get_response(self.router)
+        self.assertEqual(resp.status_int, 200)
         resp_parsed = json.loads(resp.body)
         self.assertEqual(resp_parsed['data'], 'foo')
 
@@ -78,6 +80,7 @@ class DirectTestCase(test.TestCase):
         req.method = 'POST'
         req.body = 'data=foo'
         resp = req.get_response(self.router)
+        self.assertEqual(resp.status_int, 200)
         resp_parsed = json.loads(resp.body)
         self.assertEqual(resp_parsed['data'], 'foo')
 

From 71f3fd6665b818e2195d96977244a08b74818b9b Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Fri, 4 Mar 2011 02:36:55 +0000
Subject: [PATCH 44/77] Replace objectstore images with S3 image service
 backending to glance or local

---
 bin/nova-manage            |  2 +-
 nova/flags.py              |  2 +-
 nova/tests/fake_flags.py   |  1 +
 nova/tests/test_cloud.py   | 22 +++++++++++++++-------
 nova/tests/test_compute.py |  7 ++++++-
 nova/tests/test_direct.py  |  3 +--
 6 files changed, 25 insertions(+), 12 deletions(-)

diff --git a/bin/nova-manage b/bin/nova-manage
index 9bf3a1bb..0f7604ae 100755
--- a/bin/nova-manage
+++ b/bin/nova-manage
@@ -81,7 +81,7 @@ from nova import log as logging
 from nova import quota
 from nova import rpc
 from nova import utils
-from nova.api.ec2.cloud import ec2_id_to_id
+from nova.api.ec2.ec2utils import ec2_id_to_id
 from nova.auth import manager
 from nova.cloudpipe import pipelib
 from nova.compute import instance_types
diff --git a/nova/flags.py b/nova/flags.py
index 8cf199b2..f01a4d09 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -346,7 +346,7 @@ DEFINE_string('scheduler_manager', 'nova.scheduler.manager.SchedulerManager',
               'Manager for scheduler')
 
 # The service to use for image search and retrieval
-DEFINE_string('image_service', 'nova.image.s3.S3ImageService',
+DEFINE_string('image_service', 'nova.image.glance.GlanceImageService',
               'The service to use for retrieving and searching for images.')
 
 DEFINE_string('host', socket.gethostname(),
diff --git a/nova/tests/fake_flags.py b/nova/tests/fake_flags.py
index cbd94947..5d7ca98b 100644
--- a/nova/tests/fake_flags.py
+++ b/nova/tests/fake_flags.py
@@ -32,6 +32,7 @@ flags.DECLARE('fake_network', 'nova.network.manager')
 FLAGS.network_size = 8
 FLAGS.num_networks = 2
 FLAGS.fake_network = True
+FLAGS.image_service = 'nova.image.local.LocalImageService'
 flags.DECLARE('num_shelves', 'nova.volume.driver')
 flags.DECLARE('blades_per_shelf', 'nova.volume.driver')
 flags.DECLARE('iscsi_num_targets', 'nova.volume.driver')
diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index 06191001..7d7b9165 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -38,6 +38,8 @@ from nova import test
 from nova.auth import manager
 from nova.compute import power_state
 from nova.api.ec2 import cloud
+from nova.api.ec2 import ec2utils
+from nova.image import local
 from nova.objectstore import image
 
 
@@ -76,6 +78,11 @@ class CloudTestCase(test.TestCase):
                                               project=self.project)
         host = self.network.get_network_host(self.context.elevated())
 
+        def fake_image_show(meh, context, id):
+            return dict(kernelId=1, ramdiskId=1)
+
+        self.stubs.Set(local.LocalImageService, 'show', fake_image_show)
+
     def tearDown(self):
         network_ref = db.project_get_network(self.context,
                                              self.project.id)
@@ -122,7 +129,7 @@ class CloudTestCase(test.TestCase):
         self.cloud.allocate_address(self.context)
         inst = db.instance_create(self.context, {'host': self.compute.host})
         fixed = self.network.allocate_fixed_ip(self.context, inst['id'])
-        ec2_id = cloud.id_to_ec2_id(inst['id'])
+        ec2_id = ec2utils.id_to_ec2_id(inst['id'])
         self.cloud.associate_address(self.context,
                                      instance_id=ec2_id,
                                      public_ip=address)
@@ -158,12 +165,12 @@ class CloudTestCase(test.TestCase):
         vol2 = db.volume_create(self.context, {})
         result = self.cloud.describe_volumes(self.context)
         self.assertEqual(len(result['volumeSet']), 2)
-        volume_id = cloud.id_to_ec2_id(vol2['id'], 'vol-%08x')
+        volume_id = ec2utils.id_to_ec2_id(vol2['id'], 'vol-%08x')
         result = self.cloud.describe_volumes(self.context,
                                              volume_id=[volume_id])
         self.assertEqual(len(result['volumeSet']), 1)
         self.assertEqual(
-                cloud.ec2_id_to_id(result['volumeSet'][0]['volumeId']),
+                ec2utils.ec2_id_to_id(result['volumeSet'][0]['volumeId']),
                 vol2['id'])
         db.volume_destroy(self.context, vol1['id'])
         db.volume_destroy(self.context, vol2['id'])
@@ -200,7 +207,7 @@ class CloudTestCase(test.TestCase):
         result = self.cloud.describe_instances(self.context)
         result = result['reservationSet'][0]
         self.assertEqual(len(result['instancesSet']), 2)
-        instance_id = cloud.id_to_ec2_id(inst2['id'])
+        instance_id = ec2utils.id_to_ec2_id(inst2['id'])
         result = self.cloud.describe_instances(self.context,
                                              instance_id=[instance_id])
         result = result['reservationSet'][0]
@@ -216,6 +223,7 @@ class CloudTestCase(test.TestCase):
 
     def test_console_output(self):
         image_id = FLAGS.default_image
+        print image_id
         instance_type = FLAGS.default_instance_type
         max_count = 1
         kwargs = {'image_id': image_id,
@@ -347,7 +355,7 @@ class CloudTestCase(test.TestCase):
 
     def test_update_of_instance_display_fields(self):
         inst = db.instance_create(self.context, {})
-        ec2_id = cloud.id_to_ec2_id(inst['id'])
+        ec2_id = ec2utils.id_to_ec2_id(inst['id'])
         self.cloud.update_instance(self.context, ec2_id,
                                    display_name='c00l 1m4g3')
         inst = db.instance_get(self.context, inst['id'])
@@ -365,7 +373,7 @@ class CloudTestCase(test.TestCase):
     def test_update_of_volume_display_fields(self):
         vol = db.volume_create(self.context, {})
         self.cloud.update_volume(self.context,
-                                 cloud.id_to_ec2_id(vol['id'], 'vol-%08x'),
+                                 ec2utils.id_to_ec2_id(vol['id'], 'vol-%08x'),
                                  display_name='c00l v0lum3')
         vol = db.volume_get(self.context, vol['id'])
         self.assertEqual('c00l v0lum3', vol['display_name'])
@@ -374,7 +382,7 @@ class CloudTestCase(test.TestCase):
     def test_update_of_volume_wont_update_private_fields(self):
         vol = db.volume_create(self.context, {})
         self.cloud.update_volume(self.context,
-                                 cloud.id_to_ec2_id(vol['id'], 'vol-%08x'),
+                                 ec2utils.id_to_ec2_id(vol['id'], 'vol-%08x'),
                                  mountpoint='/not/here')
         vol = db.volume_get(self.context, vol['id'])
         self.assertEqual(None, vol['mountpoint'])
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 949b5e6e..1f49baaf 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -31,7 +31,7 @@ from nova import test
 from nova import utils
 from nova.auth import manager
 from nova.compute import instance_types
-
+from nova.image import local
 
 LOG = logging.getLogger('nova.tests.compute')
 FLAGS = flags.FLAGS
@@ -47,6 +47,11 @@ class ComputeTestCase(test.TestCase):
                    network_manager='nova.network.manager.FlatManager')
         self.compute = utils.import_object(FLAGS.compute_manager)
         self.compute_api = compute.API()
+
+        def fake_image_show(meh, context, id):
+            return dict(kernelId=1, ramdiskId=1)
+
+        self.stubs.Set(local.LocalImageService, 'show', fake_image_show)
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('fake', 'fake', 'fake')
         self.project = self.manager.create_project('fake', 'fake', 'fake')
diff --git a/nova/tests/test_direct.py b/nova/tests/test_direct.py
index b6bfab53..b130e3f5 100644
--- a/nova/tests/test_direct.py
+++ b/nova/tests/test_direct.py
@@ -90,8 +90,7 @@ class DirectTestCase(test.TestCase):
 class DirectCloudTestCase(test_cloud.CloudTestCase):
     def setUp(self):
         super(DirectCloudTestCase, self).setUp()
-        compute_handle = compute.API(image_service=self.cloud.image_service,
-                                     network_api=self.cloud.network_api,
+        compute_handle = compute.API(network_api=self.cloud.network_api,
                                      volume_api=self.cloud.volume_api)
         direct.register_service('compute', compute_handle)
         self.router = direct.JsonParamsMiddleware(direct.Router())

From ec1a9218e5799d2785a5820a7c84d24f746d5dab Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Fri, 4 Mar 2011 02:49:12 +0000
Subject: [PATCH 45/77] use LocalImageServiceByDefault

---
 nova/flags.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/flags.py b/nova/flags.py
index f01a4d09..cb47ca8d 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -346,7 +346,7 @@ DEFINE_string('scheduler_manager', 'nova.scheduler.manager.SchedulerManager',
               'Manager for scheduler')
 
 # The service to use for image search and retrieval
-DEFINE_string('image_service', 'nova.image.glance.GlanceImageService',
+DEFINE_string('image_service', 'nova.image.local.LocalImageService',
               'The service to use for retrieving and searching for images.')
 
 DEFINE_string('host', socket.gethostname(),

From c8990b31006e0f1a864421d8fc33a1f5d77f01ce Mon Sep 17 00:00:00 2001
From: Cerberus <matt.dietz@rackspace.com>
Date: Fri, 4 Mar 2011 11:19:35 -0600
Subject: [PATCH 47/77] More fixes

---
 nova/tests/xenapi/stubs.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index d17951b8..caefcff3 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -221,7 +221,7 @@ class FakeSessionForVolumeFailedTests(FakeSessionForVolumeTests):
 
 
 class FakeSessionForMigrationTests(fake.SessionBase):
-    """ Stubs out a XenAPISession for Migration tests """
+    """Stubs out a XenAPISession for Migration tests"""
     def __init__(self, uri):
         super(FakeSessionForMigrationTests, self).__init__(uri)
 

From 91132271f365e4a91be7ab8d698fc97195160110 Mon Sep 17 00:00:00 2001
From: Ricardo Carrillo Cruz <emaildericky@gmail.com>
Date: Fri, 4 Mar 2011 21:07:03 +0100
Subject: [PATCH 48/77] Added initial support to delete networks nova-manage

---
 bin/nova-manage | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/bin/nova-manage b/bin/nova-manage
index 9bf3a1bb..9557f242 100755
--- a/bin/nova-manage
+++ b/bin/nova-manage
@@ -546,6 +546,16 @@ class NetworkCommands(object):
                                 network.dns)
 
 
+    def delete(self, fixed_range):
+        """Deletes a network"""
+        try:
+            network = [n for n in db.network_get_all(context.get_admin_context()) 
+                       if n.cidr == fixed_range][0]
+            
+            print network.id, network.cidr, network.project_id
+        except IndexError:
+            raise ValueError(_("Network does not exist"))
+
 class ServiceCommands(object):
     """Enable and disable running services"""
 

From 1ce6d03c32c74c14cb74df46271022257480f45f Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Mon, 7 Mar 2011 01:25:01 +0000
Subject: [PATCH 50/77] make compute get the new images properly, fix a bunch
 of tests, and provide conversion commands

---
 bin/nova-manage              | 131 ++++++++++++++++++++++++++++++++++-
 nova/tests/test_cloud.py     |  16 ++---
 nova/tests/test_compute.py   |  12 ++--
 nova/tests/test_console.py   |   2 +-
 nova/tests/test_scheduler.py |   4 +-
 nova/tests/test_volume.py    |   2 +-
 6 files changed, 146 insertions(+), 21 deletions(-)

diff --git a/bin/nova-manage b/bin/nova-manage
index 0f7604ae..ebeda05a 100755
--- a/bin/nova-manage
+++ b/bin/nova-manage
@@ -55,6 +55,8 @@
 
 import datetime
 import gettext
+import glob
+import json
 import os
 import re
 import sys
@@ -81,7 +83,7 @@ from nova import log as logging
 from nova import quota
 from nova import rpc
 from nova import utils
-from nova.api.ec2.ec2utils import ec2_id_to_id
+from nova.api.ec2 import ec2utils
 from nova.auth import manager
 from nova.cloudpipe import pipelib
 from nova.compute import instance_types
@@ -104,7 +106,7 @@ def param2id(object_id):
     args: [object_id], e.g. 'vol-0000000a' or 'volume-0000000a' or '10'
     """
     if '-' in object_id:
-        return ec2_id_to_id(object_id)
+        return ec2utils.ec2_id_to_id(object_id)
     else:
         return int(object_id)
 
@@ -735,6 +737,130 @@ class InstanceTypeCommands(object):
             self._print_instance_types(name, inst_types)
 
 
+class ImageCommands(object):
+    """Methods for dealing with a cloud in an odd state"""
+
+    def __init__(self, *args, **kwargs):
+        self.image_service = utils.import_object(FLAGS.image_service)
+
+    def _register(self, image_type, path, owner, name=None,
+                 is_public='T', architecture='x86_64',
+                 kernel_id=None, ramdisk_id=None):
+        meta = {'type': image_type,
+                'is_public': True,
+                'name': name,
+                'properties': {'image_state': 'available',
+                               'owner': owner,
+                               'architecture': architecture,
+                               'image_location': 'local',
+                               'is_public': (is_public == 'T')}}
+        if kernel_id:
+            meta['properties']['kernel_id'] = int(kernel_id)
+        if ramdisk_id:
+            meta['properties']['ramdisk_id'] = int(ramdisk_id)
+        elevated = context.get_admin_context()
+        try:
+            with open(path) as ifile:
+                image = self.image_service.create(elevated, meta, ifile)
+            new = image['id']
+            print _("Image registered to %(new)s (%(new)08x).") % locals()
+            return new
+        except Exception as exc:
+            print _("Failed to register %(path)s: %(exc)s") % locals()
+
+    def register_all(self, image, kernel, ramdisk, owner, name=None,
+                 is_public='T', architecture='x86_64'):
+        """Uploads an image, kernel, and ramdisk into the image_service
+        arguments: image kernel ramdisk owner [name] [is_public='T']
+                   [architecture='x86_64']"""
+        kernel_id = self._register('kernel', kernel, owner, None,
+                                   is_public, architecture)
+        ramdisk_id = self._register('ramdisk', ramdisk, owner, None,
+                                    is_public, architecture)
+        self._register('machine', image, owner, name, is_public,
+                       architecture, kernel_id, ramdisk_id)
+
+    def image_register(self, path, owner, name=None, is_public='T',
+              architecture='x86_64', kernel_id=None, ramdisk_id=None):
+        """Uploads an image into the image_service
+        arguments: path owner [name] [is_public='T'] [architecture='x86_64']
+                   [kernel_id] [ramdisk_id]"""
+        self._register('machine', path, owner, name, is_public,
+                       architecture, kernel_id, ramdisk_id)
+
+    def kernel_register(self, path, owner, name=None, is_public='T',
+               architecture='x86_64'):
+        """Uploads a kernel into the image_service
+        arguments: path owner [name] [is_public='T'] [architecture='x86_64']
+        """
+        self._register('kernel', path, owner, name, is_public, architecture)
+
+    def ramdisk_register(self, path, owner, name=None, is_public='T',
+                architecture='x86_64'):
+        """Uploads a ramdisk into the image_service
+        arguments: path owner [name] [is_public='T'] [architecture='x86_64']
+        """
+        self._register('ramdisk', path, owner, name, is_public, architecture)
+
+    def _lookup(self, old_image_id):
+        try:
+            internal_id = ec2utils.ec2_id_to_id(old_image_id)
+            image = self.image_service.show(context, internal_id)
+        except exception.NotFound:
+            image = self.image_service.show_by_name(context, old_image_id)
+        return image['id']
+
+    def _old_to_new(self, old):
+        new = {'type': old['type'],
+               'is_public': True,
+               'name': old['imageId'],
+               'properties': {'image_state': old['imageState'],
+                              'owner': old['imageOwnerId'],
+                              'architecture': old['architecture'],
+                              'image_location': old['imageLocation'],
+                              'is_public': old['isPublic']}}
+        if old.get('kernelId'):
+            new['properties']['kernel_id'] = self._lookup(old['kernelId'])
+        if old.get('ramdiskId'):
+            new['properties']['ramdisk_id'] = self._lookup(old['ramdiskId'])
+        return new
+
+    def _convert_images(self, images):
+        elevated = context.get_admin_context()
+        for image_path, image_metadata in images.iteritems():
+            meta = self._old_to_new(image_metadata)
+            old = meta['name']
+            try:
+                with open(image_path) as ifile:
+                    image = self.image_service.create(elevated, meta, ifile)
+                new = image['id']
+                print _("Image %(old)s converted to " \
+                        "%(new)s (%(new)08x).") % locals()
+            except Exception as exc:
+                print _("Failed to convert %(old)s: %(exc)s") % locals()
+
+
+    def convert(self, directory):
+        """Uploads old objectstore images in directory to new service
+        arguments: directory"""
+        machine_images = {}
+        other_images = {}
+        for fn in glob.glob("%s/*/info.json" % directory):
+            try:
+                image_path = os.path.join(fn.rpartition('/')[0], 'image')
+                with open(fn) as metadata_file:
+                    image_metadata = json.load(metadata_file)
+                if image_metadata['type'] == 'machine':
+                    machine_images[image_path] = image_metadata
+                else:
+                    other_images[image_path] = image_metadata
+            except Exception as exc:
+                print _("Failed to load %(fn)s.") % locals()
+        # NOTE(vish): do kernels and ramdisks first so images
+        self._convert_images(other_images)
+        self._convert_images(machine_images)
+
+
 CATEGORIES = [
     ('user', UserCommands),
     ('project', ProjectCommands),
@@ -749,6 +875,7 @@ CATEGORIES = [
     ('db', DbCommands),
     ('volume', VolumeCommands),
     ('instance_type', InstanceTypeCommands),
+    ('image', ImageCommands),
     ('flavor', InstanceTypeCommands)]
 
 
diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index 7d7b9165..8d2cd957 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -78,10 +78,11 @@ class CloudTestCase(test.TestCase):
                                               project=self.project)
         host = self.network.get_network_host(self.context.elevated())
 
-        def fake_image_show(meh, context, id):
-            return dict(kernelId=1, ramdiskId=1)
+        def fake_show(meh, context, id):
+            return {'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1}}
 
-        self.stubs.Set(local.LocalImageService, 'show', fake_image_show)
+        self.stubs.Set(local.LocalImageService, 'show', fake_show)
+        self.stubs.Set(local.LocalImageService, 'show_by_name', fake_show)
 
     def tearDown(self):
         network_ref = db.project_get_network(self.context,
@@ -195,8 +196,10 @@ class CloudTestCase(test.TestCase):
     def test_describe_instances(self):
         """Makes sure describe_instances works and filters results."""
         inst1 = db.instance_create(self.context, {'reservation_id': 'a',
+                                                  'image_id': 1,
                                                   'host': 'host1'})
         inst2 = db.instance_create(self.context, {'reservation_id': 'a',
+                                                  'image_id': 1,
                                                   'host': 'host2'})
         comp1 = db.service_create(self.context, {'host': 'host1',
                                                  'availability_zone': 'zone1',
@@ -222,11 +225,9 @@ class CloudTestCase(test.TestCase):
         db.service_destroy(self.context, comp2['id'])
 
     def test_console_output(self):
-        image_id = FLAGS.default_image
-        print image_id
         instance_type = FLAGS.default_instance_type
         max_count = 1
-        kwargs = {'image_id': image_id,
+        kwargs = {'image_id': 'ami-1',
                   'instance_type': instance_type,
                   'max_count': max_count}
         rv = self.cloud.run_instances(self.context, **kwargs)
@@ -242,8 +243,7 @@ class CloudTestCase(test.TestCase):
         greenthread.sleep(0.3)
 
     def test_ajax_console(self):
-        image_id = FLAGS.default_image
-        kwargs = {'image_id': image_id}
+        kwargs = {'image_id': 'ami-1'}
         rv = self.cloud.run_instances(self.context, **kwargs)
         instance_id = rv['instancesSet'][0]['instanceId']
         greenthread.sleep(0.3)
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 1f49baaf..8c18fafc 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -47,16 +47,16 @@ class ComputeTestCase(test.TestCase):
                    network_manager='nova.network.manager.FlatManager')
         self.compute = utils.import_object(FLAGS.compute_manager)
         self.compute_api = compute.API()
-
-        def fake_image_show(meh, context, id):
-            return dict(kernelId=1, ramdiskId=1)
-
-        self.stubs.Set(local.LocalImageService, 'show', fake_image_show)
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('fake', 'fake', 'fake')
         self.project = self.manager.create_project('fake', 'fake', 'fake')
         self.context = context.RequestContext('fake', 'fake', False)
 
+        def fake_show(meh, context, id):
+            return {'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1}}
+
+        self.stubs.Set(local.LocalImageService, 'show', fake_show)
+
     def tearDown(self):
         self.manager.delete_user(self.user)
         self.manager.delete_project(self.project)
@@ -65,7 +65,7 @@ class ComputeTestCase(test.TestCase):
     def _create_instance(self):
         """Create a test instance"""
         inst = {}
-        inst['image_id'] = 'ami-test'
+        inst['image_id'] = 1
         inst['reservation_id'] = 'r-fakeres'
         inst['launch_time'] = '10'
         inst['user_id'] = self.user.id
diff --git a/nova/tests/test_console.py b/nova/tests/test_console.py
index 49ff2441..d47c70d8 100644
--- a/nova/tests/test_console.py
+++ b/nova/tests/test_console.py
@@ -57,7 +57,7 @@ class ConsoleTestCase(test.TestCase):
         inst = {}
         #inst['host'] = self.host
         #inst['name'] = 'instance-1234'
-        inst['image_id'] = 'ami-test'
+        inst['image_id'] = 1
         inst['reservation_id'] = 'r-fakeres'
         inst['launch_time'] = '10'
         inst['user_id'] = self.user.id
diff --git a/nova/tests/test_scheduler.py b/nova/tests/test_scheduler.py
index b6888c4d..bb279ac4 100644
--- a/nova/tests/test_scheduler.py
+++ b/nova/tests/test_scheduler.py
@@ -155,7 +155,7 @@ class SimpleDriverTestCase(test.TestCase):
     def _create_instance(self, **kwargs):
         """Create a test instance"""
         inst = {}
-        inst['image_id'] = 'ami-test'
+        inst['image_id'] = 1
         inst['reservation_id'] = 'r-fakeres'
         inst['user_id'] = self.user.id
         inst['project_id'] = self.project.id
@@ -169,8 +169,6 @@ class SimpleDriverTestCase(test.TestCase):
     def _create_volume(self):
         """Create a test volume"""
         vol = {}
-        vol['image_id'] = 'ami-test'
-        vol['reservation_id'] = 'r-fakeres'
         vol['size'] = 1
         vol['availability_zone'] = 'test'
         return db.volume_create(self.context, vol)['id']
diff --git a/nova/tests/test_volume.py b/nova/tests/test_volume.py
index b40ca004..f698c85b 100644
--- a/nova/tests/test_volume.py
+++ b/nova/tests/test_volume.py
@@ -99,7 +99,7 @@ class VolumeTestCase(test.TestCase):
     def test_run_attach_detach_volume(self):
         """Make sure volume can be attached and detached from instance."""
         inst = {}
-        inst['image_id'] = 'ami-test'
+        inst['image_id'] = 1
         inst['reservation_id'] = 'r-fakeres'
         inst['launch_time'] = '10'
         inst['user_id'] = 'fake'

From 48cc0eac5ae7feb41fde6c0433ae77aaae0a0923 Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Mon, 7 Mar 2011 17:17:41 +0000
Subject: [PATCH 51/77] Merge prop changes and test fixes

---
 nova/tests/xenapi/stubs.py | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index caefcff3..11e89c9b 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -227,18 +227,8 @@ class FakeSessionForMigrationTests(fake.SessionBase):
 
 
 def stub_out_migration_methods(stubs):
-    class FakeSnapshot(object):
-        def __getattr__(self, key):
-            return str(key)
-
-        def __enter__(self):
-            return self
-
-        def __exit__(self, type, value, traceback):
-            pass
-
     def fake_get_snapshot(self, instance):
-        return FakeSnapshot()
+        return 'foo', 'bar'
 
     @classmethod
     def fake_get_vdi(cls, session, vm_ref):
@@ -251,11 +241,21 @@ def stub_out_migration_methods(stubs):
         pass
 
     @classmethod
-    def fake_scan_sr(cls, session):
+    def fake_sr(cls, session, *args):
         pass
 
-    stubs.Set(vm_utils.VMHelper, 'scan_sr', fake_scan_sr)
+    @classmethod
+    def fake_get_sr_path(cls, *args):
+        return "fake"
+
+    def fake_destroy(*args, **kwargs):
+        pass
+
+    stubs.Set(vmops.VMOps, '_destroy', fake_destroy)
+    stubs.Set(vm_utils.VMHelper, 'scan_default_sr', fake_sr)
+    stubs.Set(vm_utils.VMHelper, 'scan_sr', fake_sr)
     stubs.Set(vmops.VMOps, '_get_snapshot', fake_get_snapshot)
     stubs.Set(vm_utils.VMHelper, 'get_vdi_for_vm_safely', fake_get_vdi)
     stubs.Set(xenapi_conn.XenAPISession, 'wait_for_task', lambda x, y, z: None)
+    stubs.Set(vm_utils.VMHelper, 'get_sr_path', fake_get_sr_path)
     stubs.Set(vmops.VMOps, '_shutdown', fake_shutdown)

From a2a5074fe32ff26a0ad8e06da97800f672d8687f Mon Sep 17 00:00:00 2001
From: "Kevin L. Mitchell" <kevin.mitchell@rackspace.com>
Date: Mon, 7 Mar 2011 19:33:24 +0000
Subject: [PATCH 52/77] Create --paste_config flag defaulting to api-paste.ini
 and mv etc/nova-api.conf to match

---
 bin/nova-api | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/bin/nova-api b/bin/nova-api
index 14be4b84..0b2a44c8 100755
--- a/bin/nova-api
+++ b/bin/nova-api
@@ -43,6 +43,8 @@ from nova import wsgi
 LOG = logging.getLogger('nova.api')
 
 FLAGS = flags.FLAGS
+flags.DEFINE_string('paste_config', "api-paste.ini",
+                    'File name for the paste.deploy config for nova-api')
 flags.DEFINE_string('ec2_listen', "0.0.0.0",
                     'IP address for EC2 API to listen')
 flags.DEFINE_integer('ec2_listen_port', 8773, 'port for ec2 api to listen')
@@ -90,8 +92,9 @@ if __name__ == '__main__':
     for flag in FLAGS:
         flag_get = FLAGS.get(flag, None)
         LOG.debug("%(flag)s : %(flag_get)s" % locals())
-    conf = wsgi.paste_config_file('nova-api.conf')
+    conf = wsgi.paste_config_file(FLAGS.paste_config)
     if conf:
         run_app(conf)
     else:
-        LOG.error(_("No paste configuration found for: %s"), 'nova-api.conf')
+        LOG.error(_("No paste configuration found for: %s"),
+                  FLAGS.paste_config)

From 34803ded36aff45d7218bc3edbba4cdc010c1803 Mon Sep 17 00:00:00 2001
From: Ricardo Carrillo Cruz <emaildericky@gmail.com>
Date: Mon, 7 Mar 2011 22:18:15 +0100
Subject: [PATCH 53/77] added network_get_by_cidr method to nova.db api

---
 bin/nova-manage | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/bin/nova-manage b/bin/nova-manage
index 9557f242..b274c5bd 100755
--- a/bin/nova-manage
+++ b/bin/nova-manage
@@ -545,16 +545,9 @@ class NetworkCommands(object):
                                 network.dhcp_start,
                                 network.dns)
 
-
     def delete(self, fixed_range):
         """Deletes a network"""
-        try:
-            network = [n for n in db.network_get_all(context.get_admin_context()) 
-                       if n.cidr == fixed_range][0]
-            
-            print network.id, network.cidr, network.project_id
-        except IndexError:
-            raise ValueError(_("Network does not exist"))
+        print db.network_get_by_cidr(context.get_admin_context(), fixed_range)
 
 class ServiceCommands(object):
     """Enable and disable running services"""

From ea8e8ded7a6afd451cefa65c1983f2137ba0d3db Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Mon, 7 Mar 2011 21:20:32 +0000
Subject: [PATCH 54/77] rework register commands based on review

---
 bin/nova-manage | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/bin/nova-manage b/bin/nova-manage
index ebeda05a..b61a5d41 100755
--- a/bin/nova-manage
+++ b/bin/nova-manage
@@ -768,16 +768,16 @@ class ImageCommands(object):
         except Exception as exc:
             print _("Failed to register %(path)s: %(exc)s") % locals()
 
-    def register_all(self, image, kernel, ramdisk, owner, name=None,
+    def all_register(self, image, kernel, ramdisk, owner, name=None,
                  is_public='T', architecture='x86_64'):
         """Uploads an image, kernel, and ramdisk into the image_service
         arguments: image kernel ramdisk owner [name] [is_public='T']
                    [architecture='x86_64']"""
-        kernel_id = self._register('kernel', kernel, owner, None,
+        kernel_id = self.kernel_register(kernel, owner, None,
                                    is_public, architecture)
-        ramdisk_id = self._register('ramdisk', ramdisk, owner, None,
+        ramdisk_id = self.ramdisk_register(ramdisk, owner, None,
                                     is_public, architecture)
-        self._register('machine', image, owner, name, is_public,
+        self.image_register(image, owner, name, is_public,
                        architecture, kernel_id, ramdisk_id)
 
     def image_register(self, path, owner, name=None, is_public='T',
@@ -785,7 +785,7 @@ class ImageCommands(object):
         """Uploads an image into the image_service
         arguments: path owner [name] [is_public='T'] [architecture='x86_64']
                    [kernel_id] [ramdisk_id]"""
-        self._register('machine', path, owner, name, is_public,
+        return self._register('machine', path, owner, name, is_public,
                        architecture, kernel_id, ramdisk_id)
 
     def kernel_register(self, path, owner, name=None, is_public='T',
@@ -793,14 +793,16 @@ class ImageCommands(object):
         """Uploads a kernel into the image_service
         arguments: path owner [name] [is_public='T'] [architecture='x86_64']
         """
-        self._register('kernel', path, owner, name, is_public, architecture)
+        return self._register('kernel', path, owner, name, is_public,
+                              architecture)
 
     def ramdisk_register(self, path, owner, name=None, is_public='T',
                 architecture='x86_64'):
         """Uploads a ramdisk into the image_service
         arguments: path owner [name] [is_public='T'] [architecture='x86_64']
         """
-        self._register('ramdisk', path, owner, name, is_public, architecture)
+        return self._register('ramdisk', path, owner, name, is_public,
+                              architecture)
 
     def _lookup(self, old_image_id):
         try:

From 0357f0601a706dde7e358a1b553b92456c316c9e Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Mon, 7 Mar 2011 21:22:06 +0000
Subject: [PATCH 55/77] pep8

---
 bin/nova-manage | 1 -
 1 file changed, 1 deletion(-)

diff --git a/bin/nova-manage b/bin/nova-manage
index b61a5d41..f8cc6e68 100755
--- a/bin/nova-manage
+++ b/bin/nova-manage
@@ -841,7 +841,6 @@ class ImageCommands(object):
             except Exception as exc:
                 print _("Failed to convert %(old)s: %(exc)s") % locals()
 
-
     def convert(self, directory):
         """Uploads old objectstore images in directory to new service
         arguments: directory"""

From 6b14922f346062e7e05263e59bac8851d11d6ecf Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Mon, 7 Mar 2011 21:30:20 +0000
Subject: [PATCH 56/77] move the images_dir out of the way when converting

---
 bin/nova-manage | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/bin/nova-manage b/bin/nova-manage
index f8cc6e68..b97d8b81 100755
--- a/bin/nova-manage
+++ b/bin/nova-manage
@@ -846,6 +846,16 @@ class ImageCommands(object):
         arguments: directory"""
         machine_images = {}
         other_images = {}
+        directory = os.path.abspath(directory)
+        # NOTE(vish): If we're importing from the images path dir, attempt
+        #             to move the files out of the way before importing
+        #             so we aren't writing to the same directory. This
+        #             may fail if the dir was a mointpoint.
+        if directory == os.path.abspath(FLAGS.images_path):
+            new_dir = "%s_bak" % directory
+            os.move(directory, new_dir)
+            os.mkdir(directory)
+            directory = new_dir
         for fn in glob.glob("%s/*/info.json" % directory):
             try:
                 image_path = os.path.join(fn.rpartition('/')[0], 'image')

From 18f3ab47452bd740c158956fc1571b6d863385dc Mon Sep 17 00:00:00 2001
From: Ricardo Carrillo Cruz <emaildericky@gmail.com>
Date: Mon, 7 Mar 2011 22:37:26 +0100
Subject: [PATCH 57/77] deleted network_is_associated from nova.db api

---
 bin/nova-manage | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bin/nova-manage b/bin/nova-manage
index b274c5bd..94b0d594 100755
--- a/bin/nova-manage
+++ b/bin/nova-manage
@@ -547,8 +547,8 @@ class NetworkCommands(object):
 
     def delete(self, fixed_range):
         """Deletes a network"""
-        print db.network_get_by_cidr(context.get_admin_context(), fixed_range)
-
+        network = db.network_get_by_cidr(context.get_admin_context(), fixed_range)
+         
 class ServiceCommands(object):
     """Enable and disable running services"""
 

From 005677ce9ec04d42ebe61906c2df1bcefa36f16c Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Mon, 7 Mar 2011 22:50:35 +0000
Subject: [PATCH 58/77] And unit tests

---
 nova/tests/test_xenapi.py  | 5 +++++
 nova/tests/xenapi/stubs.py | 4 ++++
 2 files changed, 9 insertions(+)

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 7f437c2b..6e458558 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -383,6 +383,11 @@ class XenAPIMigrateInstance(test.TestCase):
         conn = xenapi_conn.get_connection(False)
         conn.attach_disk(instance, {'base_copy': 'hurr', 'cow': 'durr'})
 
+    def test_finish_resize(self):
+        instance = db.instance_create(self.values)
+        stubs.stubout_session(self.stubs, stubs.FakeSessionForMigrationTests)
+        conn = xenapi_conn.get_connection(False)
+        conn.finish_resize(instance, dict(base_copy='hurr', cow='durr'))
 
 class XenAPIDetermineDiskImageTestCase(test.TestCase):
     """
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 11e89c9b..28037c2b 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -251,6 +251,9 @@ def stub_out_migration_methods(stubs):
     def fake_destroy(*args, **kwargs):
         pass
 
+    def fake_spawn_with_disk(*args, **kwargs):
+        pass
+
     stubs.Set(vmops.VMOps, '_destroy', fake_destroy)
     stubs.Set(vm_utils.VMHelper, 'scan_default_sr', fake_sr)
     stubs.Set(vm_utils.VMHelper, 'scan_sr', fake_sr)
@@ -259,3 +262,4 @@ def stub_out_migration_methods(stubs):
     stubs.Set(xenapi_conn.XenAPISession, 'wait_for_task', lambda x, y, z: None)
     stubs.Set(vm_utils.VMHelper, 'get_sr_path', fake_get_sr_path)
     stubs.Set(vmops.VMOps, '_shutdown', fake_shutdown)
+    stubs.Set(vmops.VMOps, 'spawn_with_disk', fake_spawn_with_disk)

From 53807506cf8a7a0e88eb2a938cb8362dde649e15 Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Mon, 7 Mar 2011 23:07:05 +0000
Subject: [PATCH 59/77] A few more changes

---
 nova/tests/test_xenapi.py | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 6e458558..f5b154a5 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -377,12 +377,6 @@ class XenAPIMigrateInstance(test.TestCase):
         conn = xenapi_conn.get_connection(False)
         conn.migrate_disk_and_power_off(instance, '127.0.0.1')
 
-    def test_attach_disk(self):
-        instance = db.instance_create(self.values)
-        stubs.stubout_session(self.stubs, stubs.FakeSessionForMigrationTests)
-        conn = xenapi_conn.get_connection(False)
-        conn.attach_disk(instance, {'base_copy': 'hurr', 'cow': 'durr'})
-
     def test_finish_resize(self):
         instance = db.instance_create(self.values)
         stubs.stubout_session(self.stubs, stubs.FakeSessionForMigrationTests)

From ddc13b66e3b6919513e0dfa669d277ce5cf14b17 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Mon, 7 Mar 2011 15:22:59 -0800
Subject: [PATCH 60/77] Converted tabs to spaces in bin/nova-api

---
 bin/nova-api | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bin/nova-api b/bin/nova-api
index 2d2ef6d0..c921ec45 100755
--- a/bin/nova-api
+++ b/bin/nova-api
@@ -62,5 +62,5 @@ if __name__ == '__main__':
         LOG.error(_("No paste configuration found for: %s"), 'nova-api.conf')
         sys.exit(1)
     else:
-    	service = service.serve_wsgi(service.ApiService, conf)
+        service = service.serve_wsgi(service.ApiService, conf)
         service.wait()

From 3abb117e6f865d7b560af2b0c1dae17751285e3f Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Mon, 7 Mar 2011 15:36:04 -0800
Subject: [PATCH 61/77] Moved FLAGS.paste_config to its re-usable location

---
 bin/nova-api | 14 +++-----------
 1 file changed, 3 insertions(+), 11 deletions(-)

diff --git a/bin/nova-api b/bin/nova-api
index f48dbe5a..85ca4eef 100755
--- a/bin/nova-api
+++ b/bin/nova-api
@@ -45,9 +45,6 @@ from nova import wsgi
 LOG = logging.getLogger('nova.api')
 
 FLAGS = flags.FLAGS
-flags.DEFINE_string('paste_config', "api-paste.ini",
-                    'File name for the paste.deploy config for nova-api')
-
 
 if __name__ == '__main__':
     utils.default_flagfile()
@@ -59,11 +56,6 @@ if __name__ == '__main__':
     for flag in FLAGS:
         flag_get = FLAGS.get(flag, None)
         LOG.debug("%(flag)s : %(flag_get)s" % locals())
-    conf = wsgi.paste_config_file(FLAGS.paste_config)
-    if not conf:
-        LOG.error(_("No paste configuration found for: %s"),
-                  FLAGS.paste_config)
-        sys.exit(1)
-    else:
-        service = service.serve_wsgi(service.ApiService, conf)
-        service.wait()
+
+    service = service.serve_wsgi(service.ApiService)
+    service.wait()

From 5ff8d40423047ee1754676f85bf419df59a1ff07 Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Mon, 7 Mar 2011 23:51:20 +0000
Subject: [PATCH 62/77] Some more refactoring and a tighter unit test

---
 nova/tests/test_xenapi.py  | 14 ++++++++++----
 nova/tests/xenapi/stubs.py | 15 +++++++++++++--
 2 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index f5b154a5..919a38c0 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -360,16 +360,22 @@ class XenAPIMigrateInstance(test.TestCase):
         db_fakes.stub_out_db_instance_api(self.stubs)
         stubs.stub_out_get_target(self.stubs)
         xenapi_fake.reset()
+        self.manager = manager.AuthManager()
+        self.user = self.manager.create_user('fake', 'fake', 'fake',
+                                             admin=True)
+        self.project = self.manager.create_project('fake', 'fake', 'fake')
         self.values = {'name': 1, 'id': 1,
-                  'project_id': 'fake',
-                  'user_id': 'fake',
+                  'project_id': self.project.id,
+                  'user_id': self.user.id,
                   'image_id': 1,
-                  'kernel_id': 2,
-                  'ramdisk_id': 3,
+                  'kernel_id': None,
+                  'ramdisk_id': None,
                   'instance_type': 'm1.large',
                   'mac_address': 'aa:bb:cc:dd:ee:ff',
                   }
         stubs.stub_out_migration_methods(self.stubs)
+        glance_stubs.stubout_glance_client(self.stubs,
+                                           glance_stubs.FakeGlance)
 
     def test_migrate_disk_and_power_off(self):
         instance = db.instance_create(self.values)
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index 28037c2b..d8e35861 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -225,6 +225,17 @@ class FakeSessionForMigrationTests(fake.SessionBase):
     def __init__(self, uri):
         super(FakeSessionForMigrationTests, self).__init__(uri)
 
+    def VDI_get_by_uuid(*args):
+        return 'hurr'
+
+    def VM_start(self, _1, ref, _2, _3):
+        vm = fake.get_record('VM', ref)
+        if vm['power_state'] != 'Halted':
+            raise fake.Failure(['VM_BAD_POWER_STATE', ref, 'Halted',
+                                  vm['power_state']])
+        vm['power_state'] = 'Running'
+        vm['is_a_template'] = False
+        vm['is_control_domain'] = False
 
 def stub_out_migration_methods(stubs):
     def fake_get_snapshot(self, instance):
@@ -251,7 +262,7 @@ def stub_out_migration_methods(stubs):
     def fake_destroy(*args, **kwargs):
         pass
 
-    def fake_spawn_with_disk(*args, **kwargs):
+    def fake_reset_network(*args, **kwargs):
         pass
 
     stubs.Set(vmops.VMOps, '_destroy', fake_destroy)
@@ -261,5 +272,5 @@ def stub_out_migration_methods(stubs):
     stubs.Set(vm_utils.VMHelper, 'get_vdi_for_vm_safely', fake_get_vdi)
     stubs.Set(xenapi_conn.XenAPISession, 'wait_for_task', lambda x, y, z: None)
     stubs.Set(vm_utils.VMHelper, 'get_sr_path', fake_get_sr_path)
+    stubs.Set(vmops.VMOps, 'reset_network', fake_reset_network)
     stubs.Set(vmops.VMOps, '_shutdown', fake_shutdown)
-    stubs.Set(vmops.VMOps, 'spawn_with_disk', fake_spawn_with_disk)

From 5f70782e3adc140f0915ac5ea900b00bd01b814e Mon Sep 17 00:00:00 2001
From: Eric Windisch <eric@cloudscaling.com>
Date: Tue, 8 Mar 2011 01:01:41 -0500
Subject: [PATCH 63/77] execvp

---
 nova/tests/test_network.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index ce1c7721..6d2d8b77 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -343,13 +343,13 @@ def lease_ip(private_ip):
                                           private_ip)
     instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
                                             private_ip)
-    cmd = "%s add %s %s fake" % (binpath('nova-dhcpbridge'),
-                                 instance_ref['mac_address'],
-                                 private_ip)
+    cmd = (binpath('nova-dhcpbridge'), 'add'
+           instance_ref['mac_address'],
+           private_ip, 'fake')
     env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
            'TESTING': '1',
            'FLAGFILE': FLAGS.dhcpbridge_flagfile}
-    (out, err) = utils.execute(cmd, addl_env=env)
+    (out, err) = utils.execute(*cmd, addl_env=env)
     LOG.debug("ISSUE_IP: %s, %s ", out, err)
 
 
@@ -359,11 +359,11 @@ def release_ip(private_ip):
                                           private_ip)
     instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
                                             private_ip)
-    cmd = "%s del %s %s fake" % (binpath('nova-dhcpbridge'),
-                                 instance_ref['mac_address'],
-                                 private_ip)
+    cmd = (binpath('nova-dhcpbridge'), 'del',
+           instance_ref['mac_address'],
+           private_ip, 'fake')
     env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
            'TESTING': '1',
            'FLAGFILE': FLAGS.dhcpbridge_flagfile}
-    (out, err) = utils.execute(cmd, addl_env=env)
+    (out, err) = utils.execute(*cmd, addl_env=env)
     LOG.debug("RELEASE_IP: %s, %s ", out, err)

From 4fc941dcbfb36c97a24609b7ac6dc8cb6bd52882 Mon Sep 17 00:00:00 2001
From: Ricardo Carrillo Cruz <emaildericky@gmail.com>
Date: Tue, 8 Mar 2011 18:53:20 +0100
Subject: [PATCH 64/77] Added ability to remove networks on nova-manage command

---
 bin/nova-manage | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/bin/nova-manage b/bin/nova-manage
index 94b0d594..8ddfea5c 100755
--- a/bin/nova-manage
+++ b/bin/nova-manage
@@ -548,7 +548,11 @@ class NetworkCommands(object):
     def delete(self, fixed_range):
         """Deletes a network"""
         network = db.network_get_by_cidr(context.get_admin_context(), fixed_range)
-         
+        if network.project_id is not None:
+            raise ValueError(_('Network must be disassociated from project %s' 
+                               ' before delete' %network.project_id))
+        db.network_delete_safe(context.get_admin_context(), network.id)  
+  
 class ServiceCommands(object):
     """Enable and disable running services"""
 

From 14031b22e030ef00a85e1feacc6989b9a4de5f41 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Tue, 8 Mar 2011 20:25:05 +0000
Subject: [PATCH 65/77] update code to work with new container and disk formats
 from glance

---
 bin/nova-manage | 45 ++++++++++++++++++++++++++++++---------------
 1 file changed, 30 insertions(+), 15 deletions(-)

diff --git a/bin/nova-manage b/bin/nova-manage
index b97d8b81..b8e0563c 100755
--- a/bin/nova-manage
+++ b/bin/nova-manage
@@ -96,6 +96,7 @@ flags.DECLARE('network_size', 'nova.network.manager')
 flags.DECLARE('vlan_start', 'nova.network.manager')
 flags.DECLARE('vpn_start', 'nova.network.manager')
 flags.DECLARE('fixed_range_v6', 'nova.network.manager')
+flags.DECLARE('images_path', 'nova.image.local')
 flags.DEFINE_flag(flags.HelpFlag())
 flags.DEFINE_flag(flags.HelpshortFlag())
 flags.DEFINE_flag(flags.HelpXMLFlag())
@@ -743,17 +744,20 @@ class ImageCommands(object):
     def __init__(self, *args, **kwargs):
         self.image_service = utils.import_object(FLAGS.image_service)
 
-    def _register(self, image_type, path, owner, name=None,
-                 is_public='T', architecture='x86_64',
-                 kernel_id=None, ramdisk_id=None):
-        meta = {'type': image_type,
-                'is_public': True,
+    def _register(self, image_type, disk_format, container_format,
+                  path, owner, name=None, is_public='T',
+                  architecture='x86_64', kernel_id=None, ramdisk_id=None):
+        meta = {'is_public': True,
                 'name': name,
+                'disk_format': disk_format,
+                'container_format': container_format,
                 'properties': {'image_state': 'available',
                                'owner': owner,
+                               'type': image_type,
                                'architecture': architecture,
                                'image_location': 'local',
                                'is_public': (is_public == 'T')}}
+        print image_type, meta
         if kernel_id:
             meta['properties']['kernel_id'] = int(kernel_id)
         if ramdisk_id:
@@ -781,28 +785,31 @@ class ImageCommands(object):
                        architecture, kernel_id, ramdisk_id)
 
     def image_register(self, path, owner, name=None, is_public='T',
-              architecture='x86_64', kernel_id=None, ramdisk_id=None):
+                       architecture='x86_64', kernel_id=None, ramdisk_id=None,
+                       disk_format='ami', container_format='ami'):
         """Uploads an image into the image_service
         arguments: path owner [name] [is_public='T'] [architecture='x86_64']
-                   [kernel_id] [ramdisk_id]"""
-        return self._register('machine', path, owner, name, is_public,
-                       architecture, kernel_id, ramdisk_id)
+                   [kernel_id=None] [ramdisk_id=None]
+                   [disk_format='ami'] [container_format='ami']"""
+        return self._register('machine', disk_format, container_format, path,
+                              owner, name, is_public, architecture,
+                              kernel_id, ramdisk_id)
 
     def kernel_register(self, path, owner, name=None, is_public='T',
                architecture='x86_64'):
         """Uploads a kernel into the image_service
         arguments: path owner [name] [is_public='T'] [architecture='x86_64']
         """
-        return self._register('kernel', path, owner, name, is_public,
-                              architecture)
+        return self._register('kernel', 'aki', 'aki', path, owner, name,
+                              is_public, architecture)
 
     def ramdisk_register(self, path, owner, name=None, is_public='T',
                 architecture='x86_64'):
         """Uploads a ramdisk into the image_service
         arguments: path owner [name] [is_public='T'] [architecture='x86_64']
         """
-        return self._register('ramdisk', path, owner, name, is_public,
-                              architecture)
+        return self._register('ramdisk', 'ari', 'ari', path, owner, name,
+                              is_public, architecture)
 
     def _lookup(self, old_image_id):
         try:
@@ -813,12 +820,19 @@ class ImageCommands(object):
         return image['id']
 
     def _old_to_new(self, old):
-        new = {'type': old['type'],
+        mapping = {'machine': 'ami',
+                   'kernel': 'aki',
+                   'ramdisk': 'ari'}
+        container_format = mapping[old['type']]
+        disk_format = container_format
+        new = {'disk_format': disk_format,
+               'container_format': container_format,
                'is_public': True,
                'name': old['imageId'],
                'properties': {'image_state': old['imageState'],
                               'owner': old['imageOwnerId'],
                               'architecture': old['architecture'],
+                              'type': old['type'],
                               'image_location': old['imageLocation'],
                               'is_public': old['isPublic']}}
         if old.get('kernelId'):
@@ -851,7 +865,8 @@ class ImageCommands(object):
         #             to move the files out of the way before importing
         #             so we aren't writing to the same directory. This
         #             may fail if the dir was a mointpoint.
-        if directory == os.path.abspath(FLAGS.images_path):
+        if (FLAGS.image_service == 'nova.image.local.LocalImageService'
+            and directory == os.path.abspath(FLAGS.images_path)):
             new_dir = "%s_bak" % directory
             os.move(directory, new_dir)
             os.mkdir(directory)

From 5837809e9efb987d5bb15e871837f23bca9b448c Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Tue, 8 Mar 2011 23:17:50 +0000
Subject: [PATCH 66/77] Accidentally left some bad data around

---
 nova/tests/test_xenapi.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 919a38c0..916555af 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -376,6 +376,11 @@ class XenAPIMigrateInstance(test.TestCase):
         stubs.stub_out_migration_methods(self.stubs)
         glance_stubs.stubout_glance_client(self.stubs,
                                            glance_stubs.FakeGlance)
+    def tearDown(self):
+        super(XenAPIMigrateInstance, self).tearDown()
+        self.manager.delete_project(self.project)
+        self.manager.delete_user(self.user)
+        self.stubs.UnsetAll()
 
     def test_migrate_disk_and_power_off(self):
         instance = db.instance_create(self.values)

From 1df76c1d9c6fa6d84ef87f1f7107075f4c939e04 Mon Sep 17 00:00:00 2001
From: "matt.dietz@rackspace.com" <>
Date: Tue, 8 Mar 2011 23:24:19 +0000
Subject: [PATCH 67/77] Pep8 fixes

---
 nova/tests/test_xenapi.py  | 2 ++
 nova/tests/xenapi/stubs.py | 1 +
 2 files changed, 3 insertions(+)

diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 916555af..c26dc863 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -376,6 +376,7 @@ class XenAPIMigrateInstance(test.TestCase):
         stubs.stub_out_migration_methods(self.stubs)
         glance_stubs.stubout_glance_client(self.stubs,
                                            glance_stubs.FakeGlance)
+
     def tearDown(self):
         super(XenAPIMigrateInstance, self).tearDown()
         self.manager.delete_project(self.project)
@@ -394,6 +395,7 @@ class XenAPIMigrateInstance(test.TestCase):
         conn = xenapi_conn.get_connection(False)
         conn.finish_resize(instance, dict(base_copy='hurr', cow='durr'))
 
+
 class XenAPIDetermineDiskImageTestCase(test.TestCase):
     """
     Unit tests for code that detects the ImageType
diff --git a/nova/tests/xenapi/stubs.py b/nova/tests/xenapi/stubs.py
index d8e35861..70d46a1f 100644
--- a/nova/tests/xenapi/stubs.py
+++ b/nova/tests/xenapi/stubs.py
@@ -237,6 +237,7 @@ class FakeSessionForMigrationTests(fake.SessionBase):
         vm['is_a_template'] = False
         vm['is_control_domain'] = False
 
+
 def stub_out_migration_methods(stubs):
     def fake_get_snapshot(self, instance):
         return 'foo', 'bar'

From 4336263c66efd5c28c114d4f354ef4864777c3e2 Mon Sep 17 00:00:00 2001
From: Justin Santa Barbara <justin@fathomdb.com>
Date: Tue, 8 Mar 2011 16:45:20 -0800
Subject: [PATCH 68/77] Sorted imports correctly

---
 bin/nova-api | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bin/nova-api b/bin/nova-api
index 85ca4eef..06bb855c 100755
--- a/bin/nova-api
+++ b/bin/nova-api
@@ -34,9 +34,9 @@ if os.path.exists(os.path.join(possible_topdir, 'nova', '__init__.py')):
 
 gettext.install('nova', unicode=1)
 
-from nova import service
 from nova import flags
 from nova import log as logging
+from nova import service
 from nova import utils
 from nova import version
 from nova import wsgi

From 609346b931f58fa1513010e0b02ad52f3ca5bb53 Mon Sep 17 00:00:00 2001
From: Eric Windisch <eric@cloudscaling.com>
Date: Wed, 9 Mar 2011 00:30:05 -0500
Subject: [PATCH 69/77] execvp: almost passes tests

---
 nova/tests/test_network.py |  2 +-
 nova/tests/test_virt.py    | 11 ++++++-----
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index 6d2d8b77..19099ff4 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -343,7 +343,7 @@ def lease_ip(private_ip):
                                           private_ip)
     instance_ref = db.fixed_ip_get_instance(context.get_admin_context(),
                                             private_ip)
-    cmd = (binpath('nova-dhcpbridge'), 'add'
+    cmd = (binpath('nova-dhcpbridge'), 'add',
            instance_ref['mac_address'],
            private_ip, 'fake')
     env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index f151ae91..7f1ad002 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -315,15 +315,16 @@ class IptablesFirewallTestCase(test.TestCase):
         instance_ref = db.instance_get(admin_ctxt, instance_ref['id'])
 
 #        self.fw.add_instance(instance_ref)
-        def fake_iptables_execute(cmd, process_input=None):
-            if cmd == 'sudo ip6tables-save -t filter':
+        def fake_iptables_execute(*cmd, **kwargs):
+            process_input=kwargs.get('process_input', None)
+            if cmd == ('sudo', 'ip6tables-save', '-t', 'filter'):
                 return '\n'.join(self.in6_rules), None
-            if cmd == 'sudo iptables-save -t filter':
+            if cmd == ('sudo', 'iptables-save', '-t', 'filter'):
                 return '\n'.join(self.in_rules), None
-            if cmd == 'sudo iptables-restore':
+            if cmd == ('sudo', 'iptables-restore'):
                 self.out_rules = process_input.split('\n')
                 return '', ''
-            if cmd == 'sudo ip6tables-restore':
+            if cmd == ('sudo', 'ip6tables-restore'):
                 self.out6_rules = process_input.split('\n')
                 return '', ''
         self.fw.execute = fake_iptables_execute

From d7c2294cdb5ce46068467d484f910c01a919c53e Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Wed, 9 Mar 2011 06:56:42 +0000
Subject: [PATCH 70/77] tests and semaphore fix for image caching

---
 nova/tests/test_virt.py | 66 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index f151ae91..ec7498d7 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -14,12 +14,16 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import os
+
+import eventlet
 from xml.etree.ElementTree import fromstring as xml_to_tree
 from xml.dom.minidom import parseString as xml_to_dom
 
 from nova import context
 from nova import db
 from nova import flags
+from nova import log as logging
 from nova import test
 from nova import utils
 from nova.api.ec2 import cloud
@@ -30,6 +34,68 @@ FLAGS = flags.FLAGS
 flags.DECLARE('instances_path', 'nova.compute.manager')
 
 
+def _concurrency(wait, done, target):
+    wait.wait()
+    done.send()
+
+
+class CacheConcurrencyTestCase(test.TestCase):
+    def setUp(self):
+        super(CacheConcurrencyTestCase, self).setUp()
+
+        def fake_exists(fname):
+            basedir = os.path.join(FLAGS.instances_path, '_base')
+            if fname == basedir:
+                return True
+            return False
+
+        def fake_execute(*args, **kwargs):
+            pass
+
+        self.stubs.Set(os.path, 'exists', fake_exists)
+        self.stubs.Set(utils, 'execute', fake_execute)
+
+    def test_same_fname_concurrency(self):
+        """Ensures that the same fname cache runs at a sequentially"""
+        conn = libvirt_conn.get_connection(False)
+        wait1 = eventlet.event.Event()
+        done1 = eventlet.event.Event()
+        eventlet.spawn(conn._cache_image, _concurrency,
+                       'target', 'fname', False, wait1, done1)
+        wait2 = eventlet.event.Event()
+        done2 = eventlet.event.Event()
+        eventlet.spawn(conn._cache_image, _concurrency,
+                       'target', 'fname', False, wait2, done2)
+        wait2.send()
+        eventlet.sleep(0)
+        try:
+            self.assertFalse(done2.ready())
+        finally:
+            wait1.send()
+        done1.wait()
+        eventlet.sleep(0)
+        self.assertTrue(done2.ready())
+
+    def test_different_fname_concurrency(self):
+        """Ensures that two different fname caches are concurrent"""
+        conn = libvirt_conn.get_connection(False)
+        wait1 = eventlet.event.Event()
+        done1 = eventlet.event.Event()
+        eventlet.spawn(conn._cache_image, _concurrency,
+                       'target', 'fname2', False, wait1, done1)
+        wait2 = eventlet.event.Event()
+        done2 = eventlet.event.Event()
+        eventlet.spawn(conn._cache_image, _concurrency,
+                       'target', 'fname1', False, wait2, done2)
+        wait2.send()
+        eventlet.sleep(0)
+        try:
+            self.assertTrue(done2.ready())
+        finally:
+            wait1.send()
+            eventlet.sleep(0)
+
+
 class LibvirtConnTestCase(test.TestCase):
     def setUp(self):
         super(LibvirtConnTestCase, self).setUp()

From 2869f812a36675a7aeeb1fe33ed637d0da6a5327 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Wed, 9 Mar 2011 07:35:58 +0000
Subject: [PATCH 71/77] make static method for testing without initializing
 libvirt

---
 nova/tests/test_virt.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index ec7498d7..113632a0 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -57,7 +57,7 @@ class CacheConcurrencyTestCase(test.TestCase):
 
     def test_same_fname_concurrency(self):
         """Ensures that the same fname cache runs at a sequentially"""
-        conn = libvirt_conn.get_connection(False)
+        conn = libvirt_conn.LibvirtConnection
         wait1 = eventlet.event.Event()
         done1 = eventlet.event.Event()
         eventlet.spawn(conn._cache_image, _concurrency,
@@ -78,7 +78,7 @@ class CacheConcurrencyTestCase(test.TestCase):
 
     def test_different_fname_concurrency(self):
         """Ensures that two different fname caches are concurrent"""
-        conn = libvirt_conn.get_connection(False)
+        conn = libvirt_conn.LibvirtConnection
         wait1 = eventlet.event.Event()
         done1 = eventlet.event.Event()
         eventlet.spawn(conn._cache_image, _concurrency,

From 4691b259af740f18785d841ed7fd3c8f2f19d01a Mon Sep 17 00:00:00 2001
From: Soren Hansen <soren@linux2go.dk>
Date: Wed, 9 Mar 2011 10:30:18 +0100
Subject: [PATCH 72/77] Stop assuming anything about the order in which the two
 processes are scheduled.

---
 nova/tests/test_misc.py | 47 ++++++++++++++++++++++-------------------
 1 file changed, 25 insertions(+), 22 deletions(-)

diff --git a/nova/tests/test_misc.py b/nova/tests/test_misc.py
index 9f572b58..a658e497 100644
--- a/nova/tests/test_misc.py
+++ b/nova/tests/test_misc.py
@@ -71,30 +71,33 @@ class LockTestCase(test.TestCase):
                                                "got mangled")
 
     def test_synchronized(self):
-        rpipe, wpipe = os.pipe()
-        pid = os.fork()
-        if pid > 0:
-            os.close(wpipe)
+        rpipe1, wpipe1 = os.pipe()
+        rpipe2, wpipe2 = os.pipe()
 
-            @synchronized('testlock')
-            def f():
-                rfds, _, __ = select.select([rpipe], [], [], 1)
-                self.assertEquals(len(rfds), 0, "The other process, which was"
-                                                " supposed to be locked, "
-                                                "wrote on its end of the "
-                                                "pipe")
-                os.close(rpipe)
+        @synchronized('testlock')
+        def f(rpipe, wpipe):
+            try:
+                os.write(wpipe, "foo")
+            except OSError, e:
+                self.assertEquals(e.errno, errno.EPIPE)
+                return
 
-            f()
-        else:
+            rfds, _, __ = select.select([rpipe], [], [], 1)
+            self.assertEquals(len(rfds), 0, "The other process, which was"
+                                            " supposed to be locked, "
+                                            "wrote on its end of the "
+                                            "pipe")
             os.close(rpipe)
 
-            @synchronized('testlock')
-            def g():
-                try:
-                    os.write(wpipe, "foo")
-                except OSError, e:
-                    self.assertEquals(e.errno, errno.EPIPE)
-                    return
-            g()
+        pid = os.fork()
+        if pid > 0:
+            os.close(wpipe1)
+            os.close(rpipe2)
+
+            f(rpipe1, wpipe2)
+        else:
+            os.close(rpipe1)
+            os.close(wpipe2)
+
+            f(rpipe2, wpipe1)
             os._exit(0)

From 2a76f0d8146d9c833cc2478f45099ecdaf35192d Mon Sep 17 00:00:00 2001
From: Ricardo Carrillo Cruz <emaildericky@gmail.com>
Date: Wed, 9 Mar 2011 19:03:58 +0100
Subject: [PATCH 73/77] fixed lp715427

---
 bin/nova-manage | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/bin/nova-manage b/bin/nova-manage
index 8ddfea5c..45437d7e 100755
--- a/bin/nova-manage
+++ b/bin/nova-manage
@@ -547,10 +547,11 @@ class NetworkCommands(object):
 
     def delete(self, fixed_range):
         """Deletes a network"""
-        network = db.network_get_by_cidr(context.get_admin_context(), fixed_range)
+        network = db.network_get_by_cidr(context.get_admin_context(), \
+                                         fixed_range)
         if network.project_id is not None:
-            raise ValueError(_('Network must be disassociated from project %s' 
-                               ' before delete' %network.project_id))
+            raise ValueError(_('Network must be disassociated from project %s'
+                               ' before delete' % network.project_id))
         db.network_delete_safe(context.get_admin_context(), network.id)  
   
 class ServiceCommands(object):

From bb57f769db5dcf7086891296ce4e96ef47be2729 Mon Sep 17 00:00:00 2001
From: Ricardo Carrillo Cruz <emaildericky@gmail.com>
Date: Wed, 9 Mar 2011 19:16:26 +0100
Subject: [PATCH 74/77] Fixed pep8 issues

---
 bin/nova-manage | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/bin/nova-manage b/bin/nova-manage
index 45437d7e..7dfc3c04 100755
--- a/bin/nova-manage
+++ b/bin/nova-manage
@@ -552,8 +552,9 @@ class NetworkCommands(object):
         if network.project_id is not None:
             raise ValueError(_('Network must be disassociated from project %s'
                                ' before delete' % network.project_id))
-        db.network_delete_safe(context.get_admin_context(), network.id)  
-  
+        db.network_delete_safe(context.get_admin_context(), network.id)
+
+
 class ServiceCommands(object):
     """Enable and disable running services"""
 

From 640abcc3bf5be4a804d34671cd2a15732bca4514 Mon Sep 17 00:00:00 2001
From: Eric Windisch <eric@cloudscaling.com>
Date: Wed, 9 Mar 2011 15:33:20 -0500
Subject: [PATCH 75/77] execvp passes pep8

---
 nova/tests/test_virt.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index 7f1ad002..dfa607f1 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -316,7 +316,7 @@ class IptablesFirewallTestCase(test.TestCase):
 
 #        self.fw.add_instance(instance_ref)
         def fake_iptables_execute(*cmd, **kwargs):
-            process_input=kwargs.get('process_input', None)
+            process_input = kwargs.get('process_input', None)
             if cmd == ('sudo', 'ip6tables-save', '-t', 'filter'):
                 return '\n'.join(self.in6_rules), None
             if cmd == ('sudo', 'iptables-save', '-t', 'filter'):

From 6959e80e38d8a3f3987d71cac56233b0b85aac57 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Wed, 9 Mar 2011 21:43:35 +0000
Subject: [PATCH 76/77] remove the semaphore when there is no one waiting on it

---
 nova/tests/test_virt.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/nova/tests/test_virt.py b/nova/tests/test_virt.py
index 113632a0..56a27136 100644
--- a/nova/tests/test_virt.py
+++ b/nova/tests/test_virt.py
@@ -23,7 +23,6 @@ from xml.dom.minidom import parseString as xml_to_dom
 from nova import context
 from nova import db
 from nova import flags
-from nova import log as logging
 from nova import test
 from nova import utils
 from nova.api.ec2 import cloud
@@ -70,11 +69,13 @@ class CacheConcurrencyTestCase(test.TestCase):
         eventlet.sleep(0)
         try:
             self.assertFalse(done2.ready())
+            self.assertTrue('fname' in conn._image_sems)
         finally:
             wait1.send()
         done1.wait()
         eventlet.sleep(0)
         self.assertTrue(done2.ready())
+        self.assertFalse('fname' in conn._image_sems)
 
     def test_different_fname_concurrency(self):
         """Ensures that two different fname caches are concurrent"""