Exemple #1
0
    def get_xend_domain_lock_utility(self):
        s = self.get_config_string('xend-domain-lock-utility')

        if s:
            return os.path.join(auxbin.scripts_dir(), s)
        else:
            return self.xend_domain_lock_utility
Exemple #2
0
    def get_xend_domain_lock_utility(self):
        s = self.get_config_string('xend-domain-lock-utility')

        if s:
            return os.path.join(auxbin.scripts_dir(), s)
        else:
            return self.xend_domain_lock_utility
Exemple #3
0
 def get_resource_label_change_script(self):
     s = self.get_config_string('resource-label-change-script')
     if s:
         result = s.split(" ")
         result[0] = os.path.join(auxbin.scripts_dir(), result[0])
         return result
     else:
         return None
Exemple #4
0
 def get_resource_label_change_script(self):
     s = self.get_config_string('resource-label-change-script')
     if s:
         result = s.split(" ")
         result[0] = os.path.join(auxbin.scripts_dir(), result[0])
         return result
     else:
         return None
Exemple #5
0
}

#
# Device migration stages (eg. XendDomainInfo, XendCheckpoint, server.tpmif)
#

DEV_MIGRATE_TEST  = 0
DEV_MIGRATE_STEP1 = 1
DEV_MIGRATE_STEP2 = 2
DEV_MIGRATE_STEP3 = 3

#
# VTPM-related constants
#

VTPM_DELETE_SCRIPT = auxbin.scripts_dir() + '/vtpm-delete'

#
# Xenstore Constants
#

XS_VMROOT = "/vm/"

XS_POOLROOT = "/local/pool/"

NR_PCI_FUNC = 8
NR_PCI_DEV = 32
NR_PCI_DEVFN = NR_PCI_FUNC * NR_PCI_DEV
AUTO_PHP_SLOT = 0x100

#
Exemple #6
0
class XendOptions:
    """Configuration options."""
    """Where network control scripts live."""
    network_script_dir = auxbin.scripts_dir()
    """Where block control scripts live."""
    block_script_dir = auxbin.scripts_dir()
    """Default path to the log file. """
    logfile_default = "/var/log/xen/xend.log"
    """Default level of information to be logged."""
    loglevel_default = 'DEBUG'
    """Default Xen-API server configuration. """
    xen_api_server_default = [['unix']]
    """Default for the flag indicating whether xend should run an http server
    (deprecated)."""
    xend_http_server_default = 'no'

    xend_tcp_xmlrpc_server_default = 'no'

    xend_tcp_xmlrpc_server_address_default = 'localhost'

    xend_tcp_xmlrpc_server_port_default = 8006

    xend_unix_xmlrpc_server_default = 'yes'
    """Default interface address xend listens at. """
    xend_address_default = ''
    """Default for the flag indicating whether xend should run a relocation server."""
    xend_relocation_server_default = 'no'
    """Default for the flag indicating whether xend should run a ssl relocation server."""
    xend_relocation_ssl_server_default = 'no'
    """Default for the flag indicating whether xend should run a udev event server."""
    xend_udev_event_server_default = 'no'
    """Default interface address the xend relocation server listens at. """
    xend_relocation_address_default = ''
    """Default port xend serves HTTP at. """
    xend_port_default = 8000
    """Default port xend serves relocation at. """
    xend_relocation_port_default = 8002
    """Default port xend serves ssl relocation at. """
    xend_relocation_ssl_port_default = 8003

    xend_relocation_hosts_allow_default = ''
    """Default for the flag indicating whether xend should run a unix-domain
    server (deprecated)."""
    xend_unix_server_default = 'no'
    """Default external migration tool """
    external_migration_tool_default = ''
    """Default path the unix-domain server listens at."""
    xend_unix_path_default = '/var/lib/xend/xend-socket'

    dom0_min_mem_default = 0

    dom0_vcpus_default = 0

    vncpasswd_default = None
    """Default interface to listen for VNC connections on"""
    xend_vnc_listen_default = '127.0.0.1'
    """Use of TLS mode in QEMU VNC server"""
    xend_vnc_tls = 0
    """x509 certificate directory for QEMU VNC server"""
    xend_vnc_x509_cert_dir = auxbin.xen_configdir() + "/vnc"
    """Verify incoming client x509 certs"""
    xend_vnc_x509_verify = 0
    """Default session storage path."""
    xend_domains_path_default = '/var/lib/xend/domains'
    """Default xend management state storage."""
    xend_state_path_default = '/var/lib/xend/state'
    """Default xend QCoW storage repository location."""
    xend_storage_path_default = '/var/lib/xend/storage'
    """Default xend security state storage path."""
    xend_security_path_default = '/var/lib/xend/security'
    """Default script to configure a backend network interface"""
    vif_script = osdep.vif_script
    """Default Xen Security Module"""
    xsm_module_default = 'dummy'
    """Default rotation count of qemu-dm log file."""
    qemu_dm_logrotate_count = 10
    """Default timeout for device creation."""
    device_create_timeout_default = 100
    """Default timeout for device destruction."""
    device_destroy_timeout_default = 100

    def __init__(self):
        self.configure()

    def _logError(self, fmt, *args):
        """Logging function to log to stderr. We use this for XendOptions log
        messages because they may be logged before the logger has been
        configured.  Other components can safely use the logger.
        """
        print >> sys.stderr, "xend [ERROR]", fmt % args

    def configure(self):
        self.set_config()
        XendLogging.init(
            self.get_config_string("logfile", self.logfile_default),
            self.get_config_string("loglevel", self.loglevel_default))

    def set_config(self):
        raise NotImplementedError()

    def get_config_bool(self, name, val=None):
        raise NotImplementedError()

    def get_config_int(self, name, val=None):
        raise NotImplementedError()

    def get_config_string(self, name, val=None):
        raise NotImplementedError()

    def get_xen_api_server(self):
        raise NotImplementedError()

    def get_xend_http_server(self):
        """Get the flag indicating whether xend should run an http server.
        """
        return self.get_config_bool("xend-http-server",
                                    self.xend_http_server_default)

    def get_xend_tcp_xmlrpc_server(self):
        return self.get_config_bool("xend-tcp-xmlrpc-server",
                                    self.xend_tcp_xmlrpc_server_default)

    def get_xend_tcp_xmlrpc_server_port(self):
        return self.get_config_int("xend-tcp-xmlrpc-server-port",
                                   self.xend_tcp_xmlrpc_server_port_default)

    def get_xend_tcp_xmlrpc_server_address(self):
        return self.get_config_string(
            "xend-tcp-xmlrpc-server-address",
            self.xend_tcp_xmlrpc_server_address_default)

    def get_xend_tcp_xmlrpc_server_ssl_key_file(self):
        name = 'xend-tcp-xmlrpc-server-ssl-key-file'
        file = self.get_config_string(name)
        if os.path.dirname(file) == "":
            file = auxbin.xen_configdir() + '/' + file
        if not os.path.exists(file):
            raise XendError(
                "invalid xend config %s: directory '%s' does not exist" %
                (name, file))
        return file

    def get_xend_tcp_xmlrpc_server_ssl_cert_file(self):
        name = 'xend-tcp-xmlrpc-server-ssl-cert-file'
        file = self.get_config_string(name)
        if os.path.dirname(file) == "":
            file = auxbin.xen_configdir() + '/' + file
        if not os.path.exists(file):
            raise XendError(
                "invalid xend config %s: directory '%s' does not exist" %
                (name, file))
        return file

    def get_xend_unix_xmlrpc_server(self):
        return self.get_config_bool("xend-unix-xmlrpc-server",
                                    self.xend_unix_xmlrpc_server_default)

    def get_xend_relocation_server(self):
        """Get the flag indicating whether xend should run a relocation server.
        """
        return self.get_config_bool("xend-relocation-server",
                                    self.xend_relocation_server_default)

    def get_xend_relocation_ssl_server(self):
        """Get the flag indicating whether xend should run a ssl relocation server.
        """
        return self.get_config_bool("xend-relocation-ssl-server",
                                    self.xend_relocation_ssl_server_default)

    def get_xend_relocation_server_ssl_key_file(self):
        name = 'xend-relocation-server-ssl-key-file'
        file = self.get_config_string(name)
        if os.path.dirname(file) == "":
            file = auxbin.xen_configdir() + '/' + file
        if not os.path.exists(file):
            raise XendError(
                "invalid xend config %s: directory '%s' does not exist" %
                (name, file))
        return file

    def get_xend_relocation_server_ssl_cert_file(self):
        name = 'xend-relocation-server-ssl-cert-file'
        file = self.get_config_string(name)
        if os.path.dirname(file) == "":
            file = auxbin.xen_configdir() + '/' + file
        if not os.path.exists(file):
            raise XendError(
                "invalid xend config %s: directory '%s' does not exist" %
                (name, file))
        return file

    def get_xend_udev_event_server(self):
        return self.get_config_bool("xend-udev-event-server",
                                    self.xend_udev_event_server_default)

    def get_xend_port(self):
        """Get the port xend listens at for its HTTP interface.
        """
        return self.get_config_int('xend-port', self.xend_port_default)

    def get_xend_relocation_port(self):
        """Get the port xend listens at for connection to its relocation server.
        """
        return self.get_config_int('xend-relocation-port',
                                   self.xend_relocation_port_default)

    def get_xend_relocation_ssl_port(self):
        """Get the port xend listens at for ssl connection to its relocation
        server.
        """
        return self.get_config_int('xend-relocation-ssl-port',
                                   self.xend_relocation_ssl_port_default)

    def get_xend_relocation_ssl(self):
        """Whether to use ssl when relocating.
        """
        return self.get_config_bool('xend-relocation-ssl', 'no')

    def get_xend_relocation_hosts_allow(self):
        return self.get_config_string("xend-relocation-hosts-allow",
                                      self.xend_relocation_hosts_allow_default)

    def get_xend_address(self):
        """Get the address xend listens at for its HTTP port.
        This defaults to the empty string which allows all hosts to connect.
        If this is set to 'localhost' only the localhost will be able to connect
        to the HTTP port.
        """
        return self.get_config_string('xend-address',
                                      self.xend_address_default)

    def get_xend_relocation_address(self):
        """Get the address xend listens at for its relocation server port.
        This defaults to the empty string which allows all hosts to connect.
        If this is set to 'localhost' only the localhost will be able to connect
        to the relocation port.
        """
        return self.get_config_string('xend-relocation-address',
                                      self.xend_relocation_address_default)

    def get_xend_unix_server(self):
        """Get the flag indicating whether xend should run a unix-domain server.
        """
        return self.get_config_bool("xend-unix-server",
                                    self.xend_unix_server_default)

    def get_xend_unix_path(self):
        """Get the path the xend unix-domain server listens at.
        """
        return self.get_config_string("xend-unix-path",
                                      self.xend_unix_path_default)

    def get_xend_domains_path(self):
        """ Get the path for persistent domain configuration storage
        """
        return self.get_config_string("xend-domains-path",
                                      self.xend_domains_path_default)

    def get_xend_state_path(self):
        """ Get the path for persistent domain configuration storage
        """
        return self.get_config_string("xend-state-path",
                                      self.xend_state_path_default)

    def get_xend_storage_path(self):
        """ Get the path for persistent domain configuration storage
        """
        return self.get_config_string("xend-storage-path",
                                      self.xend_storage_path_default)

    def get_xend_security_path(self):
        """ Get the path for security state
        """
        return self.get_config_string("xend-security-path",
                                      self.xend_security_path_default)

    def get_network_script(self):
        """@return the script used to alter the network configuration when
        Xend starts and stops, or None if no such script is specified."""

        s = self.get_config_string('network-script')

        if s:
            result = s.split(" ")
            result[0] = os.path.join(self.network_script_dir, result[0])
            return result
        else:
            return None

    def get_external_migration_tool(self):
        """@return the name of the tool to handle virtual TPM migration."""
        return self.get_config_string('external-migration-tool',
                                      self.external_migration_tool_default)

    def get_enable_dump(self):
        return self.get_config_bool('enable-dump', 'no')

    def get_vif_script(self):
        return self.get_config_string('vif-script', self.vif_script)

    def get_dom0_min_mem(self):
        return self.get_config_int('dom0-min-mem', self.dom0_min_mem_default)

    def get_enable_dom0_ballooning(self):
        enable_dom0_ballooning_default = 'yes'
        if self.get_dom0_min_mem() == 0:
            enable_dom0_ballooning_default = 'no'
        return self.get_config_bool('enable-dom0-ballooning',
                                    enable_dom0_ballooning_default)

    def get_dom0_vcpus(self):
        return self.get_config_int('dom0-cpus', self.dom0_vcpus_default)

    def get_console_limit(self):
        return self.get_config_int('console-limit', 1024)

    def get_vnclisten_address(self):
        return self.get_config_string('vnc-listen',
                                      self.xend_vnc_listen_default)

    def get_vncpasswd_default(self):
        return self.get_config_string('vncpasswd', self.vncpasswd_default)

    def get_keymap(self):
        return self.get_config_string('keymap', None)

    def get_resource_label_change_script(self):
        s = self.get_config_string('resource-label-change-script')
        if s:
            result = s.split(" ")
            result[0] = os.path.join(auxbin.scripts_dir(), result[0])
            return result
        else:
            return None

    def get_vnc_tls(self):
        return self.get_config_string('vnc-tls', self.xend_vnc_tls)

    def get_vnc_x509_cert_dir(self):
        name = 'vnc-x509-cert-dir'
        vncdir = self.get_config_string(name, self.xend_vnc_x509_cert_dir)
        if os.path.dirname(vncdir) == "":
            vncdir = auxbin.xen_configdir() + '/' + vncdir
        if not os.path.exists(vncdir):
            raise XendError(
                "invalid xend config %s: directory '%s' does not exist" %
                (name, vncdir))
        return vncdir

    def get_vnc_x509_verify(self):
        return self.get_config_string('vnc-x509-verify',
                                      self.xend_vnc_x509_verify)

    def get_qemu_dm_logrotate_count(self):
        return self.get_config_int("qemu-dm-logrotate-count",
                                   self.qemu_dm_logrotate_count)

    def get_device_create_timeout(self):
        return self.get_config_int("device-create-timeout",
                                   self.device_create_timeout_default)

    def get_device_destroy_timeout(self):
        return self.get_config_int("device-destroy-timeout",
                                   self.device_destroy_timeout_default)
    def _isValidProtocol(self, protocol):
        if protocol in ('phy', 'file', 'tap'):
            return True

        return os.access(auxbin.scripts_dir() + '/block-%s' % protocol, os.X_OK)
Exemple #8
0
}

#
# Device migration stages (eg. XendDomainInfo, XendCheckpoint, server.tpmif)
#

DEV_MIGRATE_TEST  = 0
DEV_MIGRATE_STEP1 = 1
DEV_MIGRATE_STEP2 = 2
DEV_MIGRATE_STEP3 = 3

#
# VTPM-related constants
#

VTPM_DELETE_SCRIPT = auxbin.scripts_dir() + '/vtpm-delete'

#
# Xenstore Constants
#

XS_VMROOT = "/vm/"

XS_POOLROOT = "/local/pool/"

NR_PCI_FUNC = 8
NR_PCI_DEV = 32
NR_PCI_DEVFN = NR_PCI_FUNC * NR_PCI_DEV
AUTO_PHP_SLOT = 0x100

#
Exemple #9
0
    def _isValidProtocol(self, protocol):
        if protocol in ('phy', 'file', 'tap'):
            return True

        return os.access(auxbin.scripts_dir() + '/block-%s' % protocol,
                         os.X_OK)