143 lines
4.5 KiB
Python
143 lines
4.5 KiB
Python
# Copyright 2013 OpenStack Foundation
|
|
#
|
|
# 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 utils
|
|
|
|
|
|
class XenAPISessionObject(object):
|
|
"""Wrapper to make calling and mocking the session easier
|
|
|
|
The XenAPI protocol is an XML RPC API that is based around the
|
|
XenAPI database, and operations you can do on each of the objects
|
|
stored in the database, such as VM, SR, VDI, etc.
|
|
|
|
For more details see the XenAPI docs:
|
|
http://docs.vmd.citrix.com/XenServer/6.2.0/1.0/en_gb/api/
|
|
|
|
Most, objects like VM, SR, VDI, etc, share a common set of methods:
|
|
* vm_ref = session.VM.create(vm_rec)
|
|
* vm_ref = session.VM.get_by_uuid(uuid)
|
|
* session.VM.destroy(vm_ref)
|
|
* vm_refs = session.VM.get_all()
|
|
|
|
Each object also has specific messages, or functions, such as:
|
|
* session.VM.clean_reboot(vm_ref)
|
|
|
|
Each object has fields, like "VBDs" that can be fetched like this:
|
|
* vbd_refs = session.VM.get_VBDs(vm_ref)
|
|
|
|
You can get all the fields by fetching the full record.
|
|
However please note this is much more expensive than just
|
|
fetching the field you require:
|
|
* vm_rec = session.VM.get_record(vm_ref)
|
|
|
|
When searching for particular objects, you may be tempted
|
|
to use get_all(), but this often leads to races as objects
|
|
get deleted under your feet. It is preferable to use the undocumented:
|
|
* vms = session.VM.get_all_records_where(
|
|
'field "is_control_domain"="true"')
|
|
|
|
"""
|
|
|
|
def __init__(self, session, name):
|
|
self.session = session
|
|
self.name = name
|
|
|
|
def _call_method(self, method_name, *args):
|
|
call = "%s.%s" % (self.name, method_name)
|
|
return self.session.call_xenapi(call, *args)
|
|
|
|
def __getattr__(self, method_name):
|
|
return lambda *params: self._call_method(method_name, *params)
|
|
|
|
|
|
class VM(XenAPISessionObject):
|
|
"""Virtual Machine."""
|
|
def __init__(self, session):
|
|
super(VM, self).__init__(session, "VM")
|
|
|
|
|
|
class VBD(XenAPISessionObject):
|
|
"""Virtual block device."""
|
|
def __init__(self, session):
|
|
super(VBD, self).__init__(session, "VBD")
|
|
|
|
def plug(self, vbd_ref, vm_ref):
|
|
@utils.synchronized('xenapi-vbd-' + vm_ref)
|
|
def synchronized_plug():
|
|
self._call_method("plug", vbd_ref)
|
|
|
|
# NOTE(johngarbutt) we need to ensure there is only ever one
|
|
# VBD.unplug or VBD.plug happening at once per VM
|
|
# due to a bug in XenServer 6.1 and 6.2
|
|
synchronized_plug()
|
|
|
|
def unplug(self, vbd_ref, vm_ref):
|
|
@utils.synchronized('xenapi-vbd-' + vm_ref)
|
|
def synchronized_unplug():
|
|
self._call_method("unplug", vbd_ref)
|
|
|
|
# NOTE(johngarbutt) we need to ensure there is only ever one
|
|
# VBD.unplug or VBD.plug happening at once per VM
|
|
# due to a bug in XenServer 6.1 and 6.2
|
|
synchronized_unplug()
|
|
|
|
|
|
class VDI(XenAPISessionObject):
|
|
"""Virtual disk image."""
|
|
def __init__(self, session):
|
|
super(VDI, self).__init__(session, "VDI")
|
|
|
|
|
|
class SR(XenAPISessionObject):
|
|
"""Storage Repository."""
|
|
def __init__(self, session):
|
|
super(SR, self).__init__(session, "SR")
|
|
|
|
|
|
class PBD(XenAPISessionObject):
|
|
"""Physical block device."""
|
|
def __init__(self, session):
|
|
super(PBD, self).__init__(session, "PBD")
|
|
|
|
|
|
class PIF(XenAPISessionObject):
|
|
"""Physical Network Interface."""
|
|
def __init__(self, session):
|
|
super(PIF, self).__init__(session, "PIF")
|
|
|
|
|
|
class VLAN(XenAPISessionObject):
|
|
"""VLAN."""
|
|
def __init__(self, session):
|
|
super(VLAN, self).__init__(session, "VLAN")
|
|
|
|
|
|
class Host(XenAPISessionObject):
|
|
"""XenServer hosts."""
|
|
def __init__(self, session):
|
|
super(Host, self).__init__(session, "host")
|
|
|
|
|
|
class Network(XenAPISessionObject):
|
|
"""Networks that VIFs are attached to."""
|
|
def __init__(self, session):
|
|
super(Network, self).__init__(session, "network")
|
|
|
|
|
|
class Pool(XenAPISessionObject):
|
|
"""Pool of hosts."""
|
|
def __init__(self, session):
|
|
super(Pool, self).__init__(session, "pool")
|