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

DIRAC/ResourceStatusSystem/scripts/dirac_rss_set_status.py

@@ -6,9 +6,8 @@ issuer with a duration of 1 day.
 """
 from datetime import datetime, timedelta
 
-from DIRAC import S_OK
+from DIRAC import S_OK, gLogger
 from DIRAC import exit as DIRACExit
-from DIRAC import gLogger
 from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
 from DIRAC.Core.Base.Script import Script
 from DIRAC.Core.Security.ProxyInfo import getProxyInfo
@@ -29,6 +28,8 @@ def registerSwitches():
         ("status=", "Status to be changed"),
         ("reason=", "Reason to set the Status"),
         ("VO=", "VO to change a status for. When omitted, status will be changed for all VOs"),
+        ("tokenOwner=", "Owner of the token"),
+        ("days=", "Number of days the token is valid for. Default is 1 day. 0 or less days denotes forever."),
     )
 
     for switch in switches:
@@ -50,6 +51,7 @@ def parseSwitches():
     switches = dict(Script.getUnprocessedSwitches())
     switches.setdefault("statusType", None)
     switches.setdefault("VO", None)
+    switches.setdefault("days", 1)
 
     for key in ("element", "name", "status", "reason"):
         if key not in switches:
@@ -136,6 +138,9 @@ def unpack(switchDict):
         switchDictClone["statusType"] = None
         switchDictSet.append(switchDictClone)
 
+    for sd in switchDictSet:
+        sd.update({"tokenOwner": switchDict.get("tokenOwner")})
+
     return switchDictSet
 
 
@@ -180,7 +185,11 @@ def setStatus(switchDict, tokenOwner):
         )
         return S_OK()
 
-    tomorrow = datetime.utcnow().replace(microsecond=0) + timedelta(days=1)
+    tokenLifetime = int(switchDict["days"])
+    if tokenLifetime <= 0:
+        tokenExpiration = datetime.max
+    else:
+        tokenExpiration = datetime.utcnow().replace(microsecond=0) + timedelta(days=tokenLifetime)
 
     for status, statusType in elements:
         gLogger.debug(f"{status} {statusType}")
@@ -190,8 +199,16 @@ def setStatus(switchDict, tokenOwner):
             continue
 
         gLogger.debug(
-            "About to set status %s -> %s for %s, statusType: %s, VO: %s, reason: %s"
-            % (status, switchDict["status"], switchDict["name"], statusType, switchDict["VO"], switchDict["reason"])
+            "About to set status %s -> %s for %s, statusType: %s, VO: %s, reason: %s, days: %s"
+            % (
+                status,
+                switchDict["status"],
+                switchDict["name"],
+                statusType,
+                switchDict["VO"],
+                switchDict["reason"],
+                switchDict["days"],
+            )
         )
         result = rssClient.modifyStatusElement(
             switchDict["element"],
@@ -202,7 +219,7 @@ def setStatus(switchDict, tokenOwner):
             reason=switchDict["reason"],
             vO=switchDict["VO"],
             tokenOwner=tokenOwner,
-            tokenExpiration=tomorrow,
+            tokenExpiration=tokenExpiration,
         )
         if not result["OK"]:
             return result
@@ -215,14 +232,15 @@ def run(switchDict):
     Main function of the script
     """
 
-    tokenOwner = getTokenOwner()
-    if not tokenOwner["OK"]:
-        gLogger.error(tokenOwner["Message"])
-        DIRACExit(1)
-    tokenOwner = tokenOwner["Value"]
+    tokenOwner = switchDict.get("tokenOwner")
+    if tokenOwner is None:
+        tokenOwner = getTokenOwner()
+        if not tokenOwner["OK"]:
+            gLogger.error(tokenOwner["Message"])
+            DIRACExit(1)
+        tokenOwner = tokenOwner["Value"]
 
     gLogger.notice(f"TokenOwner is {tokenOwner}")
-
     result = setStatus(switchDict, tokenOwner)
     if not result["OK"]:
         gLogger.error(result["Message"])

DIRAC/Resources/Catalog/RucioFileCatalogClient.py

@@ -60,6 +60,8 @@ class RucioFileCatalogClient(FileCatalogClientBase):
         "resolveDataset",
         "getLFNForPFN",
         "getUserDirectory",
+        "getFileUserMetadata",
+        "findFilesByMetadata",
     ]
 
     WRITE_METHODS = FileCatalogClientBase.WRITE_METHODS + [
@@ -78,6 +80,7 @@ class RucioFileCatalogClient(FileCatalogClientBase):
         "createDataset",
         "changePathOwner",
         "changePathMode",
+        "setMetadata",
     ]
 
     NO_LFN_METHODS = FileCatalogClientBase.NO_LFN_METHODS + [
@@ -85,6 +88,7 @@ class RucioFileCatalogClient(FileCatalogClientBase):
         "createUserDirectory",
         "createUserMapping",
         "removeUserDirectory",
+        "findFilesByMetadata",
     ]
 
     ADMIN_METHODS = FileCatalogClientBase.ADMIN_METHODS + [
@@ -147,7 +151,7 @@ class RucioFileCatalogClient(FileCatalogClientBase):
             self.authHost = options.get("AuthHost", None)
             self.caCertPath = Locations.getCAsLocation()
             try:
-                sLog.info(f"Logging in with a proxy located at: {self.proxyPath}")
+                sLog.debug(f"Logging in with a proxy located at: {self.proxyPath}")
                 sLog.debug("account: ", self.username)
                 sLog.debug("rucio host: ", self.rucioHost)
                 sLog.debug("auth  host: ", self.authHost)
@@ -697,3 +701,193 @@ class RucioFileCatalogClient(FileCatalogClientBase):
             except Exception as err:
                 return S_ERROR(str(err))
         return S_OK(resDict)
+
+    @checkCatalogArguments
+    def getFileUserMetadata(self, path):
+        """Get the meta data attached to a file, but also to
+        all its parents
+        """
+        path = next(iter(path))
+        resDict = {"Successful": {}, "Failed": {}}
+        try:
+            did = self.__getDidsFromLfn(path)
+            meta = next(self.client.get_metadata_bulk(dids=[did], inherit=True, plugin="ALL"))
+            if meta["did_type"] == "FILE":  # Should we also return the metadata for the directories ?
+                resDict["Successful"][path] = meta
+            else:
+                resDict["Failed"][path] = "Not a file"
+        except DataIdentifierNotFound:
+            resDict["Failed"][path] = "No such file or directory"
+        except Exception as err:
+            return S_ERROR(str(err))
+        return S_OK(resDict)
+
+    @checkCatalogArguments
+    def getFileUserMetadataBulk(self, lfns):
+        """Get the meta data attached to a list of files, but also to
+        all their parents
+        """
+        resDict = {"Successful": {}, "Failed": {}}
+        dids = []
+        lfnChunks = breakListIntoChunks(lfns, 1000)
+        for lfnList in lfnChunks:
+            try:
+                dids = [self.__getDidsFromLfn(lfn) for lfn in lfnList]
+            except Exception as err:
+                return S_ERROR(str(err))
+            try:
+                for met in self.client.get_metadata_bulk(dids=dids, inherit=True):
+                    lfn = met["name"]
+                    resDict["Successful"][lfn] = met
+                for lfn in lfnList:
+                    if lfn not in resDict["Successful"]:
+                        resDict["Failed"][lfn] = "No such file or directory"
+            except Exception as err:
+                return S_ERROR(str(err))
+        return S_OK(resDict)
+
+    @checkCatalogArguments
+    def setMetadataBulk(self, pathMetadataDict):
+        """Add metadata for the given paths"""
+        resDict = {"Successful": {}, "Failed": {}}
+        dids = []
+        for path, metadataDict in pathMetadataDict.items():
+            try:
+                did = self.__getDidsFromLfn(path)
+                did["meta"] = metadataDict
+                dids.append(did)
+            except Exception as err:
+                return S_ERROR(str(err))
+        try:
+            self.client.set_dids_metadata_bulk(dids=dids, recursive=False)
+        except Exception as err:
+            return S_ERROR(str(err))
+        return S_OK(resDict)
+
+    @checkCatalogArguments
+    def setMetadata(self, path, metadataDict):
+        """Add metadata to the given path"""
+        pathMetadataDict = {}
+        path = next(iter(path))
+        pathMetadataDict[path] = metadataDict
+        return self.setMetadataBulk(pathMetadataDict)
+
+    @checkCatalogArguments
+    def removeMetadata(self, path, metadata):
+        """Remove the specified metadata for the given file"""
+        resDict = {"Successful": {}, "Failed": {}}
+        try:
+            did = self.__getDidsFromLfn(path)
+            failedMeta = {}
+            # TODO : Implement bulk delete_metadata method in Rucio
+            for meta in metadata:
+                try:
+                    self.client.delete_metadata(scope=did["scope"], name=did["name"], key=meta)
+                except DataIdentifierNotFound:
+                    return S_ERROR(f"File {path} not found")
+                except Exception as err:
+                    failedMeta[meta] = str(err)
+
+            if failedMeta:
+                metaExample = list(failedMeta)[0]
+                result = S_ERROR(f"Failed to remove {len(failedMeta)} metadata, e.g. {failedMeta[metaExample]}")
+                result["FailedMetadata"] = failedMeta
+        except Exception as err:
+            return S_ERROR(str(err))
+        return S_OK()
+
+    def findFilesByMetadata(self, metadataFilterDict, path="/", timeout=120):
+        """find the dids for the given metadataFilterDict"""
+        ruciometadataFilterDict = self.__transform_DIRAC_filter_dict_to_Rucio_filter_dict([metadataFilterDict])
+        dids = []
+        for scope in self.scopes:
+            try:
+                dids.extend(self.client.list_dids(scope=scope, filters=ruciometadataFilterDict, did_type="all"))
+            except Exception as err:
+                return S_ERROR(str(err))
+        return S_OK(dids)
+
+    def __transform_DIRAC_operator_to_Rucio(self, DIRAC_dict):
+        """
+        Transforms a DIRAC's metadata Query dictionary to a Rucio-compatible dictionary.
+        This method takes a dictionary with DIRAC operators and converts it to a
+        dictionary with Rucio-compatible operators based on predefined mappings.
+        for example :
+            input_dict={'key1': 'value1', 'key2': {'>': 10}, 'key3': {'=': 10}}
+            return = {'key1': 'value1', 'key2.gt': 10, 'key3': 10}
+        """
+        rucio_dict = {}
+        operator_mapping = {">": ".gt", "<": ".lt", ">=": ".gte", "<=": ".lte", "=<": ".lte", "!=": ".ne", "=": ""}
+
+        for key, value in DIRAC_dict.items():
+            if isinstance(value, dict):
+                for operator, num in value.items():
+                    if operator in operator_mapping:
+                        mapped_operator = operator_mapping[operator]
+                        rucio_dict[f"{key}{mapped_operator}"] = num
+            else:
+                rucio_dict[key] = value
+
+        return rucio_dict
+
+    def __transform_dict_with_in_operateur(self, DIRAC_dict_with_in_operator_list):
+        """
+        Transforms a list of DIRAC dictionaries containing 'in' operators into a combined list of dictionaries,
+        expanding the 'in' operator into individual dictionaries while preserving other keys.
+        example
+            input_dict_list = [{'particle': {'in': ['proton','electron']},'site': {'in': [ "LaPalma", 'paranal']},'configuration_id': {'=': 14} }    ]
+            return = [{'particle': 'proton', 'site': 'LaPalma', 'configuration_id': {'=': 14} }, {'particle': 'proton', 'site': 'paranal', 'configuration_id': {'=': 14} }, {'particle': 'electron', 'site': 'LaPalma', 'configuration_id': {'=': 14} }, {'particle': 'electron', 'site': 'paranal', 'configuration_id': {'=': 14} }]
+        """
+        if not isinstance(DIRAC_dict_with_in_operator_list, list):
+            raise TypeError("DIRAC_dict_with_in_operator_list must be a list of dictionaries")
+
+        combined_dict_list = []  # Final list of transformed dictionaries
+        break_reached = False  # Boolean to track if 'in' was found and processed in any dictionary
+
+        # Process each dictionary in the input list
+        for DIRAC_dict_with_in_operator in DIRAC_dict_with_in_operator_list:
+            if not isinstance(DIRAC_dict_with_in_operator, dict):
+                raise TypeError("Each element in DIRAC_dict_with_in_operator_list must be a dictionary")
+
+            in_key = None
+            in_values = []
+
+            # Extract the key with 'in' operator and the list of values
+            for key, value in DIRAC_dict_with_in_operator.items():
+                if isinstance(value, dict) and "in" in value:
+                    in_key = key
+                    in_values = value["in"]
+                    break_reached = True  # 'in' operator found
+                    break
+
+            # If an 'in' key exists, expand the dictionary for each value
+            if in_key:
+                for val in in_values:
+                    # Copy the original dictionary and replace the 'in' key
+                    new_dict = DIRAC_dict_with_in_operator.copy()
+                    new_dict[in_key] = val  # Replace the 'in' key with the current value
+                    combined_dict_list.append(new_dict)
+            else:
+                # If no 'in' key, simply add the input dictionary as-is
+                combined_dict_list.append(DIRAC_dict_with_in_operator)
+
+        return combined_dict_list, break_reached
+
+    def __transform_DIRAC_filter_dict_to_Rucio_filter_dict(self, DIRAC_filter_dict_list):
+        """
+        Transforms a list of DIRAC filter dictionaries into a list of Rucio filter dictionaries.
+        This method takes a list of filter dictionaries used in DIRAC and converts them into a format
+        that is compatible with Rucio. It handles the transformation of operators and expands filters
+        that use the 'in' operator.
+        example:
+            input_dict_list = [{'particle': {'in': ['proton','electron']},'site': {'in': [ "LaPalma", 'paranal']},'configuration_id': {'=': 14} }    ]
+            return = [{'particle': 'proton', 'site': 'LaPalma', 'configuration_id': 14}, {'particle': 'proton', 'site': 'paranal', 'configuration_id': 14}, {'particle': 'electron', 'site': 'LaPalma', 'configuration_id': 14}, {'particle': 'electron', 'site': 'paranal', 'configuration_id': 14}]
+        """
+        break_detected = True
+        DIRAC_expanded_filters = DIRAC_filter_dict_list
+        while break_detected:
+            DIRAC_expanded_filters, break_detected = self.__transform_dict_with_in_operateur(DIRAC_expanded_filters)
+        Rucio_filters = []
+        for filter in DIRAC_expanded_filters:
+            Rucio_filters.append(self.__transform_DIRAC_operator_to_Rucio(filter))
+        return Rucio_filters

DIRAC/Resources/Catalog/test/Test_RucioFileCatalogClient.py

@@ -0,0 +1,181 @@
+import unittest
+from unittest.mock import MagicMock, patch
+from DIRAC.Resources.Catalog.RucioFileCatalogClient import RucioFileCatalogClient
+
+
+class TestRucioFileCatalogClient(unittest.TestCase):
+    def setUp(self):
+        self.patcher = patch.object(RucioFileCatalogClient, "client", new_callable=MagicMock)
+        self.client = RucioFileCatalogClient()
+        self.client.scopes = ["test_scope"]
+        self.patcher.start()
+
+    def tearDown(self):
+        self.patcher.stop()
+
+    def test_transform_DIRAC_operator_to_Rucio(self):
+        DIRAC_dict = {"key1": "value1", "key2": {">": 10}, "key3": {"=": 10}}
+        expected_output = {"key1": "value1", "key2.gt": 10, "key3": 10}
+        result = self.client._RucioFileCatalogClient__transform_DIRAC_operator_to_Rucio(DIRAC_dict)
+        self.assertEqual(result, expected_output)
+
+    def test_transform_dict_with_in_operateur_2steps(self):
+        DIRAC_dict_with_in_operator_list = [
+            {
+                "particle": {"in": ["proton", "electron"]},
+                "site": {"in": ["LaPalma", "paranal"]},
+                "configuration_id": {"=": 14},
+            }
+        ]
+        expected_intermediate_output = [
+            {"particle": "proton", "site": {"in": ["LaPalma", "paranal"]}, "configuration_id": {"=": 14}},
+            {"particle": "electron", "site": {"in": ["LaPalma", "paranal"]}, "configuration_id": {"=": 14}},
+        ]
+        expected_final_output = [
+            {"particle": "proton", "site": "LaPalma", "configuration_id": {"=": 14}},
+            {"particle": "proton", "site": "paranal", "configuration_id": {"=": 14}},
+            {"particle": "electron", "site": "LaPalma", "configuration_id": {"=": 14}},
+            {"particle": "electron", "site": "paranal", "configuration_id": {"=": 14}},
+        ]
+        result_intermediate, _ = self.client._RucioFileCatalogClient__transform_dict_with_in_operateur(
+            DIRAC_dict_with_in_operator_list
+        )
+        self.assertEqual(result_intermediate, expected_intermediate_output)
+        result_final, _ = self.client._RucioFileCatalogClient__transform_dict_with_in_operateur(result_intermediate)
+        self.assertEqual(result_final, expected_final_output)
+
+    def test_transform_DIRAC_operator_to_Rucio_simple_key_value(self):
+        input_dict = {"key1": "value1", "key2": "value2"}
+        expected_output = {"key1": "value1", "key2": "value2"}
+        result = self.client._RucioFileCatalogClient__transform_DIRAC_operator_to_Rucio(input_dict)
+        self.assertEqual(result, expected_output)
+
+    def test_transform_DIRAC_operator_to_Rucio_nested_dict_with_operators_gl(self):
+        input_dict = {
+            "start": {">=": 10},
+            "end": {">": 5},
+            "pointingZ": {">=": 0.1},
+            "organization": "ViaCorp",
+            "data_levels": "DL3",
+        }
+        expected_output = {
+            "start.gte": 10,
+            "end.gt": 5,
+            "pointingZ.gte": 0.1,
+            "organization": "ViaCorp",
+            "data_levels": "DL3",
+        }
+        result = self.client._RucioFileCatalogClient__transform_DIRAC_operator_to_Rucio(input_dict)
+        self.assertEqual(result, expected_output)
+
+    def test_transform_DIRAC_operator_to_Rucio_nested_dict_with_operators_equals(self):
+        input_dict = {"start": {"=": 10}, "pointingZ": {"=": 0.1}, "organization": "ViaCorp", "data_levels": "DL3"}
+        expected_output = {"start": 10, "pointingZ": 0.1, "organization": "ViaCorp", "data_levels": "DL3"}
+        result = self.client._RucioFileCatalogClient__transform_DIRAC_operator_to_Rucio(input_dict)
+        assert result == expected_output
+
+    def test_transform_DIRAC_operator_to_Rucio_mixed_dict(self):
+        input_dict = {"key1": "value1", "key2": {">": 10}, "key3": {"=": 10}}
+        expected_output = {"key1": "value1", "key2.gt": 10, "key3": 10}
+        result = self.client._RucioFileCatalogClient__transform_DIRAC_operator_to_Rucio(input_dict)
+        assert result == expected_output
+
+    def test_transform_DIRAC_operator_to_Rucio_in_operator(self):
+        input_dict = [
+            {
+                "analysis_prog": {"in": ["ctapipe-merge", "ctapipe-process", "ctapipe-apply-models"]},
+                "key1": "value1",
+                "key3": {"=": 10},
+                "key4": {"<": 5},
+            }
+        ]
+        expected_intermediate = [
+            {"key1": "value1", "key3": 10, "key4.lt": 5, "analysis_prog": "ctapipe-merge"},
+            {"key1": "value1", "key3": 10, "key4.lt": 5, "analysis_prog": "ctapipe-process"},
+            {"key1": "value1", "key3": 10, "key4.lt": 5, "analysis_prog": "ctapipe-apply-models"},
+        ]
+        result_interm = self.client._RucioFileCatalogClient__transform_DIRAC_filter_dict_to_Rucio_filter_dict(
+            input_dict
+        )
+        assert result_interm == expected_intermediate
+
+    def test_transform_DIRAC_operator_to_Rucio_2timesin_operator(self):
+        input_dict = [{"particle": {"in": ["proton", "electron"]}, "site": {"in": ["LaPalma", "paranal"]}}]
+        expected = [
+            {"particle": "proton", "site": "LaPalma"},
+            {"particle": "proton", "site": "paranal"},
+            {"particle": "electron", "site": "LaPalma"},
+            {"particle": "electron", "site": "paranal"},
+        ]
+        result = self.client._RucioFileCatalogClient__transform_DIRAC_filter_dict_to_Rucio_filter_dict(input_dict)
+        assert result == expected
+
+    def test_2timesin_mix_operator(self):
+        input_dict = [
+            {
+                "particle": {"in": ["proton", "electron"]},
+                "site": {"in": ["LaPalma", "paranal"]},
+                "configuration_id": {"=": 14},
+            }
+        ]
+        expected = [
+            {"particle": "proton", "site": "LaPalma", "configuration_id": 14},
+            {"particle": "proton", "site": "paranal", "configuration_id": 14},
+            {"particle": "electron", "site": "LaPalma", "configuration_id": 14},
+            {"particle": "electron", "site": "paranal", "configuration_id": 14},
+        ]
+        result = self.client._RucioFileCatalogClient__transform_DIRAC_filter_dict_to_Rucio_filter_dict(input_dict)
+        assert result == expected
+
+        input_dict = [
+            {
+                "particle": {"in": ["proton", "electron"]},
+                "configuration_id": {"=": 14},
+                "site": {"in": ["LaPalma", "paranal"]},
+            }
+        ]
+        expected = [
+            {"particle": "proton", "configuration_id": 14, "site": "LaPalma"},
+            {"particle": "proton", "configuration_id": 14, "site": "paranal"},
+            {"particle": "electron", "configuration_id": 14, "site": "LaPalma"},
+            {"particle": "electron", "configuration_id": 14, "site": "paranal"},
+        ]
+        result = self.client._RucioFileCatalogClient__transform_DIRAC_filter_dict_to_Rucio_filter_dict(input_dict)
+        assert result == expected
+
+    def test_transform_DIRAC_filter_dict_to_Rucio_filter_dict(self):
+        DIRAC_filter_dict_list = [
+            {
+                "particle": {"in": ["proton", "electron"]},
+                "configuration_id": {"=": 14},
+                "site": {"in": ["LaPalma", "paranal"]},
+            }
+        ]
+        expected_output = [
+            {"particle": "proton", "configuration_id": 14, "site": "LaPalma"},
+            {"particle": "proton", "configuration_id": 14, "site": "paranal"},
+            {"particle": "electron", "configuration_id": 14, "site": "LaPalma"},
+            {"particle": "electron", "configuration_id": 14, "site": "paranal"},
+        ]
+        result = self.client._RucioFileCatalogClient__transform_DIRAC_filter_dict_to_Rucio_filter_dict(
+            DIRAC_filter_dict_list
+        )
+        self.assertEqual(result, expected_output)
+
+    def test_findFilesByMetadata(self):
+        self.client.client.list_dids.return_value = ["did1", "did2"]
+        metadataFilterDict = {"key1": "value1"}
+        result = self.client.findFilesByMetadata(metadataFilterDict)
+        self.assertTrue(result["OK"])
+        self.assertEqual(result["Value"], ["did1", "did2"])
+
+    def test_findFilesByMetadata_with_error(self):
+        self.client.client.list_dids.side_effect = Exception("Test error")
+        metadataFilterDict = {"key1": "value1"}
+        result = self.client.findFilesByMetadata(metadataFilterDict)
+        self.assertFalse(result["OK"])
+        self.assertIn("Test error", result["Message"])
+
+
+if __name__ == "__main__":
+    unittest.main()

DIRAC/Resources/Computing/AREXComputingElement.py

@@ -1,4 +1,4 @@
-""" AREX Computing Element (ARC REST interface)
+"""AREX Computing Element (ARC REST interface)
 
 Allows interacting with ARC AREX services via a REST interface.
 
@@ -48,6 +48,7 @@ import json
 import os
 import shutil
 import stat
+import tempfile
 import uuid
 
 import requests
@@ -57,7 +58,6 @@ from DIRAC.Core.Security import Locations
 from DIRAC.Core.Security.ProxyInfo import getVOfromProxyGroup
 from DIRAC.Core.Security.X509Chain import X509Chain  # pylint: disable=import-error
 from DIRAC.Resources.Computing.ComputingElement import ComputingElement
-from DIRAC.Resources.Computing.PilotBundle import writeScript
 from DIRAC.WorkloadManagementSystem.Client import PilotStatus
 
 MANDATORY_PARAMETERS = ["Queue"]
@@ -258,9 +258,6 @@ class AREXComputingElement(ComputingElement):
         if not (self.token or self.proxy):
             self.log.error("Proxy or token not set")
             return S_ERROR("Proxy or token not set")
-        if not self.proxy and self.alwaysIncludeProxy:
-            self.log.error("Proxy required but not set")
-            return S_ERROR("Proxy required but not set")
 
         # If a token is set, we use it
         if self.token:
@@ -498,7 +495,11 @@ class AREXComputingElement(ComputingElement):
         if not os.access(executableFile, os.X_OK):
             os.chmod(executableFile, stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP | stat.S_IROTH + stat.S_IXOTH)
 
-        return writeScript(wrapperContent, os.getcwd())
+        with tempfile.NamedTemporaryFile(
+            "w", delete=False, prefix="preamble-", suffix=f"-{executableFile}"
+        ) as bundleFile:
+            bundleFile.write(wrapperContent)
+            return bundleFile.name
 
     def _getArcJobID(self, executableFile, inputs, outputs, delegation):
         """Get an ARC JobID endpoint to upload executables and inputs.
@@ -806,7 +807,23 @@ class AREXComputingElement(ComputingElement):
             return S_ERROR(f"Failed decoding the status of the CE")
 
         # Look only in the relevant section out of the headache
-        queueInfo = ceData["Domains"]["AdminDomain"]["Services"]["ComputingService"]["ComputingShare"]
+        # This "safe_get" function allows to go down the dictionary
+        # even if some elements are lists instead of dictionaries
+        # and returns None if any element is not found
+        # FIXME: this is a temporary measure to be removed after https://github.com/DIRACGrid/DIRAC/issues/8354
+        def safe_get(d, *keys):
+            for k in keys:
+                if isinstance(d, list):
+                    d = d[0]  # assume first element
+                d = d.get(k) if isinstance(d, dict) else None
+                if d is None:
+                    break
+            return d
+
+        queueInfo = safe_get(ceData, "Domains", "AdminDomain", "Services", "ComputingService", "ComputingShare")
+        if queueInfo is None:
+            self.log.error("Failed to extract queue info")
+
         if not isinstance(queueInfo, list):
             queueInfo = [queueInfo]
 
@@ -818,7 +835,7 @@ class AREXComputingElement(ComputingElement):
         for qi in queueInfo:
             if qi["ID"].endswith(magic):
                 result["RunningJobs"] = int(qi["RunningJobs"])
-                result["WaitingJobs"] = int(qi["WaitingJobs"])
+                result["WaitingJobs"] = int(qi["WaitingJobs"]) + int(qi["StagingJobs"]) + int(qi["PreLRMSWaitingJobs"])
                 break  # Pick the first (should be only ...) matching queue + VO
         else:
             return S_ERROR(f"Could not find the queue {self.queue} associated to VO {vo}")