other round of refactoring

4 files changed, 142 insertions, 52 deletions

diff --git a/nova/virt/xenapi/novadeps.py b/nova/virt/xenapi/novadeps.py
new file mode 100644
index 000000000..a4e512263
--- /dev/null
+++ b/nova/virt/xenapi/novadeps.py
@@ -0,0 +1,97 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2010 Citrix Systems, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from nova import db
+from nova import flags
+from nova import process
+from nova import utils
+
+from nova.compute import power_state
+from nova.auth.manager import AuthManager
+from nova.compute import instance_types
+from nova.virt import images   
+
+XENAPI_POWER_STATE = {
+    'Halted': power_state.SHUTDOWN,
+    'Running': power_state.RUNNING,
+    'Paused': power_state.PAUSED,
+    'Suspended': power_state.SHUTDOWN,  # FIXME
+    'Crashed': power_state.CRASHED}
+    
+class Instance(object):
+
+    @classmethod
+    def get_name(self, instance):
+        return instance.name
+        
+    @classmethod
+    def get_type(self, instance):
+        return instance_types.INSTANCE_TYPES[instance.instance_type]
+ 
+    @classmethod
+    def get_project(self, instance):
+        return AuthManager().get_project(instance.project_id)
+            
+    @classmethod
+    def get_project_id(self, instance):
+        return instance.project_id
+                            
+    @classmethod
+    def get_image_id(self, instance):
+        return instance.image_id
+        
+    @classmethod
+    def get_kernel_id(self, instance):
+        return instance.kernel_id
+                    
+    @classmethod
+    def get_ramdisk_id(self, instance):
+        return instance.ramdisk_id
+
+    @classmethod
+    def get_network(self, instance):
+        return db.project_get_network(None, instance.project_id)
+    
+    @classmethod
+    def get_mac(self, instance):
+        return instance.mac_address
+    
+    @classmethod
+    def get_user(self, instance):
+        return AuthManager().get_user(instance.user_id)
+        
+
+class Network(object):
+
+    @classmethod
+    def get_bridge(self, network):
+        return network.bridge
+        
+class Image(object):
+
+    @classmethod
+    def get_url(self, image):
+        return images.image_url(image)
+        
+class User(object):
+
+    @classmethod
+    def get_access(self, user, project):
+        return AuthManager().get_access_key(user, project)
+
+    @classmethod
+    def get_secret(self, user):
+        return user.secret
\ No newline at end of file
diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
index 6fb409b26..8329f0d7e 100644
--- a/nova/virt/xenapi/vm_utils.py
+++ b/nova/virt/xenapi/vm_utils.py
@@ -30,11 +30,10 @@ from nova import db
 from nova import flags
 from nova import process
 from nova import utils
-from nova.auth.manager import AuthManager  # wrap this one
-from nova.compute import instance_types  # wrap this one
-from nova.virt import images   # wrap this one
 
-import power_state
+from novadeps import Instance
+from novadeps import Image
+from novadeps import User
           
                 
 class VMHelper():
@@ -44,7 +43,7 @@ class VMHelper():
         """Create a VM record.  Returns a Deferred that gives the new
         VM reference."""
 
-        instance_type = instance_types.INSTANCE_TYPES[instance.instance_type]
+        instance_type = Instance.get_type(instance) 
         mem = str(long(instance_type['memory_mb']) * 1024 * 1024)
         vcpus = str(instance_type['vcpus'])
         rec = {
@@ -76,9 +75,9 @@ class VMHelper():
             'user_version': '0',
             'other_config': {},
             }
-        logging.debug('Created VM %s...', instance.name)
+        logging.debug('Created VM %s...', Instance.get_name(instance))
         vm_ref = yield session.call_xenapi('VM.create', rec)
-        logging.debug('Created VM %s as %s.', instance.name, vm_ref)
+        logging.debug('Created VM %s as %s.', Instance.get_name(instance), vm_ref)
         defer.returnValue(vm_ref)
         
     @classmethod    
@@ -130,33 +129,20 @@ class VMHelper():
 
     @classmethod
     @defer.inlineCallbacks
-    def find_network_with_bridge(self, session, bridge):
-        expr = 'field "bridge" = "%s"' % bridge
-        networks = yield session.call_xenapi('network.get_all_records_where',
-                                           expr)
-        if len(networks) == 1:
-            defer.returnValue(networks.keys()[0])
-        elif len(networks) > 1:
-            raise Exception('Found non-unique network for bridge %s' % bridge)
-        else:
-            raise Exception('Found no network for bridge %s' % bridge)
-
-    @classmethod
-    @defer.inlineCallbacks
     def fetch_image(self, session, image, user, project, use_sr):
         """use_sr: True to put the image as a VDI in an SR, False to place
         it on dom0's filesystem.  The former is for VM disks, the latter for
         its kernel and ramdisk (if external kernels are being used).
         Returns a Deferred that gives the new VDI UUID."""
 
-        url = images.image_url(image)
-        access = AuthManager().get_access_key(user, project)
+        url = Image.get_url(image)
+        access = User.get_access(user, project)
         logging.debug("Asking xapi to fetch %s as %s" % (url, access))
         fn = use_sr and 'get_vdi' or 'get_kernel'
         args = {}
         args['src_url'] = url
         args['username'] = access
-        args['password'] = user.secret
+        args['password'] = User.get_secret(user)
         if use_sr:
             args['add_partition'] = 'true'
         task = yield session.async_call_plugin('objectstore', fn, args)
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index 03b7fc614..abb422502 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -25,18 +25,14 @@ from twisted.internet import defer
 from twisted.internet import reactor
 from twisted.internet import task
 
-from nova import db
-from nova import flags
-from nova import process
-from nova import utils
-from nova.auth.manager import AuthManager  # wrap this one
-from nova.compute import instance_types  # wrap this one
-from nova.virt import images   # wrap this one
-
-import power_state
+
 import VMHelper
 import NetworkHelper
 
+from novadeps import XENAPI_POWER_STATE
+from novadeps import Auth
+from novadeps import Instance
+from novadeps import Network
 
 class VMOps(object):
     def __init__(self, session):
@@ -48,44 +44,45 @@ class VMOps(object):
 
     @defer.inlineCallbacks
     def spawn(self, instance):
-        vm = yield VMHelper.lookup(self._session, instance.name)
+        vm = yield VMHelper.lookup(self._session, Instance.get_name(instance))
         if vm is not None:
             raise Exception('Attempted to create non-unique name %s' %
-                            instance.name)
+                            Instance.get_name(instance))
 
-        network = db.project_get_network(None, instance.project_id)
+        network = Instance.get_network(instance)
         network_ref = \
-            yield NetworkHelper.find_network_with_bridge(self._session, network.bridge)
+            yield NetworkHelper.find_network_with_bridge(self._session, Network.get_bridge(network))
 
-        user = AuthManager().get_user(instance.user_id)
-        project = AuthManager().get_project(instance.project_id)
+        user = Instance.get_user(instance)
+        project = Instance.get_project(instance)
         vdi_uuid = yield VMHelper.fetch_image(self._session,
-            instance.image_id, user, project, True)
+            Instance.get_image_id(instance), user, project, True)
         kernel = yield VMHelper.fetch_image(self._session,
-            instance.kernel_id, user, project, False)
+            Instance.get_kernel_id(instance), user, project, False)
         ramdisk = yield VMHelper.fetch_image(self._session,
-            instance.ramdisk_id, user, project, False)
+            Instance.get_ramdisk_id(instance), user, project, False)
         vdi_ref = yield self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid)
 
         vm_ref = yield VMHelper.create_vm(self._session, instance, kernel, ramdisk)
         yield VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True)
         if network_ref:
-            yield VMHelper.create_vif(self._session, vm_ref, network_ref, instance.mac_address)
+            yield VMHelper.create_vif(self._session, vm_ref, network_ref, Instance.get_mac(instance))
         logging.debug('Starting VM %s...', vm_ref)
         yield self._session.call_xenapi('VM.start', vm_ref, False, False)
-        logging.info('Spawning VM %s created %s.', instance.name, vm_ref)
+        logging.info('Spawning VM %s created %s.', Instance.get_name(instance), vm_ref)
 
     @defer.inlineCallbacks
     def reboot(self, instance):
-        vm = yield VMHelper.lookup(self._session, instance.name)
+        instance_name = Instance.get_name(instance)
+        vm = yield VMHelper.lookup(self._session, instance_name)
         if vm is None:
-            raise Exception('instance not present %s' % instance.name)
+            raise Exception('instance not present %s' % instance_name)
         task = yield self._session.call_xenapi('Async.VM.clean_reboot', vm)
         yield self._session.wait_for_task(task)
 
     @defer.inlineCallbacks
     def destroy(self, instance):
-        vm = yield VMHelper.lookup(self._session, instance.name)
+        vm = yield VMHelper.lookup(self._session, Instance.get_name(instance))
         if vm is None:
             # Don't complain, just return.  This lets us clean up instances
             # that have already disappeared from the underlying platform.
diff --git a/nova/virt/xenapi/power_state.py b/nova/virt/xenapi/volumeops.py
index 5892f0f48..f5b43adfb 100644
--- a/nova/virt/xenapi/power_state.py
+++ b/nova/virt/xenapi/volumeops.py
@@ -14,12 +14,22 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+"""
+Management class for Storage-related functions (attach, detach, etc).
+"""
+
+from twisted.internet import defer
+
+from nova import exception
 from nova.compute import power_state
 
 
-XENAPI_POWER_STATE = {
-    'Halted': power_state.SHUTDOWN,
-    'Running': power_state.RUNNING,
-    'Paused': power_state.PAUSED,
-    'Suspended': power_state.SHUTDOWN,  # FIXME
-    'Crashed': power_state.CRASHED}
+class VMOps(object):
+    def __init__(self, session):
+        self._session = session
+
+    def attach_volume(self, instance_name, device_path, mountpoint):
+        return True
+
+    def detach_volume(self, instance_name, mountpoint):
+        return True
\ No newline at end of file