def includeExtensionErrors():
"""Merge all the errors of all the extensions into the errors of these modules
Should be called only at the initialization of DIRAC, so by the parseCommandLine,
dirac-agent.py, dirac-service.py, dirac-executor.py
"""
for extension in reversed(extensionsByPriority()):
if extension == "DIRAC":
continue
try:
ext_derrno = importlib.import_module("%s.Core.Utilities.DErrno" % extension)
except ImportError:
pass
else:
# The next 3 dictionary MUST be present for consistency
# Global name of errors
sys.modules[__name__].__dict__.update(ext_derrno.extra_dErrName)
# Dictionary with the error codes
sys.modules[__name__].dErrorCode.update(ext_derrno.extra_dErrorCode)
# Error description string
sys.modules[__name__].dStrError.update(ext_derrno.extra_dStrError)
# extra_compatErrorString is optional
for err in getattr(ext_derrno, "extra_compatErrorString", []):
sys.modules[__name__].compatErrorString.setdefault(err, []).extend(
ext_derrno.extra_compatErrorString[err]
)
def addFunctions(clientCls):
"""Add the functions to the decorated class."""
attrDict = dict(clientCls.__dict__)
for extension in extensionsByPriority():
try:
path = importlib_resources.path(
"%s.%sSystem.Service" % (extension, systemName),
"%s.py" % handlerModuleName,
)
fullHandlerClassPath = "%s.%s" % (extension, handlerClassPath)
with path as fp:
handlerAst = ast.parse(fp.read_text(), str(path))
except (ImportError, OSError):
continue
# loop over all the nodes (classes, functions, imports) in the handlerModule
for node in ast.iter_child_nodes(handlerAst):
# find only a class with the name of the handlerClass
if not (isinstance(node, ast.ClassDef) and node.name == handlerClassName):
continue
for member in ast.iter_child_nodes(node):
# only look at functions
if not isinstance(member, ast.FunctionDef):
continue
if not member.name.startswith("export_"):
continue
funcName = member.name[len("export_") :]
if funcName in attrDict:
continue
arguments = [a.arg for a in member.args.args]
# add the implementation of the function to the class attributes
attrDict[funcName] = genFunc(funcName, arguments, fullHandlerClassPath, ast.get_docstring(member))
return type(clientCls.__name__, clientCls.__bases__, attrDict)
def loadModules(self, modulesList, hideExceptions=False):
"""
Load all modules required in moduleList
"""
for modName in modulesList:
gLogger.verbose("Checking %s" % modName)
# if it's a executor modName name just load it and be done with it
if "/" in modName:
gLogger.verbose(
"Module %s seems to be a valid name. Try to load it!" %
modName)
result = self.loadModule(modName,
hideExceptions=hideExceptions)
if not result["OK"]:
return result
continue
# Check if it's a system name
# Look in the CS
system = modName
# Can this be generated with sectionFinder?
csPath = "%s/Executors" % PathFinder.getSystemSection(system)
gLogger.verbose("Exploring %s to discover modules" % csPath)
result = gConfig.getSections(csPath)
if result["OK"]:
# Add all modules in the CS :P
for modName in result["Value"]:
result = self.loadModule("%s/%s" % (system, modName),
hideExceptions=hideExceptions)
if not result["OK"]:
return result
# Look what is installed
parentModule = None
for rootModule in extensionsByPriority():
if not system.endswith("System"):
system += "System"
parentImport = "%s.%s.%s" % (rootModule, system,
self.__csSuffix)
# HERE!
result = recurseImport(parentImport)
if not result["OK"]:
return result
parentModule = result["Value"]
if parentModule:
break
if not parentModule:
continue
parentPath = parentModule.__path__[0]
gLogger.notice("Found modules path at %s" % parentImport)
for entry in os.listdir(parentPath):
if entry == "__init__.py" or not entry.endswith(".py"):
continue
if not os.path.isfile(os.path.join(parentPath, entry)):
continue
modName = "%s/%s" % (system, entry[:-3])
gLogger.verbose("Trying to import %s" % modName)
result = self.loadModule(modName,
hideExceptions=hideExceptions,
parentModule=parentModule)
return S_OK()
def loadObjects(path, reFilter=None, parentClass=None):
"""
:param str path: the path to the syetem for example: DIRAC/AccountingSystem
:param object reFilter: regular expression used to found the class
:param object parentClass: class instance
:return: dictionary containing the name of the class and its instance
"""
if not reFilter:
reFilter = re.compile(r".*[a-z1-9]\.py$")
pathList = List.fromChar(path, "/")
objectsToLoad = {}
# Find which object files match
for parentModule in extensionsByPriority():
if six.PY3:
objDir = os.path.join(
os.path.dirname(os.path.dirname(DIRAC.__file__)), parentModule,
*pathList)
else:
objDir = os.path.join(DIRAC.rootPath, parentModule, *pathList)
if not os.path.isdir(objDir):
continue
for objFile in os.listdir(objDir):
if reFilter.match(objFile):
pythonClassName = objFile[:-3]
if pythonClassName not in objectsToLoad:
gLogger.info("Adding to load queue %s/%s/%s" %
(parentModule, path, pythonClassName))
objectsToLoad[pythonClassName] = parentModule
# Load them!
loadedObjects = {}
for pythonClassName in objectsToLoad:
parentModule = objectsToLoad[pythonClassName]
try:
# Where parentModule can be DIRAC, pathList is something like [ "AccountingSystem", "Client", "Types" ]
# And the python class name is.. well, the python class name
objPythonPath = "%s.%s.%s" % (parentModule, ".".join(pathList),
pythonClassName)
objModule = __import__(objPythonPath, globals(), locals(),
pythonClassName)
objClass = getattr(objModule, pythonClassName)
except Exception as e:
gLogger.error(
"Can't load type",
"%s/%s: %s" % (parentModule, pythonClassName, str(e)))
continue
if parentClass == objClass:
continue
if parentClass and not issubclass(objClass, parentClass):
gLogger.warn("%s is not a subclass of %s. Skipping" %
(objClass, parentClass))
continue
gLogger.info("Loaded %s" % objPythonPath)
loadedObjects[pythonClassName] = objClass
return loadedObjects
def getCSExtensions() -> list:
"""
Return list of extensions registered in the CS
They do not include DIRAC
"""
return [
ext[:-5] if ext.endswith("DIRAC") else ext
for ext in extensionsByPriority() if ext != "DIRAC"
]
def getCurrentVersion():
"""Get a string corresponding to the current version of the DIRAC package and all the installed
extension packages
"""
for ext in extensionsByPriority():
try:
return S_OK(importlib.import_module(ext).version)
except (ImportError, AttributeError):
pass
def runConfigurationWizard(params):
"""Interactively configure DIRAC using metadata from installed extensions"""
import subprocess
from prompt_toolkit import prompt, print_formatted_text, HTML
from DIRAC.Core.Utilities.Extensions import extensionsByPriority, getExtensionMetadata
for extension in extensionsByPriority():
extensionMetadata = getExtensionMetadata(extension)
if extensionMetadata.get("primary_extension", False):
break
defaultSetup = extensionMetadata.get("default_setup", "")
setups = extensionMetadata.get("setups", {})
# Run the wizard
try:
# Get the user's password and create a proxy so we can download from the CS
while True:
userPasswd = prompt(u"Enter Certificate password: "******"dirac-proxy-init", "--nocs", "--no-upload", "--pwstdin"],
input=userPasswd,
encoding="utf-8",
check=False,
)
if result.returncode == 0:
break
print_formatted_text(HTML("<red>Wizard failed, retrying...</red> (press Control + C to exit)\n"))
print_formatted_text()
# Ask the user for the appropriate configuration settings
while True:
result = _runConfigurationWizard(setups, defaultSetup)
if result:
break
print_formatted_text(HTML("<red>Wizard failed, retrying...</red> (press Control + C to exit)\n"))
except KeyboardInterrupt:
print_formatted_text(HTML("<red>Cancelled</red>"))
sys.exit(1)
# Apply the arguments to the params object
setup, csURL = result
params.setSetup(setup)
params.setServer(csURL)
params.setSkipCAChecks(True)
# Do the actual configuration
runDiracConfigure(params)
# Generate a new proxy without passing --nocs
result = subprocess.run( # pylint: disable=no-member
["dirac-proxy-init", "--pwstdin"],
input=userPasswd,
encoding="utf-8",
check=False,
)
sys.exit(result.returncode)
def getVersion():
"""Get a dictionary corresponding to the current version of the DIRAC package and all the installed
extension packages
"""
vDict = {"Extensions": {}}
for ext in extensionsByPriority():
version = get_version(ext)
vDict["Extensions"][ext] = version
return S_OK(vDict)
def __generateRootModules(self, baseModules):
"""Iterate over all the possible root modules"""
self.__rootModules = baseModules
for rootModule in reversed(extensionsByPriority()):
if rootModule not in self.__rootModules:
self.__rootModules.append(rootModule)
self.__rootModules.append("")
# Reversing the order because we want first to look in the extension(s)
self.__rootModules.reverse()
def export_installComponent(self,
componentType,
system,
component,
componentModule=""):
"""Install runit directory for the specified component"""
return gComponentInstaller.installComponent(componentType, system,
component,
extensionsByPriority(),
componentModule)
def __load(self):
if self.__orderedExtNames:
return
for extName in extensionsByPriority():
try:
res = imp.find_module(extName)
if res[0]:
res[0].close()
self.__orderedExtNames.append(extName)
self.__modules[extName] = res
except ImportError:
pass
def __call__(self, func=None):
"""Set the wrapped function or call the script
This function is either called with a decorator or directly to call the
underlying function. When running with Python 2 the raw function will always
be called however in Python 3 the priorities will be applied from the
dirac.extension_metadata entry_point.
"""
# If func is provided then the decorator is being applied to a function
if func is not None:
self._func = func
# Find the name of the command and its documentation
DIRACScript.localCfg.setUsageMessage(func.__globals__["__doc__"])
DIRACScript.scriptName = os.path.basename(
func.__globals__["__file__"])[:-3].replace("_", "-")
return functools.wraps(func)(self)
# Setuptools based installations aren't supported with Python 2
if six.PY2:
return self._func() # pylint: disable=not-callable
# This is only available in Python 3.8+ so it has to be here for now
from importlib import metadata # pylint: disable=no-name-in-module
# Iterate through all known entry_points looking for self.scriptName
matches = [
ep for ep in metadata.entry_points()["console_scripts"]
if ep.name == self.scriptName
]
if not matches:
# TODO: This should an error once the integration tests modified to use pip install
return self._func() # pylint: disable=not-callable
# raise NotImplementedError("Something is very wrong")
# Call the entry_point from the extension with the highest priority
rankedExtensions = extensionsByPriority()
entrypoint = min(
matches,
key=lambda e: rankedExtensions.index(entrypointToExtension(e)),
)
entrypointFunc = entrypoint.load()
# Check if entrypoint is DIRACScript
if not isinstance(entrypointFunc, DIRACScript):
raise ImportError(
"Invalid dirac- console_scripts entry_point: " +
repr(entrypoint) + "\n" +
"All dirac- console_scripts should be wrapped in the DiracScript "
+
"decorator to ensure extension overlays are applied correctly."
)
return entrypointFunc._func()
def export_addDefaultOptionsToCS(self,
componentType,
system,
component,
overwrite=False):
"""Add default component options to the global CS or to the local options"""
return gComponentInstaller.addDefaultOptionsToCS(
gConfig,
componentType,
system,
component,
extensionsByPriority(),
overwrite=overwrite)
def export_setupComponent(self,
componentType,
system,
component,
componentModule=""):
"""Setup the specified component for running with the runsvdir daemon
It implies installComponent
"""
result = gComponentInstaller.setupComponent(componentType, system,
component,
extensionsByPriority(),
componentModule)
gConfig.forceRefresh()
return result
def export_getComponentDocumentation(self, cType, system, module):
if cType == "service":
module = "%sHandler" % module
# Look for the component in extensions
for extension in extensionsByPriority():
moduleName = [
extension, system + "System",
cType.capitalize(), module
]
try:
importedModule = importlib.import_module(moduleName)
return S_OK(importedModule.__doc__)
except Exception:
pass
return S_ERROR("No documentation was found")
def getCSExtensions(self):
if not self.__csExt:
if six.PY3:
exts = extensionsByPriority()
else:
from DIRAC.ConfigurationSystem.Client.Config import gConfig
exts = gConfig.getValue("/DIRAC/Extensions", [])
self.__csExt = []
for ext in exts:
if ext.endswith("DIRAC"):
ext = ext[:-5]
# If the extension is now "" (i.e. vanilla DIRAC), don't include it
if ext:
self.__csExt.append(ext)
return self.__csExt
def export_getOverallStatus(self):
"""Get the complete status information of all components."""
result = gComponentInstaller.getOverallStatus(extensionsByPriority())
if not result["OK"]:
return result
statusDict = result["Value"]
for compType in statusDict:
for system in statusDict[compType]:
for component in statusDict[compType][system]:
result = gComponentInstaller.getComponentModule(
system, component, compType)
if not result["OK"]:
statusDict[compType][system][component][
"Module"] = "Unknown"
else:
statusDict[compType][system][component][
"Module"] = result["Value"]
return S_OK(statusDict)
def getVersion():
"""Get a dictionary corresponding to the current version of the DIRAC package and all the installed
extension packages
"""
vDict = {"Extensions": {}}
for ext in extensionsByPriority():
if six.PY2:
try:
version = importlib.import_module(ext).version
except (ImportError, AttributeError):
continue
if ext.endswith("DIRAC") and ext != "DIRAC":
ext = ext[: -len("DIRAC")]
else:
from importlib.metadata import version as get_version # pylint: disable=import-error,no-name-in-module
version = get_version(ext)
vDict["Extensions"][ext] = version
return S_OK(vDict)
def main():
global overwrite
global specialOptions
global module
global specialOptions
from DIRAC.FrameworkSystem.Client.ComponentInstaller import gComponentInstaller
gComponentInstaller.exitOnError = True
Script.registerSwitch("w", "overwrite",
"Overwrite the configuration in the global CS",
setOverwrite)
Script.registerSwitch("m:", "module=",
"Python module name for the component code",
setModule)
Script.registerSwitch("p:", "parameter=", "Special component option ",
setSpecialOption)
# Registering arguments will automatically add their description to the help menu
Script.registerArgument((
"System/Component: Full component name (ie: WorkloadManagement/Matcher)",
"System: Name of the DIRAC system (ie: WorkloadManagement)",
))
Script.registerArgument(
" Component: Name of the DIRAC service (ie: Matcher)",
mandatory=False)
Script.parseCommandLine()
args = Script.getPositionalArgs()
if len(args) == 1:
args = args[0].split("/")
if len(args) != 2:
Script.showHelp(exitCode=1)
system = args[0]
component = args[1]
compOrMod = module or component
result = gComponentInstaller.getSoftwareComponents(extensionsByPriority())
if not result["OK"]:
gLogger.error(result["Message"])
DIRACexit(1)
availableComponents = result["Value"]
for compType in availableComponents:
if system in availableComponents[
compType] and compOrMod in availableComponents[compType][
system]:
cType = compType[:-1].lower()
break
else:
gLogger.error("Component %s/%s is not available for installation" %
(system, component))
DIRACexit(1)
if module:
result = gComponentInstaller.addDefaultOptionsToCS(
gConfig,
cType,
system,
module,
extensionsByPriority(),
overwrite=overwrite)
result = gComponentInstaller.addDefaultOptionsToCS(
gConfig,
cType,
system,
component,
extensionsByPriority(),
specialOptions=specialOptions,
overwrite=overwrite,
addDefaultOptions=False,
)
else:
result = gComponentInstaller.addDefaultOptionsToCS(
gConfig,
cType,
system,
component,
extensionsByPriority(),
specialOptions=specialOptions,
overwrite=overwrite,
)
if not result["OK"]:
gLogger.error(result["Message"])
DIRACexit(1)
result = gComponentInstaller.installComponent(cType, system, component,
extensionsByPriority(),
module)
if not result["OK"]:
gLogger.error(result["Message"])
DIRACexit(1)
gLogger.notice(
"Successfully installed component %s in %s system, now setting it up" %
(component, system))
result = gComponentInstaller.setupComponent(cType, system, component,
extensionsByPriority(), module)
if not result["OK"]:
gLogger.error(result["Message"])
DIRACexit(1)
if component == "ComponentMonitoring":
result = MonitoringUtilities.monitorInstallation(
"DB", system, "InstalledComponentsDB")
if not result["OK"]:
gLogger.error(result["Message"])
DIRACexit(1)
result = MonitoringUtilities.monitorInstallation(cType, system, component,
module)
if not result["OK"]:
gLogger.error(result["Message"])
DIRACexit(1)
gLogger.notice("Successfully completed the installation of %s/%s" %
(system, component))
DIRACexit()
def getInstalledExtensions():
"""
Return list of extensions registered in the CS and available in local installation
"""
return extensionsByPriority()
componentType = args[0]
if len(args) == 2:
system, component = args[1].split("/")
else:
system = args[1]
component = args[2]
# imports
from DIRAC import gConfig
from DIRAC import exit as DIRACexit
from DIRAC.Core.Utilities.Extensions import extensionsByPriority
from DIRAC.FrameworkSystem.Client.ComponentInstaller import gComponentInstaller
#
gComponentInstaller.exitOnError = True
result = gComponentInstaller.addDefaultOptionsToCS(gConfig,
componentType,
system,
component,
extensionsByPriority(),
specialOptions={},
overwrite=False)
if not result["OK"]:
print("ERROR:", result["Message"])
else:
DIRACexit()
def loadModule(self, modName, hideExceptions=False, parentModule=False):
"""
Load module name.
name must take the form [DIRAC System Name]/[DIRAC module]
"""
while modName and modName[0] == "/":
modName = modName[1:]
if modName in self.__modules:
return S_OK()
modList = modName.split("/")
if len(modList) != 2:
return S_ERROR("Can't load %s: Invalid module name" % (modName))
csSection = self.__sectionFinder(modName)
loadGroup = gConfig.getValue("%s/Load" % csSection, [])
# Check if it's a load group
if loadGroup:
gLogger.info("Found load group %s. Will load %s" %
(modName, ", ".join(loadGroup)))
for loadModName in loadGroup:
if "/" not in loadModName:
loadModName = "%s/%s" % (modList[0], loadModName)
result = self.loadModule(loadModName,
hideExceptions=hideExceptions)
if not result["OK"]:
return result
return S_OK()
# Normal load
loadName = gConfig.getValue("%s/Module" % csSection, "")
if not loadName:
loadName = modName
gLogger.info("Loading %s" % (modName))
else:
if "/" not in loadName:
loadName = "%s/%s" % (modList[0], loadName)
gLogger.info("Loading %s (%s)" % (modName, loadName))
# If already loaded, skip
loadList = loadName.split("/")
if len(loadList) != 2:
return S_ERROR("Can't load %s: Invalid module name" % (loadName))
system, module = loadList
# Load
className = module
if self.__modSuffix:
className = "%s%s" % (className, self.__modSuffix)
if loadName not in self.__loadedModules:
# Check if handler is defined
loadCSSection = self.__sectionFinder(loadName)
handlerPath = gConfig.getValue("%s/HandlerPath" % loadCSSection,
"")
if handlerPath:
gLogger.info("Trying to %s from CS defined path %s" %
(loadName, handlerPath))
gLogger.verbose("Found handler for %s: %s" %
(loadName, handlerPath))
handlerPath = handlerPath.replace("/", ".")
if handlerPath.endswith(".py"):
handlerPath = handlerPath[:-3]
className = List.fromChar(handlerPath, ".")[-1]
result = recurseImport(handlerPath)
if not result["OK"]:
return S_ERROR("Cannot load user defined handler %s: %s" %
(handlerPath, result["Message"]))
gLogger.verbose("Loading %s" % handlerPath)
elif parentModule:
gLogger.info("Trying to autodiscover %s from parent" %
loadName)
# If we've got a parent module, load from there.
modImport = module
if self.__modSuffix:
modImport = "%s%s" % (modImport, self.__modSuffix)
result = recurseImport(modImport,
parentModule,
hideExceptions=hideExceptions)
else:
# Check to see if the module exists in any of the root modules
gLogger.info("Trying to autodiscover %s" % loadName)
for rootModule in extensionsByPriority():
importString = "%s.%sSystem.%s.%s" % (
rootModule, system, self.__importLocation, module)
if self.__modSuffix:
importString = "%s%s" % (importString,
self.__modSuffix)
gLogger.verbose("Trying to load %s" % importString)
result = recurseImport(importString,
hideExceptions=hideExceptions)
# Error while loading
if not result["OK"]:
return result
# Something has been found! break :)
if result["Value"]:
gLogger.verbose("Found %s" % importString)
break
# Nothing found
if not result["Value"]:
return S_ERROR("Could not find %s" % loadName)
modObj = result["Value"]
try:
# Try to get the class from the module
modClass = getattr(modObj, className)
except AttributeError:
if "__file__" in dir(modObj):
location = modObj.__file__
else:
location = modObj.__path__
gLogger.exception("%s module does not have a %s class!" %
(location, module))
return S_ERROR("Cannot load %s" % module)
# Check if it's subclass
if not issubclass(modClass, self.__superClass):
return S_ERROR("%s has to inherit from %s" %
(loadName, self.__superClass.__name__))
self.__loadedModules[loadName] = {
"classObj": modClass,
"moduleObj": modObj
}
# End of loading of 'loadName' module
# A-OK :)
self.__modules[modName] = self.__loadedModules[loadName].copy()
# keep the name of the real code module
self.__modules[modName]["modName"] = modName
self.__modules[modName]["loadName"] = loadName
gLogger.notice("Loaded module %s" % modName)
return S_OK()
def test_extensionsByPriority():
assert "DIRAC" in extensionsByPriority()
def _updateSoftwarePy3(self, version, rootPath_, diracOSVersion):
if rootPath_:
return S_ERROR(
"rootPath argument is not supported for Python 3 installations"
)
# Validate and normalise the requested version
primaryExtension = None
if "==" in version:
primaryExtension, version = version.split("==")
elif six.PY2:
return S_ERROR(
"The extension must be specified like DIRAC==vX.Y.Z if installing "
"a Python 3 version from an existing Python 2 installation.")
try:
version = Version(version)
except InvalidVersion:
self.log.exception("Invalid version passed", version)
return S_ERROR("Invalid version passed %r" % version)
isPrerelease = version.is_prerelease
version = "v%s" % version
# Find what to install
otherExtensions = []
for extension in extensionsByPriority():
if primaryExtension is None and getExtensionMetadata(
extension).get("primary_extension", False):
primaryExtension = extension
else:
otherExtensions.append(extension)
self.log.info(
"Installing Python 3 based", "%s %s with DIRACOS %s" %
(primaryExtension, version, diracOSVersion or "2"))
self.log.info("Will also install", repr(otherExtensions))
# Install DIRACOS
installer_url = "https://github.com/DIRACGrid/DIRACOS2/releases/"
if diracOSVersion:
installer_url += "download/%s/latest/download/DIRACOS-Linux-%s.sh" % (
version, platform.machine())
else:
installer_url += "latest/download/DIRACOS-Linux-%s.sh" % platform.machine(
)
self.log.info("Downloading DIRACOS2 installer from", installer_url)
with tempfile.NamedTemporaryFile(suffix=".sh", mode="wb") as installer:
with requests.get(installer_url, stream=True) as r:
if not r.ok:
return S_ERROR("Failed to download %s" % installer_url)
for chunk in r.iter_content(chunk_size=1024**2):
installer.write(chunk)
installer.flush()
self.log.info("Downloaded DIRACOS installer to", installer.name)
if six.PY2:
newProPrefix = os.path.dirname(
os.path.realpath(os.path.join(rootPath, "bashrc")))
else:
newProPrefix = rootPath
newProPrefix = os.path.join(
newProPrefix,
"versions",
"%s-%s" % (version, datetime.utcnow().strftime("%s")),
)
installPrefix = os.path.join(
newProPrefix,
"%s-%s" % (platform.system(), platform.machine()))
self.log.info("Running DIRACOS installer for prefix",
installPrefix)
r = subprocess.run( # pylint: disable=no-member
["bash", installer.name, "-p", installPrefix],
stderr=subprocess.PIPE,
universal_newlines=True,
check=False,
timeout=600,
)
if r.returncode != 0:
stderr = [
x for x in r.stderr.split("\n")
if not x.startswith("Extracting : ")
]
self.log.error("Installing DIRACOS2 failed with returncode",
"%s and stdout: %s" % (r.returncode, stderr))
return S_ERROR("Failed to install DIRACOS2 %s" % stderr)
# Install DIRAC
cmd = ["%s/bin/pip" % installPrefix, "install", "--no-color", "-v"]
if isPrerelease:
cmd += ["--pre"]
cmd += ["%s[server]==%s" % (primaryExtension, version)]
cmd += ["%s[server]" % e for e in otherExtensions]
r = subprocess.run( # pylint: disable=no-member
cmd,
stderr=subprocess.PIPE,
universal_newlines=True,
check=False,
timeout=600,
)
if r.returncode != 0:
self.log.error("Installing DIRACOS2 failed with returncode",
"%s and stdout: %s" % (r.returncode, r.stderr))
return S_ERROR("Failed to install DIRACOS2 with message %s" %
r.stderr)
# Update the pro link
oldLink = os.path.join(gComponentInstaller.instancePath, "old")
proLink = os.path.join(gComponentInstaller.instancePath, "pro")
if os.path.exists(oldLink):
os.remove(oldLink)
os.rename(proLink, oldLink)
mkLink(newProPrefix, proLink)
return S_OK()
def main():
global overwrite
global specialOptions
global module
global specialOptions
from DIRAC.FrameworkSystem.Client.ComponentInstaller import gComponentInstaller
gComponentInstaller.exitOnError = True
Script.registerSwitch("w", "overwrite",
"Overwrite the configuration in the global CS",
setOverwrite)
Script.registerSwitch("m:", "module=",
"Python module name for the component code",
setModule)
Script.registerSwitch("p:", "parameter=", "Special component option ",
setSpecialOption)
# Registering arguments will automatically add their description to the help menu
Script.registerArgument((
"System/Component: Full component name (ie: WorkloadManagement/Matcher)",
"System: Name of the DIRAC system (ie: WorkloadManagement)",
))
Script.registerArgument(
" Component: Name of the DIRAC service (ie: Matcher)",
mandatory=False)
Script.parseCommandLine()
args = Script.getPositionalArgs()
if len(args) == 1:
args = args[0].split("/")
if len(args) != 2:
Script.showHelp()
DIRACexit(1)
system = args[0]
component = args[1]
result = gComponentInstaller.addDefaultOptionsToCS(
gConfig,
"service",
system,
component,
extensionsByPriority(),
specialOptions=specialOptions,
overwrite=overwrite,
)
if not result["OK"]:
gLogger.error(result["Message"])
DIRACexit(1)
result = gComponentInstaller.addTornadoOptionsToCS(gConfig)
if not result["OK"]:
gLogger.error(result["Message"])
DIRACexit(1)
result = gComponentInstaller.installTornado()
if not result["OK"]:
gLogger.error(result["Message"])
DIRACexit(1)
gLogger.notice(
"Successfully installed component %s in %s system, now setting it up" %
(component, system))
result = gComponentInstaller.setupTornadoService(system, component,
extensionsByPriority(),
module)
if not result["OK"]:
gLogger.error(result["Message"])
DIRACexit(1)
result = MonitoringUtilities.monitorInstallation("service", system,
component, module)
if not result["OK"]:
gLogger.error(result["Message"])
DIRACexit(1)
gLogger.notice("Successfully completed the installation of %s/%s" %
(system, component))
DIRACexit()
def export_addDefaultOptionsToComponentCfg(self, componentType, system,
component):
"""Add default component options local component cfg"""
return gComponentInstaller.addDefaultOptionsToComponentCfg(
componentType, system, component, extensionsByPriority())
def export_getSoftwareComponents(self):
"""Get the list of all the components ( services and agents ) for which the software
is installed on the system
"""
return gComponentInstaller.getSoftwareComponents(
extensionsByPriority())
def getInstalledExtensions(self):
return extensionsByPriority()
