DIRAC 9.0.0a42__py3-none-any.whl → 9.0.7__py3-none-any.whl

DIRAC/WorkloadManagementSystem/DB/JobDB.py

@@ -11,8 +11,11 @@ The following options can be set in ``Systems/WorkloadManagement/Databases/JobDB
 * *CompressJDLs*:        Enable compression of JDLs when they are stored in the database, default *False*.
 
 """
+from __future__ import annotations
+
 import datetime
 import operator
+from typing import overload
 
 from DIRAC.ConfigurationSystem.Client.Helpers.Registry import getVOForGroup
 from DIRAC.ConfigurationSystem.Client.Helpers.Resources import getSiteTier
@@ -20,7 +23,14 @@ from DIRAC.Core.Base.DB import DB
 from DIRAC.Core.Utilities.ClassAd.ClassAdLight import ClassAd
 from DIRAC.Core.Utilities.Decorators import deprecated
 from DIRAC.Core.Utilities.DErrno import EWMSJMAN, EWMSSUBM, cmpError
-from DIRAC.Core.Utilities.ReturnValues import S_ERROR, S_OK
+from DIRAC.Core.Utilities.ReturnValues import (
+    S_ERROR,
+    S_OK,
+    convertToReturnValue,
+    returnValueOrRaise,
+    SErrorException,
+    DReturnType,
+)
 from DIRAC.FrameworkSystem.Client.Logger import contextLogger
 from DIRAC.ResourceStatusSystem.Client.SiteStatus import SiteStatus
 from DIRAC.WorkloadManagementSystem.Client import JobMinorStatus, JobStatus
@@ -106,18 +116,7 @@ class JobDB(DB):
         Returns a dictionary with the Job Parameters.
         If parameterList is empty - all the parameters are returned.
         """
-
-        if isinstance(jobID, (str, int)):
-            jobID = [jobID]
-
-        jobIDList = []
-        for jID in jobID:
-            ret = self._escapeString(str(jID))
-            if not ret["OK"]:
-                return ret
-            jobIDList.append(ret["Value"])
-
-        # self.log.debug('JobDB.getParameters: Getting Parameters for jobs %s' % ','.join(jobIDList))
+        jobIDList = [jobID] if isinstance(jobID, (str, int)) else jobID
 
         resultDict = {}
         if paramList:
@@ -130,7 +129,7 @@ class JobDB(DB):
                     return ret
                 paramNameList.append(ret["Value"])
             cmd = "SELECT JobID, Name, Value FROM JobParameters WHERE JobID IN ({}) AND Name IN ({})".format(
-                ",".join(jobIDList),
+                ",".join(str(int(j)) for j in jobIDList),
                 ",".join(paramNameList),
             )
             result = self._query(cmd)
@@ -207,13 +206,13 @@ class JobDB(DB):
             return S_ERROR("JobDB.getAtticJobParameters: failed to retrieve parameters")
 
     #############################################################################
+    @convertToReturnValue
     def getJobsAttributes(self, jobIDs, attrList=None):
         """Get all Job(s) Attributes for a given list of jobIDs.
         Return a dictionary with all Job Attributes as value pairs
         """
-
         if not jobIDs:
-            return S_OK({})
+            return {}
 
         # If no list of attributes is given, return all attributes
         if not attrList:
@@ -229,28 +228,29 @@ class JobDB(DB):
 
         attrNameListS = []
         for x in attrList:
-            ret = self._escapeString(x)
-            if not ret["OK"]:
-                return ret
-            x = "`" + ret["Value"][1:-1] + "`"
+            x = "`" + returnValueOrRaise(self._escapeString(x))[1:-1] + "`"
             attrNameListS.append(x)
         attrNames = "JobID," + ",".join(attrNameListS)
 
-        cmd = f"SELECT {attrNames} FROM Jobs WHERE JobID IN ({','.join(str(jobID) for jobID in jobIDs)})"
-        res = self._query(cmd)
-        if not res["OK"]:
-            return res
-        if not res["Value"]:
-            return S_OK({})
+        sqlCmd = "CREATE TEMPORARY TABLE to_select_Jobs (JobID INTEGER NOT NULL, PRIMARY KEY (JobID)) ENGINE=MEMORY;"
+        returnValueOrRaise(self._update(sqlCmd))
+        try:
+            sqlCmd = "INSERT INTO to_select_Jobs (JobID) VALUES ( %s )"
+            returnValueOrRaise(self._updatemany(sqlCmd, [(int(j),) for j in jobIDs]))
+            sqlCmd = f"SELECT {attrNames} FROM Jobs JOIN to_select_Jobs USING (JobID)"
+            result = returnValueOrRaise(self._query(sqlCmd))
+        finally:
+            sqlCmd = "DROP TEMPORARY TABLE to_select_Jobs"
+            returnValueOrRaise(self._update(sqlCmd))
 
         attributes = {}
-        for t_att in res["Value"]:
+        for t_att in result:
             jobID = int(t_att[0])
             attributes.setdefault(jobID, {})
             for tx, ax in zip(t_att[1:], attrList):
                 attributes[jobID].setdefault(ax, tx)
 
-        return S_OK(attributes)
+        return attributes
 
     #############################################################################
     def getJobAttributes(self, jobID, attrList=None):
@@ -330,23 +330,42 @@ class JobDB(DB):
 
     #############################################################################
 
-    def getInputData(self, jobID):
+    @overload
+    def getInputData(self, jobID: int | str) -> DReturnType[list[str]]:
+        ...
+
+    @overload
+    def getInputData(self, jobID: list[int | str]) -> DReturnType[dict[int, list[str]]]:
+        ...
+
+    def getInputData(self, jobID: int | str | list[int | str]) -> DReturnType[list[str] | dict[int, list[str]]]:
         """Get input data for the given job"""
-        ret = self._escapeString(jobID)
-        if not ret["OK"]:
-            return ret
-        jobID = ret["Value"]
-        cmd = f"SELECT LFN FROM InputData WHERE JobID={jobID}"
+        if isinstance(jobID, (int, str)):
+            ret = self._escapeString(jobID)
+            if not ret["OK"]:
+                return ret
+            jobID = ret["Value"]
+            query = f"JobID={jobID}"
+            result = []
+        else:
+            job_ids = {int(i) for i in jobID}
+            query = f"JobID IN ({','.join(map(str, job_ids))})"
+            result = {i: [] for i in job_ids}
+        cmd = f"SELECT JobID, LFN FROM InputData WHERE {query}"
         res = self._query(cmd)
         if not res["OK"]:
             return res
 
-        inputData = [i[0] for i in res["Value"] if i[0].strip()]
-        for index, lfn in enumerate(inputData):
+        for jid, lfn in res["Value"]:
+            lfn = lfn.strip()
             if lfn.lower().startswith("lfn:"):
-                inputData[index] = lfn[4:]
+                lfn = lfn[4:]
+            if isinstance(result, list):
+                result.append(lfn)
+            else:
+                result[jid].append(lfn)
 
-        return S_OK(inputData)
+        return S_OK(result)
 
     #############################################################################
     def setInputData(self, jobID, inputData):
@@ -527,12 +546,10 @@ class JobDB(DB):
         if not isinstance(jobID, (list, tuple)):
             jobIDList = [jobID]
 
-        jIDList = []
-        for jID in jobIDList:
-            ret = self._escapeString(jID)
-            if not ret["OK"]:
-                return ret
-            jIDList.append(ret["Value"])
+        try:
+            jIDList = [int(jID) for jID in jobIDList]
+        except ValueError as e:
+            return S_ERROR(f"JobDB.setAttributes: {e}")
 
         if len(attrNames) != len(attrValues):
             return S_ERROR("JobDB.setAttributes: incompatible Argument length")
@@ -561,7 +578,7 @@ class JobDB(DB):
         if not attr:
             return S_ERROR("JobDB.setAttributes: Nothing to do")
 
-        cmd = f"UPDATE Jobs SET {', '.join(attr)} WHERE JobID in ( {', '.join(jIDList)} )"
+        cmd = f"UPDATE Jobs SET {', '.join(attr)} WHERE JobID in ( {', '.join(str(int(j)) for j in jIDList)} )"
 
         if myDate:
             cmd += f" AND LastUpdateTime < {myDate}"
@@ -987,44 +1004,42 @@ class JobDB(DB):
         return S_OK()
 
     #############################################################################
+    @convertToReturnValue
     def removeJobFromDB(self, jobIDs):
         """
         Remove jobs from the Job DB and clean up all the job related data in various tables
         """
-
-        # ret = self._escapeString(jobID)
-        # if not ret['OK']:
-        #  return ret
-        # e_jobID = ret['Value']
-
         if not jobIDs:
-            return S_OK()
-
-        if not isinstance(jobIDs, list):
-            jobIDList = [jobIDs]
-        else:
-            jobIDList = jobIDs
+            return None
+        jobIDList = jobIDs if isinstance(jobIDs, list) else [jobIDs]
 
         failedTablesList = []
-        for table in [
-            "InputData",
-            "JobParameters",
-            "AtticJobParameters",
-            "HeartBeatLoggingInfo",
-            "OptimizerParameters",
-            "JobCommands",
-            "Jobs",
-            "JobJDLs",
-        ]:
-            cmd = f"DELETE FROM {table} WHERE JobID in ({','.join(str(j) for j in jobIDList)})"
-            result = self._update(cmd)
-            if not result["OK"]:
-                failedTablesList.append(table)
 
-        if failedTablesList:
-            return S_ERROR(f"Errors while job removal (tables {','.join(failedTablesList)})")
+        sqlCmd = "CREATE TEMPORARY TABLE to_delete_Jobs (JobID INT(11) UNSIGNED NOT NULL, PRIMARY KEY (JobID)) ENGINE=MEMORY;"
+        returnValueOrRaise(self._update(sqlCmd))
+        try:
+            sqlCmd = "INSERT INTO to_delete_Jobs (JobID) VALUES ( %s )"
+            returnValueOrRaise(self._updatemany(sqlCmd, [(j,) for j in jobIDList]))
+
+            for table in [
+                "InputData",
+                "JobParameters",
+                "AtticJobParameters",
+                "HeartBeatLoggingInfo",
+                "OptimizerParameters",
+                "JobCommands",
+                "Jobs",
+                "JobJDLs",
+            ]:
+                sqlCmd = f"DELETE m from `{table}` m JOIN to_delete_Jobs t USING (JobID)"
+                if not self._update(sqlCmd)["OK"]:
+                    failedTablesList.append(table)
+        finally:
+            sqlCmd = "DROP TEMPORARY TABLE to_delete_Jobs"
+            returnValueOrRaise(self._update(sqlCmd))
 
-        return S_OK()
+        if failedTablesList:
+            raise SErrorException(f"Errors while job removal (tables {','.join(failedTablesList)})")
 
     #############################################################################
     def rescheduleJob(self, jobID):
@@ -1175,64 +1190,6 @@ class JobDB(DB):
 
         return retVal
 
-    #############################################################################
-    def getSiteSummary(self):
-        """Get the summary of jobs in a given status on all the sites"""
-
-        waitingList = ['"Submitted"', '"Assigned"', '"Waiting"', '"Matched"']
-        waitingString = ",".join(waitingList)
-
-        result = self.getDistinctJobAttributes("Site")
-        if not result["OK"]:
-            return result
-
-        siteList = result["Value"]
-        siteDict = {}
-        totalDict = {
-            JobStatus.WAITING: 0,
-            JobStatus.RUNNING: 0,
-            JobStatus.STALLED: 0,
-            JobStatus.DONE: 0,
-            JobStatus.FAILED: 0,
-        }
-
-        for site in siteList:
-            if site == "ANY":
-                continue
-            # Waiting
-            siteDict[site] = {}
-            ret = self._escapeString(site)
-            if not ret["OK"]:
-                return ret
-            e_site = ret["Value"]
-
-            req = f"SELECT COUNT(JobID) FROM Jobs WHERE Status IN ({waitingString}) AND Site={e_site}"
-            result = self._query(req)
-            if result["OK"]:
-                count = result["Value"][0][0]
-            else:
-                return S_ERROR("Failed to get Site data from the JobDB")
-            siteDict[site][JobStatus.WAITING] = count
-            totalDict[JobStatus.WAITING] += count
-            # Running,Stalled,Done,Failed
-            for status in [
-                f'"{JobStatus.RUNNING}"',
-                f'"{JobStatus.STALLED}"',
-                f'"{JobStatus.DONE}"',
-                f'"{JobStatus.FAILED}"',
-            ]:
-                req = f"SELECT COUNT(JobID) FROM Jobs WHERE Status={status} AND Site={e_site}"
-                result = self._query(req)
-                if result["OK"]:
-                    count = result["Value"][0][0]
-                else:
-                    return S_ERROR("Failed to get Site data from the JobDB")
-                siteDict[site][status.replace('"', "")] = count
-                totalDict[status.replace('"', "")] += count
-
-        siteDict["Total"] = totalDict
-        return S_OK(siteDict)
-
     #################################################################################
     def getSiteSummaryWeb(self, selectDict, sortList, startItem, maxItems):
         """Get the summary of jobs in a given status on all the sites in the standard Web form"""

DIRAC/WorkloadManagementSystem/DB/JobDB.sql

@@ -28,7 +28,7 @@ CREATE TABLE `JobJDLs` (
   `JobRequirements` TEXT NOT NULL,
   `OriginalJDL` MEDIUMTEXT NOT NULL,
   PRIMARY KEY (`JobID`)
-) ENGINE=InnoDB DEFAULT CHARSET=latin1;
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
 
 -- ------------------------------------------------------------------------------
 DROP TABLE IF EXISTS `Jobs`;
@@ -66,7 +66,7 @@ CREATE TABLE `Jobs` (
   KEY `ApplicationStatus` (`ApplicationStatus`),
   KEY `StatusSite` (`Status`,`Site`),
   KEY `LastUpdateTime` (`LastUpdateTime`)
-) ENGINE=InnoDB DEFAULT CHARSET=latin1;
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
 
 -- ------------------------------------------------------------------------------
 DROP TABLE IF EXISTS `InputData`;
@@ -76,7 +76,7 @@ CREATE TABLE `InputData` (
   `Status` VARCHAR(32) NOT NULL DEFAULT 'AprioriGood',
   PRIMARY KEY (`JobID`,`LFN`),
   FOREIGN KEY (`JobID`) REFERENCES `Jobs`(`JobID`)
-) ENGINE=InnoDB DEFAULT CHARSET=latin1;
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
 
 -- ------------------------------------------------------------------------------
 DROP TABLE IF EXISTS `JobParameters`;
@@ -86,7 +86,7 @@ CREATE TABLE `JobParameters` (
   `Value` TEXT NOT NULL,
   PRIMARY KEY (`JobID`,`Name`),
   FOREIGN KEY (`JobID`) REFERENCES `Jobs`(`JobID`)
-) ENGINE=InnoDB DEFAULT CHARSET=latin1;
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
 
 -- ------------------------------------------------------------------------------
 DROP TABLE IF EXISTS `OptimizerParameters`;
@@ -96,7 +96,7 @@ CREATE TABLE `OptimizerParameters` (
   `Value` MEDIUMTEXT NOT NULL,
   PRIMARY KEY (`JobID`,`Name`),
   FOREIGN KEY (`JobID`) REFERENCES `Jobs`(`JobID`)
-) ENGINE=InnoDB DEFAULT CHARSET=latin1;
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
 
 -- ------------------------------------------------------------------------------
 DROP TABLE IF EXISTS `AtticJobParameters`;
@@ -107,7 +107,7 @@ CREATE TABLE `AtticJobParameters` (
   `RescheduleCycle` INT(11) UNSIGNED NOT NULL,
   PRIMARY KEY (`JobID`,`Name`,`RescheduleCycle`),
   FOREIGN KEY (`JobID`) REFERENCES `Jobs`(`JobID`)
-) ENGINE=InnoDB DEFAULT CHARSET=latin1;
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
 
 -- ------------------------------------------------------------------------------
 DROP TABLE IF EXISTS `HeartBeatLoggingInfo`;
@@ -118,7 +118,7 @@ CREATE TABLE `HeartBeatLoggingInfo` (
   `HeartBeatTime` DATETIME NOT NULL,
   PRIMARY KEY (`JobID`,`Name`,`HeartBeatTime`),
   FOREIGN KEY (`JobID`) REFERENCES `Jobs`(`JobID`)
-) ENGINE=InnoDB DEFAULT CHARSET=latin1;
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
 
 -- ------------------------------------------------------------------------------
 DROP TABLE IF EXISTS `JobCommands`;
@@ -131,4 +131,4 @@ CREATE TABLE `JobCommands` (
   `ExecutionTime` DATETIME DEFAULT NULL,
   PRIMARY KEY (`JobID`,`Arguments`,`ReceptionTime`),
   FOREIGN KEY (`JobID`) REFERENCES `Jobs`(`JobID`)
-) ENGINE=InnoDB DEFAULT CHARSET=latin1;
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

DIRAC/WorkloadManagementSystem/DB/JobDBUtils.py

@@ -1,162 +1,33 @@
 from __future__ import annotations
 
-import base64
-import zlib
+# Import stateless functions from DIRACCommon for backward compatibility
+from DIRACCommon.WorkloadManagementSystem.DB.JobDBUtils import *
 
 from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
-from DIRAC.Core.Utilities.DErrno import EWMSSUBM
 from DIRAC.Core.Utilities.ObjectLoader import ObjectLoader
-from DIRAC.Core.Utilities.ReturnValues import S_ERROR, S_OK, returnValueOrRaise
-from DIRAC.WorkloadManagementSystem.Client import JobStatus
-from DIRAC.WorkloadManagementSystem.Client.JobState.JobManifest import JobManifest
+from DIRAC.Core.Utilities.ReturnValues import returnValueOrRaise
+from DIRAC.WorkloadManagementSystem.Client.JobState.JobManifest import makeJobManifestConfig
 
 getDIRACPlatform = returnValueOrRaise(
     ObjectLoader().loadObject("ConfigurationSystem.Client.Helpers.Resources", "getDIRACPlatform")
 )
 
 
-def compressJDL(jdl):
-    """Return compressed JDL string."""
-    return base64.b64encode(zlib.compress(jdl.encode(), -1)).decode()
+def checkAndPrepareJob(
+    jobID, classAdJob, classAdReq, owner, ownerGroup, jobAttrs, vo
+):  # pylint: disable=function-redefined
+    from DIRACCommon.WorkloadManagementSystem.DB.JobDBUtils import checkAndPrepareJob
 
+    config = {
+        "inputDataPolicyForVO": Operations(vo=vo).getValue("InputDataPolicy/InputDataModule"),
+        "softwareDistModuleForVO": Operations(vo=vo).getValue("SoftwareDistModule"),
+        "defaultCPUTimeForOwnerGroup": Operations(group=ownerGroup).getValue("JobDescription/DefaultCPUTime", 86400),
+        "getDIRACPlatform": getDIRACPlatform,
+    }
+    return checkAndPrepareJob(jobID, classAdJob, classAdReq, owner, ownerGroup, jobAttrs, vo, config=config)
 
-def extractJDL(compressedJDL):
-    """Return decompressed JDL string."""
-    # the starting bracket is guaranteeed by JobManager.submitJob
-    # we need the check to be backward compatible
-    if isinstance(compressedJDL, bytes):
-        if compressedJDL.startswith(b"["):
-            return compressedJDL.decode()
-    else:
-        if compressedJDL.startswith("["):
-            return compressedJDL
-    return zlib.decompress(base64.b64decode(compressedJDL)).decode()
 
+def checkAndAddOwner(jdl: str, owner: str, ownerGroup: str):  # pylint: disable=function-redefined
+    from DIRACCommon.WorkloadManagementSystem.DB.JobDBUtils import checkAndAddOwner
 
-def checkAndAddOwner(jdl: str, owner: str, ownerGroup: str) -> JobManifest:
-    jobManifest = JobManifest()
-    res = jobManifest.load(jdl)
-    if not res["OK"]:
-        return res
-
-    jobManifest.setOptionsFromDict({"Owner": owner, "OwnerGroup": ownerGroup})
-    res = jobManifest.check()
-    if not res["OK"]:
-        return res
-
-    return S_OK(jobManifest)
-
-
-def fixJDL(jdl: str) -> str:
-    # 1.- insert original JDL on DB and get new JobID
-    # Fix the possible lack of the brackets in the JDL
-    if jdl.strip()[0].find("[") != 0:
-        jdl = "[" + jdl + "]"
-    return jdl
-
-
-def checkAndPrepareJob(jobID, classAdJob, classAdReq, owner, ownerGroup, jobAttrs, vo):
-    error = ""
-
-    jdlOwner = classAdJob.getAttributeString("Owner")
-    jdlOwnerGroup = classAdJob.getAttributeString("OwnerGroup")
-    jdlVO = classAdJob.getAttributeString("VirtualOrganization")
-
-    # The below is commented out since this is always overwritten by the submitter IDs
-    # but the check allows to findout inconsistent client environments
-    if jdlOwner and jdlOwner != owner:
-        error = "Wrong Owner in JDL"
-    elif jdlOwnerGroup and jdlOwnerGroup != ownerGroup:
-        error = "Wrong Owner Group in JDL"
-    elif jdlVO and jdlVO != vo:
-        error = "Wrong Virtual Organization in JDL"
-
-    classAdJob.insertAttributeString("Owner", owner)
-    classAdJob.insertAttributeString("OwnerGroup", ownerGroup)
-
-    if vo:
-        classAdJob.insertAttributeString("VirtualOrganization", vo)
-
-    classAdReq.insertAttributeString("Owner", owner)
-    classAdReq.insertAttributeString("OwnerGroup", ownerGroup)
-    if vo:
-        classAdReq.insertAttributeString("VirtualOrganization", vo)
-
-    inputDataPolicy = Operations(vo=vo).getValue("InputDataPolicy/InputDataModule")
-    if inputDataPolicy and not classAdJob.lookupAttribute("InputDataModule"):
-        classAdJob.insertAttributeString("InputDataModule", inputDataPolicy)
-
-    softwareDistModule = Operations(vo=vo).getValue("SoftwareDistModule")
-    if softwareDistModule and not classAdJob.lookupAttribute("SoftwareDistModule"):
-        classAdJob.insertAttributeString("SoftwareDistModule", softwareDistModule)
-
-    # priority
-    priority = classAdJob.getAttributeInt("Priority")
-    if priority is None:
-        priority = 0
-    classAdReq.insertAttributeInt("UserPriority", priority)
-
-    # CPU time
-    cpuTime = classAdJob.getAttributeInt("CPUTime")
-    if cpuTime is None:
-        opsHelper = Operations(group=ownerGroup)
-        cpuTime = opsHelper.getValue("JobDescription/DefaultCPUTime", 86400)
-    classAdReq.insertAttributeInt("CPUTime", cpuTime)
-
-    # platform(s)
-    platformList = classAdJob.getListFromExpression("Platform")
-    if platformList:
-        result = getDIRACPlatform(platformList)
-        if not result["OK"]:
-            return result
-        if result["Value"]:
-            classAdReq.insertAttributeVectorString("Platforms", result["Value"])
-        else:
-            error = "OS compatibility info not found"
-    if error:
-        retVal = S_ERROR(EWMSSUBM, error)
-        retVal["JobId"] = jobID
-        retVal["Status"] = JobStatus.FAILED
-        retVal["MinorStatus"] = error
-
-        jobAttrs["Status"] = JobStatus.FAILED
-
-        jobAttrs["MinorStatus"] = error
-        return retVal
-    return S_OK()
-
-
-def createJDLWithInitialStatus(
-    classAdJob, classAdReq, jdl2DBParameters, jobAttrs, initialStatus, initialMinorStatus, *, modern=False
-):
-    """
-    :param modern: if True, store boolean instead of string for VerifiedFlag (used by diracx only)
-    """
-    priority = classAdJob.getAttributeInt("Priority")
-    if priority is None:
-        priority = 0
-    jobAttrs["UserPriority"] = priority
-
-    for jdlName in jdl2DBParameters:
-        # Defaults are set by the DB.
-        jdlValue = classAdJob.getAttributeString(jdlName)
-        if jdlValue:
-            jobAttrs[jdlName] = jdlValue
-
-    jdlValue = classAdJob.getAttributeString("Site")
-    if jdlValue:
-        if jdlValue.find(",") != -1:
-            jobAttrs["Site"] = "Multiple"
-        else:
-            jobAttrs["Site"] = jdlValue
-
-    jobAttrs["VerifiedFlag"] = True if modern else "True"
-
-    jobAttrs["Status"] = initialStatus
-
-    jobAttrs["MinorStatus"] = initialMinorStatus
-
-    reqJDL = classAdReq.asJDL()
-    classAdJob.insertAttributeInt("JobRequirements", reqJDL)
-
-    return classAdJob.asJDL()
+    return checkAndAddOwner(jdl, owner, ownerGroup, job_manifest_config=makeJobManifestConfig(ownerGroup))

DIRAC/WorkloadManagementSystem/DB/JobLoggingDB.py

@@ -11,6 +11,7 @@ import datetime
 from DIRAC import S_ERROR, S_OK
 from DIRAC.Core.Base.DB import DB
 from DIRAC.Core.Utilities import TimeUtilities
+from DIRAC.Core.Utilities.ReturnValues import returnValueOrRaise, convertToReturnValue
 from DIRAC.FrameworkSystem.Client.Logger import contextLogger
 
 MAGIC_EPOC_NUMBER = 1270000000
@@ -145,21 +146,33 @@ class JobLoggingDB(DB):
         return S_OK(return_value)
 
     #############################################################################
+    @convertToReturnValue
     def deleteJob(self, jobID):
         """Delete logging records for given jobs"""
         if not jobID:
-            return S_OK()
+            return None
 
-        # Make sure that we have a list of strings of jobIDs
         if isinstance(jobID, int):
-            jobList = [str(jobID)]
+            jobList = [jobID]
         elif isinstance(jobID, str):
             jobList = jobID.replace(" ", "").split(",")
         else:
-            jobList = list(str(j) for j in jobID)
+            jobList = jobID
 
-        req = f"DELETE FROM LoggingInfo WHERE JobID IN ({','.join(jobList)})"
-        return self._update(req)
+        sqlCmd = (
+            "CREATE TEMPORARY TABLE to_delete_LoggingInfo (JobID INTEGER NOT NULL, PRIMARY KEY (JobID)) ENGINE=MEMORY;"
+        )
+        returnValueOrRaise(self._update(sqlCmd))
+        try:
+            sqlCmd = "INSERT INTO to_delete_LoggingInfo (JobID) VALUES ( %s )"
+            returnValueOrRaise(self._updatemany(sqlCmd, [(j,) for j in jobList]))
+            sqlCmd = "DELETE l from `LoggingInfo` l JOIN to_delete_LoggingInfo t USING (JobID)"
+            result = returnValueOrRaise(self._update(sqlCmd))
+        finally:
+            sqlCmd = "DROP TEMPORARY TABLE to_delete_LoggingInfo"
+            returnValueOrRaise(self._update(sqlCmd))
+
+        return result
 
     #############################################################################
     def getWMSTimeStamps(self, jobID):

DIRAC/WorkloadManagementSystem/DB/JobParametersDB.py

@@ -1,10 +1,10 @@
-""" Module containing a front-end to the OpenSearch-based JobParametersDB.
-    This is a drop-in replacement for MySQL-based table JobDB.JobParameters.
+"""Module containing a front-end to the OpenSearch-based JobParametersDB.
+This is a drop-in replacement for MySQL-based table JobDB.JobParameters.
 
-    The following class methods are provided for public usage
-      - getJobParameters()
-      - setJobParameter()
-      - deleteJobParameters()
+The following class methods are provided for public usage
+  - getJobParameters()
+  - setJobParameter()
+  - deleteJobParameters()
 """
 
 from DIRAC import S_ERROR, S_OK
@@ -37,11 +37,11 @@ class JobParametersDB(ElasticDB):
     def __init__(self, parentLogger=None):
         """Standard Constructor"""
 
-        self.fullname = "WorkloadManagement/ElasticJobParametersDB"
+        self.fullname = "WorkloadManagement/JobParametersDB"
         self.index_name = self.getCSOption("index_name", "job_parameters")
 
         try:
-            # Connecting to the ES cluster
+            # Connecting to the OpenSearch cluster
             super().__init__(self.fullname, self.index_name, parentLogger=parentLogger)
         except Exception:
             RuntimeError("Can't connect to JobParameters index")
@@ -69,7 +69,7 @@ class JobParametersDB(ElasticDB):
                 raise RuntimeError(result["Message"])
             self.log.always("Index created:", indexName)
 
-    def getJobParameters(self, jobIDs: int | list[int], vo: str, paramList=None) -> dict:
+    def getJobParameters(self, jobIDs: int | list[int], vo: str, paramList: list[str] | None = None) -> dict:
         """Get Job Parameters defined for jobID.
           Returns a dictionary with the Job Parameters.
           If paramList is empty - all the parameters are returned.