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

pandajedi/jeditest/brokerTest.py

@@ -0,0 +1,78 @@
+import sys
+
+from pandacommon.pandalogger.PandaLogger import PandaLogger
+
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+from pandajedi.jedicore.MsgWrapper import MsgWrapper
+from pandajedi.jedicore.ThreadUtils import ThreadPool
+from pandajedi.jediddm.DDMInterface import DDMInterface
+from pandajedi.jediorder.JobBroker import JobBroker
+from pandajedi.jediorder.JobGenerator import JobGeneratorThread
+from pandajedi.jediorder.JobSplitter import JobSplitter
+from pandajedi.jediorder.TaskSetupper import TaskSetupper
+
+logger = PandaLogger().getLogger("JobGenerator")
+tmpLog = MsgWrapper(logger)
+
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface()
+
+siteMapper = tbIF.get_site_mapper()
+
+ddmIF = DDMInterface()
+ddmIF.setupInterface()
+
+jediTaskID = int(sys.argv[1])
+
+datasetIDs = None
+if len(sys.argv) > 2:
+    datasetIDs = [int(sys.argv[2])]
+
+s, taskSpec = tbIF.getTaskWithID_JEDI(jediTaskID)
+
+cloudName = taskSpec.cloud
+vo = taskSpec.vo
+prodSourceLabel = taskSpec.prodSourceLabel
+queueID = taskSpec.workQueue_ID
+gshare_name = taskSpec.gshare
+
+workQueue = tbIF.getWorkQueueMap().getQueueWithID(queueID, gshare_name)
+
+threadPool = ThreadPool()
+
+# get typical number of files
+# typicalNumFilesMap = tbIF.getTypicalNumInput_JEDI(vo,prodSourceLabel,workQueue,
+#                                                  useResultCache=600)
+
+typicalNumFilesMap = {}
+
+tmpListList = tbIF.getTasksToBeProcessed_JEDI(
+    None,
+    vo,
+    workQueue,
+    prodSourceLabel,
+    cloudName,
+    nFiles=10,
+    simTasks=[jediTaskID],
+    fullSimulation=True,
+    typicalNumFilesMap=typicalNumFilesMap,
+    simDatasets=datasetIDs,
+)
+
+taskSetupper = TaskSetupper(vo, prodSourceLabel)
+taskSetupper.initializeMods(tbIF, ddmIF)
+
+for dummyID, tmpList in tmpListList:
+    for taskSpec, cloudName, inputChunk in tmpList:
+        jobBroker = JobBroker(taskSpec.vo, taskSpec.prodSourceLabel)
+        tmpStat = jobBroker.initializeMods(ddmIF.getInterface(vo), tbIF)
+        splitter = JobSplitter()
+        gen = JobGeneratorThread(None, threadPool, tbIF, ddmIF, siteMapper, False, taskSetupper, None, None, "dummy", None, None)
+
+        taskParamMap = None
+        if taskSpec.useLimitedSites():
+            tmpStat, taskParamMap = gen.readTaskParams(taskSpec, taskParamMap, tmpLog)
+
+        tmpStat, inputChunk = jobBroker.doBrokerage(taskSpec, cloudName, inputChunk, taskParamMap)
+
+        # tmpStat,subChunks = splitter.doSplit(taskSpec,inputChunk,siteMapper)

pandajedi/jeditest/cancelDataCarouselRequest.py

@@ -0,0 +1,35 @@
+import sys
+
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+from pandajedi.jediddm.DDMInterface import DDMInterface
+from pandajedi.jedirefine import RefinerUtils
+from pandaserver.taskbuffer.DataCarousel import DataCarouselInterface
+
+vo = "atlas"
+request_id = int(sys.argv[1])
+
+print("set tbIF")
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface(max_size=1)
+
+print("set ddmIF")
+ddmIF = DDMInterface()
+ddmIF.setupInterface()
+
+print("set DCIF")
+data_carousel_interface = DataCarouselInterface(tbIF, ddmIF.getInterface(vo))
+if data_carousel_interface is None:
+    # data carousel interface is undefined
+    errStr = f"data carousel interface is undefined for vo={vo}"
+    print(errStr)
+    sys.exit(1)
+
+print(f"cancel request_id={request_id}")
+ret = data_carousel_interface.cancel_request(request_id)
+
+if not ret:
+    # failed to cancel
+    print(f"failed; got {ret}")
+else:
+    # cancelled
+    print(f"cancelled, got {ret}")

pandajedi/jeditest/contentsFeederTest.py

@@ -0,0 +1,28 @@
+import sys
+
+try:
+    testTaskType = sys.argv[1]
+except Exception:
+    testTaskType = "test"
+
+try:
+    vo = sys.argv[2]
+except Exception:
+    vo = "atlas"
+
+import multiprocessing
+
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+from pandajedi.jediddm.DDMInterface import DDMInterface
+from pandajedi.jediorder import ContentsFeeder
+
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface()
+
+ddmIF = DDMInterface()
+ddmIF.setupInterface()
+
+parent_conn, child_conn = multiprocessing.Pipe()
+
+contentsFeeder = multiprocessing.Process(target=ContentsFeeder.launcher, args=(child_conn, tbIF, ddmIF, vo, testTaskType))
+contentsFeeder.start()

pandajedi/jeditest/contentsFeederTestWithTask.py

@@ -0,0 +1,18 @@
+import sys
+
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+from pandajedi.jediddm.DDMInterface import DDMInterface
+from pandajedi.jediorder.ContentsFeeder import ContentsFeederThread
+
+jedi_task_id = int(sys.argv[1])
+
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface()
+
+ddmIF = DDMInterface()
+ddmIF.setupInterface()
+
+task_ds_list = tbIF.getDatasetsToFeedContents_JEDI(task_id=jedi_task_id, force_read=True)
+
+c = ContentsFeederThread(taskDsList=None, threadPool=None, taskbufferIF=tbIF, ddmIF=ddmIF, pid="")
+c.feed_contents_to_tasks(task_ds_list, real_run=False)

pandajedi/jeditest/ddmTest.py

@@ -0,0 +1,4 @@
+from pandajedi.jediddm.DDMInterface import DDMInterface
+
+ddmIF = DDMInterface()
+ddmIF.setupInterface()

pandajedi/jeditest/jobGenForOneTask.py

@@ -0,0 +1,38 @@
+import os
+import socket
+import sys
+
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+from pandajedi.jedicore.ThreadUtils import ListWithLock, ThreadPool
+from pandajedi.jediddm.DDMInterface import DDMInterface
+from pandajedi.jediorder.JobGenerator import JobGeneratorThread
+from pandajedi.jediorder.TaskSetupper import TaskSetupper
+
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface()
+
+siteMapper = tbIF.get_site_mapper()
+
+ddmIF = DDMInterface()
+ddmIF.setupInterface()
+
+jediTaskID = int(sys.argv[1])
+
+# get task attributes
+s, taskSpec = tbIF.getTaskWithID_JEDI(jediTaskID)
+pid = f"{socket.getfqdn().split('.')[0]}-{os.getpid()}_{os.getpgrp()}-sgen"
+vo = taskSpec.vo
+prodSourceLabel = taskSpec.prodSourceLabel
+workQueue = tbIF.getWorkQueueMap().getQueueWithIDGshare(taskSpec.workQueue_ID, taskSpec.gshare)
+
+# get inputs
+tmpList = tbIF.getTasksToBeProcessed_JEDI(pid, None, workQueue, None, None, nFiles=1000, target_tasks=[jediTaskID])
+inputList = ListWithLock(tmpList)
+
+# create thread
+threadPool = ThreadPool()
+taskSetupper = TaskSetupper(vo, prodSourceLabel)
+taskSetupper.initializeMods(tbIF, ddmIF)
+gen = JobGeneratorThread(inputList, threadPool, tbIF, ddmIF, siteMapper, True, taskSetupper, pid, workQueue, "sgen", None, None, None, False)
+gen.start()
+gen.join()

pandajedi/jeditest/jobGeneratorTest.py

@@ -0,0 +1,43 @@
+import multiprocessing
+import sys
+
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+from pandajedi.jediddm.DDMInterface import DDMInterface
+from pandajedi.jediorder import JobGenerator
+
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface()
+
+
+ddmIF = DDMInterface()
+ddmIF.setupInterface()
+
+
+parent_conn, child_conn = multiprocessing.Pipe()
+
+try:
+    testVO = sys.argv[1]
+except Exception:
+    testVO = "atlas"
+
+try:
+    testTaskType = sys.argv[2]
+except Exception:
+    testTaskType = "test"
+
+try:
+    execJob = False
+    if sys.argv[3] == "y":
+        execJob = True
+except Exception:
+    pass
+
+try:
+    testClouds = sys.argv[4].split(",")
+except Exception:
+    testClouds = [None]
+
+print(f"{testVO} {testTaskType} {testClouds}")
+
+gen = multiprocessing.Process(target=JobGenerator.launcher, args=(child_conn, tbIF, ddmIF, testVO, testTaskType, testClouds, False, execJob, None, True))
+gen.start()

pandajedi/jeditest/jobSplitterTest.py

@@ -0,0 +1,104 @@
+import sys
+
+from pandajedi.jedicore import Interaction
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+from pandajedi.jedicore.MsgWrapper import MsgWrapper
+from pandajedi.jedicore.ThreadUtils import ListWithLock, ThreadPool
+from pandajedi.jediddm.DDMInterface import DDMInterface
+from pandajedi.jediorder.JobBroker import JobBroker
+from pandajedi.jediorder.JobGenerator import JobGeneratorThread, logger
+from pandajedi.jediorder.JobSplitter import JobSplitter
+from pandajedi.jediorder.TaskSetupper import TaskSetupper
+
+tmpLog = MsgWrapper(logger)
+
+
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface()
+
+siteMapper = tbIF.get_site_mapper()
+
+
+ddmIF = DDMInterface()
+ddmIF.setupInterface()
+
+jediTaskID = int(sys.argv[1])
+try:
+    datasetID = [int(sys.argv[2])]
+except Exception:
+    datasetID = None
+try:
+    n_files = int(sys.argv[3])
+except Exception:
+    n_files = 10
+
+s, taskSpec = tbIF.getTaskWithID_JEDI(jediTaskID)
+
+cloudName = taskSpec.cloud
+vo = taskSpec.vo
+prodSourceLabel = taskSpec.prodSourceLabel
+queueID = taskSpec.workQueue_ID
+gshare_name = taskSpec.gshare
+
+workQueue = tbIF.getWorkQueueMap().getQueueWithIDGshare(queueID, gshare_name)
+
+brokerageLockIDs = ListWithLock([])
+
+threadPool = ThreadPool()
+
+# get typical number of files
+typicalNumFilesMap = tbIF.getTypicalNumInput_JEDI(vo, prodSourceLabel, workQueue, useResultCache=600)
+
+tmpListList = tbIF.getTasksToBeProcessed_JEDI(
+    None,
+    vo,
+    workQueue,
+    prodSourceLabel,
+    cloudName,
+    nFiles=n_files,
+    simTasks=[jediTaskID],
+    fullSimulation=True,
+    typicalNumFilesMap=typicalNumFilesMap,
+    simDatasets=datasetID,
+    numNewTaskWithJumbo=5,
+    ignore_lock=True,
+)
+
+taskSetupper = TaskSetupper(vo, prodSourceLabel)
+taskSetupper.initializeMods(tbIF, ddmIF)
+
+resource_types = tbIF.load_resource_types()
+
+for dummyID, tmpList in tmpListList:
+    task_common = {}
+    for taskSpec, cloudName, inputChunk in tmpList:
+        jobBroker = JobBroker(taskSpec.vo, taskSpec.prodSourceLabel)
+        tmpStat = jobBroker.initializeMods(ddmIF.getInterface(vo), tbIF)
+        jobBrokerCore = jobBroker.getImpl(taskSpec.vo, taskSpec.prodSourceLabel)
+        jobBrokerCore.setTestMode()
+        jobBrokerCore.set_task_common_dict(task_common)
+        splitter = JobSplitter()
+        gen = JobGeneratorThread(
+            None, threadPool, tbIF, ddmIF, siteMapper, False, taskSetupper, None, None, "dummy", None, None, brokerageLockIDs, False, resource_types
+        )
+        gen.time_profile_level = 1
+
+        taskParamMap = None
+        if taskSpec.useLimitedSites():
+            tmpStat, taskParamMap = gen.readTaskParams(taskSpec, taskParamMap, tmpLog)
+        jobBroker.setLockID(taskSpec.vo, taskSpec.prodSourceLabel, 123, 0)
+        tmpStat, inputChunk = jobBroker.doBrokerage(taskSpec, cloudName, inputChunk, taskParamMap)
+        brokerageLockID = jobBroker.getBaseLockID(taskSpec.vo, taskSpec.prodSourceLabel)
+        if brokerageLockID is not None:
+            brokerageLockIDs.append(brokerageLockID)
+        for brokeragelockID in brokerageLockIDs:
+            tbIF.unlockProcessWithPID_JEDI(taskSpec.vo, taskSpec.prodSourceLabel, workQueue.queue_id, brokeragelockID, True)
+        tmpStat, subChunks, isSkipped = splitter.doSplit(taskSpec, inputChunk, siteMapper, allow_chunk_size_limit=True)
+        if tmpStat == Interaction.SC_SUCCEEDED and isSkipped:
+            # run again without chunk size limit to generate jobs for skipped snippet
+            tmpStat, tmpChunks, isSkipped = splitter.doSplit(taskSpec, inputChunk, siteMapper, allow_chunk_size_limit=False)
+            if tmpStat == Interaction.SC_SUCCEEDED:
+                subChunks += tmpChunks
+        tmpStat, pandaJobs, datasetToRegister, oldPandaIDs, parallelOutMap, outDsMap = gen.doGenerate(
+            taskSpec, cloudName, subChunks, inputChunk, tmpLog, True, splitter=splitter
+        )

pandajedi/jeditest/jobThrottlerTest.py

@@ -0,0 +1,22 @@
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+from pandajedi.jediorder.JobThrottler import JobThrottler
+
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface()
+
+vo = "atlas"
+prodSourceLabel = "managed"
+cloud = "WORLD"
+
+# get SiteMapper
+siteMapper = tbIF.get_site_mapper()
+wqMap = tbIF.getWorkQueueMap()
+
+jt = JobThrottler(vo, prodSourceLabel)
+jt.initializeMods(tbIF)
+
+workQueues = wqMap.getAlignedQueueList(vo, prodSourceLabel)
+resource_types = tbIF.load_resource_types()
+for workQueue in workQueues:
+    for resource_type in resource_types:
+        print(jt.toBeThrottled(vo, prodSourceLabel, cloud, workQueue, resource_type.resource_name))

pandajedi/jeditest/msgProcessorTest.py

@@ -0,0 +1,9 @@
+import multiprocessing
+
+from pandajedi.jediorder import JediMsgProcessor
+
+stop_event = multiprocessing.Event()
+
+agent = multiprocessing.Process(target=JediMsgProcessor.launcher, args=(stop_event,))
+agent.start()
+stop_event.wait()

pandajedi/jeditest/postProcessorTest.py

@@ -0,0 +1,18 @@
+import multiprocessing
+
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+from pandajedi.jediddm.DDMInterface import DDMInterface
+from pandajedi.jediorder import PostProcessor
+
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface()
+
+
+ddmIF = DDMInterface()
+ddmIF.setupInterface()
+
+
+parent_conn, child_conn = multiprocessing.Pipe()
+
+postProcessor = multiprocessing.Process(target=PostProcessor.launcher, args=(child_conn, tbIF, ddmIF))
+postProcessor.start()

pandajedi/jeditest/resubmitDataCarouselRequest.py

@@ -0,0 +1,35 @@
+import sys
+
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+from pandajedi.jediddm.DDMInterface import DDMInterface
+from pandajedi.jedirefine import RefinerUtils
+from pandaserver.taskbuffer.DataCarousel import DataCarouselInterface
+
+vo = "atlas"
+request_id = int(sys.argv[1])
+
+print("set tbIF")
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface(max_size=1)
+
+print("set ddmIF")
+ddmIF = DDMInterface()
+ddmIF.setupInterface()
+
+print("set DCIF")
+data_carousel_interface = DataCarouselInterface(tbIF, ddmIF.getInterface(vo))
+if data_carousel_interface is None:
+    # data carousel interface is undefined
+    errStr = f"data carousel interface is undefined for vo={vo}"
+    print(errStr)
+    sys.exit(1)
+
+print(f"resubmit for request_id={request_id}")
+dc_req_spec_resubmitted, _ = data_carousel_interface.resubmit_request(request_id)
+
+if not dc_req_spec_resubmitted:
+    # failed to resubmit
+    print(f"failed; got {dc_req_spec_resubmitted}")
+else:
+    # resubmitted
+    print(f"resubmitted; new request_id={dc_req_spec_resubmitted.request_id}")

pandajedi/jeditest/resubmitTaskParam.py

@@ -0,0 +1,20 @@
+import sys
+
+from taskbuffer.Initializer import initializer
+
+from pandajedi.jedicore import JediTaskBuffer
+
+jediTaskID = sys.argv[1]
+
+# initialize DB using dummy connection
+initializer.init()
+
+
+taskBuffer = JediTaskBuffer.JediTaskBuffer(None)
+proxy = taskBuffer.proxyPool.getProxy()
+
+s, o = proxy.getClobObj("select task_param from atlas_deft.deft_task where task_id=:task_id", {":task_id": jediTaskID})
+
+taskParamStr = o[0][0]
+
+proxy.insertTaskParams_JEDI(None, taskParamStr)

pandajedi/jeditest/taskBrokerTest.py

@@ -0,0 +1,22 @@
+import multiprocessing
+import sys
+
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+from pandajedi.jediddm.DDMInterface import DDMInterface
+from pandajedi.jediorder import TaskBroker
+
+try:
+    testTaskType = sys.argv[1]
+except Exception:
+    testTaskType = "test"
+
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface()
+
+ddmIF = DDMInterface()
+ddmIF.setupInterface()
+
+parent_conn, child_conn = multiprocessing.Pipe()
+
+taskBroker = multiprocessing.Process(target=TaskBroker.launcher, args=(child_conn, tbIF, ddmIF, "atlas", testTaskType))
+taskBroker.start()

pandajedi/jeditest/taskBrokerTestWithTask.py

@@ -0,0 +1,38 @@
+import sys
+
+from pandajedi.jedicore.FactoryBase import FactoryBase
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+from pandajedi.jediddm.DDMInterface import DDMInterface
+from pandajedi.jediorder.TaskBroker import TaskBroker
+
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface()
+
+siteMapper = tbIF.get_site_mapper()
+
+
+ddmIF = DDMInterface()
+ddmIF.setupInterface()
+
+jedi_task_id = int(sys.argv[1])
+
+s, task_spec = tbIF.getTaskWithID_JEDI(jedi_task_id)
+
+vo = task_spec.vo
+prodSourceLabel = task_spec.prodSourceLabel
+resource_type = task_spec.resource_type
+queue_id = task_spec.workQueue_ID
+gshare_name = task_spec.gshare
+
+work_queue = tbIF.getWorkQueueMap().getQueueWithIDGshare(queue_id, gshare_name)
+
+
+task_list = tbIF.getTasksToBeProcessed_JEDI(None, None, None, None, None, simTasks=[jedi_task_id], readMinFiles=True, fullSimulation=True)
+for ts in task_list:
+    for t in ts[1]:
+        t[0].nucleus = None
+
+task_broker = TaskBroker(None, tbIF, ddmIF, [vo], [prodSourceLabel])
+FactoryBase.initializeMods(task_broker, task_broker.taskBufferIF, task_broker.ddmIF)
+impl = task_broker.getImpl(vo, prodSourceLabel)
+impl.doBrokerage(task_list, vo, prodSourceLabel, work_queue, resource_type)

pandajedi/jeditest/taskBufferTest.py

@@ -0,0 +1,5 @@
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface()
+wqMap = tbIF.getWorkQueueMap()

pandajedi/jeditest/taskCommandoTest.py

@@ -0,0 +1,28 @@
+import multiprocessing
+
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+from pandajedi.jediddm.DDMInterface import DDMInterface
+from pandajedi.jediorder import TaskCommando
+
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface()
+
+
+ddmIF = DDMInterface()
+ddmIF.setupInterface()
+
+
+parent_conn, child_conn = multiprocessing.Pipe()
+
+try:
+    testVO = sys.argv[1]
+except Exception:
+    testVO = "any"
+
+try:
+    testTaskType = sys.argv[2]
+except Exception:
+    testTaskType = "any"
+
+taskCommando = multiprocessing.Process(target=TaskCommando.launcher, args=(child_conn, tbIF, ddmIF, testVO, testTaskType))
+taskCommando.start()

pandajedi/jeditest/taskRefinerTest.py

@@ -0,0 +1,30 @@
+import sys
+
+try:
+    testTaskType = sys.argv[1]
+except Exception:
+    testTaskType = "test"
+
+try:
+    vo = sys.argv[2]
+except Exception:
+    vo = "atlas"
+
+import multiprocessing
+
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+from pandajedi.jediddm.DDMInterface import DDMInterface
+from pandajedi.jediorder import TaskRefiner
+
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface()
+
+
+ddmIF = DDMInterface()
+ddmIF.setupInterface()
+
+
+parent_conn, child_conn = multiprocessing.Pipe()
+
+taskRefiner = multiprocessing.Process(target=TaskRefiner.launcher, args=(child_conn, tbIF, ddmIF, vo, testTaskType))
+taskRefiner.start()

pandajedi/jeditest/testOneTaskToRefine.py

@@ -0,0 +1,49 @@
+import sys
+
+from pandacommon.pandalogger.PandaLogger import PandaLogger
+
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+from pandajedi.jedicore.MsgWrapper import MsgWrapper
+from pandajedi.jediddm.DDMInterface import DDMInterface
+from pandajedi.jediorder.TaskRefiner import TaskRefiner
+from pandajedi.jedirefine import RefinerUtils
+
+logger = PandaLogger().getLogger("TaskRefiner")
+tmpLog = MsgWrapper(logger)
+
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface()
+
+siteMapper = tbIF.get_site_mapper()
+
+ddmIF = DDMInterface()
+ddmIF.setupInterface()
+
+
+jediTaskID = int(sys.argv[1])
+
+s, taskSpec = tbIF.getTaskWithID_JEDI(jediTaskID)
+refiner = TaskRefiner(None, tbIF, ddmIF, taskSpec.vo, taskSpec.prodSourceLabel)
+refiner.initializeMods(tbIF, ddmIF)
+
+
+taskParam = tbIF.getTaskParamsWithID_JEDI(jediTaskID)
+taskParamMap = RefinerUtils.decodeJSON(taskParam)
+
+vo = taskParamMap["vo"]
+prodSourceLabel = taskParamMap["prodSourceLabel"]
+taskType = taskParamMap["taskType"]
+
+cloudName = taskSpec.cloud
+vo = taskSpec.vo
+prodSourceLabel = taskSpec.prodSourceLabel
+queueID = taskSpec.workQueue_ID
+gshare_name = taskSpec.gshare
+
+impl = refiner.instantiateImpl(vo, prodSourceLabel, taskType, tbIF, ddmIF)
+
+workQueueMapper = tbIF.getWorkQueueMap()
+
+impl.initializeRefiner(tmpLog)
+impl.extractCommon(jediTaskID, taskParamMap, workQueueMapper, taskSpec.splitRule)
+impl.doRefine(jediTaskID, taskParamMap)

pandajedi/jeditest/testOneTaskToTaskBroker.py

@@ -0,0 +1,42 @@
+import sys
+
+from pandacommon.pandalogger.PandaLogger import PandaLogger
+
+from pandajedi.jedicore.JediTaskBufferInterface import JediTaskBufferInterface
+from pandajedi.jedicore.MsgWrapper import MsgWrapper
+from pandajedi.jediddm.DDMInterface import DDMInterface
+from pandajedi.jediorder.TaskBroker import TaskBroker
+from pandajedi.jedirefine import RefinerUtils
+
+logger = PandaLogger().getLogger("TaskBroker")
+tmpLog = MsgWrapper(logger)
+
+tbIF = JediTaskBufferInterface()
+tbIF.setupInterface()
+
+siteMapper = tbIF.get_site_mapper()
+
+ddmIF = DDMInterface()
+ddmIF.setupInterface()
+
+jediTaskID = int(sys.argv[1])
+
+s, taskSpec = tbIF.getTaskWithID_JEDI(jediTaskID, False)
+body = TaskBroker(None, tbIF, ddmIF, taskSpec.vo, taskSpec.prodSourceLabel)
+body.initializeMods(tbIF, ddmIF)
+
+taskParam = tbIF.getTaskParamsWithID_JEDI(jediTaskID)
+taskParamMap = RefinerUtils.decodeJSON(taskParam)
+
+vo = taskParamMap["vo"]
+prodSourceLabel = taskParamMap["prodSourceLabel"]
+taskType = taskParamMap["taskType"]
+
+workQueueMapper = tbIF.getWorkQueueMap()
+workQueue = workQueueMapper.getQueueWithIDGshare(taskSpec.workQueue_ID, taskSpec.gshare)
+
+impl = body.getImpl(vo, prodSourceLabel)
+
+
+tmpListItem = tbIF.getTasksToBeProcessed_JEDI(None, None, None, None, None, simTasks=[jediTaskID], readMinFiles=True)
+impl.doBrokerage(tmpListItem, taskSpec.vo, taskSpec.prodSourceLabel, workQueue, taskSpec.resource_type)