panda-server-source 0.8.0__py3-none-any.whl

pandaserver/taskbuffer/task_split_rules.py

@@ -0,0 +1,308 @@
+# split rules
+split_rule_dict = {
+    "allowEmptyInput": "AE",
+    "allowIncompleteInDS": "AI",
+    "addNthFieldToLFN": "AN",
+    "allowPartialFinish": "AP",
+    "altStageOut": "AT",
+    "avoidVP": "AV",
+    "maxCoreCount": "CC",
+    "cloudAsVO": "CV",
+    "ddmBackEnd": "DE",
+    "disableAutoFinish": "DF",
+    "disableReassign": "DI",
+    "debugMode": "DM",
+    "disableAutoRetry": "DR",
+    "dynamicNumEvents": "DY",
+    "nEsConsumers": "EC",
+    "nEventsPerInput": "EI",
+    "encJobParams": "EJ",
+    "nEventsPerWorker": "ES",
+    "firstContentsFeed": "FC",
+    "failGoalUnreached": "FG",
+    "fineGrainedProc": "FP",
+    "firstEvent": "FT",
+    "fullChain": "FU",
+    "groupBoundaryID": "GB",
+    "hpoWorkflow": "HO",
+    "instantiateTmplSite": "IA",
+    "inFilePosEvtNum": "IF",
+    "ipStack": "IK",
+    "allowInputLAN": "IL",
+    "ignoreMissingInDS": "IM",
+    "intermediateTask": "IN",
+    "ipConnectivity": "IP",
+    "inputPreStaging": "IS",
+    "instantiateTmpl": "IT",
+    "allowInputWAN": "IW",
+    "noLoopingCheck": "LC",
+    "useLocalIO": "LI",
+    "limitedSites": "LS",
+    "loadXML": "LX",
+    "minCpuEfficiency": "MC",
+    "messageDriven": "MD",
+    "mergeEsOnOS": "ME",
+    "nMaxFilesPerJob": "MF",
+    "maxJumboPerSite": "MJ",
+    "maxNumJobs": "MN",
+    "mergeOutput": "MO",
+    "multiStepExec": "MS",
+    "maxWalltime": "MW",
+    "maxEventsPerJob": "MX",
+    "noExecStrCnv": "NC",
+    "notDiscardEvents": "ND",
+    "nEventsPerJob": "NE",
+    "nFilesPerJob": "NF",
+    "nGBPerJob": "NG",
+    "noInputPooling": "NI",
+    "nJumboJobs": "NJ",
+    "noAutoPause": "NP",
+    "nSitesPerJob": "NS",
+    "nChunksToWait": "NT",
+    "noWaitParent": "NW",
+    "orderInputBy": "OI",
+    "orderByLB": "OL",
+    "onSiteMerging": "OM",
+    "osMatching": "OS",
+    "onlyTagsForFC": "OT",
+    "pushStatusChanges": "PC",
+    "pushJob": "PJ",
+    "pfnList": "PL",
+    "putLogToOS": "PO",
+    "runUntilClosed": "RC",
+    "registerDatasets": "RD",
+    "registerEsFiles": "RE",
+    "respectLB": "RL",
+    "retryModuleRules": "RM",
+    "reuseSecOnDemand": "RO",
+    "releasePerLB": "RP",
+    "respectSplitRule": "RR",
+    "randomSeed": "RS",
+    "retryRamOffset": "RX",
+    "retryRamStep": "RY",
+    "retryRamMax": "RZ",
+    "resurrectConsumers": "SC",
+    "switchEStoNormal": "SE",
+    "stayOutputOnSite": "SO",
+    "scoutSuccessRate": "SS",
+    "useSecrets": "ST",
+    "segmentedWork": "SW",
+    "totNumJobs": "TJ",
+    "tgtMaxOutputForNG": "TN",
+    "t1Weight": "TW",
+    "useBuild": "UB",
+    "useJobCloning": "UC",
+    "useRealNumEvents": "UE",
+    "useFileAsSourceLFN": "UF",
+    "usePrePro": "UP",
+    "useScout": "US",
+    "usePrefetcher": "UT",
+    "useExhausted": "UX",
+    "useZipToPin": "UZ",
+    "writeInputToFile": "WF",
+    "workflowHoldup": "WH",
+    "waitInput": "WI",
+    "maxAttemptES": "XA",
+    "decAttOnFailedES": "XF",
+    "maxAttemptEsJob": "XJ",
+    "nEventsPerMergeJob": "ZE",
+    "nFilesPerMergeJob": "ZF",
+    "nGBPerMergeJob": "ZG",
+    "nMaxFilesPerMergeJob": "ZM",
+}
+
+# changeable split rules
+changeable_split_rule_names = [
+    "allowIncompleteInDS",
+    "t1Weight",
+    "nEsConsumers",
+    "nMaxFilesPerJob",
+    "nGBPerJob",
+    "noInputPooling",
+    "nFilesPerJob",
+    "nEventsPerWorker",
+    "nJumboJobs",
+    "avoidVP",
+    "allowInputLAN",
+    "useLocalIO",
+    "noLoopingCheck",
+    "maxCoreCount",
+    "onlyTagsForFC",
+    "useZipToPin",
+    "ignoreMissingInDS",
+    "noAutoPause",
+]
+
+changeable_split_rule_tags = [split_rule_dict[tmp_name] for tmp_name in changeable_split_rule_names]
+
+
+# extract rules
+def extract_rule_values(split_rules: str, rule_names: list, is_sub_rule: bool = False) -> dict:
+    """
+    Extract rule values from split rule string
+
+    :param split_rules: a comma separated string
+    :param rule_names: a list of rule names
+    :param is_sub_rule: True to indicate the rule is a subrule
+    :return: dict of rule names and values
+    """
+    if split_rules is None:
+        split_rules = ""
+    ret = {}
+    if is_sub_rule:
+        rule_separator = "|"
+        key_value_separator = ":"
+    else:
+        rule_separator = ","
+        key_value_separator = "="
+    for tmp_rule in split_rules.split(rule_separator):
+        for tmp_name in rule_names:
+            if tmp_name in split_rule_dict and tmp_rule.startswith(split_rule_dict[tmp_name] + key_value_separator):
+                ret[tmp_name] = tmp_rule.split(key_value_separator)[-1]
+                break
+    for tmp_name in rule_names:
+        if tmp_name not in ret:
+            ret[tmp_name] = None
+    return ret
+
+
+# replace a rule
+def replace_rule(split_rules: str, rule_name: str, rule_value: int | str, is_sub_rule=False):
+    """
+    Replace a rule in the split rule string
+
+    :param split_rules: s comma separated string
+    :param rule_name: rule name
+    :param rule_value: rule value
+    :param is_sub_rule: True to indicate the rule is a subrule
+    :return: string of split rules
+    """
+    if rule_name not in split_rule_dict:
+        return split_rules
+    if split_rules is None:
+        split_rules = ""
+    if is_sub_rule:
+        rule_separator = "|"
+        key_value_separator = ":"
+    else:
+        rule_separator = ","
+        key_value_separator = "="
+    tmp_str = ""
+    for tmp_rule in split_rules.split(rule_separator):
+        if tmp_rule.startswith(split_rule_dict[rule_name] + key_value_separator):
+            continue
+        if tmp_str != "":
+            tmp_str += rule_separator
+        tmp_str += tmp_rule
+    if tmp_str != "":
+        tmp_str += rule_separator
+    tmp_str += split_rule_dict[rule_name] + key_value_separator + str(rule_value)
+    return tmp_str
+
+
+# remove a rule
+def remove_rule(split_rules: str, rule_token: str, is_sub_rule: bool = False):
+    """
+    Remove a rule from the split rule string
+
+    :param split_rules: s comma separated string
+    :param rule_token: rule token
+    :param is_sub_rule: TRue to indicate the rule is a subrule
+    :return: string of split rules
+    """
+    if split_rules is None:
+        split_rules = ""
+    if is_sub_rule:
+        rule_separator = "|"
+        key_value_separator = ":"
+    else:
+        rule_separator = ","
+        key_value_separator = "="
+    tmp_str = ""
+    for tmp_rule in split_rules.split(rule_separator):
+        if tmp_rule.startswith(rule_token + key_value_separator):
+            continue
+        if tmp_str != "":
+            tmp_str += rule_separator
+        tmp_str += tmp_rule
+    return tmp_str
+
+
+# decode split rule string: replace two-letter tags with human-readable names
+def decode_split_rule(split_rules: str) -> str:
+    """
+    Convert a compact split-rule string into a human-readable one by replacing
+    two-letter tags with their full names from split_rule_dict.
+
+    The input is a comma-separated string of ``TAG=value`` pairs, e.g.::
+
+        "AE=1,AN=1,2,3,AI=2"
+
+    Special case: ``AN`` (addNthFieldToLFN) may carry a comma-separated list
+    as its value (e.g. ``AN=1,2,3``).  All other tags treat ``=`` as the sole
+    separator and never embed commas in their values.
+
+    :param split_rules: compact comma-separated split-rule string, or None/empty
+    :return: human-readable comma-separated string, e.g.
+             ``"allowEmptyInput=1,addNthFieldToLFN=1,2,3,allowIncompleteInDS=2"``
+             Unknown tags are kept as-is.
+    """
+    if not split_rules:
+        return split_rules or ""
+
+    # build reverse map: two-letter tag -> full name
+    tag_to_name = {tag: name for name, tag in split_rule_dict.items()}
+
+    # The AN tag is the only one whose value may contain commas.
+    an_tag = split_rule_dict["addNthFieldToLFN"]  # "AN"
+
+    # Split on commas, then re-group tokens into (tag, value) pairs.
+    # A token starts a new rule when it matches "XX=..." where XX is a known
+    # two-letter tag.  Otherwise, it is appended to the current rule's value.
+    tokens = split_rules.split(",")
+    rules = []  # list of [tag, value_parts...]
+    for token in tokens:
+        # Check whether this token begins a new TAG=value entry
+        eq_pos = token.find("=")
+        if eq_pos == 2:
+            candidate_tag = token[:2]
+            if candidate_tag in tag_to_name or candidate_tag == an_tag:
+                # Start a new rule
+                rules.append([candidate_tag, token[3:]])  # token[3:] = value after "XX="
+                continue
+        # Not a recognized new rule:
+        # - if there are existing rules and the last one is AN, treat as value continuation
+        # - otherwise keep the token verbatim as its own entry
+        if rules and rules[-1][0] == an_tag:
+            rules[-1].append(token)
+        else:
+            # unknown / non-standard token — keep as-is using a sentinel
+            rules.append([None, token])
+
+    # Reconstruct using full names; rejoin multipart AN values with commas
+    result_parts = []
+    for parts in rules:
+        tag = parts[0]
+        if tag is None:
+            # unknown / non-standard token kept verbatim
+            result_parts.append(parts[1])
+        else:
+            value = "_".join(parts[1:])
+            name = tag_to_name.get(tag, tag)  # fall back to raw tag if unknown
+            result_parts.append(f"{name}={value}")
+
+    return ",".join(result_parts)
+
+
+# remove a rule with name
+def remove_rule_with_name(split_rules: str, rule_name: str, is_sub_rule: bool = False) -> str:
+    """
+    Remove a rule from the split rule string using the rule name
+
+    :param split_rules: a comma separated string
+    :param rule_name: rule name
+    :param is_sub_rule: True to indicate the rule is a subrule
+    :return: string of split rules
+    """
+    split_rules = remove_rule(split_rules, split_rule_dict[rule_name], is_sub_rule)
+    return split_rules

pandaserver/taskbuffer/workflow_processor.py

@@ -0,0 +1,249 @@
+import json
+import os.path
+import sys
+import tempfile
+import traceback
+
+import requests
+from idds.client.clientmanager import ClientManager
+from idds.common.utils import get_rest_host
+from pandacommon.pandalogger.LogWrapper import LogWrapper
+
+# import PandaLogger before idds modules not to change message levels of other modules
+from pandacommon.pandalogger.PandaLogger import PandaLogger
+from ruamel.yaml import YAML
+
+from pandaserver.srvcore.CoreUtils import clean_user_id, commands_get_status_output
+from pandaserver.srvcore.MailUtils import MailUtils
+from pandaserver.workflow import pcwl_utils, workflow_utils
+from pandaserver.workflow.snakeparser import Parser
+
+_logger = PandaLogger().getLogger("workflow_processor")
+
+
+SUPPORTED_WORKFLOW_LANGUAGES = ["cwl", "snakemake"]
+
+
+# process workflow
+class WorkflowProcessor(object):
+    # constructor
+    def __init__(self, task_buffer=None, log_stream=None):
+        self.taskBuffer = task_buffer
+        self.log = _logger
+
+    # process a file
+    def process(
+        self,
+        file_name,
+        to_delete=False,
+        test_mode=False,
+        get_log=False,
+        dump_workflow=False,
+    ):
+        is_fatal = False
+        request_id = None
+        dump_str = None
+        try:
+            with open(file_name) as f:
+                ops = json.load(f)
+                user_name = clean_user_id(ops["userName"])
+                base_platform = ops["data"].get("base_platform")
+                for task_type in ops["data"]["taskParams"]:
+                    ops["data"]["taskParams"][task_type]["userName"] = user_name
+                    if base_platform:
+                        ops["data"]["taskParams"][task_type]["basePlatform"] = base_platform
+                log_token = f"< id=\"{user_name}\" test={test_mode} outDS={ops['data']['outDS']} >"
+                tmpLog = LogWrapper(self.log, log_token)
+                tmpLog.info(f"start {file_name}")
+                sandbox_url = os.path.join(ops["data"]["sourceURL"], "cache", ops["data"]["sandbox"])
+                # IO through json files
+                ops_file = tempfile.NamedTemporaryFile(delete=False, mode="w")
+                json.dump(ops, ops_file)
+                ops_file.close()
+                # execute main in another process to avoid chdir mess
+                tmp_stat, tmp_out = commands_get_status_output(
+                    f"python {__file__} {sandbox_url} '{log_token}' {dump_workflow} {ops_file.name} '{user_name}' {test_mode}"
+                )
+                if tmp_stat:
+                    is_OK = False
+                    tmpLog.error(f"main execution failed with {tmp_stat}:{tmp_out}")
+                else:
+                    with open(tmp_out.split("\n")[-1]) as tmp_out_file:
+                        is_OK, is_fatal, request_id, dump_str = json.load(tmp_out_file)
+                    try:
+                        os.remove(tmp_out)
+                    except Exception:
+                        pass
+                if is_OK:
+                    tmpLog.info(f"is_OK={is_OK} request_id={request_id}")
+                else:
+                    tmpLog.info(f"is_OK={is_OK} is_fatal={is_fatal} request_id={request_id}")
+                if to_delete or (not test_mode and (is_OK or is_fatal)):
+                    if dump_str:
+                        dump_str = dump_str + tmpLog.dumpToString()
+                    else:
+                        dump_str = tmpLog.dumpToString()
+                    tmpLog.debug(f"delete {file_name}")
+                    try:
+                        os.remove(file_name)
+                    except Exception:
+                        pass
+                    # send notification
+                    if not test_mode and self.taskBuffer is not None:
+                        toAdder = self.taskBuffer.getEmailAddr(user_name)
+                        if toAdder is None or toAdder.startswith("notsend"):
+                            tmpLog.debug("skip to send notification since suppressed")
+                        else:
+                            # message
+                            if is_OK:
+                                mailSubject = f"PANDA Notification for Workflow {ops['data']['outDS']}"
+                                mailBody = f"Hello,\n\nWorkflow:{ops['data']['outDS']} has been accepted with RequestID:{request_id}\n\n"
+                            else:
+                                mailSubject = f"PANDA WARNING for Workflow={ops['data']['outDS']}"
+                                mailBody = "Hello,\n\nWorkflow {} was not accepted\n\n".format(ops["data"]["outDS"], request_id)
+                                mailBody += f"Reason : {dump_str}\n"
+                            # send
+                            tmpSM = MailUtils().send(toAdder, mailSubject, mailBody)
+                            tmpLog.debug(f"sent message with {tmpSM}")
+        except Exception as e:
+            is_OK = False
+            tmpLog.error(f"failed to run with {str(e)} {traceback.format_exc()}")
+        if get_log:
+            ret_val = {"status": is_OK, "request_id": request_id}
+            if is_OK:
+                ret_val["log"] = dump_str
+            else:
+                if dump_str is None:
+                    ret_val["log"] = tmpLog.dumpToString()
+                else:
+                    ret_val["log"] = dump_str
+            return ret_val
+
+
+# execute chdir in another process
+def core_exec(sandbox_url, log_token, dump_workflow, ops_file, user_name, test_mode):
+    tmpLog = LogWrapper(_logger, log_token)
+    is_OK = True
+    is_fatal = False
+    request_id = None
+    if dump_workflow == "True":
+        dump_workflow = True
+    else:
+        dump_workflow = False
+    if test_mode == "True":
+        test_mode = True
+    else:
+        test_mode = False
+    try:
+        with open(ops_file) as f:
+            ops = json.load(f)
+        try:
+            os.remove(ops_file)
+        except Exception:
+            pass
+        # go to temp dir
+        cur_dir = os.getcwd()
+        with tempfile.TemporaryDirectory() as tmp_dirname:
+            os.chdir(tmp_dirname)
+            # download sandbox
+            tmpLog.info(f"downloading sandbox from {sandbox_url}")
+            with requests.get(sandbox_url, allow_redirects=True, verify=False, stream=True) as r:
+                if r.status_code == 400:
+                    tmpLog.error("not found")
+                    is_fatal = True
+                    is_OK = False
+                elif r.status_code != 200:
+                    tmpLog.error(f"bad HTTP response {r.status_code}")
+                    is_OK = False
+                # extract sandbox
+                if is_OK:
+                    with open(ops["data"]["sandbox"], "wb") as fs:
+                        for chunk in r.raw.stream(1024, decode_content=False):
+                            if chunk:
+                                fs.write(chunk)
+                        fs.close()
+                        tmp_stat, tmp_out = commands_get_status_output(f"tar xvfz {ops['data']['sandbox']}")
+                        if tmp_stat != 0:
+                            tmpLog.error(tmp_out)
+                            dump_str = f"failed to extract {ops['data']['sandbox']}"
+                            tmpLog.error(dump_str)
+                            is_fatal = True
+                            is_OK = False
+                # parse workflow files
+                if is_OK:
+                    tmpLog.info("parse workflow")
+                    workflow_name = None
+                    if (wf_lang := ops["data"]["language"]) in SUPPORTED_WORKFLOW_LANGUAGES:
+                        if wf_lang == "cwl":
+                            workflow_name = ops["data"].get("workflow_name")
+                            nodes, root_in = pcwl_utils.parse_workflow_file(ops["data"]["workflowSpecFile"], tmpLog)
+                            with open(ops["data"]["workflowInputFile"]) as workflow_input:
+                                yaml = YAML(typ="safe", pure=True)
+                                data = yaml.load(workflow_input)
+                        elif wf_lang == "snakemake":
+                            parser = Parser(ops["data"]["workflowSpecFile"], logger=tmpLog)
+                            nodes, root_in = parser.parse_nodes()
+                            data = dict()
+                        # resolve nodes
+                        s_id, t_nodes, nodes = workflow_utils.resolve_nodes(nodes, root_in, data, 0, set(), ops["data"]["outDS"], tmpLog)
+                        workflow_utils.set_workflow_outputs(nodes)
+                        id_node_map = workflow_utils.get_node_id_map(nodes)
+                        [node.resolve_params(ops["data"]["taskParams"], id_node_map) for node in nodes]
+                        dump_str = "the description was internally converted as follows\n" + workflow_utils.dump_nodes(nodes)
+                        tmpLog.info(dump_str)
+                        for node in nodes:
+                            s_check, o_check = node.verify()
+                            tmp_str = f"Verification failure in ID:{node.id} {o_check}"
+                            if not s_check:
+                                tmpLog.error(tmp_str)
+                                dump_str += tmp_str
+                                dump_str += "\n"
+                                is_fatal = True
+                                is_OK = False
+                    else:
+                        dump_str = "{} is not supported to describe the workflow"
+                        tmpLog.error(dump_str)
+                        is_fatal = True
+                        is_OK = False
+                    # convert to workflow
+                    if is_OK:
+                        (
+                            workflow_to_submit,
+                            dump_str_list,
+                        ) = workflow_utils.convert_nodes_to_workflow(nodes, workflow_name=workflow_name)
+                        try:
+                            if workflow_to_submit:
+                                if not test_mode:
+                                    tmpLog.info("submit workflow")
+                                    wm = ClientManager(host=get_rest_host())
+                                    request_id = wm.submit(workflow_to_submit, username=user_name, use_dataset_name=False)
+                                    try:
+                                        request_id = int(request_id)
+                                    except Exception:
+                                        # wrong request_id
+                                        is_fatal = True
+                                        is_OK = False
+                            else:
+                                dump_str = "workflow is empty"
+                                tmpLog.error(dump_str)
+                                is_fatal = True
+                                is_OK = False
+                        except Exception as e:
+                            dump_str = f"failed to submit the workflow with {str(e)}"
+                            tmpLog.error(f"{dump_str} {traceback.format_exc()}")
+                        if dump_workflow:
+                            tmpLog.debug("\n" + "".join(dump_str_list))
+        os.chdir(cur_dir)
+    except Exception as e:
+        is_OK = False
+        is_fatal = True
+        tmpLog.error(f"failed to run with {str(e)} {traceback.format_exc()}")
+
+    with tempfile.NamedTemporaryFile(delete=False, mode="w") as tmp_json:
+        json.dump([is_OK, is_fatal, request_id, tmpLog.dumpToString()], tmp_json)
+        print(tmp_json.name)
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    core_exec(*sys.argv[1:])

pandaserver/taskbuffer/wrapped_oracle_conn.py

@@ -0,0 +1,18 @@
+# wrapper for Oracle Connection
+class WrappedOracleConn(object):
+    def __init__(self, conn):
+        self.orig_conn = conn
+
+    def __getattribute__(self, item):
+        try:
+            return object.__getattribute__(self.orig_conn, item)
+        except Exception:
+            pass
+        return object.__getattribute__(self, item)
+
+    # override context manager protocol not to close connection
+    def __enter__(self):
+        return self.orig_conn.__enter__()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.orig_conn.commit()

pandaserver/test/SchemaChecker.py

@@ -0,0 +1,40 @@
+"""
+Checking DB schema version for PanDA Server.
+If there is an issue and the pandaEmailNotification var is
+defined in panda_config, it will send an email notification.
+"""
+
+from packaging import version
+
+from pandaserver.config import panda_config
+from pandaserver.srvcore.MailUtils import MailUtils
+from pandaserver.taskbuffer import PandaDBSchemaInfo
+from pandaserver.taskbuffer.OraDBProxy import DBProxy
+
+proxyS = DBProxy()
+proxyS.connect(panda_config.dbhost, panda_config.dbpasswd, panda_config.dbuser, panda_config.dbname)
+
+sql = "select major || '.' || minor || '.' || patch from ATLAS_PANDA.pandadb_version where component = 'PanDA'"
+
+res = proxyS.querySQL(sql)
+dbVersion = res[0][0]
+
+serverDBVersion = PandaDBSchemaInfo.PandaDBSchemaInfo().method()
+
+if version.parse(dbVersion) >= version.parse(serverDBVersion):
+    print("DB schema check: OK")
+else:
+    message_body = (
+        f"There is an issue with {panda_config.pserveralias}. "
+        f"PanDA DB schema installed is {dbVersion} while PanDA Server requires "
+        f"version {serverDBVersion} to be installed. Please check the official docs "
+        f"for instructions on how to upgrade the schema."
+    )
+    print(message_body)
+
+    if "pandaEmailNotification" in panda_config.__dict__:
+        MailUtils().send(
+            panda_config.pandaEmailNotification,
+            f"PanDA DB Version installed is not correct for {panda_config.pserveralias}",
+            message_body,
+        )

pandaserver/test/banUser.py

@@ -0,0 +1,43 @@
+import optparse
+import sys
+
+# password
+from pandaserver.config import panda_config
+from pandaserver.taskbuffer.OraDBProxy import DBProxy
+
+option_parser = optparse.OptionParser(conflict_handler="resolve")
+option_parser.add_option("--user", action="store", dest="user", default=None, help="prodUserName")
+option_parser.add_option(
+    "--unban",
+    action="store_const",
+    const=True,
+    dest="unban",
+    default=False,
+    help="unban the user",
+)
+
+options, args = option_parser.parse_args()
+
+if options.user is None:
+    print("--user=<prodUserName> is required")
+    sys.exit(1)
+
+proxyS = DBProxy()
+proxyS.connect(panda_config.dbhost, panda_config.dbpasswd, panda_config.dbuser, panda_config.dbname)
+
+prodUserName = sys.argv[1]
+
+varMap = {}
+varMap[":name"] = options.user
+if options.unban:
+    varMap[":status"] = None
+else:
+    varMap[":status"] = "disabled"
+
+sql = "UPDATE ATLAS_PANDAMETA.users SET status=:status WHERE name=:name"
+
+status, res = proxyS.querySQLS(sql, varMap)
+if res is None:
+    print("Failed with database error")
+else:
+    print(f"{res} rows updated")

pandaserver/test/boostPrio.py

@@ -0,0 +1,19 @@
+import sys
+
+# password
+from pandaserver.config import panda_config
+from pandaserver.taskbuffer.OraDBProxy import DBProxy
+
+proxyS = DBProxy()
+proxyS.connect(panda_config.dbhost, panda_config.dbpasswd, panda_config.dbuser, panda_config.dbname)
+
+varMap = {}
+varMap[":prodSourceLabel"] = "managed"
+varMap[":taskID"] = sys.argv[1]
+varMap[":prio"] = sys.argv[2]
+sql = "UPDATE %s SET currentPriority=currentPriority+:prio WHERE prodSourceLabel=:prodSourceLabel AND taskID=:taskID"
+for table in [
+    "ATLAS_PANDA.jobsActive4",
+    "ATLAS_PANDA.jobsDefined4",
+]:
+    status, res = proxyS.querySQLS(sql % table, varMap)