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

pandaserver/jobdispatcher/Protocol.py

@@ -0,0 +1,443 @@
+import base64
+import json
+import re
+from urllib.parse import urlencode
+
+from pandaserver.dataservice import DataServiceUtils
+from pandaserver.taskbuffer import EventServiceUtils
+
+# constants
+TimeOutToken = "TimeOut"
+
+# status codes
+# succeeded
+SC_Success = 0
+# timeout
+SC_TimeOut = 10
+# no available jobs
+SC_NoJobs = 20
+# failed
+SC_Failed = 30
+# invalid token
+SC_Invalid = 50
+# invalid role
+SC_Role = 60
+# permission denied
+SC_Perms = 70
+# key missing
+SC_MissKey = 80
+# failure of proxy retrieval
+SC_ProxyError = 90
+
+
+# response
+class Response:
+    # constructor
+    def __init__(self, statusCode, errorDialog=None):
+        # create data object
+        self.data = {"StatusCode": statusCode}
+        if errorDialog is not None:
+            self.data["errorDialog"] = errorDialog
+
+    # URL encode
+    def encode(self, acceptJson=False):
+        if not acceptJson:
+            return urlencode(self.data)
+        else:
+            return {"type": "json", "content": json.dumps(self.data)}
+
+    # append Node
+    def appendNode(self, name, value):
+        self.data[name] = value
+
+    # append job
+    def appendJob(self, job, siteMapperCache=None):
+        # event service merge
+        if EventServiceUtils.isEventServiceMerge(job):
+            isEventServiceMerge = True
+        else:
+            isEventServiceMerge = False
+        # PandaID
+        self.data["PandaID"] = job.PandaID
+        # prodSourceLabel
+        self.data["prodSourceLabel"] = job.prodSourceLabel
+        # swRelease
+        self.data["swRelease"] = job.AtlasRelease
+        # homepackage
+        self.data["homepackage"] = job.homepackage
+        # transformation
+        self.data["transformation"] = job.transformation
+        # job name
+        self.data["jobName"] = job.jobName
+        # job definition ID
+        self.data["jobDefinitionID"] = job.jobDefinitionID
+        # cloud
+        self.data["cloud"] = job.cloud
+        # files
+        strIFiles = ""
+        strOFiles = ""
+        strDispatch = ""
+        strDisToken = ""
+        strDisTokenForOutput = ""
+        strDestination = ""
+        strRealDataset = ""
+        strRealDatasetIn = ""
+        strProdDBlock = ""
+        strDestToken = ""
+        strProdToken = ""
+        strProdTokenForOutput = ""
+        strGUID = ""
+        strFSize = ""
+        strCheckSum = ""
+        strFileDestinationSE = ""
+        strScopeIn = ""
+        strScopeOut = ""
+        strScopeLog = ""
+        logFile = ""
+        logGUID = ""
+        ddmEndPointIn = []
+        ddmEndPointOut = []
+        noOutput = []
+        siteSpec = None
+        inDsLfnMap = {}
+        inLFNset = set()
+        if siteMapperCache is not None:
+            siteMapper = siteMapperCache.get_object()
+            siteSpec = siteMapper.getSite(job.computingSite)
+            # resolve destSE
+            try:
+                job.destinationSE = siteMapper.resolveNucleus(job.destinationSE)
+                for tmpFile in job.Files:
+                    tmpFile.destinationSE = siteMapper.resolveNucleus(tmpFile.destinationSE)
+            except Exception:
+                pass
+            siteMapperCache.release_object()
+        for file in job.Files:
+            if file.type == "input":
+                if file.lfn in inLFNset:
+                    pass
+                else:
+                    inLFNset.add(file.lfn)
+                    if strIFiles != "":
+                        strIFiles += ","
+                    strIFiles += file.lfn
+                    if strDispatch != "":
+                        strDispatch += ","
+                    strDispatch += file.dispatchDBlock
+                    if strDisToken != "":
+                        strDisToken += ","
+                    strDisToken += file.dispatchDBlockToken
+                    strProdDBlock += f"{file.prodDBlock},"
+                    if not isEventServiceMerge:
+                        strProdToken += f"{file.prodDBlockToken},"
+                    else:
+                        strProdToken += f"{job.metadata[1][file.lfn]},"
+                    if strGUID != "":
+                        strGUID += ","
+                    strGUID += file.GUID
+                    strRealDatasetIn += f"{file.dataset},"
+                    strFSize += f"{file.fsize},"
+                    if file.checksum not in ["", "NULL", None]:
+                        strCheckSum += f"{file.checksum},"
+                    else:
+                        strCheckSum += f"{file.md5sum},"
+                    strScopeIn += f"{file.scope},"
+                    ddmEndPointIn.append(
+                        self.getDdmEndpoint(
+                            siteSpec,
+                            file.dispatchDBlockToken,
+                            "input",
+                            job.prodSourceLabel,
+                            job.job_label,
+                        )
+                    )
+                    if file.dataset not in inDsLfnMap:
+                        inDsLfnMap[file.dataset] = []
+                    inDsLfnMap[file.dataset].append(file.lfn)
+            if file.type == "output" or file.type == "log":
+                if strOFiles != "":
+                    strOFiles += ","
+                strOFiles += file.lfn
+                if strDestination != "":
+                    strDestination += ","
+                strDestination += file.destinationDBlock
+                if strRealDataset != "":
+                    strRealDataset += ","
+                strRealDataset += file.dataset
+                strFileDestinationSE += f"{file.destinationSE},"
+                if file.type == "log":
+                    logFile = file.lfn
+                    logGUID = file.GUID
+                    strScopeLog = file.scope
+                else:
+                    strScopeOut += f"{file.scope},"
+                if strDestToken != "":
+                    strDestToken += ","
+                strDestToken += re.sub("^ddd:", "dst:", file.destinationDBlockToken.split(",")[0])
+                strDisTokenForOutput += f"{file.dispatchDBlockToken},"
+                strProdTokenForOutput += f"{file.prodDBlockToken},"
+                ddmEndPointOut.append(
+                    self.getDdmEndpoint(
+                        siteSpec,
+                        file.destinationDBlockToken.split(",")[0],
+                        "output",
+                        job.prodSourceLabel,
+                        job.job_label,
+                    )
+                )
+                if file.isAllowedNoOutput():
+                    noOutput.append(file.lfn)
+        # inFiles
+        self.data["inFiles"] = strIFiles
+        # dispatch DBlock
+        self.data["dispatchDblock"] = strDispatch
+        # dispatch DBlock space token
+        self.data["dispatchDBlockToken"] = strDisToken
+        # dispatch DBlock space token for output
+        self.data["dispatchDBlockTokenForOut"] = strDisTokenForOutput[:-1]
+        # outFiles
+        self.data["outFiles"] = strOFiles
+        # destination DBlock
+        self.data["destinationDblock"] = strDestination
+        # destination DBlock space token
+        self.data["destinationDBlockToken"] = strDestToken
+        # prod DBlocks
+        self.data["prodDBlocks"] = strProdDBlock[:-1]
+        # prod DBlock space token
+        self.data["prodDBlockToken"] = strProdToken[:-1]
+        # real output datasets
+        self.data["realDatasets"] = strRealDataset
+        # real output datasets
+        self.data["realDatasetsIn"] = strRealDatasetIn[:-1]
+        # file's destinationSE
+        self.data["fileDestinationSE"] = strFileDestinationSE[:-1]
+        # log filename
+        self.data["logFile"] = logFile
+        # log GUID
+        self.data["logGUID"] = logGUID
+        # jobPars
+        self.data["jobPars"], ppSteps = job.extractMultiStepExec()
+        if ppSteps is not None:
+            self.data.update(ppSteps)
+        if job.to_encode_job_params():
+            self.data["jobPars"] = base64.b64encode(self.data["jobPars"].encode()).decode()
+        # attempt number
+        self.data["attemptNr"] = job.attemptNr
+        # GUIDs
+        self.data["GUID"] = strGUID
+        # checksum
+        self.data["checksum"] = strCheckSum[:-1]
+        # fsize
+        self.data["fsize"] = strFSize[:-1]
+        # scope
+        self.data["scopeIn"] = strScopeIn[:-1]
+        self.data["scopeOut"] = strScopeOut[:-1]
+        self.data["scopeLog"] = strScopeLog
+        # DDM endpoints
+        try:
+            self.data["ddmEndPointIn"] = ",".join(ddmEndPointIn)
+        except TypeError:
+            self.data["ddmEndPointIn"] = ""
+        try:
+            self.data["ddmEndPointOut"] = ",".join(ddmEndPointOut)
+        except TypeError:
+            self.data["ddmEndPointOut"] = ""
+        # destinationSE
+        self.data["destinationSE"] = job.destinationSE
+        # user ID
+        self.data["prodUserID"] = job.prodUserID
+        # CPU count
+        self.data["maxCpuCount"] = job.maxCpuCount
+        # RAM count
+        self.data["minRamCount"] = job.minRamCount
+        # disk count
+        self.data["maxDiskCount"] = job.maxDiskCount
+        # cmtconfig
+        if ppSteps is None or job.cmtConfig not in ["NULL", None]:
+            self.data["cmtConfig"] = job.cmtConfig
+        else:
+            self.data["cmtConfig"] = ""
+        # processingType
+        self.data["processingType"] = job.processingType
+        # transferType
+        self.data["transferType"] = job.transferType
+        # sourceSite
+        self.data["sourceSite"] = job.sourceSite
+        # current priority
+        self.data["currentPriority"] = job.currentPriority
+        # taskID
+        if job.lockedby == "jedi":
+            self.data["taskID"] = job.jediTaskID
+        else:
+            self.data["taskID"] = job.taskID
+        # core count
+        if job.coreCount in ["NULL", None]:
+            self.data["coreCount"] = 1
+        else:
+            self.data["coreCount"] = job.coreCount
+        # jobsetID
+        self.data["jobsetID"] = job.jobsetID
+        # requestID
+        self.data["reqID"] = job.reqID
+        # nucleus
+        self.data["nucleus"] = job.nucleus
+        # walltime
+        self.data["maxWalltime"] = job.maxWalltime
+        # resource type
+        self.data["resource_type"] = job.resource_type
+        # looping check
+        if job.is_no_looping_check():
+            self.data["loopingCheck"] = False
+        # debug mode
+        if job.is_debug_mode():
+            self.data["debug"] = "True"
+        # event service or job cloning or fine-grained
+        if EventServiceUtils.isJobCloningJob(job):
+            self.data["cloneJob"] = EventServiceUtils.getJobCloningType(job)
+        elif EventServiceUtils.isEventServiceJob(job) or EventServiceUtils.isJumboJob(job):
+            self.data["eventService"] = "True"
+            # prod DBlock space token for pre-merging output
+            self.data["prodDBlockTokenForOutput"] = strProdTokenForOutput[:-1]
+        elif EventServiceUtils.is_fine_grained_job(job):
+            self.data["eventService"] = "True"
+        # event service merge
+        if isEventServiceMerge:
+            self.data["eventServiceMerge"] = "True"
+            # write to file for ES merge
+            writeToFileStr = ""
+            try:
+                for outputName in job.metadata[0]:
+                    inputList = job.metadata[0][outputName]
+                    writeToFileStr += f"inputFor_{outputName}:"
+                    for tmpInput in inputList:
+                        writeToFileStr += f"{tmpInput},"
+                    writeToFileStr = writeToFileStr[:-1]
+                    writeToFileStr += "^"
+                writeToFileStr = writeToFileStr[:-1]
+            except Exception:
+                pass
+            self.data["writeToFile"] = writeToFileStr
+        elif job.writeInputToFile():
+            try:
+                # write input to file
+                writeToFileStr = ""
+                for inDS in inDsLfnMap:
+                    inputList = inDsLfnMap[inDS]
+                    inDS = re.sub("/$", "", inDS)
+                    inDS = inDS.split(":")[-1]
+                    writeToFileStr += f"tmpin_{inDS}:"
+                    writeToFileStr += ",".join(inputList)
+                    writeToFileStr += "^"
+                writeToFileStr = writeToFileStr[:-1]
+                self.data["writeToFile"] = writeToFileStr
+            except Exception:
+                pass
+        # replace placeholder
+        if EventServiceUtils.isJumboJob(job) or EventServiceUtils.isCoJumboJob(job):
+            try:
+                for inDS in inDsLfnMap:
+                    inputList = inDsLfnMap[inDS]
+                    inDS = re.sub("/$", "", inDS)
+                    inDS = inDS.split(":")[-1]
+                    srcStr = f"tmpin__cnt_{inDS}"
+                    dstStr = ",".join(inputList)
+                    self.data["jobPars"] = self.data["jobPars"].replace(srcStr, dstStr)
+            except Exception:
+                pass
+        # no output
+        if noOutput != []:
+            self.data["allowNoOutput"] = ",".join(noOutput)
+        # alternative stage-out
+        if job.getAltStgOut() is not None:
+            self.data["altStageOut"] = job.getAltStgOut()
+        # log to OS
+        if job.putLogToOS():
+            self.data["putLogToOS"] = "True"
+        # suppress execute string conversion
+        if job.noExecStrCnv():
+            self.data["noExecStrCnv"] = "True"
+        # in-file positional event number
+        if job.inFilePosEvtNum():
+            self.data["inFilePosEvtNum"] = "True"
+        # use prefetcher
+        if job.usePrefetcher():
+            self.data["usePrefetcher"] = "True"
+        # image name
+        if job.container_name not in ["NULL", None]:
+            self.data["container_name"] = job.container_name
+        # IO
+        self.data["ioIntensity"] = job.get_task_attribute("ioIntensity")
+        self.data["ioIntensityUnit"] = job.get_task_attribute("ioIntensityUnit")
+        # HPO
+        if job.is_hpo_workflow():
+            self.data["isHPO"] = "True"
+        # VP
+        if siteSpec is not None:
+            scope_input, scope_output = DataServiceUtils.select_scope(siteSpec, job.prodSourceLabel, job.job_label)
+            if siteSpec.use_vp(scope_input):
+                self.data["useVP"] = "True"
+        # on-site merging
+        if job.is_on_site_merging():
+            self.data["onSiteMerging"] = "True"
+
+    # set proxy key
+    def setProxyKey(self, proxyKey):
+        names = ["credname", "myproxy"]
+        for name in names:
+            if name in proxyKey:
+                self.data[name] = proxyKey[name]
+            else:
+                self.data[name] = ""
+
+    # set secret key for panda proxy
+    def setPandaProxySecretKey(self, secretKey):
+        self.data["pandaProxySecretKey"] = secretKey
+
+    # get ddm endpoint
+    def getDdmEndpoint(self, siteSpec, spaceToken, mode, prodSourceLabel, job_label):
+        scope_input, scope_output = DataServiceUtils.select_scope(siteSpec, prodSourceLabel, job_label)
+        if siteSpec is None or mode not in ["input", "output"]:
+            return ""
+
+        if mode == "input":
+            connected_endpoints = siteSpec.ddm_endpoints_input.get(scope_input)
+        elif mode == "output":
+            connected_endpoints = siteSpec.ddm_endpoints_output.get(scope_output)
+
+        endPoint = DataServiceUtils.getDestinationSE(spaceToken)
+        if endPoint and connected_endpoints and connected_endpoints.isAssociated(endPoint):
+            return endPoint
+
+        endPoint = DataServiceUtils.getDistributedDestination(spaceToken)
+        if endPoint and connected_endpoints and connected_endpoints.isAssociated(endPoint):
+            return endPoint
+
+        if mode == "input":
+            setokens = siteSpec.setokens_input.get(scope_input, [])
+            ddm = siteSpec.ddm_input.get(scope_input)
+        elif mode == "output":
+            setokens = siteSpec.setokens_output.get(scope_output, [])
+            ddm = siteSpec.ddm_output.get(scope_output)
+        if spaceToken in setokens:
+            return setokens[spaceToken]
+
+        # Protection against misconfigured sites
+        if not ddm:
+            ddm = ""
+
+        return ddm
+
+
+# check if secure connection
+def isSecure(req):
+    if "SSL_CLIENT_S_DN" not in req.subprocess_env:
+        return False
+    return True
+
+
+# get user DN
+def getUserDN(req):
+    try:
+        return req.subprocess_env["SSL_CLIENT_S_DN"]
+    except Exception:
+        return "None"

pandaserver/jobdispatcher/Watcher.py

@@ -0,0 +1,186 @@
+"""
+watch job
+
+"""
+
+import datetime
+import threading
+import time
+import traceback
+
+from pandacommon.pandalogger.LogWrapper import LogWrapper
+from pandacommon.pandalogger.PandaLogger import PandaLogger
+from pandacommon.pandautils.PandaUtils import naive_utcnow
+
+from pandaserver.dataservice.closer import Closer
+from pandaserver.jobdispatcher import ErrorCode
+from pandaserver.taskbuffer import EventServiceUtils, retryModule
+from pandaserver.taskbuffer.JobSpec import JobSpec
+from pandaserver.taskbuffer.SupErrors import SupErrors
+
+# logger
+_logger = PandaLogger().getLogger("Watcher")
+
+
+class Watcher(threading.Thread):
+    # constructor
+    def __init__(self, taskBuffer, pandaID, single=False, sleepTime=360, sitemapper=None):
+        threading.Thread.__init__(self)
+        self.pandaID = pandaID
+        self.taskBuffer = taskBuffer
+        self.sleepTime = sleepTime
+        self.single = single
+        self.siteMapper = sitemapper
+        self.logger = LogWrapper(_logger, str(pandaID))
+
+    # main
+    def run(self):
+        try:
+            while True:
+                self.logger.debug("start")
+                # query job
+                job = self.taskBuffer.peekJobs(
+                    [self.pandaID],
+                    fromDefined=False,
+                    fromArchived=False,
+                    fromWaiting=False,
+                )[0]
+                # check job status
+                if job is None:
+                    self.logger.debug("escape : not found")
+                    return
+                self.logger.debug(f"in {job.jobStatus}")
+                if job.jobStatus not in [
+                    "running",
+                    "sent",
+                    "starting",
+                    "holding",
+                    "stagein",
+                    "stageout",
+                ]:
+                    if job.jobStatus == "transferring" and (job.prodSourceLabel in ["user", "panda"] or job.jobSubStatus not in [None, "NULL", ""]):
+                        pass
+                    else:
+                        self.logger.debug(f"escape : wrong status {job.jobStatus}")
+                        return
+                # time limit
+                timeLimit = naive_utcnow() - datetime.timedelta(minutes=self.sleepTime)
+                if job.modificationTime < timeLimit or (job.endTime != "NULL" and job.endTime < timeLimit):
+                    self.logger.debug(f"{job.jobStatus} lastmod:{str(job.modificationTime)} endtime:{str(job.endTime)}")
+                    destDBList = []
+                    if job.jobStatus == "sent":
+                        # sent job didn't receive reply from pilot within 30 min
+                        job.jobDispatcherErrorCode = ErrorCode.EC_SendError
+                        job.jobDispatcherErrorDiag = "Sent job didn't receive reply from pilot within 30 min"
+                    elif job.exeErrorDiag == "NULL" and job.pilotErrorDiag == "NULL":
+                        # lost heartbeat
+                        if job.jobDispatcherErrorDiag == "NULL":
+                            if job.endTime == "NULL":
+                                # normal lost heartbeat
+                                job.jobDispatcherErrorCode = ErrorCode.EC_Watcher
+                                job.jobDispatcherErrorDiag = f"lost heartbeat : {str(job.modificationTime)}"
+                            else:
+                                if job.jobStatus == "holding":
+                                    job.jobDispatcherErrorCode = ErrorCode.EC_Holding
+                                elif job.jobStatus == "transferring":
+                                    job.jobDispatcherErrorCode = ErrorCode.EC_Transferring
+                                else:
+                                    job.jobDispatcherErrorCode = ErrorCode.EC_Timeout
+                                job.jobDispatcherErrorDiag = f"timeout in {job.jobStatus} : last heartbeat at {str(job.endTime)}"
+                            # get worker
+                            workerSpecs = self.taskBuffer.getWorkersForJob(job.PandaID)
+                            if len(workerSpecs) > 0:
+                                workerSpec = workerSpecs[0]
+                                if workerSpec.status in [
+                                    "finished",
+                                    "failed",
+                                    "cancelled",
+                                    "missed",
+                                ]:
+                                    job.supErrorCode = SupErrors.error_codes["WORKER_ALREADY_DONE"]
+                                    job.supErrorDiag = f"worker already {workerSpec.status} at {str(workerSpec.endTime)} with {workerSpec.diagMessage}"
+                                    job.supErrorDiag = JobSpec.truncateStringAttr("supErrorDiag", job.supErrorDiag)
+                    else:
+                        # job recovery failed
+                        job.jobDispatcherErrorCode = ErrorCode.EC_Recovery
+                        job.jobDispatcherErrorDiag = f"job recovery failed for {self.sleepTime / 60} hours"
+                    # set job status
+                    job.jobStatus = "failed"
+                    # set endTime for lost heartbeat
+                    if job.endTime == "NULL":
+                        # normal lost heartbeat
+                        job.endTime = job.modificationTime
+                    # set files status
+                    for file in job.Files:
+                        if file.type == "output" or file.type == "log":
+                            file.status = "failed"
+                            if file.destinationDBlock not in destDBList:
+                                destDBList.append(file.destinationDBlock)
+                    # event service
+                    if EventServiceUtils.isEventServiceJob(job) and not EventServiceUtils.isJobCloningJob(job):
+                        eventStat = self.taskBuffer.getEventStat(job.jediTaskID, job.PandaID)
+                        # set sub status when no successful events
+                        if EventServiceUtils.ST_finished not in eventStat:
+                            job.jobSubStatus = "es_heartbeat"
+                    # update job
+                    self.taskBuffer.updateJobs([job], False)
+                    # start closer
+                    if job.jobStatus == "failed":
+                        source = "jobDispatcherErrorCode"
+                        error_code = job.jobDispatcherErrorCode
+                        error_diag = job.jobDispatcherErrorDiag
+                        errors = [
+                            {
+                                "source": source,
+                                "error_code": error_code,
+                                "error_diag": error_diag,
+                            }
+                        ]
+
+                        try:
+                            self.logger.debug("Watcher will call job_failure_postprocessing")
+                            retryModule.job_failure_postprocessing(self.taskBuffer, job.PandaID, errors, job.attemptNr)
+                            self.logger.debug("job_failure_postprocessing is back")
+                        except Exception as e:
+                            self.logger.debug(f"job_failure_postprocessing excepted and needs to be investigated ({e}): {traceback.format_exc()}")
+
+                        # updateJobs was successful and it failed a job with taskBufferErrorCode
+                        try:
+                            self.logger.debug("Watcher.run will peek the job")
+                            job_tmp = self.taskBuffer.peekJobs(
+                                [job.PandaID],
+                                fromDefined=False,
+                                fromArchived=True,
+                                fromWaiting=False,
+                            )[0]
+                            if job_tmp.taskBufferErrorCode:
+                                source = "taskBufferErrorCode"
+                                error_code = job_tmp.taskBufferErrorCode
+                                error_diag = job_tmp.taskBufferErrorDiag
+                                self.logger.debug("Watcher.run 2 will call job_failure_postprocessing")
+                                retryModule.job_failure_postprocessing(
+                                    self.taskBuffer,
+                                    job_tmp.PandaID,
+                                    source,
+                                    error_code,
+                                    error_diag,
+                                    job_tmp.attemptNr,
+                                )
+                                self.logger.debug("job_failure_postprocessing 2 is back")
+                        except IndexError:
+                            pass
+                        except Exception as e:
+                            self.logger.error(f"job_failure_postprocessing 2 excepted and needs to be investigated ({e}): {traceback.format_exc()}")
+
+                        cThr = Closer(self.taskBuffer, destDBList, job)
+                        cThr.run()
+                    self.logger.debug("done")
+                    return
+                # single action
+                if self.single:
+                    return
+                # sleep
+                time.sleep(60 * self.sleepTime)
+        except Exception as e:
+            self.logger.error(f"run() : {str(e)} {traceback.format_exc()}")
+            return

pandaserver/pandamcp/mcp_main.py

@@ -0,0 +1,56 @@
+import json
+import os
+from importlib import import_module
+from urllib.parse import urlparse
+
+import uvicorn
+from fastmcp import FastMCP
+
+from pandaserver.api.v1.http_client import api_url
+from pandaserver.config import mcp_config
+from pandaserver.pandamcp.mcp_utils import create_tool
+
+# remove or overwrite environment variables to avoid server's credential being used
+for var in ["PANDA_AUTH_ID_TOKEN", "PANDA_AUTH_VO", "X509_USER_PROXY"]:
+    if var in os.environ:
+        del os.environ[var]
+os.environ["X509_USER_PROXY"] = "/dev/null"
+
+# extract API's module path
+p = urlparse(api_url)
+api_module_path = ".".join([seg for seg in p.path.strip("/").split("/") if seg])
+
+# get a list of API endpoints to expose
+endpoints_to_expose = {}
+
+if os.path.exists(mcp_config.endpoint_list_file):
+    with open(mcp_config.endpoint_list_file, "r") as f:
+        endpoints_to_expose = json.load(f)
+
+# add an example endpoint if the file does not exist
+endpoints_to_expose.setdefault("system", [])
+if "is_alive" not in endpoints_to_expose["system"]:
+    endpoints_to_expose["system"].append("is_alive")
+
+# create FastMCP instance
+main_mcp = FastMCP(name="Main")
+
+# add tools
+for mod, func_list in endpoints_to_expose.items():
+    api_module = import_module(f"pandaserver.{api_module_path}.{mod}_api")
+    for func_name in func_list:
+        func = getattr(api_module, func_name)
+        tool = create_tool(func)
+        main_mcp.add_tool(tool)
+
+# get HTTP app
+http_app = main_mcp.http_app(transport=mcp_config.transport)
+
+if __name__ == "__main__":
+    uvicorn.run(
+        http_app,
+        host="0.0.0.0",
+        port=int(os.getenv("PANDA_SERVER_CONF_PORT_MCP", 25888)),
+        ssl_keyfile=mcp_config.ssl_keyfile,
+        ssl_certfile=mcp_config.ssl_certfile,
+    )