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

DIRAC/DataManagementSystem/Client/FTS3Job.py

@@ -1,9 +1,11 @@
-""" FTS3Job module containing only the FTS3Job class """
+"""FTS3Job module containing only the FTS3Job class"""
 
 import datetime
 import errno
+import os
 from packaging.version import Version
 
+from cachetools import cachedmethod, LRUCache
 
 # Requires at least version 3.3.3
 from fts3 import __version__ as fts3_version
@@ -26,8 +28,9 @@ from DIRAC.Resources.Storage.StorageElement import StorageElement
 
 from DIRAC.FrameworkSystem.Client.Logger import gLogger
 from DIRAC.FrameworkSystem.Client.TokenManagerClient import gTokenManager
+from DIRAC.FrameworkSystem.Utilities.TokenManagementUtilities import getIdProviderClient
 
-from DIRAC.Core.Utilities.ReturnValues import S_OK, S_ERROR
+from DIRAC.Core.Utilities.ReturnValues import S_OK, S_ERROR, returnValueOrRaise
 from DIRAC.Core.Utilities.DErrno import cmpError
 
 from DIRAC.Core.Utilities.JEncode import JSerializable
@@ -36,6 +39,10 @@ from DIRAC.DataManagementSystem.Client.FTS3File import FTS3File
 # 3 days in seconds
 BRING_ONLINE_TIMEOUT = 259200
 
+# Number of IdP to keep in cache. Should correspond roughly
+# to the number of groups performing transfers
+IDP_CACHE_SIZE = 8
+
 
 class FTS3Job(JSerializable):
     """Abstract class to represent a job to be executed by FTS. It belongs
@@ -78,6 +85,8 @@ class FTS3Job(JSerializable):
         "userGroup",
     ]
 
+    _idp_cache = LRUCache(maxsize=IDP_CACHE_SIZE)
+
     def __init__(self):
         self.submitTime = None
         self.lastUpdate = None
@@ -111,7 +120,12 @@ class FTS3Job(JSerializable):
         # temporary used only for accounting
         # it is set by the monitor method
         # when a job is in a final state
-        self.accountingDict = None
+        self.accountingDicts = None
+
+    @classmethod
+    @cachedmethod(lambda cls: cls._idp_cache)
+    def _getIdpClient(cls, group_name: str):
+        return returnValueOrRaise(getIdProviderClient(group_name, None, client_name_prefix="fts"))
 
     def monitor(self, context=None, ftsServer=None, ucert=None):
         """Queries the fts server to monitor the job.
@@ -143,7 +157,6 @@ class FTS3Job(JSerializable):
 
         if not self.ftsGUID:
             return S_ERROR("FTSGUID not set, FTS job not submitted?")
-
         if not context:
             if not ftsServer:
                 ftsServer = self.ftsServer
@@ -170,13 +183,14 @@ class FTS3Job(JSerializable):
             self.error = jobStatusDict["reason"]
 
         if newStatus in self.FINAL_STATES:
-            self._fillAccountingDict(jobStatusDict)
+            self._fillAccountingDicts(jobStatusDict)
 
         filesInfoList = jobStatusDict["files"]
         filesStatus = {}
         statusSummary = {}
 
         # Make a copy, since we are potentially
+
         # deleting objects
         for fileDict in list(filesInfoList):
             file_state = fileDict["file_state"].capitalize()
@@ -231,7 +245,7 @@ class FTS3Job(JSerializable):
         # so we put this back into the monitoring data such that the accounting is done properly
         jobStatusDict["files"] = filesInfoList
         if newStatus in self.FINAL_STATES:
-            self._fillAccountingDict(jobStatusDict)
+            self._fillAccountingDicts(jobStatusDict)
 
         total = len(filesInfoList)
         completed = sum(statusSummary.get(state, 0) for state in FTS3File.FTS_FINAL_STATES)
@@ -509,11 +523,10 @@ class FTS3Job(JSerializable):
                     if not res["OK"]:
                         return res
                     srcTokenPath = res["Value"]
-                    res = gTokenManager.getToken(
-                        userGroup=self.userGroup,
-                        requiredTimeLeft=3600,
+                    res = self._getIdpClient(self.userGroup).fetchToken(
+                        grant_type="client_credentials",
                         scope=[f"storage.read:/{srcTokenPath}", "offline_access"],
-                        useCache=False,
+                        # TODO: add a specific audience
                     )
                     if not res["OK"]:
                         return res
@@ -528,11 +541,17 @@ class FTS3Job(JSerializable):
                     if not res["OK"]:
                         return res
                     dstTokenPath = res["Value"]
-                    res = gTokenManager.getToken(
-                        userGroup=self.userGroup,
-                        requiredTimeLeft=3600,
-                        scope=[f"storage.modify:/{dstTokenPath}", f"storage.read:/{dstTokenPath}", "offline_access"],
-                        useCache=False,
+                    res = self._getIdpClient(self.userGroup).fetchToken(
+                        grant_type="client_credentials",
+                        scope=[
+                            f"storage.modify:/{dstTokenPath}",
+                            f"storage.read:/{dstTokenPath}",
+                            # Needed because CNAF
+                            # https://ggus.eu/index.php?mode=ticket_info&ticket_id=165048
+                            f"storage.read:/{os.path.dirname(dstTokenPath)}",
+                            "offline_access",
+                        ],
+                        # TODO: add a specific audience
                     )
                     if not res["OK"]:
                         return res
@@ -728,6 +747,7 @@ class FTS3Job(JSerializable):
             retry=3,
             metadata=job_metadata,
             priority=self.priority,
+            unmanaged_tokens=True,
             **dest_spacetoken,
         )
 
@@ -882,9 +902,9 @@ class FTS3Job(JSerializable):
             gLogger.exception("Error generating context", repr(e))
             return S_ERROR(repr(e))
 
-    def _fillAccountingDict(self, jobStatusDict):
-        """This methods generates the necessary information to create a DataOperation
-        accounting record, and stores them as a instance attribute.
+    def _fillAccountingDicts(self, jobStatusDict):
+        """This methods generates the necessary information to create DataOperation
+        accounting records, and stores them as a instance attribute.
 
         For it to be relevant, it should be called only when the job is in a final state.
 
@@ -893,6 +913,7 @@ class FTS3Job(JSerializable):
         :returns: None
         """
 
+        accountingDicts = []
         accountingDict = dict()
         sourceSE = None
         targetSE = None
@@ -903,16 +924,24 @@ class FTS3Job(JSerializable):
         accountingDict["Protocol"] = "FTS3"
         accountingDict["ExecutionSite"] = self.ftsServer
 
+        # Registration values must be set anyway
+        accountingDict["RegistrationTime"] = 0.0
+        accountingDict["RegistrationOK"] = 0
+        accountingDict["RegistrationTotal"] = 0
+
         # We cannot rely on all the transient attributes (like self.filesToSubmit)
         # because it is probably not filed by the time we monitor !
 
         filesInfoList = jobStatusDict["files"]
         successfulFiles = []
+        failedFiles = []
 
         for fileDict in filesInfoList:
             file_state = fileDict["file_state"].capitalize()
             if file_state in FTS3File.FTS_SUCCESS_STATES:
                 successfulFiles.append(fileDict)
+            else:
+                failedFiles.append(fileDict)
 
         job_metadata = jobStatusDict["job_metadata"]
         # previous version of the code did not have dictionary as
@@ -921,23 +950,31 @@ class FTS3Job(JSerializable):
             sourceSE = job_metadata.get("sourceSE")
             targetSE = job_metadata.get("targetSE")
 
-        accountingDict["TransferOK"] = len(successfulFiles)
-        accountingDict["TransferTotal"] = len(filesInfoList)
-        # We need this if in the list comprehension because staging only jobs have `None` as filesize
-        accountingDict["TransferSize"] = sum(
-            fileDict["filesize"] for fileDict in successfulFiles if fileDict["filesize"]
-        )
-        accountingDict["FinalStatus"] = self.status
         accountingDict["Source"] = sourceSE
         accountingDict["Destination"] = targetSE
-        # We need this if in the list comprehension because staging only jobs have `None` as tx_duration
-        accountingDict["TransferTime"] = sum(
-            int(fileDict["tx_duration"]) for fileDict in successfulFiles if fileDict["tx_duration"]
-        )
 
-        # Registration values must be set anyway
-        accountingDict["RegistrationTime"] = 0.0
-        accountingDict["RegistrationOK"] = 0
-        accountingDict["RegistrationTotal"] = 0
+        if successfulFiles:
+            successfulDict = accountingDict.copy()
+            successfulDict["TransferOK"] = len(successfulFiles)
+            successfulDict["TransferTotal"] = len(successfulFiles)
+            # We need this if in the list comprehension because staging only jobs have `None` as filesize
+            successfulDict["TransferSize"] = sum(
+                fileDict["filesize"] for fileDict in successfulFiles if fileDict["filesize"]
+            )
+            successfulDict["FinalStatus"] = "Finished"
 
-        self.accountingDict = accountingDict
+            # We need this if in the list comprehension because staging only jobs have `None` as tx_duration
+            successfulDict["TransferTime"] = sum(
+                int(fileDict["tx_duration"]) for fileDict in successfulFiles if fileDict["tx_duration"]
+            )
+            accountingDicts.append(successfulDict)
+        if failedFiles:
+            failedDict = accountingDict.copy()
+            failedDict["TransferOK"] = 0
+            failedDict["TransferTotal"] = len(failedFiles)
+            failedDict["TransferSize"] = 0
+            failedDict["FinalStatus"] = "Failed"
+            failedDict["TransferTime"] = 0
+            accountingDicts.append(failedDict)
+
+        self.accountingDicts = accountingDicts

DIRAC/DataManagementSystem/DB/FTS3DB.py

@@ -16,6 +16,7 @@ from sqlalchemy import (
     Enum,
     Float,
     ForeignKey,
+    Index,
     Integer,
     MetaData,
     SmallInteger,
@@ -85,6 +86,7 @@ fts3JobTable = Table(
     Column("error", String(2048)),
     Column("status", Enum(*FTS3Job.ALL_STATES), server_default=FTS3Job.INIT_STATE, index=True),
     Column("assignment", String(255), server_default=None),
+    Index("idx_jobs_lastupdate_assignment", "lastUpdate", "assignment"),
     mysql_engine="InnoDB",
 )
 
@@ -110,6 +112,7 @@ fts3OperationTable = Table(
     Column("error", String(1024)),
     Column("type", String(255)),
     Column("assignment", String(255), server_default=None),
+    Index("idx_operations_lastupdate_assignment", "lastUpdate", "assignment"),
     mysql_engine="InnoDB",
 )
 

DIRAC/DataManagementSystem/DB/FileCatalogComponents/DatasetManager/DatasetManager.py

@@ -12,7 +12,7 @@ class DatasetManager:
     _tables["FC_MetaDatasets"] = {
         "Fields": {
             "DatasetID": "INT AUTO_INCREMENT",
-            "DatasetName": "VARCHAR(128) CHARACTER SET utfmb4 COLLATE utf8mb4_bin NOT NULL",
+            "DatasetName": "VARCHAR(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL",
             "MetaQuery": "VARCHAR(512)",
             "DirID": "INT NOT NULL DEFAULT 0",
             "TotalSize": "BIGINT UNSIGNED NOT NULL",

DIRAC/DataManagementSystem/Utilities/DMSHelpers.py

@@ -1,7 +1,8 @@
 """
-  This module contains helper methods for accessing operational attributes or parameters of DMS objects
+This module contains helper methods for accessing operational attributes or parameters of DMS objects
 
 """
+
 from collections import defaultdict
 from DIRAC import gConfig, gLogger, S_OK, S_ERROR
 from DIRAC.ConfigurationSystem.Client.Helpers.Path import cfgPath
@@ -17,6 +18,9 @@ sLog = gLogger.getSubLogger(__name__)
 def resolveSEGroup(seGroupList, allSEs=None):
     """
     Resolves recursively a (list of) SEs that can be groupSEs
+    For modules, JobWrapper or whatever runs at a given site,
+    prefer using :py:func:`~DIRAC.DataManagementSystem.Utilities.ResolveSE.getDestinationSEList`
+
 
     :param seGroupList: list of SEs to resolve or comma-separated SEs
     :type seGroupList: list or string
@@ -402,7 +406,7 @@ class DMSHelpers:
             return sesAtSite
         foundSEs = set(seList) & set(sesAtSite["Value"])
         if not foundSEs:
-            sLog.warn("No SE found at that site", f"in group {seGroup} at {site}")
+            sLog.verbose("No SE found at that site", f"in group {seGroup} at {site}")
             return S_OK()
         return S_OK(sorted(foundSEs))
 

DIRAC/DataManagementSystem/scripts/dirac_dms_create_moving_request.py

@@ -41,6 +41,7 @@ class CreateMovingRequest:
         self.flags = [
             ("C", "CheckMigration", "Ensure the LFNs are migrated to tape before removing any replicas"),
             ("X", "Execute", "Put Requests, else dryrun"),
+            ("", "SourceOnly", "Only treat files that are already at the Source-SE"),
         ]
         self.registerSwitchesAndParseCommandLine()
         self.getLFNList()
@@ -208,6 +209,7 @@ class CreateMovingRequest:
 
         replicate = Operation()
         replicate.Type = "ReplicateAndRegister"
+        replicate.SourceSE = ",".join(self.switches.get("SourceSE", []))
         replicate.TargetSE = self.switches.get("TargetSE")
         self.addLFNs(replicate, lfnChunk, addPFN=True)
         request.addOperation(replicate)

DIRAC/DataManagementSystem/scripts/dirac_dms_protocol_matrix.py

@@ -177,7 +177,6 @@ def main():
     for src, dst in ((x, y) for x in fromSE for y in targetSE):
         if ftsTab:
             try:
-                # breakpoint()
                 fts3TpcProto = fts3Plugin.selectTPCProtocols(sourceSEName=ses[src].name, destSEName=ses[dst].name)
                 res = ses[dst].generateTransferURLsBetweenSEs(lfn, ses[src], fts3TpcProto)
             except ValueError as e:

DIRAC/FrameworkSystem/Client/ComponentInstaller.py

@@ -60,7 +60,6 @@ from collections import defaultdict
 
 import importlib_metadata as metadata
 import importlib_resources
-import MySQLdb
 from diraccfg import CFG
 from prompt_toolkit import prompt
 
@@ -96,7 +95,6 @@ from DIRAC.Core.Utilities.Extensions import (
     findServices,
 )
 from DIRAC.Core.Utilities.File import mkDir, mkLink
-from DIRAC.Core.Utilities.MySQL import MySQL
 from DIRAC.Core.Utilities.PrettyPrint import printTable
 from DIRAC.Core.Utilities.ReturnValues import S_ERROR, S_OK
 from DIRAC.Core.Utilities.Subprocess import systemCall
@@ -2055,6 +2053,8 @@ class ComponentInstaller:
         """
         Install requested DB in MySQL server
         """
+        import MySQLdb
+
         dbName = MySQLdb.escape_string(dbName.encode()).decode()
         if not self.mysqlRootPwd:
             rootPwdPath = cfgInstallPath("Database", "RootPwd")
@@ -2202,6 +2202,8 @@ class ComponentInstaller:
         """
         Execute MySQL Command
         """
+        from DIRAC.Core.Utilities.MySQL import MySQL
+
         if not self.mysqlRootPwd:
             return S_ERROR("MySQL root password is not defined")
         if dbName not in self.db:

DIRAC/FrameworkSystem/DB/ProxyDB.py

@@ -11,7 +11,7 @@
 import textwrap
 from threading import Lock
 
-from cachetools import TTLCache, cached
+from cachetools import TTLCache, cachedmethod
 
 from DIRAC import S_ERROR, S_OK, gLogger
 from DIRAC.ConfigurationSystem.Client.Helpers import Registry
@@ -25,6 +25,10 @@ from DIRAC.Resources.ProxyProvider.ProxyProviderFactory import ProxyProviderFact
 
 DEFAULT_MAIL_FROM = "proxymanager@diracgrid.org"
 
+# Module-level cache for getProxyStrength method (shared across ProxyDB instances)
+_get_proxy_strength_cache = TTLCache(maxsize=1000, ttl=600)
+_get_proxy_strength_lock = Lock()
+
 
 class ProxyDB(DB):
     NOTIFICATION_TIMES = [2592000, 1296000]
@@ -398,7 +402,7 @@ class ProxyDB(DB):
             return S_ERROR(", ".join(errMsgs))
         return result
 
-    @cached(TTLCache(maxsize=1000, ttl=600), lock=Lock())
+    @cachedmethod(lambda self: _get_proxy_strength_cache, lock=lambda self: _get_proxy_strength_lock)
     def getProxyStrength(self, userDN, userGroup=None, vomsAttr=None):
         """Load the proxy in cache corresponding to the criteria, and check its strength
 
@@ -601,13 +605,13 @@ class ProxyDB(DB):
         :return: S_OK(dict)/S_ERROR() -- dict contain attribute and VOMS VO
         """
         if requiredVOMSAttribute:
-            return S_OK({"attribute": requiredVOMSAttribute, "VOMSVO": Registry.getVOMSVOForGroup(userGroup)})
+            return S_OK({"attribute": requiredVOMSAttribute, "VO": Registry.getVOForGroup(userGroup)})
 
         csVOMSMapping = Registry.getVOMSAttributeForGroup(userGroup)
         if not csVOMSMapping:
             return S_ERROR(f"No mapping defined for group {userGroup} in the CS")
 
-        return S_OK({"attribute": csVOMSMapping, "VOMSVO": Registry.getVOMSVOForGroup(userGroup)})
+        return S_OK({"attribute": csVOMSMapping, "VO": Registry.getVOForGroup(userGroup)})
 
     def getVOMSProxy(self, userDN, userGroup, requiredLifeTime=None, requestedVOMSAttr=None):
         """Get proxy string from the Proxy Repository for use with userDN
@@ -624,7 +628,7 @@ class ProxyDB(DB):
         if not retVal["OK"]:
             return retVal
         vomsAttr = retVal["Value"]["attribute"]
-        vomsVO = retVal["Value"]["VOMSVO"]
+        vomsVO = retVal["Value"]["VO"]
 
         # Look in the cache
         retVal = self.__getPemAndTimeLeft(userDN, userGroup, vomsAttr)

DIRAC/FrameworkSystem/Utilities/TokenManagementUtilities.py

@@ -10,11 +10,12 @@ DEFAULT_RT_EXPIRATION_TIME = 24 * 3600
 DEFAULT_AT_EXPIRATION_TIME = 1200
 
 
-def getIdProviderClient(userGroup: str, idProviderClientName: str = None):
+def getIdProviderClient(userGroup: str, idProviderClientName: str = None, client_name_prefix: str = ""):
     """Get an IdProvider client
 
     :param userGroup: group name
     :param idProviderClientName: name of an identity provider in the DIRAC CS
+    :param client_name_prefix: prefix of the client in the CS options
     """
     # Get IdProvider credentials from CS
     if not idProviderClientName and userGroup:
@@ -23,7 +24,7 @@ def getIdProviderClient(userGroup: str, idProviderClientName: str = None):
         return S_ERROR(f"The {userGroup} group belongs to the VO that is not tied to any Identity Provider.")
 
     # Prepare the client instance of the appropriate IdP
-    return IdProviderFactory().getIdProvider(idProviderClientName)
+    return IdProviderFactory().getIdProvider(idProviderClientName, client_name_prefix=client_name_prefix)
 
 
 def getCachedKey(

DIRAC/FrameworkSystem/Utilities/diracx.py

@@ -1,16 +1,11 @@
-import random
 import requests
 
 from cachetools import TTLCache, LRUCache, cached
 from cachetools.keys import hashkey
 from pathlib import Path
-from requests.adapters import HTTPAdapter
 from tempfile import NamedTemporaryFile
 from typing import Any
 from collections.abc import Generator
-from urllib3 import PoolManager
-from urllib3.connectionpool import HTTPConnectionPool, HTTPSConnectionPool
-
 from DIRAC import gConfig
 from DIRAC.ConfigurationSystem.Client.Helpers import Registry
 from contextlib import contextmanager
@@ -31,74 +26,7 @@ except ImportError:
 DEFAULT_TOKEN_CACHE_TTL = 5 * 60
 DEFAULT_TOKEN_CACHE_SIZE = 1024
 
-# Number of pools to use for a given host.
-# It should be in the order of host behind the alias
-SESSION_NUM_POOLS = 20
-# Number of connection per Pool
-SESSION_CONNECTION_POOL_MAX_SIZE = 10
-
-
-class RandomizedPoolManager(PoolManager):
-    """
-    A PoolManager subclass that creates multiple connection pools per host.
-    Each connection request randomly picks one of the available pools.
-    """
-
-    def __init__(self, num_pools=3, **kwargs):
-        self.num_pools = num_pools
-        super().__init__(**kwargs)
-
-    def connection_from_host(self, host, port=None, scheme="http", pool_kwargs=None):
-        # Pick a random index to diversify the pool key.
-
-        rand_index = random.randint(0, self.num_pools - 1)
-        pool_key = (f"{host}-{rand_index}", port, scheme)
-        if pool_key in self.pools:
-            return self.pools[pool_key]
-
-        # Create a new pool if none exists for this key.
-        if scheme == "http":
-            self.pools[pool_key] = HTTPConnectionPool(host, port, **self.connection_pool_kw)
-        elif scheme == "https":
-            self.pools[pool_key] = HTTPSConnectionPool(host, port, **self.connection_pool_kw)
-        else:
-            raise ValueError(f"Unsupported scheme: {scheme}")
-
-        return self.pools[pool_key]
-
-
-class RandomizedHTTPAdapter(HTTPAdapter):
-    """
-    An HTTPAdapter that uses the RandomizedPoolManager.
-    """
-
-    def __init__(self, num_pools=3, maxsize=10, **kwargs):
-        self.num_pools = num_pools
-        self.custom_maxsize = maxsize
-        super().__init__(**kwargs)
-
-    def init_poolmanager(self, connections, maxsize, block=False, **pool_kwargs):
-        """
-        Initialize the pool manager with our custom RandomizedPoolManager.
-        """
-        # This ends up being passed to the HTTP(s)ConnectionPool constructors
-        pool_kwargs.update(
-            {
-                "maxsize": self.custom_maxsize,
-                "block": block,
-            }
-        )
-        self.poolmanager = RandomizedPoolManager(**pool_kwargs)
-
-
-# Create a requests session.
-diracx_session = requests.Session()
-# Create an instance of the custom adapter.
-diracx_pool_adapter = RandomizedHTTPAdapter(num_pools=SESSION_NUM_POOLS, maxsize=SESSION_CONNECTION_POOL_MAX_SIZE)
-
-# Mount the adapter to handle both HTTP and HTTPS.
-diracx_session.mount("http://", diracx_pool_adapter)
-diracx_session.mount("https://", diracx_pool_adapter)
+legacy_exchange_session = requests.Session()
 
 
 def get_token(
@@ -117,7 +45,7 @@ def get_token(
     vo = Registry.getVOForGroup(group)
     scopes = [f"vo:{vo}", f"group:{group}"] + [f"property:{prop}" for prop in dirac_properties]
 
-    r = diracx_session.get(
+    r = legacy_exchange_session.get(
         f"{diracxUrl}/api/auth/legacy-exchange",
         params={
             "preferred_username": username,

DIRAC/FrameworkSystem/private/authorization/AuthServer.py

@@ -333,13 +333,13 @@ class AuthServer(_AuthorizationServer):
         """Parse request. Rewrite authlib method."""
         return self.create_oauth2_request(request, JsonRequest, True)
 
-    def validate_requested_scope(self, scope, state=None):
+    def validate_requested_scope(self, scope):
         """See :func:`authlib.oauth2.rfc6749.authorization_server.validate_requested_scope`"""
         # We also consider parametric scope containing ":" charter
         extended_scope = list_to_scope(
             [re.sub(r":.*$", ":", s) for s in scope_to_list((scope or "").replace("+", " "))]
         )
-        super().validate_requested_scope(extended_scope, state)
+        super().validate_requested_scope(extended_scope)
 
     def handle_response(self, status_code=None, payload=None, headers=None, newSession=None, delSession=None):
         """Handle response

DIRAC/FrameworkSystem/scripts/dirac_login.py

@@ -38,8 +38,8 @@ Script.disableCS()
 from DIRAC.ConfigurationSystem.Client.Helpers.Registry import (
     findDefaultGroupForDN,
     getGroupOption,
+    getVOForGroup,
     getVOMSAttributeForGroup,
-    getVOMSVOForGroup,
 )
 from DIRAC.FrameworkSystem.Client.ProxyManagerClient import gProxyManager
 from DIRAC.FrameworkSystem.private.authorization.utils.Tokens import (
@@ -285,7 +285,7 @@ class Params:
                 if not (vomsAttr := getVOMSAttributeForGroup(self.group)):
                     print(HTML(f"<yellow>No VOMS attribute foud for {self.group}</yellow>"))
                 else:
-                    vo = getVOMSVOForGroup(self.group)
+                    vo = getVOForGroup(self.group)
                     if not (result := VOMS().setVOMSAttributes(self.outputFile, attribute=vomsAttr, vo=vo))["OK"]:
                         return S_ERROR(f"Failed adding VOMS attribute: {result['Message']}")
                     chain = result["Value"]

DIRAC/FrameworkSystem/scripts/dirac_proxy_init.py

@@ -96,7 +96,7 @@ class ProxyInit:
             )
 
         resultVomsAttributes = VOMS.VOMS().setVOMSAttributes(
-            self.__proxyGenerated, attribute=vomsAttr, vo=Registry.getVOMSVOForGroup(self.__piParams.diracGroup)
+            self.__proxyGenerated, attribute=vomsAttr, vo=Registry.getVOForGroup(self.__piParams.diracGroup)
         )
         if not resultVomsAttributes["OK"]:
             return S_ERROR(

DIRAC/Interfaces/API/Dirac.py

@@ -46,6 +46,7 @@ from DIRAC.WorkloadManagementSystem.Client import JobStatus
 from DIRAC.WorkloadManagementSystem.Client.JobMonitoringClient import JobMonitoringClient
 from DIRAC.WorkloadManagementSystem.Client.SandboxStoreClient import SandboxStoreClient
 from DIRAC.WorkloadManagementSystem.Client.WMSClient import WMSClient
+from DIRAC.WorkloadManagementSystem.Utilities.jobAdministration import _filterJobStateTransition
 
 
 def parseArguments(args):
@@ -421,6 +422,14 @@ class Dirac(API):
                 sandbox = [isFile.strip() for isFile in sandbox.split(",")]
             for isFile in sandbox:
                 self.log.debug(f"Resolving Input Sandbox {isFile}")
+                # If the sandbox is already in the sandbox store, download it
+                if isFile.startswith("SB:"):
+                    result = SandboxStoreClient(useCertificates=self.useCertificates).downloadSandbox(
+                        isFile, destinationDir=os.getcwd()
+                    )
+                    if not result["OK"]:
+                        return S_ERROR(f"Cannot download Input sandbox {isFile}: {result['Message']}")
+                    continue
                 if isFile.lower().startswith("lfn:"):  # isFile is an LFN
                     isFile = isFile[4:]
                 # Attempt to copy into job working directory, unless it is already there
@@ -1450,10 +1459,12 @@ class Dirac(API):
         # Remove any job IDs that can't change to the Killed or Deleted states
         filteredJobs = set()
         for filterState in (JobStatus.KILLED, JobStatus.DELETED):
-            filterRes = JobStatus.filterJobStateTransition(jobIDs, filterState)
-            if not filterRes["OK"]:
-                return filterRes
-            filteredJobs.update(filterRes["Value"])
+            # get a dictionary of jobID:status
+            res = JobMonitoringClient().getJobsStatus(jobIDs)
+            if not res["OK"]:
+                return res
+            # then filter
+            filteredJobs.update(_filterJobStateTransition(res["Value"], filterState))
 
         return WMSClient(useCertificates=self.useCertificates).deleteJob(list(filteredJobs))
 
@@ -1480,11 +1491,12 @@ class Dirac(API):
             return ret
         jobIDs = ret["Value"]
 
-        # Remove any job IDs that can't change to the rescheduled state
-        filterRes = JobStatus.filterJobStateTransition(jobIDs, JobStatus.RESCHEDULED)
-        if not filterRes["OK"]:
-            return filterRes
-        jobIDsToReschedule = filterRes["Value"]
+        # get a dictionary of jobID:status
+        res = JobMonitoringClient().getJobsStatus(jobIDs)
+        if not res["OK"]:
+            return res
+        # then filter
+        jobIDsToReschedule = _filterJobStateTransition(res["Value"], JobStatus.RESCHEDULED)
 
         return WMSClient(useCertificates=self.useCertificates).rescheduleJob(jobIDsToReschedule)
 
@@ -1510,10 +1522,12 @@ class Dirac(API):
         # Remove any job IDs that can't change to the Killed or Deleted states
         filteredJobs = set()
         for filterState in (JobStatus.KILLED, JobStatus.DELETED):
-            filterRes = JobStatus.filterJobStateTransition(jobIDs, filterState)
-            if not filterRes["OK"]:
-                return filterRes
-            filteredJobs.update(filterRes["Value"])
+            # get a dictionary of jobID:status
+            res = JobMonitoringClient().getJobsStatus(jobIDs)
+            if not res["OK"]:
+                return res
+            # then filter
+            filteredJobs.update(_filterJobStateTransition(res["Value"], filterState))
 
         return WMSClient(useCertificates=self.useCertificates).killJob(list(filteredJobs))