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

pandaserver/daemons/scripts/add_sub.py

@@ -0,0 +1,221 @@
+import datetime
+import glob
+import os
+import re
+import sys
+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 pandacommon.pandautils.thread_utils import GenericThread
+
+import pandaserver.taskbuffer.ErrorCode
+import pandaserver.userinterface.Client as Client
+from pandaserver.brokerage.SiteMapper import SiteMapper
+from pandaserver.config import panda_config
+from pandaserver.srvcore.CoreUtils import commands_get_status_output
+
+# logger
+_logger = PandaLogger().getLogger("add_sub")
+
+
+# main
+def main(argv=tuple(), tbuf=None, **kwargs):
+    tmp_log = LogWrapper(_logger, None)
+    requester_id = GenericThread().get_full_id(__name__, sys.modules[__name__].__file__)
+
+    tmp_log.debug("===================== start =====================")
+
+    # current minute
+    current_minute = naive_utcnow().minute
+
+    # instantiate TB
+    if tbuf is None:
+        from pandaserver.taskbuffer.TaskBuffer import taskBuffer
+
+        taskBuffer.init(
+            panda_config.dbhost,
+            panda_config.dbpasswd,
+            nDBConnection=1,
+            useTimeout=True,
+            requester=requester_id,
+        )
+    else:
+        taskBuffer = tbuf
+
+    # instantiate sitemapper
+    aSiteMapper = SiteMapper(taskBuffer)
+
+    # count # of getJob/updateJob in dispatcher's log
+    try:
+        # don't update when logrotate is running
+        timeNow = naive_utcnow()
+        logRotateTime = timeNow.replace(hour=3, minute=2, second=0, microsecond=0)
+        if (timeNow > logRotateTime and (timeNow - logRotateTime) < datetime.timedelta(minutes=5)) or (
+            logRotateTime > timeNow and (logRotateTime - timeNow) < datetime.timedelta(minutes=5)
+        ):
+            tmp_log.debug("skip pilotCounts session for logrotate")
+        else:
+            # log filename
+            dispLogName = f"{panda_config.logdir}/panda-PilotRequests.log"
+            # time limit
+            timeLimit = naive_utcnow() - datetime.timedelta(hours=3)
+            timeLimitS = naive_utcnow() - datetime.timedelta(hours=1)
+            # check if tgz is required
+            com = f"head -1 {dispLogName}"
+            lostat, loout = commands_get_status_output(com)
+            useLogTgz = True
+            if lostat == 0:
+                match = re.search("^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}", loout)
+                if match is not None:
+                    startTime = datetime.datetime(*time.strptime(match.group(0), "%Y-%m-%d %H:%M:%S")[:6])
+                    # current log contains all info
+                    if startTime < timeLimit:
+                        useLogTgz = False
+            # log files
+            dispLogNameList = [dispLogName]
+            if useLogTgz:
+                today = datetime.date.today()
+                dispLogNameList.append(f"{dispLogName}-{today.strftime('%Y%m%d')}.gz")
+            # delete tmp
+            commands_get_status_output(f"rm -f {dispLogName}.tmp-*")
+            # tmp name
+            tmp_logName = f"{dispLogName}.tmp-{naive_utcnow().strftime('%Y-%m-%d-%H-%M-%S')}"
+            # loop over all files
+            pilotCounts = {}
+            pilotCountsS = {}
+            for tmpDispLogName in dispLogNameList:
+                # expand or copy
+                if tmpDispLogName.endswith(".gz"):
+                    com = f"gunzip -c {tmpDispLogName} > {tmp_logName}"
+                else:
+                    com = f"cp {tmpDispLogName} {tmp_logName}"
+                lostat, loout = commands_get_status_output(com)
+                if lostat != 0:
+                    errMsg = f"failed to expand/copy {tmpDispLogName} with : {loout}"
+                    raise RuntimeError(errMsg)
+                # search string
+                sStr = "^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}).*"
+                sStr += "method=(.+),site=(.+),node=(.+),type=(.+)"
+                # read
+                logFH = open(tmp_logName)
+                for line in logFH:
+                    # check format
+                    match = re.search(sStr, line)
+                    if match is not None:
+                        # check timerange
+                        timeStamp = datetime.datetime(*time.strptime(match.group(1), "%Y-%m-%d %H:%M:%S")[:6])
+                        if timeStamp < timeLimit:
+                            continue
+                        tmpMethod = match.group(2)
+                        tmpSite = match.group(3)
+                        tmpNode = match.group(4)
+
+                        # protection against corrupted entries from pilot,
+                        # e.g. pilot reading site json from cvmfs while it was being updated
+                        if tmpSite not in aSiteMapper.siteSpecList:
+                            continue
+                        # sum
+                        pilotCounts.setdefault(tmpSite, {})
+                        pilotCounts[tmpSite].setdefault(tmpMethod, {})
+                        pilotCounts[tmpSite][tmpMethod].setdefault(tmpNode, 0)
+                        pilotCounts[tmpSite][tmpMethod][tmpNode] += 1
+                        # short
+                        if timeStamp > timeLimitS:
+                            if tmpSite not in pilotCountsS:
+                                pilotCountsS[tmpSite] = dict()
+                            if tmpMethod not in pilotCountsS[tmpSite]:
+                                pilotCountsS[tmpSite][tmpMethod] = dict()
+                            if tmpNode not in pilotCountsS[tmpSite][tmpMethod]:
+                                pilotCountsS[tmpSite][tmpMethod][tmpNode] = 0
+                            pilotCountsS[tmpSite][tmpMethod][tmpNode] += 1
+                # close
+                logFH.close()
+            # delete tmp
+            commands_get_status_output(f"rm {tmp_logName}")
+            # update
+            hostID = panda_config.pserverhost.split(".")[0]
+            tmp_log.debug("pilotCounts session")
+            retPC = taskBuffer.updateSiteData(hostID, pilotCounts, interval=3)
+            tmp_log.debug(retPC)
+            retPC = taskBuffer.updateSiteData(hostID, pilotCountsS, interval=1)
+            tmp_log.debug(retPC)
+    except Exception:
+        errType, errValue = sys.exc_info()[:2]
+        tmp_log.error(f"updateJob/getJob : {errType} {errValue}")
+
+    # nRunning
+    tmp_log.debug("nRunning session")
+    try:
+        if (current_minute / panda_config.nrun_interval) % panda_config.nrun_hosts == panda_config.nrun_snum:
+            retNR = taskBuffer.insertnRunningInSiteData()
+            tmp_log.debug(retNR)
+    except Exception:
+        errType, errValue = sys.exc_info()[:2]
+        tmp_log.error(f"nRunning : {errType} {errValue}")
+
+    # session for co-jumbo jobs
+    tmp_log.debug("co-jumbo session")
+    try:
+        ret = taskBuffer.getCoJumboJobsToBeFinished(30, 0, 1000)
+        if ret is None:
+            tmp_log.debug("failed to get co-jumbo jobs to finish")
+        else:
+            coJumboA, coJumboD, coJumboTokill = ret
+            tmp_log.debug(f"finish {len(coJumboA)} co-jumbo jobs in Active")
+            if len(coJumboA) > 0:
+                jobSpecs = taskBuffer.peekJobs(
+                    coJumboA,
+                    fromDefined=False,
+                    fromActive=True,
+                    fromArchived=False,
+                    fromWaiting=False,
+                )
+                for jobSpec in jobSpecs:
+                    fileCheckInJEDI = taskBuffer.checkInputFileStatusInJEDI(jobSpec)
+                    if not fileCheckInJEDI:
+                        jobSpec.jobStatus = "closed"
+                        jobSpec.jobSubStatus = "cojumbo_wrong"
+                        jobSpec.taskBufferErrorCode = pandaserver.taskbuffer.ErrorCode.EC_EventServiceInconsistentIn
+                    taskBuffer.archiveJobs([jobSpec], False)
+            tmp_log.debug(f"finish {len(coJumboD)} co-jumbo jobs in Defined")
+            if len(coJumboD) > 0:
+                jobSpecs = taskBuffer.peekJobs(
+                    coJumboD,
+                    fromDefined=True,
+                    fromActive=False,
+                    fromArchived=False,
+                    fromWaiting=False,
+                )
+                for jobSpec in jobSpecs:
+                    fileCheckInJEDI = taskBuffer.checkInputFileStatusInJEDI(jobSpec)
+                    if not fileCheckInJEDI:
+                        jobSpec.jobStatus = "closed"
+                        jobSpec.jobSubStatus = "cojumbo_wrong"
+                        jobSpec.taskBufferErrorCode = pandaserver.taskbuffer.ErrorCode.EC_EventServiceInconsistentIn
+                    taskBuffer.archiveJobs([jobSpec], True)
+            if len(coJumboTokill) > 0:
+                jediJobs = list(coJumboTokill)
+                nJob = 100
+                iJob = 0
+                while iJob < len(jediJobs):
+                    tmp_log.debug(f" killing {str(jediJobs[iJob:iJob + nJob])}")
+                    Client.kill_jobs(jediJobs[iJob : iJob + nJob], 51, keepUnmerged=True)
+                    iJob += nJob
+    except Exception:
+        errStr = traceback.format_exc()
+        tmp_log.error(errStr)
+
+    # stop taskBuffer if created inside this script
+    if tbuf is None:
+        taskBuffer.cleanup(requester=requester_id)
+
+    tmp_log.debug("===================== end =====================")
+
+
+# run
+if __name__ == "__main__":
+    main(argv=sys.argv)

pandaserver/daemons/scripts/cache_pilots.py

@@ -0,0 +1,47 @@
+import os
+import shutil
+import traceback
+from pathlib import Path
+
+from pandacommon.pandalogger.PandaLogger import PandaLogger
+
+from pandaserver.config import panda_config
+
+# logger
+_logger = PandaLogger().getLogger("cache_pilot_config")
+
+# list of source files to be copied
+source_file_list = [
+    "/cvmfs/atlas.cern.ch/repo/sw/PandaPilot/tar/pilot2.tar.gz",
+    "/cvmfs/atlas.cern.ch/repo/sw/PandaPilot/tar/pilot3.tar.gz",
+]
+
+# default destination directory
+default_dest_dir = getattr(panda_config, "pilot_cache_dir", "/var/cache/pandaserver/pilot")
+
+
+def main(argv=tuple(), tbuf=None, **kwargs):
+    _logger.debug("start")
+    try:
+        # ensure the destination directory
+        dest_dir_path = Path(default_dest_dir)
+        try:
+            dest_dir_path.mkdir(mode=0o755, exist_ok=True)
+        except Exception as e:
+            _logger.error(f"failed to mkdir {dest_dir_path}: {e}")
+        # copy
+        for source_file in source_file_list:
+            if not os.path.exists(source_file):
+                _logger.warning(f"source file {source_file} does not exist, skipped")
+                continue
+            dest_file_path = shutil.copy(source_file, dest_dir_path)
+            _logger.debug(f"copied {source_file} to {dest_file_path}")
+    except Exception as e:
+        err_str = traceback.format_exc()
+        _logger.error(f"failed to copy files: {err_str}")
+    # done
+    _logger.debug("done")
+
+
+if __name__ == "__main__":
+    main()

pandaserver/daemons/scripts/cache_schedconfig.py

@@ -0,0 +1,286 @@
+#! /usr/bin/env python
+#
+# Dump schedconfig on a per-queue basis into cache files
+#
+#
+
+import json
+import os
+import shutil
+import sys
+import traceback
+from argparse import ArgumentParser
+from copy import deepcopy
+from pathlib import Path
+
+from pandacommon.pandalogger.PandaLogger import PandaLogger
+from pandacommon.pandautils.thread_utils import GenericThread
+
+from pandaserver.config import panda_config
+
+# logger
+_logger = PandaLogger().getLogger("cache_schedconfig")
+
+# default destination directory
+default_dest_dir = getattr(panda_config, "schedconfig_cache_dir", "/var/cache/pandaserver/schedconfig")
+
+
+class cacheSchedConfig:
+    """
+    Class to dump schedconfig on a per-queue basis into cache files
+    """
+
+    def __init__(self, tbuf):
+        self.tbuf = tbuf
+        self.queueData = None
+        self.cloudStatus = None
+        # Define this here, but could be more flexible...
+        self.queueDataFields = {
+            # Note that json dumps always use sort_keys=True; for pilot format
+            # the order defined here is respected
+            "pilot": [
+                "appdir",
+                "allowdirectaccess",
+                "cloud",
+                "datadir",
+                "dq2url",
+                "copytool",
+                "copytoolin",
+                "copysetup",
+                "copysetupin",
+                "ddm",
+                "se",
+                "sepath",
+                "seprodpath",
+                "envsetup",
+                "envsetupin",
+                "region",
+                "copyprefix",
+                "copyprefixin",
+                "lfcpath",
+                "lfcprodpath",
+                "lfchost",
+                "lfcregister",
+                "sein",
+                "wntmpdir",
+                "proxy",
+                "retry",
+                "recoverdir",
+                "space",
+                "memory",
+                "cmtconfig",
+                "status",
+                "setokens",
+                "glexec",
+                "seopt",
+                "gatekeeper",
+                "pcache",
+                "maxinputsize",
+                "timefloor",
+                "corecount",
+                "faxredirector",
+                "allowfax",
+                "maxtime",
+                "maxwdir",
+            ],
+            "factory": [
+                "site",
+                "siteid",
+                "nickname",
+                "cloud",
+                "status",
+                "jdl",
+                "queue",
+                "localqueue",
+                "nqueue",
+                "environ",
+                "proxy",
+                "glexec",
+                "depthboost",
+                "idlepilotsupression",
+                "pilotlimit",
+                "transferringlimit",
+                "memory",
+                "maxtime",
+                "system",
+                "fairsharepolicy",
+                "autosetup_pre",
+                "autosetup_post",
+            ],
+            # None is magic here and really means "all"
+            "all": None,
+        }
+
+    def query_column_sql(self, sql, varMap=None, arraySize=100):
+        res = self.tbuf.querySQL(sql, varMap, arraySize=arraySize)
+        retList = []
+        for (
+            panda_queue,
+            data,
+        ) in res:
+            if isinstance(data, str):
+                dictData = json.loads(data)
+            elif isinstance(data, dict):
+                dictData = data
+            else:
+                dictData = json.loads(data.read())
+            dictData["siteid"] = panda_queue
+            retList.append(dictData)
+        return retList
+
+    def getQueueData(self, site=None, queue=None):
+        # Dump schedconfig in a single query (it's not very big)
+        varDict = {}
+        sql = f"SELECT panda_queue, data from {panda_config.schemaPANDA}.SCHEDCONFIG_JSON"
+        if site:
+            sql += " where panda_queue=:site"
+            varDict[":site"] = site
+            self.queueData = self.query_column_sql(sql, varDict)
+        elif queue:
+            sql += " where panda_queue=:queue"
+            varDict[":queue"] = queue
+            self.queueData = self.query_column_sql(sql, varDict)
+        else:
+            self.queueData = self.query_column_sql(sql)
+
+    def dumpSingleQueue(self, queueDict, dest="/tmp", outputSet="all", format="txt"):
+        try:
+            file = os.path.join(dest, queueDict["nickname"] + "." + outputSet + "." + format)
+            output = open(file, "w")
+            outputFields = self.queueDataFields[outputSet]
+            if outputFields is None:
+                outputFields = queueDict.keys()
+            if format == "txt":
+                for outputField in outputFields:
+                    output.write(outputField + "=" + str(queueDict[outputField]))
+            if format == "pilot":
+                outputStr = ""
+                for outputField in outputFields:
+                    if outputField in queueDict and queueDict[outputField]:
+                        outputStr += outputField + "=" + str(queueDict[outputField]) + "|"
+                    else:
+                        outputStr += outputField + "=|"
+                output.write(outputStr[:-1])
+            if format == "json":
+                dumpMe = {}
+                for outputField in outputFields:
+                    if outputField in queueDict:
+                        val = queueDict[outputField]
+                    else:
+                        val = ""
+                    dumpMe[outputField] = val
+                json.dump(self.queueDictPythonise(dumpMe), output, sort_keys=True, indent=4)
+            output.close()
+            # a copy of the file, when makes sense, with filename based on siteid
+            newfile = os.path.join(dest, queueDict["siteid"] + "." + outputSet + "." + format)
+            if newfile != file:
+                shutil.copy(file, newfile)
+        except Exception:
+            raise
+
+    def queueDictPythonise(self, queueDict, deepCopy=True):
+        """Turn queue dictionary with SQL text fields into a more stuctured python representation"""
+        if deepCopy:
+            structDict = deepcopy(queueDict)
+        else:
+            structDict = queueDict
+
+        if "releases" in structDict and structDict["releases"] is not None:
+            if isinstance(structDict["releases"], str):
+                structDict["releases"] = structDict["releases"].split("|")
+
+        for timeKey in "lastmod", "tspace":
+            if timeKey in structDict:
+                structDict[timeKey] = structDict[timeKey].isoformat()
+        return structDict
+
+    def dumpAllSchedConfig(self, queueArray=None, dest="/tmp"):
+        """Dumps all of schedconfig into a single json file - allows clients to retrieve a
+        machine readable version of schedconfig efficiently"""
+        file = os.path.join(dest, "schedconfig.all.json")
+        if queueArray is None:
+            queueArray = self.queueData
+        output = open(file, "w")
+        dumpMe = {}
+        for queueDict in queueArray:
+            dumpMe[queueDict["nickname"]] = {}
+            for k in queueDict:
+                v = queueDict[k]
+                dumpMe[queueDict["nickname"]][k] = v
+            dumpMe[queueDict["nickname"]] = self.queueDictPythonise(dumpMe[queueDict["nickname"]])
+        json.dump(dumpMe, output, sort_keys=True, indent=4)
+        self.dump_pilot_gdp_config(dest)
+
+    def dump_pilot_gdp_config(self, dest="/tmp"):
+        app = "pilot"
+        dump_me = {}
+        sql = f"SELECT key, component, vo from {panda_config.schemaPANDA}.config where app=:app"
+        r = self.tbuf.querySQL(sql, {":app": app})
+        for key, component, vo in r:
+            dump_me.setdefault(vo, {})
+            value = self.tbuf.getConfigValue(component, key, app, vo)
+            dump_me[vo][key] = value
+        # dump
+        _logger.debug(f"pilot GDP config: {str(dump_me)}")
+        with open(os.path.join(dest, "pilot_gdp_config.json"), "w") as f:
+            json.dump(dump_me, f, sort_keys=True, indent=4)
+
+
+def main(argv=tuple(), tbuf=None, **kwargs):
+    _logger.debug("start")
+    try:
+        # parse arguments
+        parser = ArgumentParser()
+        parser.add_argument(
+            "-o",
+            "--output",
+            dest="dirname",
+            default=default_dest_dir,
+            help="write cache outputs to DIR",
+            metavar="DIR",
+        )
+        args = parser.parse_args(list(argv)[1:])
+        # ensure destination directory
+        dest_dir_path = Path(args.dirname)
+        dest_dir_path.mkdir(mode=0o755, exist_ok=True)
+        # instantiate TB
+        requester_id = GenericThread().get_full_id(__name__, sys.modules[__name__].__file__)
+        if tbuf is None:
+            from pandaserver.taskbuffer.TaskBuffer import taskBuffer
+
+            taskBuffer.init(
+                panda_config.dbhost,
+                panda_config.dbpasswd,
+                nDBConnection=1,
+                useTimeout=True,
+                requester=requester_id,
+            )
+        else:
+            taskBuffer = tbuf
+
+        # initialize
+        cacher = cacheSchedConfig(tbuf=taskBuffer)
+        cacher.getQueueData()
+
+        # dump
+        for queue in cacher.queueData:
+            cacher.dumpSingleQueue(queue, dest=args.dirname, outputSet="pilot", format="pilot")
+            cacher.dumpSingleQueue(queue, dest=args.dirname, outputSet="pilot", format="json")
+            cacher.dumpSingleQueue(queue, dest=args.dirname, outputSet="all", format="json")
+            cacher.dumpSingleQueue(queue, dest=args.dirname, outputSet="factory", format="json")
+        _logger.debug("dumped json files for each queue")
+        # Big dumper
+        cacher.dumpAllSchedConfig(dest=args.dirname)
+        _logger.debug("dumped schedconfig.all.json")
+        # stop taskBuffer if created inside this script
+        if tbuf is None:
+            taskBuffer.cleanup(requester=requester_id)
+    except Exception as e:
+        err_str = traceback.format_exc()
+        _logger.error(f"failed to copy files: {err_str}")
+    # done
+    _logger.debug("done")
+
+
+if __name__ == "__main__":
+    main(argv=sys.argv)

pandaserver/daemons/scripts/carbon.py

@@ -0,0 +1,50 @@
+import sys
+import time
+
+from pandacommon.pandalogger import logger_utils
+from pandacommon.pandautils.thread_utils import GenericThread
+from pandaserver.config import panda_config
+from pandaserver.configurator import Carbon as carbon_module
+from pandaserver.configurator.Carbon import CarbonEmissions
+
+# logger
+base_logger = carbon_module._logger
+
+
+# main
+def main(argv=tuple(), tbuf=None, **kwargs):
+    requester_id = GenericThread().get_full_id(__name__, sys.modules[__name__].__file__)
+
+    # instantiate TB
+    if tbuf is None:
+        from pandaserver.taskbuffer.TaskBuffer import taskBuffer
+
+        taskBuffer.init(
+            panda_config.dbhost,
+            panda_config.dbpasswd,
+            nDBConnection=1,
+            useTimeout=True,
+            requester=requester_id,
+        )
+    else:
+        taskBuffer = tbuf
+
+    # If no argument, call the basic configurator
+    if len(argv) == 1:
+        _logger = logger_utils.make_logger(base_logger, "Carbon")
+        t1 = time.time()
+        carbon_emissions = CarbonEmissions(taskBuffer=taskBuffer)
+        carbon_emissions.run()
+        t2 = time.time()
+        _logger.debug(f"Carbon run took {t2 - t1}s")
+
+    else:
+        base_logger.error("Carbon module being called with wrong arguments. Use no arguments")
+
+    # stop taskBuffer if created inside this script
+    if tbuf is None:
+        taskBuffer.cleanup(requester=requester_id)
+
+
+if __name__ == "__main__":
+    main(argv=sys.argv)

pandaserver/daemons/scripts/configurator.py

@@ -0,0 +1,94 @@
+import sys
+import time
+
+from pandacommon.pandalogger import logger_utils
+from pandacommon.pandautils.thread_utils import GenericThread
+from pandaserver.config import panda_config
+from pandaserver.configurator import Configurator as configurator_module
+from pandaserver.configurator.Configurator import (
+    Configurator,
+    NetworkConfigurator,
+    SchedconfigJsonDumper,
+    SWTagsDumper,
+)
+
+# logger
+base_logger = configurator_module._logger
+
+
+# main
+def main(argv=tuple(), tbuf=None, **kwargs):
+    requester_id = GenericThread().get_full_id(__name__, sys.modules[__name__].__file__)
+
+    # instantiate TB
+    if tbuf is None:
+        from pandaserver.taskbuffer.TaskBuffer import taskBuffer
+
+        taskBuffer.init(
+            panda_config.dbhost,
+            panda_config.dbpasswd,
+            nDBConnection=1,
+            useTimeout=True,
+            requester=requester_id,
+        )
+    else:
+        taskBuffer = tbuf
+
+    # If no argument, call the basic configurator
+    if len(argv) == 1:
+        _logger = logger_utils.make_logger(base_logger, "Configurator")
+        t1 = time.time()
+        configurator = Configurator(taskBuffer=taskBuffer, log_stream=_logger)
+
+        if not configurator.retrieve_data():
+            _logger.error("Data was not retrieved correctly")
+            return
+
+        if not configurator.run():
+            _logger.error("Configurator loop FAILED")
+        t2 = time.time()
+        _logger.debug(f"Configurator run took {t2 - t1}s")
+
+    # If --network argument, call the network configurator
+    elif len(argv) == 2 and argv[1].lower() == "--network":
+        _logger = logger_utils.make_logger(base_logger, "NetworkConfigurator")
+        t1 = time.time()
+        network_configurator = NetworkConfigurator(taskBuffer=taskBuffer, log_stream=_logger)
+        if not network_configurator.retrieve_data():
+            _logger.error("Data was not retrieved correctly")
+            return
+        if not network_configurator.run():
+            _logger.error("Configurator loop FAILED")
+        t2 = time.time()
+        _logger.debug(f" run took {t2 - t1}s")
+
+    # If --json_dump
+    elif len(argv) == 2 and argv[1].lower() == "--json_dump":
+        _logger = logger_utils.make_logger(base_logger, "SchedconfigJsonDumper")
+        t1 = time.time()
+        json_dumper = SchedconfigJsonDumper(taskBuffer=taskBuffer, log_stream=_logger)
+        out_msg = json_dumper.run()
+        _logger.debug(f"Json_dumper finished with {out_msg}")
+        t2 = time.time()
+        _logger.debug(f" run took {t2 - t1}s")
+
+    # If --sw_tags
+    elif len(argv) == 2 and argv[1].lower() == "--sw_tags":
+        _logger = logger_utils.make_logger(base_logger, "SWTagsDumper")
+        t1 = time.time()
+        sw_tag_collector = SWTagsDumper(taskBuffer=taskBuffer, log_stream=_logger)
+        out_msg = sw_tag_collector.run()
+        _logger.debug(f"sw_tag_collector finished with {out_msg}")
+        t2 = time.time()
+        _logger.debug(f" run took {t2 - t1}s")
+
+    else:
+        base_logger.error("Configurator being called with wrong arguments. Use either no arguments or --network or --json_dump")
+
+    # stop taskBuffer if created inside this script
+    if tbuf is None:
+        taskBuffer.cleanup(requester=requester_id)
+
+
+if __name__ == "__main__":
+    main(argv=sys.argv)