XenAPI 2.14__tar.gz → 23.8.0__tar.gz

XenAPI-23.8.0/Makefile

@@ -0,0 +1,12 @@
+PROFILE=release
+SETUPTOOLS_SCM_PRETEND_VERSION ?= ""
+
+.PHONY: build clean
+
+build:
+	SETUPTOOLS_SCM_PRETEND_VERSION=$(XAPI_VERSION) python -m build --wheel .
+	SETUPTOOLS_SCM_PRETEND_VERSION=$(XAPI_VERSION) python -m build --sdist .
+
+clean:
+	dune clean
+	rm -rf dist/ build/ XenAPI.egg-info/

XenAPI-23.8.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.1
+Name: XenAPI
+Version: 23.8.0
+Summary: XenAPI SDK, for communication with XenServer.
+Home-page: https://www.citrix.com/community/citrix-developer/citrix-hypervisor-developer/
+Author: Citrix Systems, Inc.
+Author-email: xen-api@lists.xenproject.org
+License: BSD-2-Clause
+Project-URL: Bug Tracker, https://github.com/xapi-project/xen-api/issues
+Project-URL: Source Code, https://github.com/xapi-project/xen-api
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,<4,>=2.7
+Description-Content-Type: text/markdown; charset=UTF-8
+
+Usage
+=====
+
+To install the package, enable the virtual environment where it's going to be used and run
+`$ pip install XenAPI`
+
+Examples
+--------
+
+The [examples](https://github.com/xapi-project/xen-api/tree/master/scripts/examples/python) will not work unless they have been placed in the same directory as `XenAPI.py` or `XenAPI` package from PyPI has been installed (`pip install XenAPI`)
+
+Packaging
+=========
+
+`setup.py` is generated using an ocaml binary that fetches the api version string from xapi. An opam switch with the [xs-opam](https://github.com/xapi-project/xs-opam) repository is needed in order to build the binary.
+
+To build the package `setuptools>=38.6.0` and `wheel` need to be installed in the system or in the active python virtualenv.
+
+To build, use the command `make`.

{XenAPI-2.14 → XenAPI-23.8.0}/README.md

@@ -7,7 +7,7 @@ To install the package, enable the virtual environment where it's going to be us
 Examples
 --------
 
-The examples now will not work unless they have been placed in the same directory as `XenAPI.py` or `XenAPI` package from PyPI has been installed (`pip installed XenAPI`)
+The [examples](https://github.com/xapi-project/xen-api/tree/master/scripts/examples/python) will not work unless they have been placed in the same directory as `XenAPI.py` or `XenAPI` package from PyPI has been installed (`pip install XenAPI`)
 
 Packaging
 =========

{XenAPI-2.14 → XenAPI-23.8.0}/XenAPI/XenAPI.py

@@ -55,11 +55,17 @@
 # --------------------------------------------------------------------
 
 import gettext
-import six.moves.xmlrpc_client as xmlrpclib
-import six.moves.http_client as httplib
 import socket
 import sys
 
+if sys.version_info[0] == 2:
+    import httplib as httplib
+    import xmlrpclib as xmlrpclib
+else:
+    import http.client as httplib
+    import xmlrpc.client as xmlrpclib
+
+
 translation = gettext.translation('xen-xm', fallback = True)
 
 API_VERSION_1_1 = '1.1'
@@ -92,26 +98,14 @@ class UDSHTTPConnection(httplib.HTTPConnection):
         self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
         self.sock.connect(path)
 
-class UDSHTTP(httplib.HTTPConnection):
-    _connection_class = UDSHTTPConnection
-
 class UDSTransport(xmlrpclib.Transport):
-    def __init__(self, use_datetime=0):
-        self._use_datetime = use_datetime
-        self._extra_headers=[]
-        self._connection = (None, None)
     def add_extra_header(self, key, value):
         self._extra_headers += [ (key,value) ]
     def make_connection(self, host):
-        # Python 2.4 compatibility
-        if sys.version_info[0] <= 2 and sys.version_info[1] < 7:
-            return UDSHTTP(host)
-        else:
-            return UDSHTTPConnection(host)
-    def send_request(self, connection, handler, request_body):
-        connection.putrequest("POST", handler)
-        for key, value in self._extra_headers:
-            connection.putheader(key, value)
+        return UDSHTTPConnection(host)
+
+def notimplemented(name, *args, **kwargs):
+    raise NotImplementedError("XMLRPC proxies do not support python magic methods", name, *args, **kwargs)
 
 class Session(xmlrpclib.ServerProxy):
     """A server proxy and session manager for communicating with xapi using
@@ -215,6 +209,8 @@ class Session(xmlrpclib.ServerProxy):
             return lambda *params: self._login(name, params)
         elif name == 'logout':
             return _Dispatcher(self.API_version, self.xenapi_request, "logout")
+        elif name.startswith('__') and name.endswith('__'):
+            return lambda *args, **kwargs: notimplemented(name, args, kwargs)
         else:
             return xmlrpclib.ServerProxy.__getattr__(self, name)
 

XenAPI-23.8.0/XenAPI.egg-info/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.1
+Name: XenAPI
+Version: 23.8.0
+Summary: XenAPI SDK, for communication with XenServer.
+Home-page: https://www.citrix.com/community/citrix-developer/citrix-hypervisor-developer/
+Author: Citrix Systems, Inc.
+Author-email: xen-api@lists.xenproject.org
+License: BSD-2-Clause
+Project-URL: Bug Tracker, https://github.com/xapi-project/xen-api/issues
+Project-URL: Source Code, https://github.com/xapi-project/xen-api
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,<4,>=2.7
+Description-Content-Type: text/markdown; charset=UTF-8
+
+Usage
+=====
+
+To install the package, enable the virtual environment where it's going to be used and run
+`$ pip install XenAPI`
+
+Examples
+--------
+
+The [examples](https://github.com/xapi-project/xen-api/tree/master/scripts/examples/python) will not work unless they have been placed in the same directory as `XenAPI.py` or `XenAPI` package from PyPI has been installed (`pip install XenAPI`)
+
+Packaging
+=========
+
+`setup.py` is generated using an ocaml binary that fetches the api version string from xapi. An opam switch with the [xs-opam](https://github.com/xapi-project/xs-opam) repository is needed in order to build the binary.
+
+To build the package `setuptools>=38.6.0` and `wheel` need to be installed in the system or in the active python virtualenv.
+
+To build, use the command `make`.

XenAPI-23.8.0/XenAPI.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+Makefile
+README.md
+XenAPIPlugin.py
+echo.py
+exportimport.py
+inventory.py
+lvhd-api-test.py
+mini-xenrt.py
+monitor-unwanted-domains.py
+provision.py
+pyproject.toml
+renameif.py
+setup.cfg
+shell.py
+xva.py
+XenAPI/XenAPI.py
+XenAPI/__init__.py
+XenAPI.egg-info/PKG-INFO
+XenAPI.egg-info/SOURCES.txt
+XenAPI.egg-info/dependency_links.txt
+XenAPI.egg-info/top_level.txt

XenAPI-23.8.0/XenAPIPlugin.py

@@ -0,0 +1,54 @@
+#!/usr/bin/python
+
+# XenAPI python plugin boilerplate code
+
+from __future__ import print_function
+
+import sys
+
+import XenAPI
+
+if sys.version_info[0] == 2:
+    import xmlrpclib as xmlrpclib
+else:
+    import xmlrpc.client as xmlrpclib
+
+class Failure(Exception):
+    """Provide compatibilty with plugins written against XenServer 5.5 API"""
+
+    def __init__(self, code, params):
+        Exception.__init__(self)
+        self.params = [ code ] + params
+    def __str__(self):
+        return str(self.params)
+
+def success_message(result):
+    rpcparams = { 'Status': 'Success', 'Value': result }
+    return xmlrpclib.dumps((rpcparams, ), '', True)
+
+def failure_message(description):
+    rpcparams = { 'Status': 'Failure', 'ErrorDescription': description }
+    return xmlrpclib.dumps((rpcparams, ), '', True)
+
+def dispatch(fn_table):
+    if len(sys.argv) != 2:
+        raise Exception("Incorrect number of commandline arguments")
+    params, methodname = xmlrpclib.loads(sys.argv[1])
+    session_id = params[0]
+    args = params[1]
+    if methodname in fn_table:
+        x = XenAPI.xapi_local()
+        x._session = session_id
+        try:
+            result = fn_table[methodname](x, args)
+            print(success_message(result))
+        except SystemExit:
+            # SystemExit should not be caught, as it is handled elsewhere in the plugin system.
+            raise
+        except Failure as e:
+            print(failure_message(e.params))
+        except Exception as e:
+            print(failure_message(['XENAPI_PLUGIN_FAILURE',
+                                   methodname, e.__class__.__name__, str(e)]))
+    else:
+        print(failure_message(['UNKNOWN_XENAPI_PLUGIN_FUNCTION', methodname]))

XenAPI-23.8.0/echo.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+
+# Simple XenAPI plugin
+import XenAPIPlugin, time
+
+def main(session, args):
+    if "sleep" in args:
+        secs = int(args["sleep"])
+        time.sleep(secs)
+    return "args were: %s" % (repr(args))
+
+if __name__ == "__main__":
+    XenAPIPlugin.dispatch({"main": main})
+
+

XenAPI-23.8.0/exportimport.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2014 Citrix, Inc.
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+# Demonstrate how to
+#  - export raw disk images
+#  - import raw disk images
+#  - connect an export to an import to copy a raw disk image
+
+from __future__ import print_function
+import sys, os, socket, urllib2, urlparse, XenAPI, traceback, ssl, time
+
+def exportimport(url, xapi, session, src_vdi, dst_vdi):
+  # If an HTTP operation fails then it will record the error on the task
+  # object. Note you can't use the HTTP response code for this because
+  # it must be sent *before* the stream is processed.
+  import_task = xapi.xenapi.task.create("import " + dst_vdi, "")
+  export_task = xapi.xenapi.task.create("export " + src_vdi, "")
+  try:
+    # an HTTP GET of this will export a disk:
+    get_url = "/export_raw_vdi?session_id=%s&vdi=%s&task_id=%s" % (session, src_vdi, export_task)
+    # an HTTP PUT to this will import a disk:
+    put_url = "/import_raw_vdi?session_id=%s&vdi=%s&task_id=%s" % (session, dst_vdi, import_task)
+
+    # 'data' is the stream of raw data:
+    data = urllib2.urlopen(url + get_url)
+
+    # python's builtin library doesn't support HTTP PUT very well
+    # so we do it manually. Note xapi doesn't support Transfer-encoding:
+    # chunked so we must send the data raw.
+    url = urlparse.urlparse(url)
+    host = url.netloc.split(":")[0] # assume port 443
+    if url.scheme != "https":
+      print("Sorry, this example only supports HTTPS (not HTTP)", file=sys.stderr)
+      print("Plaintext HTTP has the following problems:", file=sys.stderr)
+      print("  - the data can be captured by other programs on the network", file=sys.stderr)
+      print("  - some network middleboxes will mangle the data", file=sys.stderr)
+      # time wasted debugging a problem caused by a middlebox: 3hrs
+      # Just use HTTPS!
+      return
+
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    output = ssl.wrap_socket(s)
+    output.connect((host, 443))
+
+    # HTTP/1.0 with no transfer-encoding
+    headers = [
+      "PUT %s HTTP/1.0" % put_url,
+      "Connection:close",
+      ""
+    ]
+    print("Sending HTTP request:")
+    for h in headers:
+      output.send("%s\r\n" % h)
+      print("%s\r\n" % h)
+    result = output.recv(1024)
+    print("Received HTTP response:")
+    print(result)
+    if "200 OK" not in result:
+      print("Expected an HTTP 200, got %s" % result, file=sys.stderr)
+      return
+
+    # Copy the raw bytes, signal completion by closing the socket
+    virtual_size = long(xapi.xenapi.VDI.get_virtual_size(src_vdi))
+    print("Copying %Ld bytes" % virtual_size)
+    left = virtual_size
+    while left > 0:
+      block = data.read(min(65536, left))
+      if block is None:
+        break
+      output.send(block)
+      left = left - len(block)
+    output.close()
+
+    # Wait for the tasks to complete and check whether they both
+    # succeeded. It takes a few seconds to detach the disk etc.
+    finished = False
+    while not finished:
+      import_status = xapi.xenapi.task.get_status(import_task)
+      export_status = xapi.xenapi.task.get_status(export_task)
+      finished = import_status != "pending" and export_task != "pending"
+      time.sleep(1)
+    if import_status == "success" and export_status == "success":
+      print("OK")
+    else:
+      print("FAILED")
+      if import_status != "success":
+        print("The import task failed with: ", " ".join(xapi.xenapi.task.get_error_info(import_task)))
+      if export_status != "success":
+        print("The export task failed with: ", " ".join(xapi.xenapi.task.get_error_info(export_task)))
+
+  finally:
+    # The task creator has to destroy them at the end:
+    xapi.xenapi.task.destroy(import_task)
+    xapi.xenapi.task.destroy(export_task)
+
+if __name__ == "__main__":
+  if len(sys.argv) != 5:
+    print("Usage:")
+    print(sys.argv[0], " <url> <username> <password> <vdi-uuid>")
+    print(" -- creates a fresh VDI and streams the contents of <vdi-uuid> into it.")
+    print()
+    print("Example:")
+    print("SR=$(xe pool-list params=default-SR --minimal)")
+    print("VDI=$(xe vdi-create sr-uuid=$SR name-label=test virtual-size=128MiB type=user)")
+    print(sys.argv[0], "https://localhost password $VDI")
+    sys.exit(1)
+  url = sys.argv[1]
+  username = sys.argv[2]
+  password = sys.argv[3]
+  vdi_uuid = sys.argv[4]
+  # First acquire a valid session by logging in:
+  xapi = XenAPI.Session(url)
+  xapi.xenapi.login_with_password(username, password, '1.0', 'xen-api-scripts-exportimport.py')
+  dst_vdi = None
+  try:
+    src_vdi = xapi.xenapi.VDI.get_by_uuid(vdi_uuid)
+    sr = xapi.xenapi.VDI.get_SR(src_vdi)
+    # Create an empty VDI with the same initial parameters (e.g. size)
+    # to upload into
+    vdi_args = xapi.xenapi.VDI.get_record(src_vdi)
+    dst_vdi = xapi.xenapi.VDI.create(vdi_args)
+    exportimport(url, xapi, xapi._session, src_vdi, dst_vdi)
+  except Exception as e:
+    print("Caught %s: trying to clean up" % str(e))
+    traceback.print_exc()
+    if dst_vdi:
+      xapi.xenapi.VDI.destroy(dst_vdi)
+  finally:
+    xapi.xenapi.logout()

XenAPI-23.8.0/inventory.py

@@ -0,0 +1,32 @@
+# Simple functions to read the constants from the xensource-inventory file
+
+INVENTORY="@INVENTORY@"
+INSTALLATION_UUID="INSTALLATION_UUID"
+
+
+def read_kvpairs(filename):
+   """Read in a file of key-value pairs in the format used by the inventory file"""
+   f = open(filename)
+   all_entries = {}
+   try:
+        for line in f.readlines():
+            equals = line.index("=")    
+            key = line[0:equals]
+            value = line[equals+1:].strip().strip("'")
+            all_entries[key] = value
+   finally:
+        f.close()
+        return all_entries
+
+
+def parse():
+    """Return the contents of the xensource inventory file as a dictionary"""
+    try:
+        return read_kvpairs(INVENTORY)  
+    except:
+        return {}
+
+
+def get_localhost_uuid():
+    """Return the UUID of the local host"""
+    return parse()[INSTALLATION_UUID]

XenAPI-23.8.0/lvhd-api-test.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+
+from __future__ import print_function
+import XenAPI, sys
+
+def go(x, name):
+    vm = x.xenapi.VM.get_by_name_label(name)[0]
+    vbds = x.xenapi.VM.get_VBDs(vm)
+    non_empty = filter(lambda y:not(x.xenapi.VBD.get_empty(y)), vbds)
+    vdis = map(lambda y:x.xenapi.VBD.get_VDI(y), non_empty)
+    
+    print("Calling API call on %s" % (repr(vdis)))
+    result = x.xenapi.SR.lvhd_stop_using_these_vdis_and_call_script(vdis, "echo", "main", { "hello": "there", "sleep": "10" })
+    print(repr(result))
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage:", file=sys.stderr)
+        print(" %s <VM name-label>" % (sys.argv[0]), file=sys.stderr)
+        print("     -- Call SR.lvhd_stop_using_these_vdis_and_call_script with all VDIs with VBDs (attached or not) linking to specified VM", file=sys.stderr)
+        sys.exit(1)
+    name = sys.argv[1]
+    x = XenAPI.xapi_local()
+    x.xenapi.login_with_password("root", "", "1.0", "xen-api-scripts-lvhd-api-test.py")
+    try:
+        go(x, name)
+    finally:
+        x.xenapi.logout()

XenAPI-23.8.0/mini-xenrt.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+
+# Receive multiple VMs
+# Issue parallel loops of: reboot, suspend/resume, migrate
+
+from __future__ import print_function
+import xmlrpclib
+from threading import Thread
+import time, sys
+
+iso8601 = "%Y%m%dT%H:%M:%SZ"
+
+stop_on_first_failure = True
+stop = False
+
+class Operation:
+    def __init__(self):
+        raise "this is supposed to be abstract, dummy"
+    def execute(self, server, session_id):
+        raise "this is supposed to be abstract, dummy"
+
+class Reboot(Operation):
+    def __init__(self, vm):
+        self.vm = vm
+    def execute(self, server, session_id):
+        return server.VM.clean_reboot(session_id, self.vm)
+    def __str__(self):
+        return "clean_reboot(%s)" % self.vm
+
+class SuspendResume(Operation):
+    def __init__(self, vm):
+        self.vm = vm
+    def execute(self, server, session_id):
+        x = { "ErrorDescription": [ "VM_MISSING_PV_DRIVERS" ] }
+        while "ErrorDescription" in x and x["ErrorDescription"][0] == "VM_MISSING_PV_DRIVERS":
+            x = server.VM.suspend(session_id, self.vm)
+            if "ErrorDescription" in x:
+                time.sleep(1)
+        if x["Status"] != "Success":
+            return x
+        return server.VM.resume(session_id, self.vm, False, False)
+    def __str__(self):
+        return "suspendresume(%s)" % self.vm
+
+class ShutdownStart(Operation):
+    def __init__(self, vm):
+        self.vm = vm
+    def execute(self, server, session_id):
+        x = server.VM.clean_shutdown(session_id, self.vm)
+        if x["Status"] != "Success":
+            return x
+        return server.VM.start(session_id, self.vm, False, False)
+        #return { "Status": "bad", "ErrorDescription": "foo" }
+    def __str__(self):
+        return "shutdownstart(%s)" % self.vm
+
+class LocalhostMigrate(Operation):
+    def __init__(self, vm):
+        self.vm = vm
+    def execute(self, server, session_id):
+        return server.VM.pool_migrate(session_id, self.vm, server.VM.get_resident_on(session_id, self.vm)["Value"], { "live": "true" } )
+    def __str__(self):
+        return "localhostmigrate(%s)" % self.vm
+
+# Use this to give each thread a different ID
+worker_count = 0
+
+class Worker(Thread):
+    def __init__(self, server, session_id, operations):
+        Thread.__init__(self)
+        self.server = server
+        self.session_id = session_id
+        self.operations = operations
+        self.num_successes = 0
+        self.num_failures = 0
+        global worker_count
+        self.id = worker_count
+        worker_count = worker_count + 1
+    def run(self):
+        global iso8601
+        global stop_on_first_failure, stop
+        for op in self.operations:
+            description = str(op)
+
+            if stop:
+                return
+            
+            start = time.strftime(iso8601, time.gmtime(time.time ()))
+            result = op.execute(self.server, self.session_id)
+            end = time.strftime(iso8601, time.gmtime(time.time ()))
+
+            if result["Status"] == "Success":
+                print("SUCCESS %d %s %s %s" % (self.id, start, end, description))
+                self.num_successes = self.num_successes + 1
+            else:
+                error_descr = result["ErrorDescription"]
+                print("FAILURE %d %s %s %s %s" % (self.id, start, end, error_descr[0], description))
+                self.num_failures = self.num_failures + 1
+                if stop_on_first_failure:
+                    stop = True
+
+def make_operation_list(vm):
+    return [ Reboot(vm), SuspendResume(vm), LocalhostMigrate(vm) ] * 100
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        print("Usage:")
+        print("  %s <URL> <other-config key>" % (sys.argv[0]))
+        print("  -- performs parallel operations on VMs with the specified other-config key")
+        sys.exit(1)
+    
+    x = xmlrpclib.Server(sys.argv[1])
+    key = sys.argv[2]
+    session = x.session.login_with_password("root", "xenroot", "1.0", "xen-api-scripts-minixenrt.py")["Value"]
+    vms = x.VM.get_all_records(session)["Value"]
+
+    workers = []
+    for vm in vms.keys():
+        if key in vms[vm]["other_config"]:
+            allowed_ops = vms[vm]["allowed_operations"]
+            for op in [ "clean_reboot", "suspend", "pool_migrate" ]:
+                if op not in allowed_ops:
+                    raise "VM %s is not in a state where it can %s" % (vms[vm]["name_label"], op)
+            workers.append(Worker(x, session, make_operation_list(vm)))
+    for w in workers:
+        w.start()
+    for w in workers:
+        w.join()
+    successes = 0
+    failures = 0
+    for w in workers:
+        successes = successes + w.num_successes
+        failures = failures + w.num_failures
+    print("Total successes = %d" % successes)
+    print("Total failures = %d" % failures)
+    if failures == 0:
+        print("PASS")
+        sys.exit(0)
+    else:
+        print("FAIL")
+        sys.exit(1)
+