panda-server-source 0.8.0__py3-none-any.whl

pandaserver/taskbuffer/DatasetSpec.py

@@ -0,0 +1,137 @@
+"""
+dataset specification
+
+"""
+
+
+class DatasetSpec(object):
+    # attributes
+    _attributes = (
+        "vuid",
+        "name",
+        "version",
+        "type",
+        "status",
+        "numberfiles",
+        "currentfiles",
+        "creationdate",
+        "modificationdate",
+        "MoverID",
+        "transferStatus",
+        "subType",
+    )
+
+    # attributes which have 0 by default
+    _zeroAttrs = ("MoverID", "transferStatus")
+
+    # constructor
+    def __init__(self):
+        # install attributes
+        for attr in self._attributes:
+            setattr(self, attr, None)
+
+    # override __getattribute__ for SQL
+    def __getattribute__(self, name):
+        ret = object.__getattribute__(self, name)
+        if ret is None:
+            return "NULL"
+        return ret
+
+    # return a tuple of values
+    def values(self):
+        ret = []
+        for attr in self._attributes:
+            val = getattr(self, attr)
+            ret.append(val)
+        return tuple(ret)
+
+    # return map of values
+    def valuesMap(self):
+        ret = {}
+        for attr in self._attributes:
+            val = getattr(self, attr)
+            if val == "NULL":
+                if attr in self._zeroAttrs:
+                    val = 0
+                else:
+                    val = None
+            ret[f":{attr}"] = val
+        return ret
+
+    # pack tuple into DatasetSpec
+    def pack(self, values):
+        for i in range(len(self._attributes)):
+            attr = self._attributes[i]
+            val = values[i]
+            setattr(self, attr, val)
+
+    # return column names for INSERT
+    def columnNames(cls):
+        ret = ""
+        for attr in cls._attributes:
+            if ret != "":
+                ret += ","
+            ret += attr
+        return ret
+
+    columnNames = classmethod(columnNames)
+
+    # return expression of values for INSERT
+    def valuesExpression(cls):
+        ret = "VALUES("
+        for attr in cls._attributes:
+            ret += "%s"
+            if attr != cls._attributes[len(cls._attributes) - 1]:
+                ret += ","
+        ret += ")"
+        return ret
+
+    valuesExpression = classmethod(valuesExpression)
+
+    # return expression of bind values for INSERT
+    def bindValuesExpression(cls):
+        ret = "VALUES("
+        for attr in cls._attributes:
+            ret += f":{attr},"
+        ret = ret[:-1]
+        ret += ")"
+        return ret
+
+    bindValuesExpression = classmethod(bindValuesExpression)
+
+    # return an expression for UPDATE
+    def updateExpression(cls):
+        ret = ""
+        for attr in cls._attributes:
+            ret = ret + attr + "=%s"
+            if attr != cls._attributes[len(cls._attributes) - 1]:
+                ret += ","
+        return ret
+
+    updateExpression = classmethod(updateExpression)
+
+    # return an expression of bind variables for UPDATE
+    def bindUpdateExpression(cls):
+        ret = ""
+        for attr in cls._attributes:
+            ret += f"{attr}=:{attr},"
+        ret = ret[:-1]
+        return ret
+
+    bindUpdateExpression = classmethod(bindUpdateExpression)
+
+    # return state values to be pickled
+    def __getstate__(self):
+        state = []
+        for attr in self._attributes:
+            val = getattr(self, attr)
+            state.append(val)
+        return state
+
+    # restore state from the unpickled state values
+    def __setstate__(self, state):
+        for i, attr in enumerate(self._attributes):
+            if i < len(state):
+                setattr(self, attr, state[i])
+            else:
+                setattr(self, attr, None)

pandaserver/taskbuffer/DdmSpec.py

@@ -0,0 +1,201 @@
+"""
+ddm endpoint specification object
+
+"""
+
+import re
+
+
+class DdmSpec(object):
+    # constructor
+    def __init__(self):
+        self.all = {}
+        self.local = set()
+        self.default_read = None
+        self.default_write = None
+        self.tape = set()
+
+    def add(self, relation, endpoint_dictionary):
+        """
+        Add an endpoint to the DDM specification.
+
+        This method adds an endpoint to the DDM specification by copying all properties
+        about the DDM endpoint and relation. It also updates local endpoints, default
+        read/write endpoints, and tape endpoints.
+
+        Args:
+            relation (dict): A dictionary containing the relation properties.
+            endpoint_dictionary (dict): A dictionary containing the endpoint properties.
+        """
+        name = relation["ddm_endpoint_name"]
+
+        # Protection against inconsistent dict
+        if name not in endpoint_dictionary:
+            return
+
+        # All endpoints, copy all properties about DDM endpoint and relation
+        self.all[name] = {}
+        for key in endpoint_dictionary[name]:
+            value = endpoint_dictionary[name][key]
+            self.all[name][key] = value
+        for key in relation:
+            value = relation[key]
+            self.all[name][key] = value
+
+        # Local endpoints
+        if relation["is_local"] != "N":
+            self.local.add(name)
+
+        # Default read and write
+        if relation["default_read"] == "Y":
+            self.default_read = name
+        if relation["default_write"] == "Y":
+            self.default_write = name
+
+        # Tape
+        if relation["is_tape"] == "Y":
+            self.tape.add(name)
+
+    def getAllEndPoints(self):
+        """
+        Get all DDM endpoints. This method returns a list of all DDM endpoints.
+
+        Returns:
+            list: A list of all DDM endpoints.
+        """
+        return list(self.all)
+
+    def getEndPoint(self, endpoint_name):
+        """
+        Get a specific DDM endpoint.
+
+        This method returns the properties of a specific DDM endpoint.
+
+        Args:
+            endpoint_name (str): The name of the DDM endpoint.
+        Returns:
+            dict or None: A dictionary containing the properties of the DDM endpoint, or None if not found.
+        """
+        if endpoint_name in self.all:
+            return self.all[endpoint_name]
+        return None
+
+    def getLocalEndPoints(self):
+        """
+        This method returns a sorted list of local DDM endpoints.
+
+        Returns:
+            list: A sorted list of local DDM endpoints.
+        """
+        sorted_endpoints = sorted(self.local)
+        return sorted_endpoints
+
+    def getDefaultWrite(self):
+        """
+        This method returns the default write DDM endpoint.
+
+        Returns:
+            str or None: The default write DDM endpoint, or None if not set.
+        """
+        return self.default_write
+
+    def getDefaultRead(self):
+        """
+        This method returns the default read DDM endpoint.
+
+        Returns:
+            str or None: The default write DDM endpoint, or None if not set.
+        """
+        return self.default_read
+
+    def getTapeEndPoints(self):
+        """
+        This method returns a tuple of tape DDM endpoints.
+
+        Returns:
+            tuple: A tuple of tape DDM endpoints.
+        """
+        return tuple(self.tape)
+
+    def isAssociated(self, endpoint_name):
+        """
+        This method checks if a given endpoint name is associated with any DDM endpoint.
+
+        Args:
+            endpoint_name (str): The name of the DDM endpoint.
+
+        Returns:
+            bool: True if the endpoint is associated, False otherwise.
+        """
+        return endpoint_name in self.all
+
+    def getAssociatedEndpoint(self, patt, mode="output"):
+        """
+        This method returns the DDM endpoint associated with a given pattern and of the lowest order.
+
+        Args:
+            patt (str): The pattern to match.
+            mode (str): The mode, either "input" or "output". Default is "output".
+        Returns:
+            dict or None: A dictionary containing the properties of the associated DDM endpoint, or None if not found.
+        """
+        patt = patt.split("/")[-1]
+        if patt in self.all:
+            return self.all[patt]
+
+        endpoint = None
+        order = 10**6  # Like infinite
+        for tmp_ddm_endpoint_name in self.all:
+            tmp_ddm_endpoint_dict = self.all[tmp_ddm_endpoint_name]
+            # get the order of the current loop endpoint
+            if mode == "input":
+                tmp_order = tmp_ddm_endpoint_dict["order_read"]
+            elif mode == "output":
+                tmp_order = tmp_ddm_endpoint_dict["order_write"]
+            # we already have a closer endpoint, so skip the looping one
+            if tmp_order > order:
+                continue
+
+            # check name
+            if re.search(patt, tmp_ddm_endpoint_name) is not None:
+                endpoint = self.all[tmp_ddm_endpoint_name]
+                order = tmp_order
+
+            # check type
+            pattern_without_vo = re.sub("ATLAS", "", patt)
+            if self.all[tmp_ddm_endpoint_name]["type"] == pattern_without_vo:
+                endpoint = self.all[tmp_ddm_endpoint_name]
+                order = tmp_order
+
+        return endpoint
+
+    def getTokenMap(self, mode):
+        """
+        This method returns a mapping between space tokens and endpoint names based on the mode.
+
+        Args:
+            mode (str): The mode, either "input" or "output".
+        Returns:
+            dict: A dictionary mapping tokens to endpoint names.
+        """
+        ret_map = {}
+        orders = {}
+        for tmp_ddm_endpoint_name in self.all:
+            tmp_ddm_endpoint_dict = self.all[tmp_ddm_endpoint_name]
+            token = tmp_ddm_endpoint_dict["ddm_spacetoken_name"]
+
+            # get the order
+            if mode == "input":
+                order = tmp_ddm_endpoint_dict["order_read"]
+            elif mode == "output":
+                order = tmp_ddm_endpoint_dict["order_write"]
+
+            # map already contains this token
+            if token in ret_map and orders[token] < order:
+                continue
+
+            # add
+            ret_map[token] = tmp_ddm_endpoint_name
+            orders[token] = order
+
+        return ret_map

pandaserver/taskbuffer/ErrorCode.py

@@ -0,0 +1,87 @@
+# error code
+
+# killed
+EC_Kill = 100
+
+# transfer timeout
+EC_Transfer = 101
+
+# expire
+EC_Expire = 102
+
+# aborted
+EC_Aborted = 103
+
+# reassigned by re-brokerage
+EC_Reassigned = 105
+
+# reassigned by server-side retry
+EC_Retried = 106
+
+# retried by pilot
+EC_PilotRetried = 107
+
+# retried for event service
+EC_EventServiceRetried = 111
+
+# merge for event service
+EC_EventServiceMerge = 112
+
+# merge job failed
+EC_MergeFailed = 113
+
+# max attempt reached for Event Service
+EC_EventServiceMaxAttempt = 114
+
+# do nothing since other consumers are still running
+EC_EventServiceWaitOthers = 115
+
+# killed since unused and unnecessary anymore
+EC_EventServiceUnused = 116
+
+# didn't process any events on WN
+EC_EventServiceUnprocessed = 117
+
+# didn't process any events on WN and last consumer
+EC_EventServiceLastUnprocessed = 118
+
+# all event ranges failed
+EC_EventServiceAllFailed = 119
+
+# associated consumer generated ES merge
+EC_EventServiceKillOK = 120
+
+# associated consumer failed
+EC_EventServiceKillNG = 121
+
+# killed for preemption
+EC_EventServicePreemption = 122
+
+# retried but didn't process any events on WN
+EC_EventServiceNoEvent = 123
+
+# input files inconsistent with JEDI
+EC_EventServiceInconsistentIn = 124
+
+# No event service queues available for new consumers
+EC_EventServiceNoEsQueues = 125
+
+# Closed in bad job status
+EC_EventServiceBadStatus = 126
+
+# Fast re-brokerage for overloaded
+EC_FastRebrokerage = 130
+
+# failed to lock semaphore for job cloning
+EC_JobCloningUnlock = 200
+
+# worker is done before job is done
+EC_WorkerDone = 300
+
+# http error codes
+
+# forbidden request
+EC_Forbidden = 403
+
+# file not found
+EC_NotFound = 404