trunk merge, pip-requires and novatools to novaclient changes

.mailmap

@@ -19,6 +19,7 @@
 <jmckenty@gmail.com> <jmckenty@joshua-mckentys-macbook-pro.local>
 <jmckenty@gmail.com> <jmckenty@yyj-dhcp171.corp.flock.com>
 <jmckenty@gmail.com> <joshua.mckenty@nasa.gov>
+<josh@jk0.org> <josh.kearney@rackspace.com>
 <justin@fathomdb.com> <justinsb@justinsb-desktop>
 <justin@fathomdb.com> <superstack@superstack.org>
 <masumotok@nttdata.co.jp> Masumoto<masumotok@nttdata.co.jp>

Authors

@@ -31,7 +31,7 @@ John Dewey <john@dewey.ws>
 Jonathan Bryce <jbryce@jbryce.com>
 Jordan Rinke <jordan@openstack.org>
 Josh Durgin <joshd@hq.newdream.net>
-Josh Kearney <josh.kearney@rackspace.com>
+Josh Kearney <josh@jk0.org>
 Joshua McKenty <jmckenty@gmail.com>
 Justin Santa Barbara <justin@fathomdb.com>
 Kei Masumoto <masumotok@nttdata.co.jp>

bin/nova-manage

@@ -84,6 +84,7 @@ from nova import utils
 from nova.api.ec2.cloud import ec2_id_to_id
 from nova.auth import manager
 from nova.cloudpipe import pipelib
+from nova.compute import instance_types
 from nova.db import migration
 
 FLAGS = flags.FLAGS
@@ -661,6 +662,79 @@ class VolumeCommands(object):
                            "mountpoint": volume['mountpoint']}})
 
 
+class InstanceTypeCommands(object):
+    """Class for managing instance types / flavors."""
+
+    def _print_instance_types(self, n, val):
+        deleted = ('', ', inactive')[val["deleted"] == 1]
+        print ("%s: Memory: %sMB, VCPUS: %s, Storage: %sGB, FlavorID: %s, "
+            "Swap: %sGB, RXTX Quota: %sGB, RXTX Cap: %sMB%s") % (
+            n, val["memory_mb"], val["vcpus"], val["local_gb"],
+            val["flavorid"], val["swap"], val["rxtx_quota"],
+            val["rxtx_cap"], deleted)
+
+    def create(self, name, memory, vcpus, local_gb, flavorid,
+               swap=0, rxtx_quota=0, rxtx_cap=0):
+        """Creates instance types / flavors
+           arguments: name memory vcpus local_gb flavorid [swap] [rxtx_quota]
+                      [rxtx_cap]
+        """
+        try:
+            instance_types.create(name, memory, vcpus, local_gb,
+                                  flavorid, swap, rxtx_quota, rxtx_cap)
+        except exception.InvalidInputException:
+            print "Must supply valid parameters to create instance type"
+            print e
+            sys.exit(1)
+        except exception.DBError, e:
+            print "DB Error: %s" % e
+            sys.exit(2)
+        except:
+            print "Unknown error"
+            sys.exit(3)
+        else:
+            print "%s created" % name
+
+    def delete(self, name, purge=None):
+        """Marks instance types / flavors as deleted
+        arguments: name"""
+        try:
+            if purge == "--purge":
+                instance_types.purge(name)
+                verb = "purged"
+            else:
+                instance_types.destroy(name)
+                verb = "deleted"
+        except exception.ApiError:
+            print "Valid instance type name is required"
+            sys.exit(1)
+        except exception.DBError, e:
+            print "DB Error: %s" % e
+            sys.exit(2)
+        except:
+            sys.exit(3)
+        else:
+            print "%s %s" % (name, verb)
+
+    def list(self, name=None):
+        """Lists all active or specific instance types / flavors
+        arguments: [name]"""
+        try:
+            if name == None:
+                inst_types = instance_types.get_all_types()
+            elif name == "--all":
+                inst_types = instance_types.get_all_types(1)
+            else:
+                inst_types = instance_types.get_instance_type(name)
+        except exception.DBError, e:
+            _db_error(e)
+        if isinstance(inst_types.values()[0], dict):
+            for k, v in inst_types.iteritems():
+                self._print_instance_types(k, v)
+        else:
+            self._print_instance_types(name, inst_types)
+
+
 CATEGORIES = [
     ('user', UserCommands),
     ('project', ProjectCommands),
@@ -673,7 +747,9 @@ CATEGORIES = [
     ('service', ServiceCommands),
     ('log', LogCommands),
     ('db', DbCommands),
-    ('volume', VolumeCommands)]
+    ('volume', VolumeCommands),
+    ('instance_type', InstanceTypeCommands),
+    ('flavor', InstanceTypeCommands)]
 
 
 def lazy_match(name, key_value_tuples):

nova/scheduler/zone_manager.py

@@ -17,7 +17,7 @@
 ZoneManager oversees all communications with child Zones.
 """
 
-import novatools
+import novaclient
 import thread
 import traceback
 
@@ -85,9 +85,9 @@ class ZoneState(object):
                             "attempts. Marking inactive.") % locals())
 
 
-def _call_novatools(zone):
+def _call_novaclient(zone):
-    """Call novatools. Broken out for testing purposes."""
+    """Call novaclient. Broken out for testing purposes."""
-    client = novatools.OpenStack(zone.username, zone.password, zone.api_url)
+    client = novaclient.OpenStack(zone.username, zone.password, zone.api_url)
     return client.zones.info()._info
 
 
@@ -95,7 +95,7 @@ def _poll_zone(zone):
     """Eventlet worker to poll a zone."""
     logging.debug(_("Polling zone: %s") % zone.api_url)
     try:
-        zone.update_metadata(_call_novatools(zone))
+        zone.update_metadata(_call_novaclient(zone))
     except Exception, e:
         zone.log_error(traceback.format_exc())
 

nova/tests/test_instance_types.py

@@ -0,0 +1,86 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Ken Pepple
+#    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.
+"""
+Unit Tests for instance types code
+"""
+import time
+
+from nova import context
+from nova import db
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova import test
+from nova import utils
+from nova.compute import instance_types
+from nova.db.sqlalchemy.session import get_session
+from nova.db.sqlalchemy import models
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.tests.compute')
+
+
+class InstanceTypeTestCase(test.TestCase):
+    """Test cases for instance type code"""
+    def setUp(self):
+        super(InstanceTypeTestCase, self).setUp()
+        session = get_session()
+        max_flavorid = session.query(models.InstanceTypes).\
+                                     order_by("flavorid desc").\
+                                     first()
+        self.flavorid = max_flavorid["flavorid"] + 1
+        self.name = str(int(time.time()))
+
+    def test_instance_type_create_then_delete(self):
+        """Ensure instance types can be created"""
+        starting_inst_list = instance_types.get_all_types()
+        instance_types.create(self.name, 256, 1, 120, self.flavorid)
+        new = instance_types.get_all_types()
+        self.assertNotEqual(len(starting_inst_list),
+                            len(new),
+                            'instance type was not created')
+        instance_types.destroy(self.name)
+        self.assertEqual(1,
+                    instance_types.get_instance_type(self.name)["deleted"])
+        self.assertEqual(starting_inst_list, instance_types.get_all_types())
+        instance_types.purge(self.name)
+        self.assertEqual(len(starting_inst_list),
+                         len(instance_types.get_all_types()),
+                         'instance type not purged')
+
+    def test_get_all_instance_types(self):
+        """Ensures that all instance types can be retrieved"""
+        session = get_session()
+        total_instance_types = session.query(models.InstanceTypes).\
+                                            count()
+        inst_types = instance_types.get_all_types()
+        self.assertEqual(total_instance_types, len(inst_types))
+
+    def test_invalid_create_args_should_fail(self):
+        """Ensures that instance type creation fails with invalid args"""
+        self.assertRaises(
+                exception.InvalidInputException,
+                instance_types.create, self.name, 0, 1, 120, self.flavorid)
+        self.assertRaises(
+                exception.InvalidInputException,
+                instance_types.create, self.name, 256, -1, 120, self.flavorid)
+        self.assertRaises(
+                exception.InvalidInputException,
+                instance_types.create, self.name, 256, 1, "aa", self.flavorid)
+
+    def test_non_existant_inst_type_shouldnt_delete(self):
+        """Ensures that instance type creation fails with invalid args"""
+        self.assertRaises(exception.ApiError,
+                          instance_types.destroy, "sfsfsdfdfs")

nova/tests/test_xenapi.py

@@ -233,7 +233,7 @@ class XenAPIVMTestCase(test.TestCase):
         vm = vms[0]
 
         # Check that m1.large above turned into the right thing.
-        instance_type = instance_types.INSTANCE_TYPES['m1.large']
+        instance_type = db.instance_type_get_by_name(conn, 'm1.large')
         mem_kib = long(instance_type['memory_mb']) << 10
         mem_bytes = str(mem_kib << 10)
         vcpus = instance_type['vcpus']

nova/tests/test_zones.py

@@ -18,7 +18,7 @@ Tests For ZoneManager
 
 import datetime
 import mox
-import novatools
+import novaclient
 
 from nova import context
 from nova import db
@@ -40,8 +40,8 @@ class FakeZone:
             setattr(self, k, v)
 
 
-def exploding_novatools(zone):
+def exploding_novaclient(zone):
-    """Used when we want to simulate a novatools call failing."""
+    """Used when we want to simulate a novaclient call failing."""
     raise Exception("kaboom")
 
 
@@ -139,8 +139,8 @@ class ZoneManagerTestCase(test.TestCase):
         self.assertEquals(zm.zone_states[2].username, 'user2')
 
     def test_poll_zone(self):
-        self.mox.StubOutWithMock(zone_manager, '_call_novatools')
+        self.mox.StubOutWithMock(zone_manager, '_call_novaclient')
-        zone_manager._call_novatools(mox.IgnoreArg()).AndReturn(
+        zone_manager._call_novaclient(mox.IgnoreArg()).AndReturn(
                         dict(name='zohan', capabilities='hairdresser'))
 
         zone_state = zone_manager.ZoneState()
@@ -156,7 +156,7 @@ class ZoneManagerTestCase(test.TestCase):
         self.assertEquals(zone_state.name, 'zohan')
 
     def test_poll_zone_fails(self):
-        self.stubs.Set(zone_manager, "_call_novatools", exploding_novatools)
+        self.stubs.Set(zone_manager, "_call_novaclient", exploding_novaclient)
 
         zone_state = zone_manager.ZoneState()
         zone_state.update_credentials(FakeZone(id=2,

nova/tests/xenapi/stubs.py

@@ -27,7 +27,7 @@ def stubout_instance_snapshot(stubs):
     def fake_fetch_image(cls, session, instance_id, image, user, project,
                          type):
         # Stubout wait_for_task
-        def fake_wait_for_task(self, id, task):
+        def fake_wait_for_task(self, task, id):
             class FakeEvent:
 
                 def send(self, value):