def _get_kit_by_component(self, comp_name, comp_version=None):
"""
Gets a kit by compoent name/version.
:param comp_name: the name of the component
:param comp_version: the version of the component
:raises KitNotFound:
:raises ComponentNotFound:
"""
kit_list = self._kit_db_api.getKitList()
kits = [
kit for kit in kit_list for component in kit.getComponentList()
if component.getName() == comp_name and (
comp_version is None or component.getVersion() == comp_version)
]
if not kits:
raise KitNotFound('Kit containing component [%s] not found' %
(comp_name))
if len(kits) > 1:
raise ComponentNotFound(
'Kit name must be specified, multiple kits contain '
'component: {}'.format(comp_name))
return kits[0]
def _getCoreComponentForOsInfo(self, session: Session, osInfo):
# Find core component
baseKit = None
for baseKit in self._kit_db_api.getKitList(session):
if not baseKit.getName() == self.BASE_KIT_NAME:
continue
break
else:
raise KitNotFound('Kit [%s] not found.' % (self.BASE_KIT_NAME))
baseComp = None
for baseComp in baseKit.getComponentList():
if baseComp.getName() != 'core':
continue
break
else:
raise ComponentNotFound('Component [%s] not found in kit [%s]' %
('core', baseKit.getName()))
comp = self._component_db_api.getBestMatchComponent(
session, baseComp.getName(), baseComp.getVersion(), osInfo,
baseKit.getId())
comp.setKit(baseKit)
return comp
def getComponent(self, kitName, kitVersion, kitIteration, compdescr): \
# pylint: disable=no-self-use
"""
Get Component matching 'compdescr' from specified kit
Raises:
ComponentNotFound
"""
kitApi = KitWsApi(username=self.getUsername(),
password=self.getPassword(),
baseurl=self.getUrl())
k = kitApi.getKit(kitName, kitVersion, kitIteration)
c = None
for c in k.getComponentList():
_compDescr = '%s-%s' % (c.getName(), c.getVersion())
if _compDescr == compdescr:
break
else:
raise ComponentNotFound('Component [%s] not found in kit [%s]' %
(compdescr, k))
return c
def getComponentByOsFamilyInfo(self, session, name, version, osFamilyInfo):
try:
return session.query(Component).filter(
and_(
Component.name == name, Component.version == version,
Component.family.any(name=osFamilyInfo.getName(),
version=osFamilyInfo.getVersion(),
arch=osFamilyInfo.getArch()))).one()
except NoResultFound:
raise ComponentNotFound('Component [%s-%s] (%s) not found.' %
(name, version, osFamilyInfo))
def getComponentById(self, session, _id):
"""
Raises:
ComponentNotFound
"""
dbComponent = session.query(Component).get(_id)
if not dbComponent:
raise ComponentNotFound('Component ID [%d] not found' % (_id))
return dbComponent
def _getOsInfo(self, session: Session, bOsMediaRequired: bool):
if not bOsMediaRequired:
# As a placeholder, use the same OS as the installer
# Find installer node entry
node = self._node_db_api.getNode(session,
ConfigManager().getInstaller(),
{'softwareprofile': True})
return node.getSoftwareProfile().getOsInfo()
# Use available operating system kit; raise exception if
# multiple available
os_kits = self._kit_db_api.getKitList(session, os_kits_only=True)
if not os_kits:
raise KitNotFound('No operating system kit installed')
if len(os_kits) > 1:
raise KitNotFound(
'Multiple OS kits defined; use --os option to specify'
' operating system')
kit = self._kit_db_api.getKit(session, os_kits[0].getName(),
os_kits[0].getVersion(), '0')
components = kit.getComponentList()
if not components:
raise ComponentNotFound('Malformed operating system kit [%s]' %
(os_kits))
osinfo_list = components[0].getOsInfoList()
if len(osinfo_list) > 1:
raise ComponentNotFound(
'Multiple operating system components for kit [%s];'
' use --os argument to specify operating system' %
(os_kits[0]))
return osinfo_list[0]
def lookup_cname(self, cname):
'''
Return the ComponentActions object from the KitActions whose
name is "cname"
Raises:
ComponentNotFound
'''
for c in self.components:
if c.__component_name__ == cname:
return c(self)
raise ComponentNotFound("Can't find component [%s] in kit [%s]" %
(cname, self.__class__.__name__))
def _getComponent(self, kit, compName, compVersion): \
# pylint: disable=no-self-use
# Iterate over component list, looking for a match
comp = None
for comp in kit.getComponentList():
if comp.getName() == compName and \
comp.getVersion() == compVersion:
break
else:
raise ComponentNotFound("Component [%s-%s] not found in kit [%s]" %
(compName, compVersion, kit))
return comp
def getBestMatchComponent(self, session, name, version, osInfo, kitId):
"""
Return best match component
The query will search for an exact or family match.
"""
self.getLogger().debug(
'Retrieving best match component for %s-%s (%s)' % (
name, version, osInfo))
osConfig = osHelper.getOsInfo(
osInfo.getName(), osInfo.getVersion(), osInfo.getArch())
matchSpec = or_(
Component.os.any(
name=osInfo.getName(),
version=osInfo.getVersion(),
arch=osInfo.getArch()),
Component.family.any(
name=osConfig.getOsFamilyInfo().getName(),
version=osConfig.getOsFamilyInfo().getVersion(),
arch=osInfo.getArch()),
Component.family.any(
name=osConfig.getOsFamilyInfo().getName(),
version=osConfig.getOsFamilyInfo().getVersion(),
arch=None),
Component.family.any(name='root')
)
if version:
filter_spec = and_(Component.kitId == kitId,
Component.name == name,
Component.version == version, matchSpec)
else:
filter_spec = and_(Component.kitId == kitId,
Component.name == name, matchSpec)
dbComponent = session.query(Component).filter(filter_spec).first()
if not dbComponent:
comp_label = '%s-%s' % (name, version) if version else name
excmsg = 'Component %s (%s) is not found.' % (comp_label, osInfo)
raise ComponentNotFound(excmsg)
return dbComponent
def get_osfamily_component(self, name: str,
osfamily: OperatingSystemFamily):
"""
Get compatible component.
Raises:
ComponentNotFound
"""
for component in self.components:
if component.name == name:
for component_osfamily in component.osfamily_components:
if osfamily.name == component_osfamily.family.name and \
osfamily.version == component_osfamily.family.version and \
osfamily.arch == component_osfamily.family.arch:
break
else:
continue
return component
else:
raise ComponentNotFound(
'Component [{}] not found'.format(name))
def _enable_kit_component(self, session: Session, kit, comp_name,
comp_version, software_profile):
"""
Enables a regular kit component on a specific software profile.
:param kit: the Kit instance, whose component is being
enabled
:param comp_name: the name of the component to enable
:param comp_version: the version of the component to enable
:param software_profile: the software profile on which the component
will be enabled
:return: the Component instance that was enabled
"""
kit_spec = (kit.getName(), kit.getVersion(), kit.getIteration())
installer = get_kit_installer(kit_spec)()
installer.session = session
comp_installer = installer.get_component_installer(comp_name)
if comp_installer is None:
raise ComponentNotFound('Component [%s] not found in kit [%s]' %
(comp_name, kit))
if not comp_installer.is_enableable(software_profile):
self._logger.warning('Component cannot be enabled: {}'.format(
comp_installer.spec))
return None
comp_installer.run_action('pre_enable', software_profile.getName())
best_match_component = self._add_component_to_software_profile(
session, kit, comp_name, comp_version, software_profile)
comp_installer.run_action('enable', software_profile.getName())
comp_installer.run_action('post_enable', software_profile.getName())
return best_match_component
def _getCoreComponentForOsInfo(self, osInfo):
# Find core component
# Find the version of the 'core' component
import tortuga.kit.kitApi
_kitApi = tortuga.kit.kitApi.KitApi()
baseKit = None
for baseKit in _kitApi.getKitList():
if not baseKit.getName() == self.BASE_KIT_NAME:
continue
break
else:
raise KitNotFound('Kit [%s] not found.' % (self.BASE_KIT_NAME))
baseComp = None
for baseComp in baseKit.getComponentList():
if baseComp.getName() != 'core':
continue
break
else:
raise ComponentNotFound('Component [%s] not found in kit [%s]' %
('core', baseKit.getName()))
comp = osUtility.getOsObjectFactory().getComponentManager().\
getBestMatchComponent(
baseComp.getName(), baseComp.getVersion(), osInfo,
baseKit.getId())
comp.setKit(baseKit)
return comp
def _disable_kit_component(self, session, kit, comp_name, comp_version,
software_profile):
"""
Disables a regular kit component on a specific software profile.
:param kit: the Kit instance, whose component is being
disabled
:param comp_name: the name of the component to disable
:param comp_version: the version of the component to disable
:param software_profile: the software profile on which the component
will be disable
:return: the Component instance that was disabled
"""
kit_spec = (kit.getName(), kit.getVersion(), kit.getIteration())
installer = get_kit_installer(kit_spec)()
installer.session = session
comp_installer = installer.get_component_installer(comp_name)
if comp_installer is None:
raise ComponentNotFound('Component [%s] not found in kit [%s]' %
(comp_name, kit))
comp_installer.run_action('pre_disable', software_profile.getName())
comp_installer.run_action('disable', software_profile.getName())
best_match_component = \
self._remove_component_from_software_profile(
session, kit, comp_name, comp_version, software_profile)
comp_installer.run_action('post_disable', software_profile.getName())
return best_match_component
def main():
cm = ConfigManager()
p = argparse.ArgumentParser()
p.add_argument('-f',
'--force',
dest='force',
action='store_true',
default=False)
p.add_argument('name', help='Software profile name')
p.add_argument('kit', help='Kit descriptor (NAME-VERSION-ITERATION)')
p.add_argument('component', help='Component descriptor (NAME-VERSION)')
args = p.parse_args()
kitNameAndVersion, kitIteration = args.kit.rsplit('-', 1)
kitName, kitVersion = kitNameAndVersion.split('-', 1)
compName, _ = args.component.split('-', 2)
flagFile = os.path.join(
cm.getRoot(), 'var/run/actions/%s/component_%s_%s_post_install' %
(args.name, args.kit, args.component))
if os.path.exists(flagFile):
if not args.force:
sys.stderr.write(
'post-install component action for [%s] already run\n' %
(compName))
sys.exit(0)
# Remove the existing flag file, we're forcing a run
os.unlink(flagFile)
load_kits()
kit_spec = (kitName, kitVersion, kitIteration)
try:
with DbManager().session() as session:
kit_installer = get_kit_installer(kit_spec)()
kit_installer.session = session
c = kit_installer.get_component_installer(compName)
if c is None:
raise ComponentNotFound(
'Component [%s] not found in kit [%s]' %
(compName, kitName))
c.run_action('post_install')
logger.debug(
'post_install component action run for [%s] from kit [%s]' %
(args.component, args.kit))
# Ensure destination directory exists
if not os.path.exists(os.path.dirname(flagFile)):
os.makedirs(os.path.dirname(flagFile))
# touch flagFile
open(flagFile, 'w').close()
except Exception as exc: # noqa pylint: disable=broad-except
print('Error: {}'.format(exc), file=sys.stderr)
sys.exit(0)
