XenAPI 24.26.0__tar.gz → 24.27.0__tar.gz

{xenapi-24.26.0 → xenapi-24.27.0}/Makefile

@@ -8,5 +8,4 @@ build:
 	SETUPTOOLS_SCM_PRETEND_VERSION=$(XAPI_VERSION) python -m build --sdist .
 
 clean:
-	dune clean
 	rm -rf dist/ build/ XenAPI.egg-info/

{xenapi-24.26.0/XenAPI.egg-info → xenapi-24.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: XenAPI
-Version: 24.26.0
+Version: 24.27.0
 Summary: XenAPI SDK, for communication with XenServer.
 Home-page: https://xapi-project.github.io/
 Author: Xapi project developers and maintainers
@@ -13,7 +13,7 @@ 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
+Requires-Python: <4,>=3.6
 Description-Content-Type: text/markdown; charset=UTF-8
 
 Usage

{xenapi-24.26.0 → xenapi-24.27.0}/XenAPI/XenAPI.py

@@ -58,13 +58,8 @@ import gettext
 import os
 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
+import http.client as httplib
+import xmlrpc.client as xmlrpclib
 
 otel = False
 try:
@@ -147,18 +142,13 @@ class Session(xmlrpclib.ServerProxy):
     session.xenapi.session.logout()
     """
 
-    def __init__(self, uri, transport=None, encoding=None, verbose=0,
-                 allow_none=1, ignore_ssl=False):
+    def __init__(self, uri, transport=None, encoding=None, verbose=False,
+                 allow_none=True, ignore_ssl=False):
 
-        if sys.version_info[0] > 2:
-            # this changed to be a 'bool' in Python3
-            verbose = bool(verbose)
-            allow_none = bool(allow_none)
+        verbose = bool(verbose)
+        allow_none = bool(allow_none)
 
-        # Fix for CA-172901 (+ Python 2.4 compatibility)
-        # Fix for context=ctx ( < Python 2.7.9 compatibility)
-        if not (sys.version_info[0] <= 2 and sys.version_info[1] <= 7 and sys.version_info[2] <= 9 ) \
-                and ignore_ssl:
+        if ignore_ssl:
             import ssl
             ctx = ssl._create_unverified_context()
             xmlrpclib.ServerProxy.__init__(self, uri, transport, encoding,

{xenapi-24.26.0 → xenapi-24.27.0/XenAPI.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: XenAPI
-Version: 24.26.0
+Version: 24.27.0
 Summary: XenAPI SDK, for communication with XenServer.
 Home-page: https://xapi-project.github.io/
 Author: Xapi project developers and maintainers
@@ -13,7 +13,7 @@ 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
+Requires-Python: <4,>=3.6
 Description-Content-Type: text/markdown; charset=UTF-8
 
 Usage

{xenapi-24.26.0 → xenapi-24.27.0}/XenAPI.egg-info/SOURCES.txt

@@ -2,17 +2,8 @@ Makefile
 PACKAGING.md
 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
 XenAPI/XenAPI.py
 XenAPI/__init__.py
 XenAPI.egg-info/PKG-INFO

{xenapi-24.26.0 → xenapi-24.27.0}/XenAPIPlugin.py

@@ -7,16 +7,11 @@
 from __future__ import print_function
 
 import sys
-
+import xmlrpc.client as xmlrpclib
 import XenAPI
 
-if sys.version_info[0] == 2:
-    import xmlrpclib
-else:
-    import xmlrpc.client as xmlrpclib
-
 class Failure(Exception):
-    """Provide compatibilty with plugins written against XenServer 5.5 API"""
+    """Provide compatibility with plugins written against the XenServer 5.5 API"""
 
     def __init__(self, code, params):
         Exception.__init__(self)
@@ -44,9 +39,6 @@ def dispatch(fn_table):
         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:

{xenapi-24.26.0 → xenapi-24.27.0}/pyproject.toml

@@ -3,4 +3,4 @@ requires = ["setuptools >= 38.6.0", "setuptools_scm[toml]", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools_scm]
-root = "../../.."
+root = "../.."

{xenapi-24.26.0 → xenapi-24.27.0}/setup.cfg

@@ -19,10 +19,7 @@ classifiers =
 
 [options]
 packages = find:
-python_requires = >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <4
-
-[bdist_wheel]
-universal = 1
+python_requires = >=3.6, <4
 
 [egg_info]
 tag_build = 

xenapi-24.26.0/echo.py

@@ -1,17 +0,0 @@
-#!/usr/bin/env python3
-
-# Simple XenAPI plugin
-import time
-
-import XenAPIPlugin
-
-
-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-24.26.0/exportimport.py

@@ -1,142 +0,0 @@
-#!/usr/bin/env python3
-
-# 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, urllib.request, urllib.error, urllib.parse, 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 = urllib.request.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 = urllib.parse.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-24.26.0/inventory.py

@@ -1,32 +0,0 @@
-# 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-24.26.0/lvhd-api-test.py

@@ -1,29 +0,0 @@
-#!/usr/bin/env python3
-
-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-24.26.0/mini-xenrt.py

@@ -1,141 +0,0 @@
-#!/usr/bin/env python3
-
-# Receive multiple VMs
-# Issue parallel loops of: reboot, suspend/resume, migrate
-
-from __future__ import print_function
-import xmlrpc.client
-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 NotImplementedError
-    def execute(self, server, session_id):
-        raise NotImplementedError
-
-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 = xmlrpc.client.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 RuntimeError("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)  

xenapi-24.26.0/monitor-unwanted-domains.py

@@ -1,89 +0,0 @@
-#!/usr/bin/env python3
-
-from __future__ import print_function
-import os, subprocess, XenAPI, inventory, time, sys
-
-# Script which monitors the domains running on a host, looks for
-# paused domains which don't correspond to VMs which are running here
-# or are about to run here, logs them and optionally destroys them.
-
-# Return a list of (domid, uuid) tuples, one per paused domain on this host
-def list_paused_domains():
-    results = []
-    all = subprocess.Popen(["@OPTDIR@/bin/list_domains"], stdout=subprocess.PIPE).communicate()[0]
-    lines = all.split("\n")
-    for domain in lines[1:]:
-        bits = domain.split()
-        if bits != []:
-            domid = bits[0]
-            uuid = bits[2]
-            state = bits[4]
-            if 'P' in state:
-                results.append( (domid, uuid) )
-    return results
-
-# Given localhost's uuid and a (domid, uuid) tuple, return True if the domain
-# be somewhere else i.e. we think it may have leaked here
-def should_domain_be_somewhere_else(localhost_uuid, domain):
-    (domid, uuid) = domain
-    try:
-        x = XenAPI.xapi_local()
-        x.xenapi.login_with_password("root", "", "1.0", "xen-api-scripts-monitor-unwanted-domains.py")
-        try:
-            try:
-                vm = x.xenapi.VM.get_by_uuid(uuid)
-                resident_on = x.xenapi.VM.get_resident_on(vm)
-                current_operations = x.xenapi.VM.get_current_operations(vm)
-                result = current_operations == {} and resident_on != localhost_uuid
-                if result:
-                    log("domid %s uuid %s: is not being operated on and is not resident here" % (domid, uuid))
-                    return result
-            except XenAPI.Failure as e:
-                if e.details[0] == "UUID_INVALID":
-                    # VM is totally bogus
-                    log("domid %s uuid %s: is not in the xapi database" % (domid, uuid))
-                    return True
-                # fail safe for now
-                return False
-        finally:
-            x.xenapi.logout()
-    except:
-        return False
-
-def log(str):
-    print(str)
-
-# Destroy the given domain
-def destroy_domain(domain):
-    (domid, uuid) = domain
-    log("destroying domid %s uuid %s" % (domid, uuid))
-    all = subprocess.Popen(["@OPTDIR@/debug/destroy_domain", "-domid", domid], stdout=subprocess.PIPE).communicate()[0]
-
-# Keep track of when a domain first looked like it should be here
-domain_first_noticed = {}
-
-# Number of seconds after which we conclude that a domain really shouldn't be here
-threshold = 60
-
-if __name__ == "__main__":
-    localhost_uuid = inventory.get_localhost_uuid ()
-    while True:
-        time.sleep(1)
-        paused = list_paused_domains ()
-        # GC the domain_first_noticed map
-        for d in domain_first_noticed.keys():
-            if d not in paused:
-                log("domid %s uuid %s: looks ok now, forgetting about it" % d)
-                del domain_first_noticed[d]
-
-        for d in list_paused_domains():
-            if should_domain_be_somewhere_else(localhost_uuid, d):
-                if d not in domain_first_noticed:
-                    domain_first_noticed[d] = time.time()
-                noticed_for = time.time() - domain_first_noticed[d]
-                if noticed_for > threshold:
-                    log("domid %s uuid %s: has been in bad state for over threshold" % d)
-                    if "-destroy" in sys.argv:
-                        destroy_domain(d)
-
-

xenapi-24.26.0/provision.py

@@ -1,111 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2007 XenSource, 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.
-
-# Parse/regenerate the "disk provisioning" XML contained within templates
-# NB this provisioning XML refers to disks which should be created when
-# a VM is installed from this template. It does not apply to templates
-# which have been created from real VMs -- they have their own disks.
-
-from __future__ import print_function
-import XenAPI
-import xml.dom.minidom
-
-class Disk:
-    """Represents a disk which should be created for this VM"""
-    def __init__(self, device, size, sr, bootable):
-        self.device = device # 0, 1, 2, ...
-        self.size = size     # in bytes
-        self.sr = sr         # uuid of SR
-        self.bootable = bootable
-    def toElement(self, doc):
-        disk = doc.createElement("disk")
-        disk.setAttribute("device", self.device)
-        disk.setAttribute("size", self.size)
-        disk.setAttribute("sr", self.sr)
-        b = "false"
-        if self.bootable: b = "true"
-        disk.setAttribute("bootable", b)
-        return disk
-
-def parseDisk(element):
-    device = element.getAttribute("device")
-    size = element.getAttribute("size")
-    sr = element.getAttribute("sr")
-    b = element.getAttribute("bootable") == "true"
-    return Disk(device, size, sr, b)
-
-class ProvisionSpec:
-    """Represents a provisioning specification: currently a list of required disks"""
-    def __init__(self):
-        self.disks = []
-    def toElement(self, doc):
-        element = doc.createElement("provision")
-        for disk in self.disks:
-            element.appendChild(disk.toElement(doc))
-        return element
-    def setSR(self, sr):
-        """Set the requested SR for each disk"""
-        for disk in self.disks:
-            disk.sr = sr
-
-def parseProvisionSpec(txt):
-    """Return an instance of type ProvisionSpec given XML text"""
-    doc = xml.dom.minidom.parseString(txt)
-    all = doc.getElementsByTagName("provision")
-    if len(all) != 1:
-        raise ValueError("Expected to find exactly one <provision> element")
-    ps = ProvisionSpec()
-    disks = all[0].getElementsByTagName("disk")
-    for disk in disks:
-        ps.disks.append(parseDisk(disk))
-    return ps
-
-def printProvisionSpec(ps):
-    """Return a string containing pretty-printed XML corresponding to the supplied provisioning spec"""
-    doc = xml.dom.minidom.Document()
-    doc.appendChild(ps.toElement(doc))
-    return doc.toprettyxml()
-
-def getProvisionSpec(session, vm):
-    """Read the provision spec of a template/VM"""
-    other_config = session.xenapi.VM.get_other_config(vm)
-    return parseProvisionSpec(other_config['disks'])
-
-def setProvisionSpec(session, vm, ps):
-    """Set the provision spec of a template/VM"""
-    txt = printProvisionSpec(ps)
-    try:
-        session.xenapi.VM.remove_from_other_config(vm, "disks")
-    except:
-        pass
-    session.xenapi.VM.add_to_other_config(vm, "disks", txt)
-
-if __name__ == "__main__":
-    print("Unit test of provision XML spec module")
-    print("--------------------------------------")
-    ps = ProvisionSpec()
-    ps.disks.append(Disk("0", "1024", "0000-0000", True))
-    ps.disks.append(Disk("1", "2048", "1111-1111", False))
-    print("* Pretty-printing spec")
-    txt = printProvisionSpec(ps)
-    print(txt)
-    print("* Re-parsing output")
-    ps2 = parseProvisionSpec(txt)
-    print("* Pretty-printing spec")
-    txt2 = printProvisionSpec(ps)
-    print(txt2)
-    if txt != txt2:
-        raise AssertionError("Sanity-check failed: print(parse(print(x))) <> print(x)")
-    print("* OK: print(parse(print(x))) == print(x)")

xenapi-24.26.0/renameif.py

@@ -1,167 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2008 XenSource, 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.
-
-# Allow the user to change the MAC address -> interface mapping
-
-from __future__ import print_function
-import XenAPI, inventory, sys
-
-def warn(txt):
-    print(txt, file=sys.stderr)
-
-def show_pifs(pifs):
-    print("NIC MAC               Notes")
-    print("----------------------------------------------")
-    for ref in pifs.keys():
-        notes = []
-        if pifs[ref]['management']:
-            notes.append("management interface")
-        nic = pifs[ref]['device'][3:]
-        try:
-            metrics = session.xenapi.PIF_metrics.get_record(session.xenapi.PIF.get_metrics(ref))
-            if metrics['carrier']:
-                notes.append("carrier detected")
-            else:
-                notes.append("no carrier detected")
-        except:
-            pass
-                
-        print("%3s %s %s" % (nic, pifs[ref]['MAC'], ", ".join(notes)))
-
-def select(pifs, key):
-    """Select a PIF by device name or MAC"""
-    for ref in pifs.keys():
-        if pifs[ref]['device'][3:] == key:
-            return ref
-        if pifs[ref]['MAC'].upper() == key.upper():
-            return ref
-    return None
-
-def save(session, host, pifs):
-    """Commit changes"""
-    # Check that device names are unique
-    devices = []
-    for ref in pifs.keys():
-        devices.append(pifs[ref]['device'][3:])
-    for i in set(devices):
-        devices.remove(i)
-    if devices != []:
-        print("ERROR: cannot assign two interfaces the same NIC number (%s)" % (", ".join(i)))
-        print("Aborted.")
-        sys.exit(1)
-    vifs = []
-    for ref in pifs.keys():
-        net = pifs[ref]['network']
-        for vif in session.xenapi.network.get_VIFs(net):
-            if session.xenapi.VIF.get_currently_attached(vif):
-                vifs.append(vif)
-    if len(vifs) > 0:
-        plural = ""
-        if len(vifs) > 1:
-            plural = "s"
-        print("WARNING: this operation requires unplugging %d guest network interface%s" % (len(vifs), plural))
-        print("Are you sure you want to continue? (yes/no) > ", end=' ')
-        if sys.stdin.readline().strip().lower() != "yes":
-            print("Aborted.")
-            sys.exit(1)
-    for vif in vifs:
-        dev = session.xenapi.VIF.get_device(vif)
-        vm = session.xenapi.VIF.get_VM(vif)
-        uuid = session.xenapi.VM.get_uuid(vm)
-        print("Hot-unplugging interface %s on VM %s" % (dev, uuid))
-        session.xenapi.VIF.unplug(vif)
-        
-    for ref in pifs.keys():
-        mac = pifs[ref]['MAC']        
-        if pifs[ref]['management']:
-            print("Disabling management NIC (%s)" % mac)
-            session.xenapi.host.management_disable()
-        session.xenapi.PIF.forget(ref)
-    for ref in pifs.keys():
-        mac = pifs[ref]['MAC']
-        device = pifs[ref]['device']
-        mode = pifs[ref]['ip_configuration_mode']
-        IP = pifs[ref]['IP']
-        netmask = pifs[ref]['IP']
-        gateway = pifs[ref]['gateway']
-        DNS = pifs[ref]['DNS']
-        new_ref = session.xenapi.PIF.introduce(host, mac, device)
-        session.xenapi.PIF.reconfigure_ip(new_ref, mode, IP, netmask, gateway, DNS)
-        if pifs[ref]['management']:
-            print("Re-enabling management NIC (%s)" % mac)
-            session.xenapi.host.management_reconfigure(new_ref)
-
-    for vif in vifs:
-        dev = session.xenapi.VIF.get_device(vif)
-        vm = session.xenapi.VIF.get_VM(vif)
-        uuid = session.xenapi.VM.get_uuid(vm)
-        print("Hot-plugging interface %s on VM %s" % (dev, uuid))
-        session.xenapi.VIF.plug(vif)
-
-def renameif(session):
-    uuid = inventory.get_localhost_uuid ()
-    host = session.xenapi.host.get_by_uuid(uuid)
-    pool = session.xenapi.pool.get_all()[0]
-    master = session.xenapi.pool.get_master(pool)
-    if host != master:
-        warn("This host is a slave; it is not possible to rename the management interface")
-
-    pifs = session.xenapi.PIF.get_all_records()
-    for ref in pifs.keys():
-        if pifs[ref]['host'] != host or pifs[ref]['physical'] != True:
-            del pifs[ref]
-            
-    while True:
-        print("Current mappings:")
-        show_pifs(pifs)
-        print()
-        print("Type 'quit' to quit; 'save' to save; or a NIC number or MAC address to edit")
-        print("> ", end=' ')
-        x = sys.stdin.readline().strip()
-        if x.lower() == 'quit':
-            sys.exit(0)
-        if x.lower() == 'save':
-            # If a slave, filter out the management PIF
-            if host != master:
-                for ref in pifs.keys():
-                    if pifs[ref]['management']:
-                        del pifs[ref]
-            save(session, host, pifs)
-            sys.exit(0)
-        pif = select(pifs, x)
-        if pif != None:
-            # Make sure this is not a slave's management PIF
-            if host != master and pifs[pif]['management']:
-                print("ERROR: cannot modify the management interface of a slave.")
-            else:
-                print("Selected NIC with MAC '%s'. Enter new NIC number:" % pifs[pif]['MAC'])
-                print("> ", end=' ')
-                nic = sys.stdin.readline().strip()
-                if not(nic.isdigit()):
-                    print("ERROR: must enter a number (e.g. 0, 1, 2, 3, ...)")
-                else:
-                    pifs[pif]['device'] = "eth" + nic
-        else:
-            print("NIC '%s' not found" % (x))
-        print()
-        
-
-if __name__ == "__main__":
-    session = XenAPI.xapi_local()
-    session.login_with_password("", "", "1.0", "xen-api-scripts-renameifs.py")
-    try:
-        renameif(session)
-    finally:
-        session.logout()

xenapi-24.26.0/shell.py

@@ -1,118 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2006-2008 Citrix Systems.
-#
-# 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.
-
-from __future__ import print_function
-import atexit
-import cmd
-import pprint
-import readline
-import shlex
-import string
-import sys
-
-import XenAPI
-
-def logout():
-    try:
-        session.xenapi.session.logout()
-    except:
-        pass
-atexit.register(logout)
-
-class Shell(cmd.Cmd):
-    def __init__(self):
-        cmd.Cmd.__init__(self)
-        self.identchars = string.ascii_letters + string.digits + '_.'
-        self.prompt = "xe> "
-
-    def preloop(self):
-        cmd.Cmd.preloop(self)
-        readline.set_completer_delims(' ')
-
-    def default(self, line):
-        words = shlex.split(line)
-        if len(words) > 0:
-            res = session.xenapi_request(words[0], tuple(words[1:]))
-            if res is not None and res != '':
-                pprint.pprint(res)
-        return False
-
-    def completedefault(self, text, line, begidx, endidx):
-        words = shlex.split(line[:begidx])
-        clas, func = words[0].split('.')
-        if len(words) > 1 or \
-           func.startswith('get_by_') or \
-           func == 'get_all':
-            return []
-        uuids = session.xenapi_request('%s.get_all' % clas, ())
-        return [u + " " for u in uuids if u.startswith(text)]
-
-    def emptyline(self):
-        pass
-
-    def do_EOF(self, line):
-        print()
-        sys.exit(0)
-
-def munge_types (str):
-    if str == "True":
-        return True
-    elif str == "False":
-        return False
-    
-    try:
-        return int(str)
-    except:
-        return str
-
-if __name__ == "__main__":
-    if len(sys.argv) < 2:
-        print("Usage:")
-        print(sys.argv[0], " <url> <username> <password>")
-        sys.exit(1) 
-
-    if sys.argv[1] != "-" and len(sys.argv) < 4:
-        print("Usage:")
-        print(sys.argv[0], " <url> <username> <password>")
-        sys.exit(1) 
-
-    if sys.argv[1] != "-":
-        url = sys.argv[1]
-        username = sys.argv[2]
-        password = sys.argv[3]
-        session = XenAPI.Session(url)
-        session.xenapi.login_with_password(username, password, "1.0", "xen-api-scripts-shell.py")
-        cmdAt = 4
-    else:
-        session = XenAPI.xapi_local()
-        session.xenapi.login_with_password("", "", "1.0", "xen-api-scripts-shell.py")
-        cmdAt = 2
-
-    # We want to support directly executing the cmd line,
-    # where appropriate
-    if len(sys.argv) > cmdAt:
-        cmd = sys.argv[cmdAt]
-        params = [munge_types(x) for x in sys.argv[(cmdAt + 1):]]
-        try:
-            print(session.xenapi_request(cmd, tuple(params)), file=sys.stdout)
-        except XenAPI.Failure as x:
-            print(x, file=sys.stderr)
-            sys.exit(2)
-        except Exception as e:
-            print(e, file=sys.stderr)
-            sys.exit(3)
-        sys.exit(0)
-    else:
-        Shell().cmdloop('Welcome to the XenServer shell. (Try "VM.get_all")')