def runCommand(self):
self.parseArgs(_('Adds new application kit to Tortuga'))
api = getKitApi(self.getUsername(), self.getPassword())
self.installKitHelper(api, accept_eula=self.getArgs().acceptEula)
# restart tortugawsd and celery after installing new kit
cmd = None
try:
if platform.dist()[1].startswith('7'):
cmd = 'systemctl restart tortugawsd celery'
except ValueError:
pass
if not cmd:
cmd = 'service tortugawsd restart && service celery restart'
p = subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
retval = p.wait()
if retval != 0:
print('Error restarting services: rc=[{}]'.format(retval),
file=sys.stderr)
sys.exit(1)
def getComponent(self, kitName, kitVersion, kitIteration, compdescr): \
# pylint: disable=no-self-use
"""
Get Component matching 'compdescr' from specified kit
Raises:
ComponentNotFound
"""
kitApi = kitApiFactory.getKitApi()
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 _getOsInfo(self, bOsMediaRequired):
if not bOsMediaRequired:
# As a placeholder, use the same OS as the installer
# Find installer node entry
node = self._node_db_api.getNode(ConfigManager().getInstaller(),
{'softwareprofile': True})
return node.getSoftwareProfile().getOsInfo()
# Use available operating system kit; raise exception if
# multiple available
os_kits = _get_os_kits()
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 = kitApiFactory.getKitApi().getKit(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 runCommand(self):
self.parseArgs(
_("""
Installs operating system media to Tortuga for the purpose of
package-based node provisioning.
"""))
load_kits()
api = getKitApi(self.getUsername(), self.getPassword())
# Pre-process the media URL list
os_media_urls: List[str] = self.getArgs().osMediaUrl.split(',')
with DbManager().session() as session:
api.installOsKit(session,
os_media_urls,
bUseSymlinks=self.getArgs().symlinksFlag,
bInteractive=True,
mirror=self.getArgs().mirror)
if self.getArgs().sync:
Puppet().agent()
def __init__(self):
super().__init__()
self._kit_api = getKitApi()
def _get_os_kits():
return [
kit for kit in kitApiFactory.getKitApi().getKitList() if kit.getIsOs()
]
def createSoftwareProfile(self, swProfileSpec, settingsDict=None):
"""
Exceptions:
ConfigurationError
NetworkNotFound
ComponentNotFound
KitNotFound
OSError
"""
# Parse 'settingsDict'
if settingsDict:
# ... bOsMediaRequired; default is True
bOsMediaRequired = settingsDict['bOsMediaRequired'] \
if 'bOsMediaRequired' in settingsDict else True
# ... unmanagedProfile; default is False
unmanagedProfile = settingsDict['unmanagedProfile'] \
if 'unmanagedProfile' in settingsDict else False
# Validate software profile name
validation.validateProfileName(swProfileSpec.getName())
# Insert default description for software profile
if not swProfileSpec.getDescription() or \
swProfileSpec.getDescription() == '**DEFAULT**':
swProfileSpec.setDescription('%s Nodes' %
(swProfileSpec.getName()))
self.getLogger().debug('Creating software profile [%s]' %
(swProfileSpec))
osInfo = swProfileSpec.getOsInfo() \
if swProfileSpec.getOsInfo() else self._getOsInfo(bOsMediaRequired)
# If we're creating an unmanaged software profile (no
# DHCP/PXE/kickstart/OS) just create it now and we're done
if unmanagedProfile:
self._sp_db_api.addSoftwareProfile(swProfileSpec)
else:
if bOsMediaRequired and swProfileSpec.getOsInfo():
try:
kitApiFactory.getKitApi().getKit(
swProfileSpec.getOsInfo().getName(),
swProfileSpec.getOsInfo().getVersion(), '0')
except KitNotFound:
self._logger.error('OS kit for [%s] not found' %
(swProfileSpec.getOsInfo()))
raise
else:
swProfileSpec.setOsInfo(osInfo)
# Get component manager for appropriate OS family
osConfig = osHelper.getOsInfo(osInfo.getName(),
osInfo.getVersion(),
osInfo.getArch())
osObjFactory = osUtility.getOsObjectFactory(
osConfig.getOsFamilyInfo().getName())
compManager = osObjFactory.getComponentManager()
# Need to be fancy with components
spComponents = swProfileSpec.getComponents()
swProfileSpec.setComponents(TortugaObjectList())
bFoundOsComponent = False
bFoundCoreComponent = False
components = []
# Iterate over components, adding them to the software profile
for c in spComponents:
cobj = compManager.getBestMatchComponent(
c.getName(), c.getVersion(), osInfo,
c.getKit().getId())
k = cobj.getKit()
if k.getIsOs():
# This component is a member of the OS kit, set the flag
bFoundOsComponent = True
else:
if c.getName() == 'core':
# Found the 'core' component, set the flag
bFoundCoreComponent = True
components.append(cobj)
# If the operating system is undefined for this software
# profile, use the same OS as the installer.
if bOsMediaRequired and not bFoundOsComponent:
# Find OS component
osCompName = '%s-%s-%s' % (
osInfo.getName(), osInfo.getVersion(), osInfo.getArch())
self.getLogger().debug('Automatically adding OS component [%s]'
' (not specified in template)' %
(osCompName))
try:
osComponent = self._component_db_api.getComponent(
osCompName, osInfo.getVersion(), osInfo, {'kit': True})
components.append(osComponent)
except ComponentNotFound:
# Cannot find OS component, don't freak out
pass
# Ensure 'core' component is enabled
if not bFoundCoreComponent:
# Attempt to automatically add the core component, only
# if one exists for this OS
try:
comp = self._getCoreComponentForOsInfo(osInfo)
self.getLogger().debug(
'Automatically adding [core] component'
' (not specified in template)')
components.append(comp)
except ComponentNotFound:
pass
# Initialize values for kernel, kernelParams, and initrd
if not swProfileSpec.getKernel():
swProfileSpec.setKernel(
osObjFactory.getOsSysManager().getKernel(osInfo))
if not swProfileSpec.getInitrd():
swProfileSpec.setInitrd(
osObjFactory.getOsSysManager().getInitrd(osInfo))
# Add the software profile
self._sp_db_api.addSoftwareProfile(swProfileSpec)
# Enable components in one fell swoop
for comp in components:
self.getLogger().debug('Enabling component [%s]' %
(comp.getName()))
if comp.getKit().getIsOs():
# Don't use enableComponent() on OS kit
self._component_db_api.\
addComponentToSoftwareProfile(
comp.getId(), swProfileSpec.getId())
continue
self.enableComponent(swProfileSpec.getName(),
comp.getKit().getName(),
comp.getKit().getVersion(),
comp.getKit().getIteration(),
comp.getName(), comp.getVersion())
self.getLogger().debug(
'Software profile [%s] created successfully' %
(swProfileSpec.getName()))
def __init__(self):
super(TortugaProxyConfig, self).__init__(validArgCount=4)
self._cm = ConfigManager()
self._kitApi = kitApiFactory.getKitApi()