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

DIRAC/Interfaces/Utilities/DConfigCache.py

@@ -9,6 +9,7 @@ from DIRAC import gLogger
 from DIRAC.Core.Base.Script import Script
 from DIRAC.Core.Utilities.File import secureOpenForWrite
 from DIRAC.ConfigurationSystem.Client.ConfigurationData import gConfigurationData
+from DIRAC.ConfigurationSystem.Client.Helpers.Registry import reset_all_caches
 
 
 class ConfigCache:
@@ -69,5 +70,6 @@ class ConfigCache:
             try:
                 with open(self.configCacheName, "rb") as fh:
                     gConfigurationData.mergedCFG = pickle.load(fh)
+                    reset_all_caches()
             except:
                 gLogger.error("Cache corrupt or unreadable")

DIRAC/Interfaces/scripts/dirac_wms_job_parameters.py

@@ -17,7 +17,6 @@ Example:
    'LocalAccount': 'prod006',
    'LocalBatchID': '',
    'LocalJobID': '277821.ce.labmc.inf.utfsm.cl',
-   'MatcherServiceTime': '2.27646398544',
    'Memory(kB)': '858540kB',
    'ModelName': 'Intel(R)Xeon(R)CPU5110@1.60GHz',
    'NormCPUTime(s)': '1.02',

DIRAC/MonitoringSystem/DB/MonitoringDB.py

@@ -5,8 +5,7 @@ Wrapper on top of ElasticDB. It is used to manage the DIRAC monitoring types.
 
 The following option can be set in `Systems/Monitoring/Databases/MonitoringDB`
 
-* *IndexPrefix*:  Prefix used to prepend to indexes created in the ES instance. If this
-                  is not present in the CS, the indexes are prefixed with the setup name.
+* *IndexPrefix*:  Prefix used to prepend to indexes created in the OpenSearch instance.
 
 For each monitoring types managed, the Period (how often a new index is created)
 can be defined with::
@@ -33,7 +32,6 @@ import time
 
 from DIRAC import S_ERROR, S_OK
 from DIRAC.ConfigurationSystem.Client.Config import gConfig
-from DIRAC.ConfigurationSystem.Client.Helpers import CSGlobals
 from DIRAC.ConfigurationSystem.Client.PathFinder import getDatabaseSection
 from DIRAC.Core.Base.ElasticDB import ElasticDB
 from DIRAC.Core.Utilities.Plotting.TypeLoader import TypeLoader
@@ -48,7 +46,7 @@ class MonitoringDB(ElasticDB):
 
         try:
             section = getDatabaseSection("Monitoring/MonitoringDB")
-            indexPrefix = gConfig.getValue(f"{section}/IndexPrefix", CSGlobals.getSetup()).lower()
+            indexPrefix = gConfig.getValue(f"{section}/IndexPrefix", "").lower()
             # Connecting to the ES cluster
             super().__init__(fullName=name, indexPrefix=indexPrefix)
         except RuntimeError as ex:
@@ -192,7 +190,10 @@ class MonitoringDB(ElasticDB):
         # and now we group with bucket aggregation
         groupingAggregation = self._A("terms", field=grouping, size=self.RESULT_SIZE)
         groupingAggregation.bucket(
-            "end_data", "date_histogram", field="timestamp", interval=interval  # name  # type
+            "end_data",
+            "date_histogram",
+            field="timestamp",
+            interval=interval,
         ).metric("timeAggregation", timeAggregation).pipeline(
             "timeAggregation_avg_bucket", "avg_bucket", buckets_path="timeAggregation>total", gap_policy="insert_zeros"
         )

DIRAC/MonitoringSystem/Service/WebAppHandler.py

@@ -2,6 +2,7 @@
 The WebAppHandler module provides a class to handle web requests from the DIRAC WebApp.
 It is not indented to be used in diracx
 """
+
 from DIRAC import S_ERROR, S_OK
 from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
 from DIRAC.ConfigurationSystem.Client.Helpers.Resources import getSites
@@ -28,19 +29,29 @@ class WebAppHandler(RequestHandler):
             result = ObjectLoader().loadObject("WorkloadManagementSystem.DB.PilotAgentsDB", "PilotAgentsDB")
             if not result["OK"]:
                 return result
-            cls.pilotAgentsDB = result["Value"](parentLogger=cls.log)
+            try:
+                cls.pilotAgentsDB = result["Value"](parentLogger=cls.log)
+            except RuntimeError:
+                cls.log.warn("Could not connect to PilotAgentsDB")
 
             result = ObjectLoader().loadObject("WorkloadManagementSystem.DB.JobDB", "JobDB")
             if not result["OK"]:
                 return result
-            cls.jobDB = result["Value"](parentLogger=cls.log)
+            try:
+                cls.jobDB = result["Value"](parentLogger=cls.log)
+            except RuntimeError:
+                cls.log.warn("Could not connect to JobDB")
 
             result = ObjectLoader().loadObject("TransformationSystem.DB.TransformationDB", "TransformationDB")
             if not result["OK"]:
                 return result
-            cls.transformationDB = result["Value"](parentLogger=cls.log)
+            try:
+                cls.transformationDB = result["Value"](parentLogger=cls.log)
+            except RuntimeError:
+                cls.log.warn("Could not connect to TransformationDB")
 
         except RuntimeError as excp:
+            cls.log.exception()
             return S_ERROR(f"Can't connect to DB: {excp}")
 
         return S_OK()
@@ -517,13 +528,21 @@ class WebAppHandler(RequestHandler):
         ops = Operations()
         # Prepare the standard structure now within the resultDict dictionary
         resultDict = {}
-        trList = res["Records"]
+        # Reconstruct just the values list
+        trList = [
+            [str(item) if not isinstance(item, int) else item for item in trans_dict.values()]
+            for trans_dict in res["Value"]
+        ]
+
         # Create the total records entry
         nTrans = len(trList)
         resultDict["TotalRecords"] = nTrans
         # Create the ParameterNames entry
-        # As this list is a reference to the list in the DB, we cannot extend it, therefore copy it
-        resultDict["ParameterNames"] = list(res["ParameterNames"])
+        try:
+            resultDict["ParameterNames"] = list(res["Value"][0].keys())
+        except IndexError:
+            # As this list is a reference to the list in the DB, we cannot extend it, therefore copy it
+            resultDict["ParameterNames"] = list(cls.transformationDB.TRANSPARAMS)
         # Add the job states to the ParameterNames entry
         taskStateNames = TASKS_STATE_NAMES + ops.getValue("Transformations/AdditionalTaskStates", [])
         resultDict["ParameterNames"] += ["Jobs_" + x for x in taskStateNames]

DIRAC/MonitoringSystem/private/MainReporter.py

@@ -5,7 +5,6 @@ import hashlib
 import re
 
 from DIRAC import S_OK, S_ERROR, gConfig
-from DIRAC.ConfigurationSystem.Client.Helpers import CSGlobals
 from DIRAC.ConfigurationSystem.Client.PathFinder import getServiceSection
 from DIRAC.MonitoringSystem.private.Plotters.BasePlotter import BasePlotter as myBasePlotter
 from DIRAC.Core.Utilities.ObjectLoader import loadObjects
@@ -56,7 +55,6 @@ class MainReporter:
         :param str setup: DIRAC setup
         """
         self.__db = db
-        self.__setup = CSGlobals.getSetup().lower()
         self.__csSection = getServiceSection("Monitoring/Monitoring")
         self.__plotterList = PlottersList()
 
@@ -75,7 +73,6 @@ class MainReporter:
             requestToHash[key] = epoch - epoch % granularity
         md5Hash = hashlib.md5()
         md5Hash.update(repr(requestToHash).encode())
-        md5Hash.update(self.__setup.encode())
         return md5Hash.hexdigest()
 
     def generate(self, reportRequest):

DIRAC/RequestManagementSystem/Agent/RequestExecutingAgent.py

@@ -48,13 +48,13 @@ from DIRAC.RequestManagementSystem.private.RequestTask import RequestTask
 # # agent name
 AGENT_NAME = "RequestManagement/RequestExecutingAgent"
 # # requests/cycle
-REQUESTSPERCYCLE = 100
+REQUESTSPERCYCLE = 300
 # # minimal nb of subprocess running
-MINPROCESS = 20
+MINPROCESS = 50
 # # maximal nb of subprocess executed same time
-MAXPROCESS = 20
+MAXPROCESS = 50
 # # ProcessPool queue size
-QUEUESIZE = 20
+QUEUESIZE = 100
 # # file timeout
 FILETIMEOUT = 300
 # # operation timeout
@@ -62,7 +62,9 @@ OPERATIONTIMEOUT = 300
 # # ProcessPool finalization timeout
 POOLTIMEOUT = 900
 # # ProcessPool sleep time
-POOLSLEEP = 5
+POOLSLEEP = 1
+# # Fetch multiple requests at once from the DB. Otherwise, one by one
+BULKREQUEST = 300
 
 
 class AgentConfigError(Exception):
@@ -108,7 +110,7 @@ class RequestExecutingAgent(AgentModule):
         self.__poolSleep = POOLSLEEP
         self.__requestClient = None
         # Size of the bulk if use of getRequests. If 0, use getRequest
-        self.__bulkRequest = 0
+        self.__bulkRequest = BULKREQUEST
         self.__rmsMonitoring = False
 
     def processPool(self):

DIRAC/RequestManagementSystem/ConfigTemplate.cfg

@@ -44,19 +44,19 @@ Agents
   {
     PollingTime = 60
     # number of Requests to execute per cycle
-    RequestsPerCycle = 100
+    RequestsPerCycle = 300
     # minimum number of workers process in the ProcessPool
-    MinProcess = 20
+    MinProcess = 50
     # maximum number of workers process in the ProcessPool; recommended to set it to the same value as MinProcess
-    MaxProcess = 20
+    MaxProcess = 50
     # queue depth of the ProcessPool
-    ProcessPoolQueueSize = 20
+    ProcessPoolQueueSize = 100
     # timeout for the ProcessPool finalization
     ProcessPoolTimeout = 900
     # sleep time before retrying to get a free slot in the ProcessPool
-    ProcessPoolSleep = 5
+    ProcessPoolSleep = 1
     # If a positive integer n is given, we fetch n requests at once from the DB. Otherwise, one by one
-    BulkRequest = 0
+    BulkRequest = 300
     OperationHandlers
     {
       ForwardDISET

DIRAC/ResourceStatusSystem/Command/FreeDiskSpaceCommand.py

@@ -121,7 +121,9 @@ class FreeDiskSpaceCommand(Command):
             "Site": siteRes["Value"] if siteRes["Value"] else "unassigned",
         }
 
-        results["Used"] = results["Total"] - results["Free"]
+        # There are sometimes small discrepencies which can lead to negative
+        # used values.
+        results["Used"] = max(0, results["Total"] - results["Free"])
 
         for sType in ["Total", "Free", "Used"]:
             spaceTokenAccounting = StorageOccupancy()

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.
 
@@ -807,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]
 

DIRAC/Resources/Computing/BatchSystems/Condor.py

@@ -203,9 +203,6 @@ class Condor(object):
             resultDict["Jobs"] = []
             for i in range(submittedJobs):
                 resultDict["Jobs"].append(".".join([cluster, str(i)]))
-            # Executable is transferred afterward
-            # Inform the caller that Condor cannot delete it before the end of the execution
-            resultDict["ExecutableToKeep"] = executable
         else:
             resultDict["Status"] = status
             resultDict["Message"] = error

DIRAC/Resources/Computing/BatchSystems/executeBatch.py

@@ -35,8 +35,10 @@ if __name__ == "__main__":
       from urllib.parse import unquote as urlunquote
 
 
-  arguments = sys.argv[1]
-  inputDict = json.loads(urlunquote(arguments))
+  # Read options from JSON file
+  optionsFilePath = sys.argv[1]
+  with open(optionsFilePath, 'r') as f:
+    inputDict = json.load(f)
 
   method = inputDict.pop('Method')
   batchSystem = inputDict.pop('BatchSystem')
@@ -45,9 +47,15 @@ if __name__ == "__main__":
   try:
     result = getattr(batch, method)(**inputDict)
   except Exception:
-    result = traceback.format_exc()
-
-  resultJson = urlquote(json.dumps(result))
-  print("============= Start output ===============")
-  print(resultJson)
+    # Wrap the traceback in a proper error structure
+    result = {
+      'Status': -1,
+      'Message': 'Exception during batch method execution',
+      'Traceback': traceback.format_exc()
+    }
+
+  # Write result to JSON file
+  resultFilePath = optionsFilePath.replace('.json', '_result.json')
+  with open(resultFilePath, 'w') as f:
+    json.dump(result, f)
 """

DIRAC/Resources/Computing/LocalComputingElement.py

@@ -182,8 +182,6 @@ class LocalComputingElement(ComputingElement):
             batchSystemName = self.batchSystem.__class__.__name__.lower()
             jobIDs = ["ssh" + batchSystemName + "://" + self.ceName + "/" + _id for _id in resultSubmit["Jobs"]]
             result = S_OK(jobIDs)
-            if "ExecutableToKeep" in resultSubmit:
-                result["ExecutableToKeep"] = resultSubmit["ExecutableToKeep"]
         else:
             result = S_ERROR(resultSubmit["Message"])
 

DIRAC/Resources/Computing/SSHComputingElement.py

@@ -67,9 +67,10 @@ import json
 import os
 import shutil
 import stat
+import tempfile
 import uuid
 from shlex import quote as shlex_quote
-from urllib.parse import quote, unquote, urlparse
+from urllib.parse import urlparse
 
 import pexpect
 
@@ -484,47 +485,69 @@ class SSHComputingElement(ComputingElement):
         options["User"] = self.user
         options["Queue"] = self.queue
 
-        options = json.dumps(options)
-        options = quote(options)
+        localOptionsFile = None
+        remoteOptionsFile = None
+        localResultFile = None
+        remoteResultFile = None
+        try:
+            # Write options to a local temporary file
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+                json.dump(options, f)
+                localOptionsFile = f.name
+
+            # Upload the options file to the remote host
+            remoteOptionsFile = f"{self.sharedArea}/batch_options_{uuid.uuid4().hex}.json"
+            result = ssh.scpCall(30, localOptionsFile, remoteOptionsFile)
+            if not result["OK"]:
+                return result
 
-        cmd = (
-            "bash --login -c 'python3 %s/execute_batch %s || python %s/execute_batch %s || python2 %s/execute_batch %s'"
-            % (self.sharedArea, options, self.sharedArea, options, self.sharedArea, options)
-        )
+            # Execute the batch command with the options file path
+            cmd = (
+                f"bash --login -c 'python3 {self.sharedArea}/execute_batch {remoteOptionsFile} || "
+                f"python {self.sharedArea}/execute_batch {remoteOptionsFile} || "
+                f"python2 {self.sharedArea}/execute_batch {remoteOptionsFile}'"
+            )
 
-        self.log.verbose(f"CE submission command: {cmd}")
+            self.log.verbose(f"CE submission command: {cmd}")
 
-        result = ssh.sshCall(120, cmd)
-        if not result["OK"]:
-            self.log.error(f"{self.ceType} CE job submission failed", result["Message"])
-            return result
+            result = ssh.sshCall(120, cmd)
+            if not result["OK"]:
+                self.log.error(f"{self.ceType} CE job submission failed", result["Message"])
+                return result
 
-        sshStatus = result["Value"][0]
-        sshStdout = result["Value"][1]
-        sshStderr = result["Value"][2]
-
-        # Examine results of the job submission
-        if sshStatus == 0:
-            output = sshStdout.strip().replace("\r", "").strip()
-            if not output:
-                return S_ERROR("No output from remote command")
-
-            try:
-                index = output.index("============= Start output ===============")
-                output = output[index + 42 :]
-            except ValueError:
-                return S_ERROR(f"Invalid output from remote command: {output}")
-
-            try:
-                output = unquote(output)
-                result = json.loads(output)
-                if isinstance(result, str) and result.startswith("Exception:"):
-                    return S_ERROR(result)
-                return S_OK(result)
-            except Exception:
-                return S_ERROR("Invalid return structure from job submission")
-        else:
-            return S_ERROR("\n".join([sshStdout, sshStderr]))
+            sshStatus = result["Value"][0]
+            if sshStatus != 0:
+                sshStdout = result["Value"][1]
+                sshStderr = result["Value"][2]
+                return S_ERROR(f"CE job submission command failed with status {sshStatus}: {sshStdout} {sshStderr}")
+
+            # The result should be written to a JSON file by execute_batch
+            # Compute the expected result file path
+            remoteResultFile = remoteOptionsFile.replace(".json", "_result.json")
+
+            # Try to download the result file
+            with tempfile.NamedTemporaryFile(mode="r", suffix=".json", delete=False) as f:
+                localResultFile = f.name
+
+            result = ssh.scpCall(30, localResultFile, remoteResultFile, upload=False)
+            if not result["OK"]:
+                return result
+
+            # Read the result from the downloaded file
+            with open(localResultFile) as f:
+                result = json.load(f)
+            return S_OK(result)
+        finally:
+            # Clean up local temporary file
+            if localOptionsFile and os.path.exists(localOptionsFile):
+                os.remove(localOptionsFile)
+            if localResultFile and os.path.exists(localResultFile):
+                os.remove(localResultFile)
+            # Clean up remote temporary files
+            if remoteOptionsFile:
+                ssh.sshCall(30, f"rm -f {remoteOptionsFile}")
+            if remoteResultFile:
+                ssh.sshCall(30, f"rm -f {remoteResultFile}")
 
     def submitJob(self, executableFile, proxy, numberOfJobs=1):
         #    self.log.verbose( "Executable file path: %s" % executableFile )

DIRAC/Resources/IdProvider/CheckInIdProvider.py

@@ -26,3 +26,16 @@ class CheckInIdProvider(OAuth2IdProvider):
 
             idPScope = f"eduperson_entitlement?value=urn:mace:egi.eu:group:{vo}:role={groupElements[1]}#aai.egi.eu"
         return scope_to_list(idPScope)
+
+    def fetchToken(self, **kwargs):
+        """Fetch token
+
+        :param kwargs:
+        :return: dict
+        """
+
+        if "audience" in kwargs:
+            kwargs["resource"] = kwargs["audience"]
+            kwargs.pop("audience")
+
+        return super().fetchToken(**kwargs)

DIRAC/Resources/IdProvider/IdProviderFactory.py

@@ -1,6 +1,7 @@
-"""  The Identity Provider Factory instantiates IdProvider objects
-     according to their configuration
+"""The Identity Provider Factory instantiates IdProvider objects
+according to their configuration
 """
+
 import jwt
 
 from DIRAC import S_OK, S_ERROR, gLogger, gConfig
@@ -40,11 +41,12 @@ class IdProviderFactory:
             return result
         return self.getIdProvider(result["Value"])
 
-    def getIdProvider(self, name, **kwargs):
+    def getIdProvider(self, name, client_name_prefix="", **kwargs):
         """This method returns a IdProvider instance corresponding to the supplied
         name.
 
         :param str name: the name of the Identity Provider client
+        :param str client_name_prefix: name of the client of the IdP
 
         :return: S_OK(IdProvider)/S_ERROR()
         """
@@ -68,8 +70,16 @@ class IdProviderFactory:
             if not result["OK"]:
                 self.log.error("Failed to read configuration", f"{name}: {result['Message']}")
                 return result
+
             pDict = result["Value"]
 
+            if client_name_prefix:
+                client_name_prefix = client_name_prefix + "_"
+            if f"{client_name_prefix}client_id" in pDict:
+                pDict["client_id"] = pDict[f"{client_name_prefix}client_id"]
+            if f"{client_name_prefix}client_secret" in pDict:
+                pDict["client_secret"] = pDict[f"{client_name_prefix}client_secret"]
+
         pDict.update(kwargs)
         pDict["ProviderName"] = name
 

DIRAC/Resources/IdProvider/tests/Test_IdProviderFactory.py

@@ -63,6 +63,12 @@ Resources
       client_secret = IdP_client_secret
       scope = openid+profile+offline_access+eduperson_entitlement
     }
+    SomeIdP3.partial
+    {
+      ProviderType = OAuth2
+      issuer = https://and-another-idp.url/
+      scope = openid+profile+offline_access+eduperson_entitlement
+    }
   }
 }
 """
@@ -77,6 +83,7 @@ idps = IdProviderFactory()
         ("SomeIdP1.2", {"OK": True}, "https://idp.url/", "IdP_client_id2", "IdP_client_secret"),
         ("SomeIdP2", {"OK": True}, "https://another-idp.url/", "IdP_client_id1", "IdP_client_secret"),
         ("SomeIdP3", {"OK": True}, "https://and-another-idp.url/", "IdP_client_id3", "IdP_client_secret"),
+        ("SomeIdP3.partial", {"OK": True}, "https://and-another-idp.url/", None, None),
         # Try to get an unknown DIRAC client
         ("DIRACUnknown", {"OK": False, "Message": "DIRACUnknown does not exist"}, None, None, None),
     ],

DIRAC/Resources/Storage/FileStorage.py

@@ -1,10 +1,13 @@
 """
- This is the File StorageClass, only meant to be used localy
- """
+This is the File StorageClass, only meant to be used localy
+"""
+
 import os
 import shutil
 import errno
 import stat
+import struct
+import time
 
 from DIRAC import gLogger, S_OK, S_ERROR
 from DIRAC.Resources.Storage.Utilities import checkArgumentFormat
@@ -12,6 +15,116 @@ from DIRAC.Resources.Storage.StorageBase import StorageBase
 from DIRAC.Core.Utilities.Adler import fileAdler
 
 
+def set_xattr_adler32(path, checksum):
+    """
+    Set the adler32 checksum extended attribute on a file.
+
+    This is needed for case where you write the data on a locally mounted
+    file system, but then want to access it from outside via xroot (like the HLT farm)
+
+    Hopefully, this whole function will be part of xroot at some point
+    https://github.com/xrootd/xrootd/pull/2650
+
+
+    This function replicates the exact behavior of the C++ function fSetXattrAdler32
+
+    It writes the checksum in XrdCksData binary format with the following structure:
+        - Name[16]:    Algorithm name ("adler32"), null-padded
+        - fmTime (8):  File modification time (network byte order, int64)
+        - csTime (4):  Time delta from mtime (network byte order, int32)
+        - Rsvd1 (2):   Reserved (int16)
+        - Rsvd2 (1):   Reserved (uint8)
+        - Length (1):  Checksum length in bytes (uint8)
+        - Value[64]:   Binary checksum value (4 bytes for adler32)
+
+    Total structure size: 96 bytes
+
+    Parameters
+    ----------
+    path : str
+        Path to the file (must be a regular file on local filesystem)
+    checksum : str
+        8-character hexadecimal adler32 checksum (e.g., "deadbeef")
+
+
+    Notes
+    -----
+    - The attribute is stored as "user.XrdCks.adler32"
+
+    """
+    # Validate checksum format
+    if not isinstance(checksum, str) or len(checksum) != 8:
+        raise ValueError("Checksum must be exactly 8 characters")
+
+    # Validate it's valid hex
+    try:
+        int(checksum, 16)
+    except ValueError:
+        raise ValueError(f"Checksum must be valid hexadecimal: {checksum}")
+
+    # Check file exists and is regular
+
+    st = os.stat(path)
+
+    # Import xattr module
+    try:
+        import xattr
+    except ImportError:
+        raise ImportError("The 'xattr' module is required. Install it with: pip install xattr")
+
+    # Build XrdCksData structure (96 bytes total)
+    # Reference: src/XrdCks/XrdCksData.hh
+
+    # 1. Name[16] - Algorithm name, null-padded
+    name = b"adler32"
+    name_field = name.ljust(16, b"\x00")
+
+    # 2. fmTime (8 bytes) - File modification time (network byte order = big-endian)
+    fm_time = int(st.st_mtime)
+    fm_time_field = struct.pack(">q", fm_time)  # signed 64-bit big-endian
+
+    # 3. csTime (4 bytes) - Delta from mtime to now (network byte order)
+    cs_time = int(time.time()) - fm_time
+    cs_time_field = struct.pack(">i", cs_time)  # signed 32-bit big-endian
+
+    # 4. Rsvd1 (2 bytes) - Reserved, set to 0
+    rsvd1_field = struct.pack(">h", 0)  # signed 16-bit big-endian
+
+    # 5. Rsvd2 (1 byte) - Reserved, set to 0
+    rsvd2_field = struct.pack("B", 0)  # unsigned 8-bit
+
+    # 6. Length (1 byte) - Checksum length in bytes
+    # Adler32 is 4 bytes (8 hex chars / 2)
+    length_field = struct.pack("B", 4)  # unsigned 8-bit
+
+    # 7. Value[64] - Binary checksum value
+    # Convert hex string to 4 bytes, pad rest with zeros
+    checksum_bytes = bytes.fromhex(checksum)
+    value_field = checksum_bytes + b"\x00" * (64 - len(checksum_bytes))
+
+    # Assemble complete structure
+    xrd_cks_data = (
+        name_field  # 16 bytes
+        + fm_time_field  #  8 bytes
+        + cs_time_field  #  4 bytes
+        + rsvd1_field  #  2 bytes
+        + rsvd2_field  #  1 byte
+        + length_field  #  1 byte
+        + value_field  # 64 bytes
+    )  # Total: 96 bytes
+
+    assert len(xrd_cks_data) == 96, f"Structure size mismatch: {len(xrd_cks_data)}"
+
+    # Set the extended attribute
+    # XRootD uses "XrdCks.adler32" which becomes "user.XrdCks.adler32" on Linux
+    attr_name = "user.XrdCks.adler32"
+
+    try:
+        xattr.setxattr(path, attr_name, xrd_cks_data)
+    except OSError as e:
+        raise OSError(f"Failed to set extended attribute on {path}: {e}") from e
+
+
 class FileStorage(StorageBase):
     """.. class:: FileStorage
 
@@ -165,6 +278,12 @@ class FileStorage(StorageBase):
                     os.makedirs(dirname)
                 shutil.copy2(src_file, dest_url)
                 fileSize = os.path.getsize(dest_url)
+                try:
+                    src_cks = fileAdler(src_file)
+                    set_xattr_adler32(dest_url, src_cks)
+                except Exception as e:
+                    gLogger.warn("Could not set checksum", f"{e!r}")
+
                 if sourceSize and (sourceSize != fileSize):
                     try:
                         os.unlink(dest_url)