172 lines
5.5 KiB
Python
172 lines
5.5 KiB
Python
'''
|
|
Installer classes are responsible for building and installing virtualization
|
|
specific software components. This is the main entry point for tests that
|
|
wish to install virtualization software components.
|
|
|
|
The most common use case is to simply call make_installer() inside your tests.
|
|
'''
|
|
|
|
from autotest_lib.client.common_lib import error
|
|
from autotest_lib.client.virt import base_installer
|
|
|
|
__all__ = ['InstallerRegistry', 'INSTALLER_REGISTRY', 'make_installer',
|
|
'run_installers']
|
|
|
|
class InstallerRegistry(dict):
|
|
'''
|
|
Holds information on known installer classes
|
|
|
|
This class is used to create a single instance, named INSTALLER_REGISTRY,
|
|
that will hold all information on known installer types.
|
|
|
|
For registering a new installer class, use the register() method. If the
|
|
virt type is not set explicitly, it will be set to 'base'. Example:
|
|
|
|
>>> INSTALLER_REGISTRY.register('yum', base_installer.YumInstaller)
|
|
|
|
If you want to register a virt specific installer class, set the virt
|
|
(third) param:
|
|
|
|
>>> INSTALLER_REGISTRY.register('yum', kvm_installer.YumInstaller, 'kvm')
|
|
|
|
For getting a installer class, use the get_installer() method. This method
|
|
has a fallback option 'get_default_virt' that will return a generic virt
|
|
installer if set to true.
|
|
'''
|
|
|
|
DEFAULT_VIRT_NAME = 'base'
|
|
|
|
def __init__(self, **kwargs):
|
|
dict.__init__(self, **kwargs)
|
|
self[self.DEFAULT_VIRT_NAME] = {}
|
|
|
|
|
|
def register(self, mode, klass, virt=None):
|
|
'''
|
|
Register a class as responsible for installing virt software components
|
|
|
|
If virt is not set, it will assume a default of 'base'.
|
|
'''
|
|
if virt is None:
|
|
virt = self.DEFAULT_VIRT_NAME
|
|
elif not self.has_key(virt):
|
|
self[virt] = {}
|
|
|
|
self[virt][mode] = klass
|
|
|
|
|
|
def get_installer(self, mode, virt=None, get_default_virt=False):
|
|
'''
|
|
Gets a installer class that should be able to install the virt software
|
|
|
|
Always try to use classes that are specific to the virtualization
|
|
technology that is being tested. If you have confidence that the
|
|
installation is rather trivial and does not require custom steps, you
|
|
may be able to get away with a base class (by setting get_default_virt
|
|
to True).
|
|
'''
|
|
if virt is None:
|
|
virt = self.DEFAULT_VIRT_NAME
|
|
if not self.has_key(virt):
|
|
# return a base installer so the test could and give it a try?
|
|
if get_default_virt:
|
|
return self[self.DEFAULT_VIRT_NAME].get(mode)
|
|
else:
|
|
return self[virt].get(mode)
|
|
|
|
|
|
def get_modes(self, virt=None):
|
|
'''
|
|
Returns a list of all registered installer modes
|
|
'''
|
|
if virt is None:
|
|
virt = self.DEFAULT_VIRT_NAME
|
|
|
|
if not self.has_key(virt):
|
|
return []
|
|
|
|
return self[virt].keys()
|
|
|
|
|
|
#
|
|
# InstallerRegistry unique instance
|
|
#
|
|
INSTALLER_REGISTRY = InstallerRegistry()
|
|
|
|
|
|
#
|
|
# Register base installers
|
|
#
|
|
INSTALLER_REGISTRY.register('yum',
|
|
base_installer.YumInstaller)
|
|
INSTALLER_REGISTRY.register('koji',
|
|
base_installer.KojiInstaller)
|
|
INSTALLER_REGISTRY.register('git_repo',
|
|
base_installer.GitRepoInstaller)
|
|
INSTALLER_REGISTRY.register('local_src',
|
|
base_installer.LocalSourceDirInstaller)
|
|
INSTALLER_REGISTRY.register('local_tar',
|
|
base_installer.LocalSourceTarInstaller)
|
|
INSTALLER_REGISTRY.register('remote_tar',
|
|
base_installer.RemoteSourceTarInstaller)
|
|
|
|
|
|
def installer_name_split(fullname, virt=None):
|
|
'''
|
|
Split a full installer name into mode and short name
|
|
|
|
Examples:
|
|
git_repo_foo -> (git_repo, foo)
|
|
local_src_foo -> (local_src, foo)
|
|
'''
|
|
for mode in INSTALLER_REGISTRY.get_modes(virt):
|
|
if fullname.startswith('%s_' % mode):
|
|
null, _name = fullname.split(mode)
|
|
name = _name[1:]
|
|
return (mode, name)
|
|
|
|
return (None, None)
|
|
|
|
|
|
def make_installer(fullname, params, test=None):
|
|
'''
|
|
Installer factory: returns a new installer for the chosen mode and vm type
|
|
|
|
This is the main entry point for acquiring an installer. Tests, such as
|
|
the build test, should use this function.
|
|
|
|
Param priority evaluation order is 'install_mode', then 'mode'. For virt
|
|
type, 'vm_type' is consulted.
|
|
|
|
@param fullname: the full name of instance, eg: git_repo_foo
|
|
@param params: dictionary with parameters generated from cartersian config
|
|
@param test: the test instance
|
|
'''
|
|
virt = params.get("vm_type", None)
|
|
|
|
mode, name = installer_name_split(fullname, virt)
|
|
if mode is None or name is None:
|
|
|
|
error_msg = ('Invalid installer mode or name for "%s". Probably an '
|
|
'installer has not been registered' % fullname)
|
|
if virt is not None:
|
|
error_msg += ' specifically for virt type "%s"' % virt
|
|
|
|
raise error.TestError(error_msg)
|
|
|
|
klass = INSTALLER_REGISTRY.get_installer(mode, virt)
|
|
if klass is None:
|
|
raise error.TestError('Installer mode %s is not registered' % mode)
|
|
else:
|
|
return klass(mode, name, test, params)
|
|
|
|
|
|
def run_installers(params, test=None):
|
|
'''
|
|
Runs the installation routines for all installers, one at a time
|
|
|
|
This is usually the main entry point for tests
|
|
'''
|
|
for name in params.get("installers", "").split():
|
|
installer = make_installer(name, params, test)
|
|
installer.install()
|