renamed xxxnode to xxservice

3 files changed, 50 insertions, 50 deletions

diff --git a/nova/tests/cloud_unittest.py b/nova/tests/cloud_unittest.py
index 7ab2c257a..38f4de8d9 100644
--- a/nova/tests/cloud_unittest.py
+++ b/nova/tests/cloud_unittest.py
@@ -28,7 +28,7 @@ from nova import flags
 from nova import rpc
 from nova import test
 from nova.auth import users
-from nova.compute import computenode
+from nova.compute import computeservice
 from nova.endpoint import api
 from nova.endpoint import cloud
 
@@ -53,12 +53,12 @@ class CloudTestCase(test.BaseTestCase):
                                                       proxy=self.cloud)
         self.injected.append(self.cloud_consumer.attach_to_tornado(self.ioloop))
 
-        # set up a node
-        self.node = computenode.ComputeNode()
-        self.node_consumer = rpc.AdapterConsumer(connection=self.conn,
+        # set up a service
+        self.compute = computeservice.ComputeService()
+        self.compute_consumer = rpc.AdapterConsumer(connection=self.conn,
                                                      topic=FLAGS.compute_topic,
-                                                     proxy=self.node)
-        self.injected.append(self.node_consumer.attach_to_tornado(self.ioloop))
+                                                     proxy=self.compute)
+        self.injected.append(self.compute_consumer.attach_to_tornado(self.ioloop))
 
         try:
             users.UserManager.instance().create_user('admin', 'admin', 'admin')
@@ -76,11 +76,11 @@ class CloudTestCase(test.BaseTestCase):
             logging.debug("Can't test instances without a real virtual env.")
             return
         instance_id = 'foo'
-        inst = yield self.node.run_instance(instance_id)
+        inst = yield self.compute.run_instance(instance_id)
         output = yield self.cloud.get_console_output(self.context, [instance_id])
         logging.debug(output)
         self.assert_(output)
-        rv = yield self.node.terminate_instance(instance_id)
+        rv = yield self.compute.terminate_instance(instance_id)
 
     def test_run_instances(self):
         if FLAGS.fake_libvirt:
@@ -112,7 +112,7 @@ class CloudTestCase(test.BaseTestCase):
              # for instance in reservations[res_id]:
            for instance in reservations[reservations.keys()[0]]:
                logging.debug("Terminating instance %s" % instance['instance_id'])
-               rv = yield self.node.terminate_instance(instance['instance_id'])
+               rv = yield self.compute.terminate_instance(instance['instance_id'])
 
     def test_instance_update_state(self):
         def instance(num):
diff --git a/nova/tests/compute_unittest.py b/nova/tests/compute_unittest.py
index 4c0f1afb3..db08308bb 100644
--- a/nova/tests/compute_unittest.py
+++ b/nova/tests/compute_unittest.py
@@ -26,7 +26,7 @@ from nova import flags
 from nova import test
 from nova import utils
 from nova.compute import model
-from nova.compute import computenode
+from nova.compute import computeservice
 
 
 FLAGS = flags.FLAGS
@@ -60,7 +60,7 @@ class ComputeConnectionTestCase(test.TrialTestCase):
         self.flags(fake_libvirt=True,
                    fake_storage=True,
                    fake_users=True)
-        self.node = computenode.ComputeNode()
+        self.compute = computeservice.ComputeService()
 
     def create_instance(self):
         instdir = model.InstanceDirectory()
@@ -81,48 +81,48 @@ class ComputeConnectionTestCase(test.TrialTestCase):
     def test_run_describe_terminate(self):
         instance_id = self.create_instance()
 
-        rv = yield self.node.run_instance(instance_id)
+        rv = yield self.compute.run_instance(instance_id)
 
-        rv = yield self.node.describe_instances()
+        rv = yield self.compute.describe_instances()
         logging.info("Running instances: %s", rv)
         self.assertEqual(rv[instance_id].name, instance_id)
 
-        rv = yield self.node.terminate_instance(instance_id)
+        rv = yield self.compute.terminate_instance(instance_id)
 
-        rv = yield self.node.describe_instances()
+        rv = yield self.compute.describe_instances()
         logging.info("After terminating instances: %s", rv)
         self.assertEqual(rv, {})
 
     @defer.inlineCallbacks
     def test_reboot(self):
         instance_id = self.create_instance()
-        rv = yield self.node.run_instance(instance_id)
+        rv = yield self.compute.run_instance(instance_id)
 
-        rv = yield self.node.describe_instances()
+        rv = yield self.compute.describe_instances()
         self.assertEqual(rv[instance_id].name, instance_id)
 
-        yield self.node.reboot_instance(instance_id)
+        yield self.compute.reboot_instance(instance_id)
 
-        rv = yield self.node.describe_instances()
+        rv = yield self.compute.describe_instances()
         self.assertEqual(rv[instance_id].name, instance_id)
-        rv = yield self.node.terminate_instance(instance_id)
+        rv = yield self.compute.terminate_instance(instance_id)
 
     @defer.inlineCallbacks
     def test_console_output(self):
         instance_id = self.create_instance()
-        rv = yield self.node.run_instance(instance_id)
+        rv = yield self.compute.run_instance(instance_id)
 
-        console = yield self.node.get_console_output(instance_id)
+        console = yield self.compute.get_console_output(instance_id)
         self.assert_(console)
-        rv = yield self.node.terminate_instance(instance_id)
+        rv = yield self.compute.terminate_instance(instance_id)
 
     @defer.inlineCallbacks
     def test_run_instance_existing(self):
         instance_id = self.create_instance()
-        rv = yield self.node.run_instance(instance_id)
+        rv = yield self.compute.run_instance(instance_id)
 
-        rv = yield self.node.describe_instances()
+        rv = yield self.compute.describe_instances()
         self.assertEqual(rv[instance_id].name, instance_id)
 
-        self.assertRaises(exception.Error, self.node.run_instance, instance_id)
-        rv = yield self.node.terminate_instance(instance_id)
+        self.assertRaises(exception.Error, self.compute.run_instance, instance_id)
+        rv = yield self.compute.terminate_instance(instance_id)
diff --git a/nova/tests/volume_unittest.py b/nova/tests/volume_unittest.py
index c176453d8..568b199a0 100644
--- a/nova/tests/volume_unittest.py
+++ b/nova/tests/volume_unittest.py
@@ -21,8 +21,8 @@ import logging
 from nova import exception
 from nova import flags
 from nova import test
-from nova.compute import computenode
-from nova.volume import volumenode
+from nova.compute import computeservice
+from nova.volume import volumeservice
 
 
 FLAGS = flags.FLAGS
@@ -32,24 +32,24 @@ class VolumeTestCase(test.TrialTestCase):
     def setUp(self):
         logging.getLogger().setLevel(logging.DEBUG)
         super(VolumeTestCase, self).setUp()
-        self.mynode = computenode.ComputeNode()
-        self.mystorage = None
+        self.compute = computeservice.ComputeService()
+        self.volume = None
         self.flags(fake_libvirt=True,
                    fake_storage=True)
-        self.mystorage = volumenode.VolumeNode()
+        self.volume = volumeservice.VolumeService()
 
     def test_run_create_volume(self):
         vol_size = '0'
         user_id = 'fake'
         project_id = 'fake'
-        volume_id = self.mystorage.create_volume(vol_size, user_id, project_id)
+        volume_id = self.volume.create_volume(vol_size, user_id, project_id)
         # TODO(termie): get_volume returns differently than create_volume
         self.assertEqual(volume_id,
-                         volumenode.get_volume(volume_id)['volume_id'])
+                         volumeservice.get_volume(volume_id)['volume_id'])
 
-        rv = self.mystorage.delete_volume(volume_id)
+        rv = self.volume.delete_volume(volume_id)
         self.assertRaises(exception.Error,
-                          volumenode.get_volume,
+                          volumeservice.get_volume,
                           volume_id)
 
     def test_too_big_volume(self):
@@ -57,7 +57,7 @@ class VolumeTestCase(test.TrialTestCase):
         user_id = 'fake'
         project_id = 'fake'
         self.assertRaises(TypeError,
-                          self.mystorage.create_volume,
+                          self.volume.create_volume,
                           vol_size, user_id, project_id)
 
     def test_too_many_volumes(self):
@@ -68,26 +68,26 @@ class VolumeTestCase(test.TrialTestCase):
         total_slots = FLAGS.slots_per_shelf * num_shelves
         vols = []
         for i in xrange(total_slots):
-            vid = self.mystorage.create_volume(vol_size, user_id, project_id)
+            vid = self.volume.create_volume(vol_size, user_id, project_id)
             vols.append(vid)
-        self.assertRaises(volumenode.NoMoreVolumes,
-                          self.mystorage.create_volume,
+        self.assertRaises(volumeservice.NoMoreVolumes,
+                          self.volume.create_volume,
                           vol_size, user_id, project_id)
         for id in vols:
-            self.mystorage.delete_volume(id)
+            self.volume.delete_volume(id)
 
     def test_run_attach_detach_volume(self):
-        # Create one volume and one node to test with
+        # Create one volume and one compute to test with
         instance_id = "storage-test"
         vol_size = "5"
         user_id = "fake"
         project_id = 'fake'
         mountpoint = "/dev/sdf"
-        volume_id = self.mystorage.create_volume(vol_size, user_id, project_id)
+        volume_id = self.volume.create_volume(vol_size, user_id, project_id)
 
-        volume_obj = volumenode.get_volume(volume_id)
+        volume_obj = volumeservice.get_volume(volume_id)
         volume_obj.start_attach(instance_id, mountpoint)
-        rv = yield self.mynode.attach_volume(volume_id,
+        rv = yield self.compute.attach_volume(volume_id,
                                           instance_id,
                                           mountpoint)
         self.assertEqual(volume_obj['status'], "in-use")
@@ -96,16 +96,16 @@ class VolumeTestCase(test.TrialTestCase):
         self.assertEqual(volume_obj['mountpoint'], mountpoint)
 
         self.assertRaises(exception.Error,
-                          self.mystorage.delete_volume,
+                          self.volume.delete_volume,
                           volume_id)
 
-        rv = yield self.mystorage.detach_volume(volume_id)
-        volume_obj = volumenode.get_volume(volume_id)
+        rv = yield self.volume.detach_volume(volume_id)
+        volume_obj = volumeservice.get_volume(volume_id)
         self.assertEqual(volume_obj['status'], "available")
 
-        rv = self.mystorage.delete_volume(volume_id)
+        rv = self.volume.delete_volume(volume_id)
         self.assertRaises(exception.Error,
-                          volumenode.get_volume,
+                          volumeservice.get_volume,
                           volume_id)
 
     def test_multi_node(self):