DIRAC 9.0.0a69__py3-none-any.whl → 9.0.0a70__py3-none-any.whl

DIRAC/DataManagementSystem/Client/FTS3Job.py

@@ -1,9 +1,15 @@
-""" FTS3Job module containing only the FTS3Job class """
+"""FTS3Job module containing only the FTS3Job class"""
 
 import datetime
 import errno
+import os
+import requests
 from packaging.version import Version
 
+from cachetools import cachedmethod, LRUCache, TTLCache, cached
+from threading import Lock
+from typing import Optional
+
 
 # Requires at least version 3.3.3
 from fts3 import __version__ as fts3_version
@@ -26,8 +32,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 +43,54 @@ 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
+
+
+_scitag_cache = TTLCache(maxsize=10, ttl=3600)
+_scitag_lock = Lock()
+_scitag_json_cache = TTLCache(maxsize=1, ttl=86400)
+_scitag_json_lock = Lock()
+
+
+@cached(_scitag_cache, lock=_scitag_lock)
+def get_scitag(vo: str, activity: Optional[str] = None) -> int:
+    """
+    Get the scitag based on the VO and activity.
+    If the VO is not found in the scitag.json, it defaults to 1.
+    If no specific activity is provided, it defaults to the "default" activityName.
+
+    :param vo: The VO for which to get the scitag
+    :param activity: The activity for which to get the scitag
+    :return: The scitag value
+    """
+
+    @cached(_scitag_json_cache, lock=_scitag_json_lock)
+    def get_remote_json():
+        gLogger.verbose("Fetching https://scitags.org/api.json from the network")
+        response = requests.get("https://scitags.org/api.json")
+        response.raise_for_status()
+        return response.json()
+
+    vo_id = 1  # Default VO ID
+    activity_id = 1  # Default activity ID
+
+    try:
+        # Load the JSON data from the cache or network
+        sj = get_remote_json()
+
+        for experiment in sj.get("experiments", []):
+            if experiment.get("expName") == vo.lower():
+                vo_id = experiment.get("expId")
+                for act in experiment.get("activities", []):
+                    if act.get("activityName") == activity:
+                        activity_id = act.get("activityId")
+    except Exception as e:
+        gLogger.error(f"Error fetching or parsing scitag.json. Using default scitag values.", repr(e))
+    # Logic to determine the scitag based on vo and activity (this is what FTS wants)
+    return vo_id << 6 | activity_id  # Example logic, replace with actual implementation
+
 
 class FTS3Job(JSerializable):
     """Abstract class to represent a job to be executed by FTS. It belongs
@@ -78,6 +133,8 @@ class FTS3Job(JSerializable):
         "userGroup",
     ]
 
+    _idp_cache = LRUCache(maxsize=IDP_CACHE_SIZE)
+
     def __init__(self):
         self.submitTime = None
         self.lastUpdate = None
@@ -111,7 +168,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 +205,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 +231,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 +293,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)
@@ -456,6 +518,9 @@ class FTS3Job(JSerializable):
 
                 ftsFileID = getattr(ftsFile, "fileID")
 
+                # scitag 65 is 1 << 6 | 1 (default experiment, default activity)
+                scitag = get_scitag(vo=self.vo, activity=self.activity)
+
                 # Under normal circumstances, we simply submit an fts transfer as such:
                 # * srcProto://myFile -> destProto://myFile
                 #
@@ -485,6 +550,7 @@ class FTS3Job(JSerializable):
                         filesize=ftsFile.size,
                         metadata=stageTrans_metadata,
                         activity=self.activity,
+                        scitag=scitag,
                     )
                     transfers.append(stageTrans)
 
@@ -509,11 +575,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 +593,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
@@ -553,6 +624,7 @@ class FTS3Job(JSerializable):
                     activity=self.activity,
                     source_token=srcToken,
                     destination_token=dstToken,
+                    scitag=scitag,
                 )
 
                 transfers.append(trans)
@@ -588,6 +660,7 @@ class FTS3Job(JSerializable):
             multihop=isMultiHop,
             metadata=job_metadata,
             priority=self.priority,
+            unmanaged_tokens=True,
             archive_timeout=archive_timeout,
             **dest_spacetoken,
         )
@@ -728,6 +801,7 @@ class FTS3Job(JSerializable):
             retry=3,
             metadata=job_metadata,
             priority=self.priority,
+            unmanaged_tokens=True,
             **dest_spacetoken,
         )
 
@@ -882,9 +956,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 +967,7 @@ class FTS3Job(JSerializable):
         :returns: None
         """
 
+        accountingDicts = []
         accountingDict = dict()
         sourceSE = None
         targetSE = None
@@ -903,16 +978,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 +1004,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/Client/test/Test_FTS3Objects.py

@@ -204,6 +204,7 @@ def generateFTS3Job(sourceSE, targetSE, lfns, multiHopSE=None):
     newJob.sourceSE = sourceSE
     newJob.targetSE = targetSE
     newJob.multiHopSE = multiHopSE
+    newJob.vo = "lhcb"
     filesToSubmit = []
 
     for i, lfn in enumerate(lfns, start=1):

DIRAC/DataManagementSystem/Client/test/Test_scitag.py

@@ -0,0 +1,69 @@
+from unittest.mock import Mock, patch
+
+import pytest
+
+from DIRAC.DataManagementSystem.Client.FTS3Job import get_scitag
+
+
+class TestGetScitag:
+    def test_valid_vo_and_activity(self):
+        """Test get_scitag with valid VO and activity."""
+        result = get_scitag("atlas", "Analysis Input")
+        expected = 2 << 6 | 17  # atlas expId=2, analysis activityId=17
+        assert result == expected
+
+    def test_valid_vo_no_activity(self):
+        """Test get_scitag with valid VO but no specific activity (should use default)."""
+        result = get_scitag("cms")
+        expected = 3 << 6 | 1  # cms expId=200, default activityId=1
+        assert result == expected
+
+    def test_invalid_vo(self):
+        """Test get_scitag with invalid VO (should use default vo_id=1)."""
+        result = get_scitag("nonexistent")
+        expected = 1 << 6 | 1  # default vo_id=1, default activity_id=1
+        assert result == expected
+
+    def test_valid_vo_invalid_activity(self):
+        """Test get_scitag with valid VO but invalid activity."""
+        result = get_scitag("atlas", "nonexistent_activity")
+        expected = 2 << 6 | 1  # atlas expId=2, default activity_id=1
+        assert result == expected
+
+    def test_case_insensitive_vo(self):
+        """Test that VO matching is case insensitive."""
+        result = get_scitag("ATLAS", "Data Brokering")
+        expected = 2 << 6 | 3  # atlas expId=2, production activityId=3
+        assert result == expected
+
+
+@pytest.mark.parametrize(
+    "vo,activity,expected_vo_id,expected_activity_id",
+    [
+        ("atlas", "Analysis Output", 2, 18),
+        ("atlas", "Debug", 2, 9),
+        ("cms", "Cache", 3, 3),
+        ("cms", "default", 3, 1),
+        ("nonexistent", "any", 1, 1),  # defaults
+        ("atlas", "nonexistent", 2, 1),  # valid vo, invalid activity
+    ],
+)
+def test_parametrized_scenarios(vo, activity, expected_vo_id, expected_activity_id):
+    """Parametrized test for various VO and activity combinations."""
+    result = get_scitag(vo, activity)
+    expected = expected_vo_id << 6 | expected_activity_id
+    assert result == expected
+
+
+@pytest.mark.parametrize(
+    "vo,expected_result",
+    [
+        ("atlas", 2 << 6 | 1),  # Should use default activity
+        ("cms", 3 << 6 | 1),  # Should use default activity
+        ("unknown", 1 << 6 | 1),  # Should use all defaults
+    ],
+)
+def test_no_activity_parameter(vo, expected_result):
+    """Test behavior when no activity parameter is provided."""
+    result = get_scitag(vo)
+    assert result == expected_result

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/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/FrameworkSystem/DB/InstalledComponentsDB.py

@@ -1,6 +1,7 @@
 """
 Classes and functions for easier management of the InstalledComponents database
 """
+
 import re
 import datetime
 
@@ -90,7 +91,7 @@ class Host(componentsBase):
     __table_args__ = {"mysql_engine": "InnoDB", "mysql_charset": "utf8mb4"}
 
     hostID = Column("HostID", Integer, primary_key=True)
-    hostName = Column("HostName", String(32), nullable=False)
+    hostName = Column("HostName", String(255), nullable=False)
     cpu = Column("CPU", String(64), nullable=False)
     installationList = relationship("InstalledComponent", backref="installationHost")
 
@@ -219,7 +220,7 @@ class HostLogging(componentsBase):
     __tablename__ = "HostLogging"
     __table_args__ = {"mysql_engine": "InnoDB", "mysql_charset": "utf8mb4"}
 
-    hostName = Column("HostName", String(32), nullable=False, primary_key=True)
+    hostName = Column("HostName", String(255), nullable=False, primary_key=True)
     # status
     DIRAC = Column("DIRACVersion", String(64))
     Extension = Column("Extension", String(512))

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/MonitoringUtilities.py

@@ -1,6 +1,7 @@
 """
 Utilities for ComponentMonitoring features
 """
+
 import datetime
 import socket
 

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,20 +1,25 @@
-import requests
-
-from cachetools import TTLCache, LRUCache, cached
-from cachetools.keys import hashkey
+import os
+import re
+import subprocess
+from collections.abc import Generator
+from contextlib import contextmanager
 from pathlib import Path
 from tempfile import NamedTemporaryFile
+import tempfile
 from typing import Any
-from collections.abc import Generator
-from DIRAC import gConfig
-from DIRAC.ConfigurationSystem.Client.Helpers import Registry
-from contextlib import contextmanager
 
+import requests
+from cachetools import LRUCache, TTLCache, cached
+from cachetools.keys import hashkey
+from diracx.cli.internal.legacy import _apply_fixes
+from diracx.core.config.schema import Config as DiracxConfig
+from diracx.core.models import TokenResponse
 from diracx.core.preferences import DiracxPreferences
-
 from diracx.core.utils import write_credentials
+from pydantic import ValidationError
 
-from diracx.core.models import TokenResponse
+from DIRAC import S_ERROR, S_OK, gConfig
+from DIRAC.ConfigurationSystem.Client.Helpers import Registry
 
 try:
     from diracx.client.sync import SyncDiracClient
@@ -104,3 +109,29 @@ def TheImpersonator(credDict: dict[str, Any], *, source: str = "") -> Generator[
         client.__enter__()
         diracx_client_cache[token_location] = client
     yield client
+
+
+def diracxVerifyConfig(cfgData):
+    """Verify CS config using DiracX config validation
+
+    Args:
+        cfgData: CFG data
+
+    Returns:
+        S_OK | S_ERROR: Value: diracx Config validation
+    """
+    os.environ["DIRAC_COMPAT_ENABLE_CS_CONVERSION"] = "true"
+    with tempfile.NamedTemporaryFile() as temp_cfg:
+        with tempfile.NamedTemporaryFile() as temp_diracx_cfg:
+            cfgData.writeToFile(temp_cfg.name)
+            cmd = ["dirac", "internal", "legacy", "cs-sync", temp_cfg.name, temp_diracx_cfg.name]
+            res = subprocess.run(cmd, capture_output=True, text=True, timeout=15)
+    os.environ.pop("DIRAC_COMPAT_ENABLE_CS_CONVERSION")
+    if res.returncode == 0:
+        return S_OK(res.stdout)
+    else:
+        err = res.stderr.strip()
+        match = re.search(r"(ValidationError:.*)", err, flags=re.DOTALL)
+        if match:
+            return S_ERROR(match.group(1))
+        return S_ERROR(err)

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/FrameworkSystem/scripts/dirac_uninstall_component.py

@@ -2,6 +2,7 @@
 """
 Uninstallation of a DIRAC component
 """
+
 import socket
 
 from DIRAC import exit as DIRACexit

DIRAC/Interfaces/API/Dirac.py

@@ -1463,9 +1463,8 @@ class Dirac(API):
             res = JobMonitoringClient().getJobsStatus(jobIDs)
             if not res["OK"]:
                 return res
-            js = {k: v["Status"] for k, v in res["Value"].items()}
             # then filter
-            filteredJobs.update(_filterJobStateTransition(js, filterState))
+            filteredJobs.update(_filterJobStateTransition(res["Value"], filterState))
 
         return WMSClient(useCertificates=self.useCertificates).deleteJob(list(filteredJobs))
 
@@ -1496,9 +1495,8 @@ class Dirac(API):
         res = JobMonitoringClient().getJobsStatus(jobIDs)
         if not res["OK"]:
             return res
-        js = {k: v["Status"] for k, v in res["Value"].items()}
         # then filter
-        jobIDsToReschedule = _filterJobStateTransition(js, JobStatus.RESCHEDULED)
+        jobIDsToReschedule = _filterJobStateTransition(res["Value"], JobStatus.RESCHEDULED)
 
         return WMSClient(useCertificates=self.useCertificates).rescheduleJob(jobIDsToReschedule)
 
@@ -1528,9 +1526,8 @@ class Dirac(API):
             res = JobMonitoringClient().getJobsStatus(jobIDs)
             if not res["OK"]:
                 return res
-            js = {k: v["Status"] for k, v in res["Value"].items()}
             # then filter
-            filteredJobs.update(_filterJobStateTransition(js, filterState))
+            filteredJobs.update(_filterJobStateTransition(res["Value"], filterState))
 
         return WMSClient(useCertificates=self.useCertificates).killJob(list(filteredJobs))