def main(): Script.registerSwitch( "v:", "vo=", "Location of pilot version in CS /Operations/<vo>/Pilot/Version" " (default value specified in CS under /DIRAC/DefaultSetup)", ) # Registering arguments will automatically add their description to the help menu Script.registerArgument("version: pilot version you want to update to") Script.parseCommandLine(ignoreErrors=False) # parseCommandLine show help when mandatory arguments are not specified or incorrect argument version = Script.getPositionalArgs(group=True) vo = None for switch in Script.getUnprocessedSwitches(): if switch[0] == "v" or switch[0] == "vo": vo = switch[1] from DIRAC import S_OK, S_ERROR from DIRAC import gConfig, gLogger from DIRAC.ConfigurationSystem.Client.CSAPI import CSAPI def updatePilot(version, vo): """ Update in the CS the pilot version used, If only one version present in CS it's overwritten. If two versions present, the new one is added and the last removed :param version: version vArBpC of pilot you want to use :param vo: Location of pilot version in CS /Operations/<vo>/Pilot/Version """ setup = vo if not vo: setup = gConfig.getValue("/DIRAC/DefaultSetup") if not setup: return S_ERROR("No value set for /DIRAC/DefaultSetup in CS") pilotVersion = gConfig.getValue("Operations/%s/Pilot/Version" % setup, []) if not pilotVersion: return S_ERROR("No pilot version set under Operations/%s/Pilot/Version in CS" % setup) pilotVersion.pop() pilotVersion.insert(0, version) api = CSAPI() api.setOption("Operations/%s/Pilot/Version" % setup, ", ".join(pilotVersion)) result = api.commit() if not result["OK"]: gLogger.fatal("Could not commit new version of pilot!") return result newVersion = gConfig.getValue("Operations/%s/Pilot/Version" % setup) return S_OK("New version of pilot set to %s" % newVersion) result = updatePilot(version, vo) if not result["OK"]: gLogger.fatal(result["Message"]) DIRAC.exit(1) gLogger.notice(result["Value"]) DIRAC.exit(0)
def parseSwitches(): """ Parses the arguments passed by the user """ Script.parseCommandLine(ignoreErrors=True) args = Script.getPositionalArgs() if args: subLogger.error( "Found the following positional args '%s', but we only accept switches" % args) subLogger.error("Please, check documentation below") Script.showHelp(exitCode=1) switches = dict(Script.getUnprocessedSwitches()) # Default values switches.setdefault("element", None) switches.setdefault("defaultStatus", "Banned") if not switches["element"] in ("all", "Site", "Resource", "Node", None): subLogger.error("Found %s as element switch" % switches["element"]) subLogger.error("Please, check documentation below") Script.showHelp(exitCode=1) subLogger.debug("The switches used are:") map(subLogger.debug, switches.items()) return switches
def main(): Script.registerSwitch("", "Full", " Print full list of requests") Script.parseCommandLine() from DIRAC.RequestManagementSystem.Client.ReqClient import ReqClient fullPrint = False for switch in Script.getUnprocessedSwitches(): if switch[0] == "Full": fullPrint = True reqClient = ReqClient() for server, rpcClient in reqClient.requestProxies().items(): DIRAC.gLogger.always("Checking request cache at %s" % server) reqCache = rpcClient.listCacheDir() if not reqCache["OK"]: DIRAC.gLogger.error("Cannot list request cache", reqCache) continue reqCache = reqCache["Value"] if not reqCache: DIRAC.gLogger.always("No request in cache") else: if fullPrint: DIRAC.gLogger.always("List of requests", reqCache) else: DIRAC.gLogger.always("Number of requests in the cache", len(reqCache)) DIRAC.exit(0)
def main(): Script.localCfg.addDefaultEntry("LogLevel", "fatal") fileName = "" def setFilename(args): global fileName fileName = args return DIRAC.S_OK() raw = False def setRaw(args): global raw raw = True return DIRAC.S_OK() Script.registerSwitch("f:", "file=", "Dump Configuration data into <file>", setFilename) Script.registerSwitch("r", "raw", "Do not make any modification to the data", setRaw) Script.parseCommandLine() from DIRAC import gConfig, gLogger result = gConfig.dumpCFGAsLocalCache(fileName, raw) if not result["OK"]: print("Error: %s" % result["Message"]) sys.exit(1) if not fileName: print(result["Value"]) sys.exit(0)
def main(): Script.registerSwitch("e", "extended", "Show extended info") Script.parseCommandLine(ignoreErrors=True) from DIRAC import exit as DIRACExit from DIRAC.Interfaces.API.DiracAdmin import DiracAdmin diracAdmin = DiracAdmin() exitCode = 0 errorList = [] extendedInfo = False for unprocSw in Script.getUnprocessedSwitches(): if unprocSw[0] in ("e", "extended"): extendedInfo = True if not extendedInfo: result = diracAdmin.csListHosts() for host in result["Value"]: print(" %s" % host) else: result = diracAdmin.csDescribeHosts() print(diracAdmin.pPrint.pformat(result["Value"])) for error in errorList: print("ERROR %s: %s" % error) DIRACExit(exitCode)
def main(): PARAMS = Params() PARAMS.registerSwitches() Script.parseCommandLine(ignoreErrors=False) # Create Data Recovery Agent and run over single transformation. from DIRAC.TransformationSystem.Client.TransformationClient import TransformationClient from DIRAC.TransformationSystem.Agent.DataRecoveryAgent import DataRecoveryAgent DRA = DataRecoveryAgent("Transformation/DataRecoveryAgent", "Transformation/DataRecoveryAgent") DRA.jobStatus = ["Done", "Failed"] DRA.enabled = PARAMS.enabled TRANSFORMATION = TransformationClient().getTransformations( condDict={"TransformationID": PARAMS.transID}) if not TRANSFORMATION["OK"]: gLogger.error("Failed to find transformation: %s" % TRANSFORMATION["Message"]) exit(1) if not TRANSFORMATION["Value"]: gLogger.error("Did not find any transformations") exit(1) TRANS_INFO_DICT = TRANSFORMATION["Value"][0] TRANS_INFO_DICT.pop("Body", None) gLogger.notice("Found transformation: %s" % TRANS_INFO_DICT) DRA.treatTransformation(PARAMS.transID, TRANS_INFO_DICT) exit(0)
def main(): """reads command line parameters, makes check and creates replication transformation""" from DIRAC import gLogger, exit as dexit from DIRAC.TransformationSystem.Utilities.ReplicationCLIParameters import Params clip = Params() clip.registerSwitches(Script) Script.parseCommandLine() from DIRAC.TransformationSystem.Utilities.ReplicationTransformation import createDataTransformation if not clip.checkSettings(Script)["OK"]: gLogger.error("ERROR: Missing settings") dexit(1) for metaValue in clip.metaValues: resCreate = createDataTransformation( flavour=clip.flavour, targetSE=clip.targetSE, sourceSE=clip.sourceSE, metaKey=clip.metaKey, metaValue=metaValue, extraData=clip.extraData, extraname=clip.extraname, groupSize=clip.groupSize, tGroup=clip.groupName, plugin=clip.plugin, enable=clip.enable, ) if not resCreate["OK"]: gLogger.error("Failed to create Transformation", resCreate["Message"]) dexit(1) dexit(0)
def parseSwitchesAndPositionalArguments(): """ Parse switches and positional arguments given to the script """ # Parse the command line and initialize DIRAC Script.parseCommandLine(ignoreErrors=False) # Get arguments allArgs = Script.getPositionalArgs() gLogger.debug("All arguments: %s" % ", ".join(allArgs)) # Get unprocessed switches switches = dict(Script.getUnprocessedSwitches()) gLogger.debug("The switches used are:") map(gLogger.debug, switches.iteritems()) # Get grouped positional arguments repType, user, services = Script.getPositionalArgs(group=True) gLogger.debug("The positional arguments are:") gLogger.debug("Report type:", repType) gLogger.debug("Name or DN:", user) gLogger.debug("Services:", services) return switches, repType, user, services
def main(): params = Params() Script.registerSwitch("f:", "file=", "File to use as proxy", params.setProxyLocation) Script.registerSwitch("D", "DN", "Use DN as myproxy username", params.setDNAsUsername) Script.registerSwitch("i", "version", "Print version", params.showVersion) Script.addDefaultOptionValue("LogLevel", "always") Script.parseCommandLine() from DIRAC.Core.Security.MyProxy import MyProxy from DIRAC.Core.Security import Locations if not params.proxyLoc: params.proxyLoc = Locations.getProxyLocation() if not params.proxyLoc: print("Can't find any valid proxy") sys.exit(1) print("Uploading proxy file %s" % params.proxyLoc) mp = MyProxy() retVal = mp.uploadProxy(params.proxyLoc, params.dnAsUsername) if not retVal["OK"]: print("Can't upload proxy:") print(" ", retVal["Message"]) sys.exit(1) print("Proxy uploaded") sys.exit(0)
def processScriptSwitches(): global vo, dry, doCEs, hostURL, onecore Script.registerSwitch("V:", "vo=", "Virtual Organization") Script.registerSwitch("D", "dry", "Dry run") Script.registerSwitch("C", "ce", "Process Computing Elements") Script.registerSwitch("H:", "host=", "use this url for information querying") Script.registerSwitch( "", "onecore", "Add Single Core Queues for each MultiCore Queue, set RequiredTag for those Queues" ) Script.parseCommandLine(ignoreErrors=True) vo = "" dry = False doCEs = False hostURL = None onecore = False for sw in Script.getUnprocessedSwitches(): if sw[0] in ("V", "vo"): vo = sw[1] if sw[0] in ("D", "dry"): dry = True if sw[0] in ("C", "ce"): doCEs = True if sw[0] in ("H", "host"): hostURL = sw[1] if sw[0] in ("onecore",): onecore = True
def main(): # Registering arguments will automatically add their description to the help menu Script.registerArgument( ("LFN: LFN", "File: File name containing a list of affected LFNs")) Script.registerArgument(" SE: Name of Storage Element") Script.registerArgument(" Status: New Status for the replica") Script.parseCommandLine(ignoreErrors=False) import DIRAC from DIRAC import gLogger from DIRAC.Resources.Catalog.FileCatalog import FileCatalog import os # parseCommandLine show help when mandatory arguments are not specified or incorrect argument inputFileName, storageElement, status = Script.getPositionalArgs( group=True) if os.path.exists(inputFileName): inputFile = open(inputFileName, "r") string = inputFile.read() inputFile.close() lfns = sorted(string.splitlines()) else: lfns = [inputFileName] fc = FileCatalog() res = fc.getReplicas(lfns, allStatus=True) if not res["OK"]: gLogger.error("Failed to get catalog replicas.", res["Message"]) DIRAC.exit(-1) lfnDict = {} for lfn, error in res["Value"]["Failed"].items(): gLogger.error("Failed to get replicas for file.", "%s:%s" % (lfn, error)) for lfn, replicas in res["Value"]["Successful"].items(): if storageElement not in replicas.keys(): gLogger.error("LFN not registered at provided storage element.", "%s %s" % (lfn, storageElement)) else: lfnDict[lfn] = { "SE": storageElement, "PFN": replicas[storageElement], "Status": status } if not lfnDict: gLogger.error("No files found at the supplied storage element.") DIRAC.exit(2) res = fc.setReplicaStatus(lfnDict) if not res["OK"]: gLogger.error("Failed to set catalog replica status.", res["Message"]) DIRAC.exit(-1) for lfn, error in res["Value"]["Failed"].items(): gLogger.error("Failed to set replica status for file.", "%s:%s" % (lfn, error)) gLogger.notice("Successfully updated the status of %d files at %s." % (len(res["Value"]["Successful"].keys()), storageElement)) DIRAC.exit(0)
def registerSwitchesAndParseCommandLine(self): """Register the default plus additional parameters and parse options. :param list options: list of three tuple for options to add to the script :param list flags: list of three tuple for flags to add to the script :param str opName """ for short, longOption, doc in self.options: Script.registerSwitch(short + ":" if short else "", longOption + "=", doc) for short, longOption, doc in self.flags: Script.registerSwitch(short, longOption, doc) self.switches[longOption] = False Script.parseCommandLine() if Script.getPositionalArgs(): Script.showHelp(exitCode=1) for switch in Script.getUnprocessedSwitches(): for short, longOption, doc in self.options: if switch[0] == short or switch[0].lower() == longOption.lower( ): sLog.verbose("Found switch %r with value %r" % (longOption, switch[1])) self.switches[longOption] = switch[1] break for short, longOption, doc in self.flags: if switch[0] == short or switch[0].lower() == longOption.lower( ): self.switches[longOption] = True break self.checkSwitches() self.switches["DryRun"] = not self.switches.get("Execute", False) self.switches["SourceSE"] = self.switches.get("SourceSE", "").split(",")
def main(): Script.parseCommandLine(ignoreErrors=False) from DIRAC.TransformationSystem.Client.TransformationCLI import TransformationCLI cli = TransformationCLI() cli.cmdloop()
def main(): # Registering arguments will automatically add their description to the help menu Script.registerArgument(["LFN: Logical File Name or file containing LFNs"]) Script.parseCommandLine(ignoreErrors=True) lfns = Script.getPositionalArgs() if len(lfns) < 1: Script.showHelp() from DIRAC.Interfaces.API.Dirac import Dirac dirac = Dirac() exitCode = 0 if len(lfns) == 1: try: with open(lfns[0], "r") as f: lfns = f.read().splitlines() except Exception: pass result = dirac.getFile(lfns, printOutput=True) if not result["OK"]: print("ERROR %s" % (result["Message"])) exitCode = 2 DIRAC.exit(exitCode)
def main(): Script.parseCommandLine() from DIRAC.ProductionSystem.Client.ProductionClient import ProductionClient prodClient = ProductionClient() res = prodClient.getProductions() fields = [ "ProductionName", "Status", "ProductionID", "CreationDate", "LastUpdate", "AuthorDN", "AuthorGroup" ] records = [] if res["OK"]: prodList = res["Value"] if not isinstance(res["Value"], list): prodList = [res["Value"]] for prod in prodList: records.append([ str(prod["ProductionName"]), str(prod["Status"]), str(prod["ProductionID"]), str(prod["CreationDate"]), str(prod["LastUpdate"]), str(prod["AuthorDN"]), str(prod["AuthorGroup"]), ]) else: DIRAC.gLogger.error(res["Message"]) DIRAC.exit(-1) printTable(fields, records) DIRAC.exit(0)
def main(): Script.disableCS() Script.parseCommandLine() from DIRAC.FrameworkSystem.Client.ComponentInstaller import gComponentInstaller gComponentInstaller.exitOnError = True gComponentInstaller.setupPortal()
def main(): Script.localCfg.addDefaultEntry("LogLevel", "info") Script.parseCommandLine() from DIRAC.AccountingSystem.Client.AccountingCLI import AccountingCLI acli = AccountingCLI() acli.start()
def registerSwitchesAndParseCommandLine(self): """Register the default plus additional parameters and parse options. :param list options: list of three tuple for options to add to the script :param list flags: list of three tuple for flags to add to the script :param str opName """ for short, longOption, doc in self.options: Script.registerSwitch(short + ":" if short else "", longOption + "=", doc) for short, longOption, doc in self.flags: Script.registerSwitch(short, longOption, doc) self.switches[longOption] = False Script.parseCommandLine() if Script.getPositionalArgs(): Script.showHelp(exitCode=1) ops = Operations() if not ops.getValue("DataManagement/ArchiveFiles/Enabled", False): sLog.error( 'The "ArchiveFiles" operation is not enabled, contact your administrator!' ) DIRAC.exit(1) for _short, longOption, _doc in self.options: defaultValue = ops.getValue( "DataManagement/ArchiveFiles/%s" % longOption, None) if defaultValue: sLog.verbose( "Found default value in the CS for %r with value %r" % (longOption, defaultValue)) self.switches[longOption] = defaultValue for _short, longOption, _doc in self.flags: defaultValue = ops.getValue( "DataManagement/ArchiveFiles/%s" % longOption, False) if defaultValue: sLog.verbose( "Found default value in the CS for %r with value %r" % (longOption, defaultValue)) self.switches[longOption] = defaultValue for switch in Script.getUnprocessedSwitches(): for short, longOption, doc in self.options: if switch[0] == short or switch[0].lower() == longOption.lower( ): sLog.verbose("Found switch %r with value %r" % (longOption, switch[1])) self.switches[longOption] = switch[1] break for short, longOption, doc in self.flags: if switch[0] == short or switch[0].lower() == longOption.lower( ): self.switches[longOption] = True break self.checkSwitches() self.switches["DryRun"] = not self.switches.get("Execute", False) self.switches["SourceSE"] = self.switches.get("SourceSE", "").split(",")
def main(): global overwrite Script.registerSwitch("f", "force", "Force overwrite of existing file", setOverwrite) Script.parseCommandLine(ignoreErrors=True) args = Script.getPositionalArgs() if len(args) < 1 or len(args) > 4: Script.showHelp(exitCode=1) from DIRAC.DataManagementSystem.Client.DataManager import DataManager from DIRAC import gLogger import DIRAC exitCode = 0 lfns = [] if len(args) == 1: inputFileName = args[0] if os.path.exists(inputFileName): inputFile = open(inputFileName, "r") for line in inputFile: line = line.rstrip() items = line.split() items[0] = items[0].replace("LFN:", "").replace("lfn:", "") lfns.append(getDict(items)) inputFile.close() else: gLogger.error("Error: LFN list '%s' missing." % inputFileName) exitCode = 4 else: lfns.append(getDict(args)) dm = DataManager() for lfn in lfns: if not os.path.exists(lfn["localfile"]): gLogger.error("File %s must exist locally" % lfn["localfile"]) exitCode = 1 continue if not os.path.isfile(lfn["localfile"]): gLogger.error("%s is not a file" % lfn["localfile"]) exitCode = 2 continue gLogger.notice("\nUploading %s" % lfn["lfn"]) res = dm.putAndRegister(lfn["lfn"], lfn["localfile"], lfn["SE"], lfn["guid"], overwrite=overwrite) if not res["OK"]: exitCode = 3 gLogger.error("Error: failed to upload %s to %s: %s" % (lfn["lfn"], lfn["SE"], res)) continue else: gLogger.notice("Successfully uploaded file to %s" % lfn["SE"]) DIRAC.exit(exitCode)
def main(): Script.disableCS() Script.registerSwitch("t:", "type=", "Installation type. 'server' by default.", setInstallType) Script.parseCommandLine(ignoreErrors=True) # Collect all the requested python modules to install reqDict = {} for entry in os.listdir(rootPath): if len(entry) < 5 or entry.find("DIRAC") != len(entry) - 5: continue reqFile = os.path.join(rootPath, entry, "releases.cfg") try: with open(reqFile, "r") as extfd: reqCFG = CFG().loadFromBuffer(extfd.read()) except Exception: gLogger.verbose("%s not found" % reqFile) continue reqList = reqCFG.getOption( "/RequiredExternals/%s" % instType.capitalize(), []) if not reqList: gLogger.verbose( "%s does not have requirements for %s installation" % (entry, instType)) continue for req in reqList: reqName = False reqCond = "" for cond in ("==", ">="): iP = cond.find(req) if iP > 0: reqName = req[:iP] reqCond = req[iP:] break if not reqName: reqName = req if reqName not in reqDict: reqDict[reqName] = (reqCond, entry) else: gLogger.notice("Skipping %s, it's already requested by %s" % (reqName, reqDict[reqName][1])) if not reqDict: gLogger.notice("No extra python module requested to be installed") sys.exit(0) for reqName in reqDict: package = "%s%s" % (reqName, reqDict[reqName][0]) gLogger.notice("Requesting installation of %s" % package) status, output = pipInstall(package) if status != 0: gLogger.error(output) else: gLogger.notice("Successfully installed %s" % package)
def main(): Script.registerSwitch("N:", "NumberOfProcessors=", "Run n parallel copies of the benchmark") Script.registerSwitch("U", "Update", "Update dirac.cfg with the resulting value") Script.registerSwitch("R:", "Reconfig=", "Update given configuration file with the resulting value") Script.parseCommandLine(ignoreErrors=True) update = False configFile = None numberOfProcessors = 0 for unprocSw in Script.getUnprocessedSwitches(): if unprocSw[0] in ("U", "Update"): update = True elif unprocSw[0] in ("R", "Reconfig"): configFile = unprocSw[1] elif unprocSw[0] in ("N", "NumberOfProcessors"): try: numberOfProcessors = int(unprocSw[1]) except ValueError: gLogger.warn("Cannot make benchmark measurements: NumberOfProcessors is not a number") # if numberOfProcessors has not been provided, try to get it from the configuration if not numberOfProcessors: numberOfProcessors = gConfig.getValue("/Resources/Computing/CEDefaults/NumberOfProcessors", 1) gLogger.info("Computing benchmark measurements on", "%d processor(s)..." % numberOfProcessors) # we want to get the logs coming from db12 gLogger.enableLogsFromExternalLibs() # multiprocessor allocations generally have a CPU Power lower than single core one. # in order to avoid having wrong estimations, we run multiple copies of the benchmark simultaneously result = multipleDiracBenchmark(numberOfProcessors) if result is None: gLogger.error("Cannot make benchmark measurements") DIRAC.exit(1) # we take a conservative approach and use the minimum value returned as the CPU Power db12Result = min(result["raw"]) # because hardware is continuously evolving, original benchmark scores might need a correction corr = Operations().getValue("JobScheduling/CPUNormalizationCorrection", 1.0) gLogger.info("Applying a correction on the CPU power:", corr) cpuPower = round(db12Result / corr, 1) gLogger.notice("Estimated CPU power is %.1f HS06" % cpuPower) if update: gConfig.setOptionValue("/LocalSite/CPUNormalizationFactor", cpuPower) if configFile: gConfig.dumpLocalCFGToFile(configFile) else: gConfig.dumpLocalCFGToFile(gConfig.diracConfigFilePath) DIRAC.exit()
def main(): cliParams = CLIParams() cliParams.registerCLISwitches() Script.parseCommandLine() retVal = uploadProxy(cliParams) if not retVal["OK"]: print(retVal["Message"]) sys.exit(1) sys.exit(0)
def main(): # Registering arguments will automatically add their description to the help menu Script.registerArgument( "Request: ID of the Stage request in the StorageManager") Script.parseCommandLine(ignoreErrors=False) args = Script.getPositionalArgs() if not len(args) == 1: Script.showHelp() from DIRAC import exit as DIRACExit, gLogger try: taskID = int(args[0]) except Exception: gLogger.fatal("Stage requestID must be an integer") DIRACExit(2) from DIRAC.StorageManagementSystem.Client.StorageManagerClient import StorageManagerClient client = StorageManagerClient() res = client.getTaskSummary(taskID) if not res["OK"]: gLogger.error(res["Message"]) DIRACExit(2) taskInfo = res["Value"]["TaskInfo"] replicaInfo = res["Value"]["ReplicaInfo"] outStr = "%s: %s" % ("TaskID".ljust(20), taskID) outStr += "\n%s: %s" % ("Status".ljust(20), taskInfo[taskID]["Status"]) outStr += "\n%s: %s" % ("Source".ljust(20), taskInfo[taskID]["Source"]) outStr += "\n%s: %s" % ("SourceTaskID".ljust(20), taskInfo[taskID]["SourceTaskID"]) outStr += "\n%s: %s" % ("CallBackMethod".ljust(20), taskInfo[taskID]["CallBackMethod"]) outStr += "\n%s: %s" % ("SubmitTime".ljust(20), taskInfo[taskID]["SubmitTime"]) outStr += "\n%s: %s" % ("CompleteTime".ljust(20), taskInfo[taskID]["CompleteTime"]) for lfn, metadata in replicaInfo.items(): outStr += "\n" outStr += "\n\t%s: %s" % ("LFN".ljust(8), lfn.ljust(100)) outStr += "\n\t%s: %s" % ("SE".ljust(8), metadata["StorageElement"].ljust(100)) outStr += "\n\t%s: %s" % ("PFN".ljust(8), str( metadata["PFN"]).ljust(100)) outStr += "\n\t%s: %s" % ("Size".ljust(8), str( metadata["FileSize"]).ljust(100)) outStr += "\n\t%s: %s" % ("Status".ljust(8), metadata["Status"].ljust(100)) outStr += "\n\t%s: %s" % ("Reason".ljust(8), str( metadata["Reason"]).ljust(100)) gLogger.notice(outStr)
def main(): host = None Script.registerSwitch("H:", "host=", " Target host") Script.parseCommandLine(ignoreErrors=False) for switch in Script.getUnprocessedSwitches(): if switch[0].lower() == "h" or switch[0].lower() == "host": host = switch[1] from DIRAC.FrameworkSystem.Client.SystemAdministratorClientCLI import SystemAdministratorClientCLI cli = SystemAdministratorClientCLI(host) cli.cmdloop()
def main(): Script.registerSwitch("p:", "property=", "Add property to the user <name>=<value>") Script.registerSwitch("f", "force", "create the user if it doesn't exist") # Registering arguments will automatically add their description to the help menu Script.registerArgument(" user: User name") Script.registerArgument(" DN: DN of the User") Script.registerArgument(["group: Add the user to the group"]) Script.parseCommandLine(ignoreErrors=True) from DIRAC.Interfaces.API.DiracAdmin import DiracAdmin diracAdmin = DiracAdmin() exitCode = 0 forceCreation = False errorList = [] userProps = {} for unprocSw in Script.getUnprocessedSwitches(): if unprocSw[0] in ("f", "force"): forceCreation = True elif unprocSw[0] in ("p", "property"): prop = unprocSw[1] pl = prop.split("=") if len(pl) < 2: errorList.append(( "in arguments", "Property %s has to include a '=' to separate name from value" % prop)) exitCode = 255 else: pName = pl[0] pValue = "=".join(pl[1:]) print("Setting property %s to %s" % (pName, pValue)) userProps[pName] = pValue userName, userProps["DN"], userProps["Groups"] = Script.getPositionalArgs( group=True) if not diracAdmin.csModifyUser( userName, userProps, createIfNonExistant=forceCreation): errorList.append(("modify user", "Cannot modify user %s" % userName)) exitCode = 255 else: result = diracAdmin.csCommitChanges() if not result["OK"]: errorList.append(("commit", result["Message"])) exitCode = 255 for error in errorList: print("ERROR %s: %s" % error) DIRAC.exit(exitCode)
def main(): # Registering arguments will automatically add their description to the help menu Script.registerArgument(("LocalFile: Path to local file containing LFNs", "LFN: Logical File Names")) Script.parseCommandLine() from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations allowUsers = Operations().getValue( "DataManagement/AllowUserReplicaManagement", False) from DIRAC.Core.Security.ProxyInfo import getProxyInfo res = getProxyInfo() if not res["OK"]: gLogger.fatal("Can't get proxy info", res["Message"]) dexit(1) properties = res["Value"].get("groupProperties", []) if not allowUsers: if "FileCatalogManagement" not in properties: gLogger.error( "You need to use a proxy from a group with FileCatalogManagement" ) dexit(5) from DIRAC.Resources.Catalog.FileCatalog import FileCatalog fc = FileCatalog() import os # parseCommandLine show help when mandatory arguments are not specified or incorrect argument args = Script.getPositionalArgs() inputFileName = args[0] if os.path.exists(inputFileName): inputFile = open(inputFileName, "r") string = inputFile.read() lfns = [lfn.strip() for lfn in string.splitlines()] inputFile.close() else: lfns = [inputFileName] res = fc.removeFile(lfns) if not res["OK"]: print("Error:", res["Message"]) dexit(1) for lfn in sorted(res["Value"]["Failed"].keys()): message = res["Value"]["Failed"][lfn] print("Error: failed to remove %s: %s" % (lfn, message)) print("Successfully removed %d catalog files." % (len(res["Value"]["Successful"])))
def run(): """ main program entry point """ options = Params() options.registerCLISwitches() Script.parseCommandLine(ignoreErrors=True) if options.delete_all and options.vos: gLogger.error("-a and -v options are mutually exclusive. Please pick one or the other.") return 1 proxyLoc = Locations.getDefaultProxyLocation() if not os.path.exists(proxyLoc): gLogger.error("No local proxy found in %s, exiting." % proxyLoc) return 1 result = ProxyInfo.getProxyInfo(proxyLoc, True) if not result["OK"]: raise RuntimeError("Failed to get local proxy info.") if result["Value"]["secondsLeft"] < 60 and options.needsValidProxy(): raise RuntimeError("Lifetime of local proxy too short, please renew proxy.") userDN = result["Value"]["identity"] if options.delete_all: # delete remote proxies remote_groups = getProxyGroups() if not remote_groups: gLogger.notice("No remote proxies found.") for vo_group in remote_groups: deleteRemoteProxy(userDN, vo_group) # delete local proxy deleteLocalProxy(proxyLoc) elif options.vos: vo_groups = set() for voname in options.vos: vo_groups.update(mapVoToGroups(voname)) # filter set of all groups to only contain groups for which there is a user proxy user_groups = getProxyGroups() vo_groups.intersection_update(user_groups) if not vo_groups: gLogger.notice("You have no proxies registered for any of the specified VOs.") for group in vo_groups: deleteRemoteProxy(userDN, group) else: deleteLocalProxy(proxyLoc) return 0
def main(): global includeMasterCS Script.registerSwitch("n", "noMasterCS", "do not include master CS", setNoMasterCS) Script.parseCommandLine() from DIRAC import gLogger, exit as DIRACExit from DIRAC.WorkloadManagementSystem.Utilities.PilotCStoJSONSynchronizer import PilotCStoJSONSynchronizer ps = PilotCStoJSONSynchronizer() gLogger.verbose("Parameters for this sync:") gLogger.verbose("repo=" + ps.pilotRepo) gLogger.verbose("VO repo=" + ps.pilotVORepo) gLogger.verbose("projectDir=" + ps.projectDir) gLogger.verbose("pilotScriptsPath=" + ps.pilotScriptPath) gLogger.verbose("pilotVOScriptsPath=" + ps.pilotVOScriptPath) gLogger.verbose("pilotRepoBranch=" + ps.pilotRepoBranch) gLogger.verbose("pilotVORepoBranch=" + ps.pilotVORepoBranch) # pilot.json res = ps.getCSDict(includeMasterCS=includeMasterCS) if not res["OK"]: DIRACExit(1) pilotDict = res["Value"] print(json.dumps(pilotDict, indent=4, sort_keys=True)) # just print here as formatting is important with open("pilot.json", "w") as jf: json.dump(pilotDict, jf) # pilot files res = ps.syncScripts() if not res["OK"]: DIRACExit(1) gLogger.always(res["Value"]) tarPath, tarFiles = res["Value"] allFiles = [tarPath] + tarFiles + ["pilot.json"] # checksums checksumDict = {} for pFile in allFiles: filename = os.path.basename(pFile) with open(pFile, "rb") as fp: checksumDict[filename] = hashlib.sha512(fp.read()).hexdigest() cksPath = "checksums.sha512" with open(cksPath, "wt") as chksums: for filename, chksum in sorted(checksumDict.items()): # same as the output from sha512sum commands chksums.write("%s %s\n" % (chksum, filename)) allFiles = allFiles + [cksPath] print(allFiles)
def parseSwitches(): """ Parses the arguments passed by the user """ Script.parseCommandLine(ignoreErrors=True) args = Script.getPositionalArgs() if len(args) < 3: error( "Missing all mandatory 'query', 'element', 'tableType' arguments") elif args[0].lower() not in ("select", "add", "modify", "delete"): error("Incorrect 'query' argument") elif args[1].lower() not in ("site", "resource", "component", "node"): error("Incorrect 'element' argument") elif args[2].lower() not in ("status", "log", "history"): error("Incorrect 'tableType' argument") else: query = args[0].lower() switches = dict(Script.getUnprocessedSwitches()) # Default values switches.setdefault("name", None) switches.setdefault("statusType", None) switches.setdefault("status", None) switches.setdefault("elementType", None) switches.setdefault("reason", None) switches.setdefault("lastCheckTime", None) switches.setdefault("tokenOwner", None) switches.setdefault("VO", None) if "status" in switches and switches["status"] is not None: switches["status"] = switches["status"].title() if switches["status"] not in ("Active", "Probing", "Degraded", "Banned", "Unknown", "Error"): error("'%s' is an invalid argument for switch 'status'" % switches["status"]) # when it's a add/modify query and status/reason/statusType are not specified # then some specific defaults are set up if query == "add" or query == "modify": if "status" not in switches or switches["status"] is None: switches["status"] = "Unknown" if "reason" not in switches or switches["reason"] is None: switches["reason"] = "Unknown reason" if "statusType" not in switches or switches["statusType"] is None: switches["statusType"] = "all" subLogger.debug("The switches used are:") map(subLogger.debug, switches.items()) return args, switches
def main(): Script.parseCommandLine(ignoreErrors=True) from DIRAC.Interfaces.API.DiracAdmin import DiracAdmin diracAdmin = DiracAdmin() result = diracAdmin.getPilotSummary() if result["OK"]: DIRAC.exit(0) else: print(result["Message"]) DIRAC.exit(2)