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

DIRAC/WorkloadManagementSystem/Client/JobState/JobManifest.py

@@ -1,266 +1,37 @@
-from diraccfg import CFG
+from __future__ import annotations
 
-from DIRAC import S_OK, S_ERROR
-from DIRAC.Core.Utilities import List
-from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
-from DIRAC.Core.Utilities.JDL import loadJDLAsCFG, dumpCFGAsJDL
-
-
-class JobManifest:
-    def __init__(self, manifest=""):
-        self.__manifest = CFG()
-        self.__dirty = False
-        self.__ops = False
-        if manifest:
-            result = self.load(manifest)
-            if not result["OK"]:
-                raise Exception(result["Message"])
-
-    def isDirty(self):
-        return self.__dirty
-
-    def setDirty(self):
-        self.__dirty = True
-
-    def clearDirty(self):
-        self.__dirty = False
-
-    def load(self, dataString):
-        """
-        Auto discover format type based on [ .. ] of JDL
-        """
-        dataString = dataString.strip()
-        if dataString[0] == "[" and dataString[-1] == "]":
-            return self.loadJDL(dataString)
-        else:
-            return self.loadCFG(dataString)
-
-    def loadJDL(self, jdlString):
-        """
-        Load job manifest from JDL format
-        """
-        result = loadJDLAsCFG(jdlString.strip())
-        if not result["OK"]:
-            self.__manifest = CFG()
-            return result
-        self.__manifest = result["Value"][0]
-        return S_OK()
-
-    def loadCFG(self, cfgString):
-        """
-        Load job manifest from CFG format
-        """
-        try:
-            self.__manifest.loadFromBuffer(cfgString)
-        except Exception as e:
-            return S_ERROR(f"Can't load manifest from cfg: {str(e)}")
-        return S_OK()
-
-    def dumpAsCFG(self):
-        return str(self.__manifest)
-
-    def getAsCFG(self):
-        return self.__manifest.clone()
-
-    def dumpAsJDL(self):
-        return dumpCFGAsJDL(self.__manifest)
-
-    def __getCSValue(self, varName, defaultVal=None):
-        if not self.__ops:
-            self.__ops = Operations(group=self.__manifest["OwnerGroup"])
-        if varName[0] != "/":
-            varName = f"JobDescription/{varName}"
-        return self.__ops.getValue(varName, defaultVal)
-
-    def __checkNumericalVar(self, varName, defaultVal, minVal, maxVal):
-        """
-        Check a numerical var
-        """
-        initialVal = False
-        if varName not in self.__manifest:
-            varValue = self.__getCSValue(f"Default{varName}", defaultVal)
-        else:
-            varValue = self.__manifest[varName]
-            initialVal = varValue
-        try:
-            varValue = int(varValue)
-        except ValueError:
-            return S_ERROR(f"{varName} must be a number")
-        minVal = self.__getCSValue(f"Min{varName}", minVal)
-        maxVal = self.__getCSValue(f"Max{varName}", maxVal)
-        varValue = max(minVal, min(varValue, maxVal))
-        if initialVal != varValue:
-            self.__manifest.setOption(varName, varValue)
-        return S_OK(varValue)
-
-    def __checkChoiceVar(self, varName, defaultVal, choices):
-        """
-        Check a choice var
-        """
-        initialVal = False
-        if varName not in self.__manifest:
-            varValue = self.__getCSValue(f"Default{varName}", defaultVal)
-        else:
-            varValue = self.__manifest[varName]
-            initialVal = varValue
-        if varValue not in self.__getCSValue(f"Choices{varName}", choices):
-            return S_ERROR(f"{varValue} is not a valid value for {varName}")
-        if initialVal != varValue:
-            self.__manifest.setOption(varName, varValue)
-        return S_OK(varValue)
-
-    def __checkMultiChoice(self, varName, choices):
-        """
-        Check a multi choice var
-        """
-        initialVal = False
-        if varName not in self.__manifest:
-            return S_OK()
-        else:
-            varValue = self.__manifest[varName]
-            initialVal = varValue
-        choices = self.__getCSValue(f"Choices{varName}", choices)
-        for v in List.fromChar(varValue):
-            if v not in choices:
-                return S_ERROR(f"{v} is not a valid value for {varName}")
-        if initialVal != varValue:
-            self.__manifest.setOption(varName, varValue)
-        return S_OK(varValue)
+from DIRACCommon.WorkloadManagementSystem.Client.JobState.JobManifest import *  # noqa: F401, F403
 
-    def __checkMaxInputData(self, maxNumber):
-        """
-        Check Maximum Number of Input Data files allowed
-        """
-        varName = "InputData"
-        if varName not in self.__manifest:
-            return S_OK()
-        varValue = self.__manifest[varName]
-        if len(List.fromChar(varValue)) > maxNumber:
-            return S_ERROR(
-                "Number of Input Data Files (%s) greater than current limit: %s"
-                % (len(List.fromChar(varValue)), maxNumber)
-            )
-        return S_OK()
-
-    def __contains__(self, key):
-        """Check if the manifest has the required key"""
-        return key in self.__manifest
+from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
 
-    def setOptionsFromDict(self, varDict):
-        for k in sorted(varDict):
-            self.setOption(k, varDict[k])
 
+def makeJobManifestConfig(ownerGroup: str) -> JobManifestConfig:
+    ops = Operations(group=ownerGroup)
+
+    allowedJobTypesForGroup = ops.getValue(
+        "JobDescription/ChoicesJobType",
+        ops.getValue("JobDescription/AllowedJobTypes", ["User", "Test", "Hospital"])
+        + ops.getValue("Transformations/DataProcessing", []),
+    )
+
+    return {
+        "defaultForGroup": {
+            "CPUTime": ops.getValue("JobDescription/DefaultCPUTime", 86400),
+            "Priority": ops.getValue("JobDescription/DefaultPriority", 1),
+        },
+        "minForGroup": {
+            "CPUTime": ops.getValue("JobDescription/MinCPUTime", 100),
+            "Priority": ops.getValue("JobDescription/MinPriority", 0),
+        },
+        "maxForGroup": {
+            "CPUTime": ops.getValue("JobDescription/MaxCPUTime", 500000),
+            "Priority": ops.getValue("JobDescription/MaxPriority", 10),
+        },
+        "allowedJobTypesForGroup": allowedJobTypesForGroup,
+        "maxInputData": Operations().getValue("JobDescription/MaxInputData", 500),
+    }
+
+
+class JobManifest(JobManifest):  # noqa: F405 pylint: disable=function-redefined
     def check(self):
-        """
-        Check that the manifest is OK
-        """
-        for k in ["Owner", "OwnerGroup"]:
-            if k not in self.__manifest:
-                return S_ERROR(f"Missing var {k} in manifest")
-
-        # Check CPUTime
-        result = self.__checkNumericalVar("CPUTime", 86400, 100, 500000)
-        if not result["OK"]:
-            return result
-
-        result = self.__checkNumericalVar("Priority", 1, 0, 10)
-        if not result["OK"]:
-            return result
-
-        maxInputData = Operations().getValue("JobDescription/MaxInputData", 500)
-        result = self.__checkMaxInputData(maxInputData)
-        if not result["OK"]:
-            return result
-
-        operation = Operations(group=self.__manifest["OwnerGroup"])
-        allowedJobTypes = operation.getValue("JobDescription/AllowedJobTypes", ["User", "Test", "Hospital"])
-        transformationTypes = operation.getValue("Transformations/DataProcessing", [])
-        result = self.__checkMultiChoice("JobType", allowedJobTypes + transformationTypes)
-        if not result["OK"]:
-            return result
-        return S_OK()
-
-    def createSection(self, secName, contents=False):
-        if secName not in self.__manifest:
-            if contents and not isinstance(contents, CFG):
-                return S_ERROR(f"Contents for section {secName} is not a cfg object")
-            self.__dirty = True
-            return S_OK(self.__manifest.createNewSection(secName, contents=contents))
-        return S_ERROR(f"Section {secName} already exists")
-
-    def getSection(self, secName):
-        self.__dirty = True
-        if secName not in self.__manifest:
-            return S_ERROR(f"{secName} does not exist")
-        sec = self.__manifest[secName]
-        if not sec:
-            return S_ERROR(f"{secName} section empty")
-        return S_OK(sec)
-
-    def setSectionContents(self, secName, contents):
-        if contents and not isinstance(contents, CFG):
-            return S_ERROR(f"Contents for section {secName} is not a cfg object")
-        self.__dirty = True
-        if secName in self.__manifest:
-            self.__manifest[secName].reset()
-            self.__manifest[secName].mergeWith(contents)
-        else:
-            self.__manifest.createNewSection(secName, contents=contents)
-
-    def setOption(self, varName, varValue):
-        """
-        Set a var in job manifest
-        """
-        self.__dirty = True
-        levels = List.fromChar(varName, "/")
-        cfg = self.__manifest
-        for l in levels[:-1]:
-            if l not in cfg:
-                cfg.createNewSection(l)
-            cfg = cfg[l]
-        cfg.setOption(levels[-1], varValue)
-
-    def remove(self, opName):
-        levels = List.fromChar(opName, "/")
-        cfg = self.__manifest
-        for l in levels[:-1]:
-            if l not in cfg:
-                return S_ERROR(f"{opName} does not exist")
-            cfg = cfg[l]
-        if cfg.deleteKey(levels[-1]):
-            self.__dirty = True
-            return S_OK()
-        return S_ERROR(f"{opName} does not exist")
-
-    def getOption(self, varName, defaultValue=None):
-        """
-        Get a variable from the job manifest
-        """
-        cfg = self.__manifest
-        return cfg.getOption(varName, defaultValue)
-
-    def getOptionList(self, section=""):
-        """
-        Get a list of variables in a section of the job manifest
-        """
-        cfg = self.__manifest.getRecursive(section)
-        if not cfg or "value" not in cfg:
-            return []
-        cfg = cfg["value"]
-        return cfg.listOptions()
-
-    def isOption(self, opName):
-        """
-        Check if it is a valid option
-        """
-        return self.__manifest.isOption(opName)
-
-    def getSectionList(self, section=""):
-        """
-        Get a list of sections in the job manifest
-        """
-        cfg = self.__manifest.getRecursive(section)
-        if not cfg or "value" not in cfg:
-            return []
-        cfg = cfg["value"]
-        return cfg.listSections()
+        return super().check(config=makeJobManifestConfig(self.__manifest["OwnerGroup"]))

DIRAC/WorkloadManagementSystem/Client/JobStateUpdateClient.py

@@ -28,3 +28,6 @@ class JobStateUpdateClient(Client):
 
         else:
             self.serverURL = url
+
+    def setJobStatus(self, jobID, status="", minorStatus="", source="Unknown", datetime_=None, force=False, **kwargs):
+        return self._getRPC(**kwargs).setJobStatus(jobID, status, minorStatus, source, datetime_, force)

DIRAC/WorkloadManagementSystem/Client/JobStatus.py

@@ -1,154 +1,10 @@
-"""
-This module contains constants and lists for the possible job states.
-"""
-
-from DIRAC import gLogger, S_OK, S_ERROR
-from DIRAC.Core.Utilities.StateMachine import State, StateMachine
-from DIRAC.Core.Utilities.Decorators import deprecated
-
-from DIRAC.WorkloadManagementSystem.Client.JobMonitoringClient import JobMonitoringClient
-
-
-#:
-SUBMITTING = "Submitting"
-#:
-RECEIVED = "Received"
-#:
-CHECKING = "Checking"
-#:
-STAGING = "Staging"
-#:
-SCOUTING = "Scouting"
-#:
-WAITING = "Waiting"
-#:
-MATCHED = "Matched"
-#: The Rescheduled status is effectively never stored in the DB.
-#: It could be considered a "virtual" status, and might even be dropped.
-RESCHEDULED = "Rescheduled"
-#:
-RUNNING = "Running"
-#:
-STALLED = "Stalled"
-#:
-COMPLETING = "Completing"
-#:
-DONE = "Done"
-#:
-COMPLETED = "Completed"
-#:
-FAILED = "Failed"
-#:
-DELETED = "Deleted"
-#:
-KILLED = "Killed"
-
-#: Possible job states
-JOB_STATES = [
-    SUBMITTING,
-    RECEIVED,
-    CHECKING,
-    SCOUTING,
-    STAGING,
-    WAITING,
-    MATCHED,
-    RESCHEDULED,
-    RUNNING,
-    STALLED,
-    COMPLETING,
-    DONE,
-    COMPLETED,
-    FAILED,
-    DELETED,
-    KILLED,
-]
-
-# Job States when the payload work has finished
-JOB_FINAL_STATES = [DONE, COMPLETED, FAILED, KILLED]
-
-# WMS internal job States indicating the job object won't be updated
-JOB_REALLY_FINAL_STATES = [DELETED]
-
-
-class JobsStateMachine(StateMachine):
-    """Jobs state machine"""
-
-    def __init__(self, state):
-        """c'tor
-        Defines the state machine transactions
-        """
-        super().__init__(state)
+"""Backward compatibility wrapper - moved to DIRACCommon
 
-        # States transitions
-        self.states = {
-            DELETED: State(15),  # final state
-            KILLED: State(14, [DELETED], defState=KILLED),
-            FAILED: State(13, [RESCHEDULED, DELETED], defState=FAILED),
-            DONE: State(12, [DELETED], defState=DONE),
-            COMPLETED: State(11, [DONE, FAILED], defState=COMPLETED),
-            COMPLETING: State(10, [DONE, FAILED, COMPLETED, STALLED, KILLED], defState=COMPLETING),
-            STALLED: State(9, [RUNNING, FAILED, KILLED], defState=STALLED),
-            RUNNING: State(8, [STALLED, DONE, FAILED, RESCHEDULED, COMPLETING, KILLED, RECEIVED], defState=RUNNING),
-            RESCHEDULED: State(7, [WAITING, RECEIVED, DELETED, FAILED, KILLED], defState=RESCHEDULED),
-            MATCHED: State(6, [RUNNING, FAILED, RESCHEDULED, KILLED], defState=MATCHED),
-            WAITING: State(5, [MATCHED, RESCHEDULED, DELETED, KILLED], defState=WAITING),
-            STAGING: State(4, [CHECKING, WAITING, FAILED, KILLED], defState=STAGING),
-            SCOUTING: State(3, [CHECKING, FAILED, STALLED, KILLED], defState=SCOUTING),
-            CHECKING: State(2, [SCOUTING, STAGING, WAITING, RESCHEDULED, FAILED, DELETED, KILLED], defState=CHECKING),
-            RECEIVED: State(1, [SCOUTING, CHECKING, STAGING, WAITING, FAILED, DELETED, KILLED], defState=RECEIVED),
-            SUBMITTING: State(0, [RECEIVED, CHECKING, DELETED, KILLED], defState=SUBMITTING),  # initial state
-        }
+This module has been moved to DIRACCommon.WorkloadManagementSystem.Client.JobStatus to avoid
+circular dependencies and allow DiracX to use these utilities without
+triggering DIRAC's global state initialization.
 
-
-@deprecated("Use filterJobStateTransition instead")
-def checkJobStateTransition(jobID, candidateState, currentStatus=None, jobMonitoringClient=None):
-    """Utility to check if a job state transition is allowed"""
-    if not currentStatus:
-        if not jobMonitoringClient:
-            from DIRAC.WorkloadManagementSystem.Client.JobMonitoringClient import JobMonitoringClient
-
-            jobMonitoringClient = JobMonitoringClient()
-
-        res = jobMonitoringClient.getJobsStatus(jobID)
-        if not res["OK"]:
-            return res
-        try:
-            currentStatus = res["Value"][jobID]["Status"]
-        except KeyError:
-            return S_ERROR("Job does not exist")
-
-    res = JobsStateMachine(currentStatus).getNextState(candidateState)
-    if not res["OK"]:
-        return res
-
-    # If the JobsStateMachine does not accept the candidate, return an ERROR
-    if candidateState != res["Value"]:
-        gLogger.error(
-            "Job Status Error",
-            f"{jobID} can't move from {currentStatus} to {candidateState}",
-        )
-        return S_ERROR("Job state transition not allowed")
-    return S_OK()
-
-
-def filterJobStateTransition(jobIDs, candidateState):
-    """Given a list of jobIDs, return a list that are allowed to transition
-    to the given candidate state.
-    """
-    allowedJobs = []
-
-    if not isinstance(jobIDs, list):
-        jobIDs = [jobIDs]
-
-    res = JobMonitoringClient().getJobsStatus(jobIDs)
-    if not res["OK"]:
-        return res
-
-    for jobID in jobIDs:
-        if jobID in res["Value"]:
-            curState = res["Value"][jobID]["Status"]
-            stateRes = JobsStateMachine(curState).getNextState(candidateState)
-            if stateRes["OK"]:
-                if stateRes["Value"] == candidateState:
-                    allowedJobs.append(jobID)
-    return S_OK(allowedJobs)
+All exports are maintained for backward compatibility.
+"""
+# Re-export everything from DIRACCommon for backward compatibility
+from DIRACCommon.WorkloadManagementSystem.Client.JobStatus import *  # noqa: F401, F403

DIRAC/WorkloadManagementSystem/Client/SandboxStoreClient.py

@@ -1,13 +1,18 @@
 """ Client for the SandboxStore.
     Will connect to the WorkloadManagement/SandboxStore service.
 """
+from __future__ import annotations
 
 import hashlib
 import os
 import re
 import tarfile
 import tempfile
+from contextlib import contextmanager
 from io import BytesIO, StringIO
+from typing import Literal
+
+import zstandard
 
 from DIRAC import S_ERROR, S_OK, gLogger
 from DIRAC.ConfigurationSystem.Client.Helpers.Registry import getVOForGroup
@@ -18,9 +23,27 @@ from DIRAC.Core.Utilities.ReturnValues import returnSingleResult
 from DIRAC.Resources.Storage.StorageElement import StorageElement
 
 
+@contextmanager
+def ZstdCompatibleTarFile(tarFileName: os.PathLike, *, mode: Literal["r"] = "r"):
+    """Context manager to extend tarfile.open to support zstd compressed files.
+
+    This is only needed for Python <=3.13.
+    """
+    with open(tarFileName, "rb") as f:
+        magic = f.read(4)
+    # Read magic bytes to determine compression format
+    if magic.startswith(b"\x28\xb5\x2f\xfd"):  # zstd magic number
+        dctx = zstandard.ZstdDecompressor()
+        with open(tarFileName, "rb") as f, dctx.stream_reader(f) as decompressor:
+            with tarfile.open(fileobj=decompressor, mode=f"{mode}|") as tf:
+                yield tf
+    else:
+        with tarfile.open(name=tarFileName, mode=mode) as tf:
+            yield tf
+
+
 class SandboxStoreClient:
     __validSandboxTypes = ("Input", "Output")
-    __smdb = None
 
     def __init__(self, rpcClient=None, transferClient=None, smdb=False, **kwargs):
         """Constructor
@@ -37,21 +60,8 @@ class SandboxStoreClient:
         self.__transferClient = transferClient
         self.__kwargs = kwargs
         self.__vo = None
-        SandboxStoreClient.__smdb = smdb
         if "delegatedGroup" in kwargs:
             self.__vo = getVOForGroup(kwargs["delegatedGroup"])
-        if SandboxStoreClient.__smdb is True:
-            try:
-                from DIRAC.WorkloadManagementSystem.DB.SandboxMetadataDB import SandboxMetadataDB
-
-                SandboxStoreClient.__smdb = SandboxMetadataDB()
-                result = SandboxStoreClient.__smdb._getConnection()  # pylint: disable=protected-access
-                if not result["OK"]:
-                    SandboxStoreClient.__smdb = False
-                else:
-                    result["Value"].close()
-            except (ImportError, RuntimeError, AttributeError):
-                SandboxStoreClient.__smdb = False
 
     def __getRPCClient(self):
         """Get an RPC client for SB service"""
@@ -206,7 +216,7 @@ class SandboxStoreClient:
 
         try:
             sandboxSize = 0
-            with tarfile.open(name=tarFileName, mode="r") as tf:
+            with ZstdCompatibleTarFile(tarFileName, mode="r") as tf:
                 for tarinfo in tf:
                     tf.extract(tarinfo, path=destinationDir)
                     sandboxSize += tarinfo.size
@@ -227,29 +237,6 @@ class SandboxStoreClient:
     ##############
     # Jobs
 
-    def assignSandboxesToJob(self, jobId, sbList, ownerName="", ownerGroup=""):
-        """
-        Assign sandboxes to a job.
-        sbList must be a list of sandboxes and relation types
-        sbList = [ ( "SB:SEName|SEPFN", "Input" ), ( "SB:SEName|SEPFN", "Output" ) ]
-        """
-        eId = f"Job:{jobId}"
-        for sbT in sbList:
-            if sbT[1] not in self.__validSandboxTypes:
-                return S_ERROR(f"Invalid Sandbox type {sbT[1]}")
-        if SandboxStoreClient.__smdb and ownerName and ownerGroup:
-            return SandboxStoreClient.__smdb.assignSandboxesToEntities({eId: sbList}, ownerName, ownerGroup)
-        return self.__getRPCClient().assignSandboxesToEntities({eId: sbList}, ownerName, ownerGroup)
-
-    def unassignJobs(self, jobIdList):
-        """Unassign SB to a job"""
-        if isinstance(jobIdList, int):
-            jobIdList = [jobIdList]
-        entitiesList = []
-        for jobId in jobIdList:
-            entitiesList.append(f"Job:{jobId}")
-        return self.__getRPCClient().unassignEntities(entitiesList)
-
     def downloadSandboxForJob(self, jobId, sbType, destinationPath="", inMemory=False, unpack=True):
         """Download SB for a job"""
         result = self.__getRPCClient().getSandboxesAssignedToEntity(f"Job:{jobId}")

DIRAC/WorkloadManagementSystem/Client/WMSClient.py

@@ -2,11 +2,10 @@
     methods necessary to communicate with the Workload Management System
 """
 import os
-from io import StringIO
 import time
+from io import StringIO
 
-from DIRAC import S_OK, S_ERROR, gLogger
-
+from DIRAC import S_ERROR, S_OK, gLogger
 from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
 from DIRAC.Core.Utilities import File
 from DIRAC.Core.Utilities.ClassAd.ClassAdLight import ClassAd

DIRAC/WorkloadManagementSystem/Client/test/Test_Client_DownloadInputData.py

@@ -1,6 +1,8 @@
 """Test for WMS clients."""
 # pylint: disable=protected-access, missing-docstring, invalid-name
 
+from pathlib import Path
+import shutil
 import pytest
 
 from unittest.mock import MagicMock
@@ -280,3 +282,30 @@ def test_DLI_execute_NoLocal(mocker, dli, mockSE):
     assert res["Value"]["Failed"]
     assert "/a/lfn/1.txt" in res["Value"]["Failed"], res
     assert res["Value"]["Failed"][0] == "/a/lfn/1.txt", res
+
+
+def test_DLI_execute_jobIDPath(mocker, dli, mockSE):
+    """Specify a jobIDPath. Output should be in the jobIDPath directory."""
+    mocker.patch("DIRAC.WorkloadManagementSystem.Client.DownloadInputData.gConfig.getValue", return_value=2)
+
+    # Create the jobIDPath directory
+    jobIDPath = Path().cwd() / "job" / "12345"
+    jobIDPath.mkdir(parents=True, exist_ok=True)
+
+    dli.configuration["JobIDPath"] = str(jobIDPath)
+
+    mocker.patch("DIRAC.WorkloadManagementSystem.Client.DownloadInputData.gConfig.getValue", return_value=2)
+    mockObjectSE = mockSE.return_value
+    mockObjectSE.getFileMetadata.return_value = S_OK(
+        {"Successful": {"/a/lfn/1.txt": {"Cached": 1, "Accessible": 0}}, "Failed": {}}
+    )
+    dli._downloadFromSE = MagicMock(side_effect=[S_ERROR("Failed to down"), S_OK({"path": jobIDPath / "1.txt"})])
+    dli._isCache = MagicMock(return_value=True)
+    res = dli.execute(dataToResolve=["/a/lfn/1.txt"])
+
+    assert res["OK"]
+    assert not res["Value"]["Failed"]
+    assert "/a/lfn/1.txt" in res["Value"]["Successful"], res
+
+    # Check that the output path is in the jobIDPath directory
+    assert res["Value"]["Successful"]["/a/lfn/1.txt"]["path"] == jobIDPath / "1.txt", res

DIRAC/WorkloadManagementSystem/ConfigTemplate.cfg

@@ -263,14 +263,10 @@ Agents
     # the DN of the certificate proxy used to submit pilots. If not found here, what is in Operations/Pilot section of the CS will be used
     PilotDN =
 
-    # List of sites that will be treated by this SiteDirector (No value can refer to any Site defined in the CS)
-    Site =
-    # List of CEs that will be treated by this SiteDirector (No value can refer to any CE defined in the CS)
-    CEs =
-    # List of CE types that will be treated by this SiteDirector (No value can refer to any type of CE defined in the CS)
-    CETypes =
-    # List of Tags that are required to be present in the CE/Queue definition
-    Tags =
+    # Site = # List of CEs that will be treated by this SiteDirector (No value can refer to any CE defined in the CS)
+    # CEs =  # List of CE types that will be treated by this SiteDirector (No value can refer to any type of CE defined in the CS)
+    # CETypes = # List of Tags that are required to be present in the CE/Queue definition
+    # Tags =
 
     # How many cycles to skip if queue is not working
     FailedQueueCycleFactor = 10