def testProcessDataset(self): with self.bb.queues: self.assertEquals(self.bb.queues.dataAvailable.length(), 0) policy = Policy.createPolicy(os.path.join(exampledir, "ccdassembly-joboffice.paf")) spolicy = policy.getPolicy("schedule") # manipulate the policy idp = Policy.createPolicy(PolicyString(idpolicy)) spolicy.set("job.identity", idp) self.sched = DataTriggeredScheduler(self.bb, spolicy, self.logger) # pdb.set_trace() ds = Dataset("PostISR", visitid=88, ccdid=22, snapid=0, ampid=15) self.sched.processDataset(ds) with self.bb.queues: self.assertEquals(self.bb.queues.dataAvailable.length(), 1) self.assertEquals(self.bb.queues.jobsPossible.length(), 1) job = self.bb.queues.jobsPossible.get(0) self.assertEquals(job.getName(), "Job-1") self.assertEquals(job.triggerHandler.getNeededDatasetCount(), 15) self.assertEquals(self.sched.nameNumber, 2) ds = Dataset("PostISR", visitid=95, ccdid=22, snapid=0, ampid=15) self.sched.processDataset(ds) with self.bb.queues: self.assertEquals(self.bb.queues.dataAvailable.length(), 2) self.assertEquals(self.bb.queues.jobsPossible.length(), 2) job = self.bb.queues.jobsPossible.get(1) self.assertEquals(job.getName(), "Job-2") self.assertEquals(job.triggerHandler.getNeededDatasetCount(), 15) inputs = job.getInputDatasets() self.assertEquals(len(inputs), 16) self.assertEquals(inputs[0].type, "PostISR") self.assertEquals(self.sched.nameNumber, 3) ds = Dataset("PostISR", visitid=88, ccdid=22, snapid=0, ampid=14) self.sched.processDataset(ds) with self.bb.queues: self.assertEquals(self.bb.queues.dataAvailable.length(), 3) self.assertEquals(self.bb.queues.jobsPossible.length(), 2) job = self.bb.queues.jobsPossible.get(0) self.assertEquals(job.triggerHandler.getNeededDatasetCount(), 14) # pdb.set_trace() for i in xrange(14): ds = Dataset("PostISR", visitid=88, ccdid=22, snapid=0, ampid=i) self.sched.processDataset(ds) with self.bb.queues: self.assertEquals(self.bb.queues.dataAvailable.length(), 17) self.assertEquals(self.bb.queues.jobsPossible.length(), 2) job = self.bb.queues.jobsPossible.get(0) self.assertEquals(job.triggerHandler.getNeededDatasetCount(), 0) self.assert_(job.isReady())
def main(): """ run the job office """ (cl.opts, cl.args) = cl.parse_args() if len(cl.args) == 0: fail("Missing policy file") if not os.path.exists(cl.args[0]): fail("%s: policy file not found" % cl.args[0]) if not os.path.exists(cl.opts.rootdir): fail("%s: root directory not found" % cl.opts.rootdir) if not cl.opts.runid: logger.log(Log.WARN, "No RunID given (via -r)") defpolf = DefaultPolicyFile("ctrl_sched", "JobOffice_dict.paf", "policies") policy = Policy.createPolicy(cl.args[0]) policy.mergeDefaults(Policy.createPolicy(defpolf, defpolf.getRepositoryPath())) name = policy.getString("name") # set job office root directory if not os.path.isabs(cl.opts.rootdir): cl.opts.rootdir = os.path.abspath(cl.opts.rootdir) persistdir = os.path.join(cl.opts.rootdir, name) if policy.exists("persist.dir"): persistdir = policy.get("persist.dir") % \ {"schedroot": cl.opts.rootdir, "name": name } # create the logger(s) logfile = cl.opts.logfile if not logfile: logfile = os.path.join(persistdir, "joboffice.log") if not os.path.exists(logfile): if not os.path.exists(os.path.dirname(logfile)): os.makedirs(os.path.dirname(logfile)) if not cl.opts.asdaemon or cl.opts.toscreen: ofclogger = DualLog(logfile, Log.DEBUG, Log.DEBUG, False) # logging bug workaround ofclogger.setScreenVerbose(False) else: ofclogger = Log() ofclogger.addDestination(logfile) ofclogger.setThreshold(run.verbosity2threshold(cl.opts.logverb, 0)) ofclogger.log(-2,"office threshold: %i" % ofclogger.getThreshold()) try: # create the JobOffice instance office = createJobOffice(cl.opts.rootdir, policy, ofclogger, cl.opts.runid, cl.opts.brokerhost, cl.opts.brokerport) except Exception, ex: logger.log(Log.FATAL, "Failed to create job office: " + str(ex)) raise sys.exit(1)
def main(): try: (cl.opts, cl.args) = cl.parse_args(); setVerbosity(cl.opts.verbosity) nodes = [] if cl.opts.policy is not None: policy = Policy.createPolicy(cl.opts.policy) nodes = getHeadNodes(policy) nodes.extend(cl.args) logger.log(Log.DEBUG, "Killing pipelines on " + ", ".join(nodes)) remcmd = "%s %s" % \ (os.path.join(os.environ[pkgdirvar], "bin", remkill),cl.opts.runid) remcmd = remcmd.strip() for node in nodes: cmd = ("ssh", node, remcmd) logger.log(Log.INFO, "executing: %s %s '%s'" % cmd) if subprocess.call(cmd) != 0: logger.log(Log.WARN, "Failed to kill processes on " + node) except: tb = traceback.format_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]) logger.log(Log.FATAL, tb[-1].strip()) logger.log(Log.DEBUG, "".join(tb[0:-1]).strip()) sys.exit(1) sys.exit(0)
def setup(self, policyDict="DataReady_dict.paf"): deffile = DefaultPolicyFile("ctrl_sched", policyDict, "policies") defpol = Policy.createPolicy(deffile, deffile.getRepositoryPath()) if not hasattr(self,"policy") or not self.policy: self.policy = Policy() self.policy.mergeDefaults(defpol.getDictionary()) # self.mode = self.policy.getString("mode") # if self.mode not in "parallel serial": # raise RuntimeError("Stage %s: Unsupported mode: %s" % # (self.getName(), self.mode)) self.clipboardKeys = {} self.clipboardKeys["completedDatasets"] = \ self.policy.getString("inputKeys.completedDatasets") self.clipboardKeys["possibleDatasets"] = \ self.policy.getString("inputKeys.possibleDatasets") self.dataclients = [] clpols = [] if self.policy.exists("datasets"): clpols = self.policy.getPolicyArray("datasets") for pol in clpols: dstype = None if pol.exists("datasetType"): dstype = pol.getString("datasetType") topic = pol.getString("dataReadyEvent") reportAll = pol.getBool("reportAllPossible") client = DataReadyClient(self.getRun(), self.getName(), topic, self.getEventBrokerHost(), dstype, reportAll) self.dataclients.append(client)
def testSetAdd(self): p = Policy.createPolicy(self.getTestDictionary("defaults_dictionary_good.paf"), "", True) self.assert_(p.canValidate()) self.assertValidationError( ValidationError.TOO_MANY_VALUES, p.add, "bool_set_count", True) self.assert_(p.valueCount("bool_set_count") == 1) self.assertValidationError( ValidationError.VALUE_DISALLOWED, p.set, "bool_set_count", False) self.assert_(p.getBool("bool_set_count") == True) p.set("int_range_count", -7) self.assertValidationError( ValidationError.VALUE_OUT_OF_RANGE, p.add, "int_range_count", 10) # add & set don't check against minOccurs, but validate() does try: p.validate() except ValidationError as ve: self.assert_(ve.getErrors("int_range_count") == ValidationError.NOT_AN_ARRAY) self.assert_(ve.getErrors("required") == ValidationError.MISSING_REQUIRED) p.add("int_range_count", -8) p.set("required", "foo") p.validate()
def testPolicyCopy(self): p = Policy.createPolicy("examples/EventTransmitter_policy.paf") pp = Policy(p, True) self.assertEquals(p.get("transmitter.serializationFormat"), "deluxe") self.assertEquals(pp.getString("transmitter.serializationFormat"), "deluxe") p = None self.assertEquals(pp.getString("transmitter.serializationFormat"), "deluxe")
def testSelfValidation(self): # assign a dictionary after creation p = Policy(self.getTestDictionary("types_policy_good.paf")) p.loadPolicyFiles(self.getTestDictionary(), True) typesDict = Dictionary(self.getTestDictionary("types_dictionary.paf")) valuesDict = Dictionary(self.getTestDictionary("values_dictionary.paf")) self.assert_(not p.canValidate()) p.setDictionary(typesDict) self.assert_(p.canValidate()) p.validate() p.set("bool_type", True) self.assertValidationError( ValidationError.WRONG_TYPE, p.set, "bool_type", "foo") # create with dictionary p = Policy.createPolicy(self.getTestDictionary("types_dictionary.paf"), "", True) self.assert_(p.canValidate()) p.set("bool_type", True) self.assertValidationError( ValidationError.WRONG_TYPE, p.set, "bool_type", "foo") # assign a dictionary after invalid modifications p = Policy() p.set("bool_type", "foo") p.setDictionary(typesDict) ve = ValidationError("Dictionary_1.py", 1, "testSelfValidation") p.validate(ve) self.assert_(ve.getErrors("bool_type") == ValidationError.WRONG_TYPE) try: p.validate() except ValidationError, e: ve = e.args[0] self.assert_(ve.getErrors("bool_type") == ValidationError.WRONG_TYPE) self.assert_(ve.getParamCount() == 1)
def extractIncludedFilenames(prodPolicyFile, repository=".", pipefile=None, logger=None): """ extract all the filenames included, directly or indirectly, from the given policy file. When a repository is provided, included files will be recursively opened and searched. The paths in the returned set will not include the repository directory. Use pipefile to skip the inclusion of pipeline policy files. @param prodPolicyFile the policy file to examine. This must be the full path to the file @param repository the policy repository. If None, the current directory is assumed. @param pipefile the hierarchical policy name for a pipeline definition. Any included policy filenames at this node or lower will not be added. @param logger if provided, use this Log to record any warnings about missing or bad files; otherwise, problems are silently ignored. @return set containing the unique set of policy filenames found, including the given top file and the """ prodPolicy = Policy.createPolicy(prodPolicyFile, False) filenames = set([prodPolicyFile]) ProvenanceSetup._listFilenames(filenames, prodPolicy, None, repository, pipefile, logger) filenames.discard(prodPolicyFile) return filenames
def setup(self): deffile = DefaultPolicyFile("ctrl_sched", "GetAJob_dict.paf", "policies") defpol = Policy.createPolicy(deffile, deffile.getRepositoryPath()) if not hasattr(self, "policy") or not self.policy: self.policy = Policy() self.policy.mergeDefaults(defpol.getDictionary()) self.jobid = None self.tagLogger(None) # self.mode = self.policy.getString("mode") # if self.mode not in "parallel serial": # raise RuntimeError("Stage %s: Unsupported mode: %s" % # (self.getName(), self.mode)) self.clipboardKeys = {} self.clipboardKeys["jobIdentity"] = \ self.policy.getString("outputKeys.jobIdentity") self.clipboardKeys["inputDatasets"] = \ self.policy.getString("outputKeys.inputDatasets") self.clipboardKeys["outputDatasets"] = \ self.policy.getString("outputKeys.outputDatasets") self.clipboardKeys["completedDatasets"] = \ self.policy.getString("outputKeys.completedDatasets") self.log.log(Log.INFO - 1, "clipboard keys: " + str(self.clipboardKeys)) topic = self.policy.getString("pipelineEvent") self.client = GetAJobClient(self.getRun(), self.getName(), topic, self.getEventBrokerHost(), self.log) self.log.log(Log.INFO - 1, "Using OriginatorId = %d" % self.client.getOriginatorId())
def setup(self, policyDict="DataReady_dict.paf"): deffile = DefaultPolicyFile("ctrl_sched", policyDict, "policies") defpol = Policy.createPolicy(deffile, deffile.getRepositoryPath()) if not hasattr(self, "policy") or not self.policy: self.policy = Policy() self.policy.mergeDefaults(defpol.getDictionary()) # self.mode = self.policy.getString("mode") # if self.mode not in "parallel serial": # raise RuntimeError("Stage %s: Unsupported mode: %s" % # (self.getName(), self.mode)) self.clipboardKeys = {} self.clipboardKeys["completedDatasets"] = \ self.policy.getString("inputKeys.completedDatasets") self.clipboardKeys["possibleDatasets"] = \ self.policy.getString("inputKeys.possibleDatasets") self.dataclients = [] clpols = [] if self.policy.exists("datasets"): clpols = self.policy.getPolicyArray("datasets") for pol in clpols: dstype = None if pol.exists("datasetType"): dstype = pol.getString("datasetType") topic = pol.getString("dataReadyEvent") reportAll = pol.getBool("reportAllPossible") client = DataReadyClient(self.getRun(), self.getName(), topic, self.getEventBrokerHost(), dstype, reportAll) self.dataclients.append(client)
def testPolicyCopy(self): p = Policy.createPolicy(os.path.join(proddir, "examples", "EventTransmitter_policy.paf")) pp = Policy(p, True) self.assertEqual(p.get("transmitter.serializationFormat"), "deluxe") self.assertEqual(pp.getString("transmitter.serializationFormat"), "deluxe") p = None self.assertEqual(pp.getString("transmitter.serializationFormat"), "deluxe")
def setup(self): deffile = DefaultPolicyFile("ctrl_sched","GetAJob_dict.paf","policies") defpol = Policy.createPolicy(deffile, deffile.getRepositoryPath()) if not hasattr(self,"policy") or not self.policy: self.policy = Policy() self.policy.mergeDefaults(defpol.getDictionary()) self.jobid = None self.tagLogger(None) # self.mode = self.policy.getString("mode") # if self.mode not in "parallel serial": # raise RuntimeError("Stage %s: Unsupported mode: %s" % # (self.getName(), self.mode)) self.clipboardKeys = {} self.clipboardKeys["jobIdentity"] = \ self.policy.getString("outputKeys.jobIdentity") self.clipboardKeys["inputDatasets"] = \ self.policy.getString("outputKeys.inputDatasets") self.clipboardKeys["outputDatasets"] = \ self.policy.getString("outputKeys.outputDatasets") self.clipboardKeys["completedDatasets"] = \ self.policy.getString("outputKeys.completedDatasets") self.log.log(Log.INFO-1, "clipboard keys: " + str(self.clipboardKeys)) topic = self.policy.getString("pipelineEvent") self.client = GetAJobClient(self.getRun(), self.getName(), topic, self.getEventBrokerHost(), self.log) self.log.log(Log.INFO-1, "Using OriginatorId = %d" % self.client.getOriginatorId())
def testCreateName(self): policy = Policy.createPolicy(os.path.join(exampledir, "ccdassembly-joboffice.paf")) spolicy = policy.getPolicy("schedule") sched = DataTriggeredScheduler(self.bb, spolicy, self.logger) ds = Dataset("PostISR", ampid=3) self.assertEquals(sched.createName(ds), "Job-1")
def testCreateName2(self): policy = Policy.createPolicy(os.path.join(exampledir, "ccdassembly-joboffice.paf")) spolicy = policy.getPolicy("schedule") spolicy.set("job.name.template", "%(type)s-v%(ampid)s") sched = DataTriggeredScheduler(self.bb, spolicy, self.logger) ds = Dataset("PostISR", ampid=3) self.assertEquals(sched.createName(ds), "PostISR-v3")
def testSelfValidation(self): # assign a dictionary after creation p = Policy(self.getTestDictionary("types_policy_good.paf")) p.loadPolicyFiles(self.getTestDictionary(), True) typesDict = Dictionary(self.getTestDictionary("types_dictionary.paf")) valuesDict = Dictionary( self.getTestDictionary("values_dictionary.paf")) self.assertFalse(p.canValidate()) p.setDictionary(typesDict) self.assertTrue(p.canValidate()) p.validate() p.set("bool_type", True) self.assertValidationError(ValidationError.WRONG_TYPE, p.set, "bool_type", "foo") # create with dictionary p = Policy.createPolicy(self.getTestDictionary("types_dictionary.paf"), "", True) self.assertTrue(p.canValidate()) p.set("bool_type", True) self.assertValidationError(ValidationError.WRONG_TYPE, p.set, "bool_type", "foo") # assign a dictionary after invalid modifications p = Policy() p.set("bool_type", "foo") p.setDictionary(typesDict) ve = ValidationError("Dictionary_1.py", 1, "testSelfValidation") p.validate(ve.cpp) self.assertEqual(ve.getErrors("bool_type"), ValidationError.WRONG_TYPE) try: p.validate() except ValidationError as ve: self.assertEqual(ve.getErrors("bool_type"), ValidationError.WRONG_TYPE) self.assertEqual(ve.getParamCount(), 1) p.set("bool_type", True) p.set("int_type", 1) p.validate() # switch dictionaries oldD = p.getDictionary() p.setDictionary(valuesDict) try: p.validate() except ValidationError as ve: self.assertEqual(ve.getErrors("bool_type"), ValidationError.UNKNOWN_NAME) p.set("string_range_type", "moo") try: p.set("string_range_type", "victor") except ValidationError as ve: self.assertEqual(ve.getErrors("string_range_type"), ValidationError.VALUE_OUT_OF_RANGE) p.setDictionary(oldD) p.remove("string_range_type") p.validate()
def setUp(self): policy = Policy.createPolicy(policyFile) # pdb.set_trace() self.joboffice = DataTriggeredJobOffice(testdir, policy=policy, log=None, runId="testing", brokerHost=brokerhost) self.joboffice.log.setThreshold(self.joboffice.log.WARN) self.jodir = os.path.join(testdir, "ccdassembly")
def __init__(self, policyfile=None): """ create an item with the given properties. @param policyfile A policy """ # the properties attached to this items self._props = None if policyfile: self._props = Policy.createPolicy(policyfile) else: self._props = Policy()
def testSelfValidation(self): # assign a dictionary after creation p = Policy(self.getTestDictionary("types_policy_good.paf")) p.loadPolicyFiles(self.getTestDictionary(), True) typesDict = Dictionary(self.getTestDictionary("types_dictionary.paf")) valuesDict = Dictionary(self.getTestDictionary("values_dictionary.paf")) self.assert_(not p.canValidate()) p.setDictionary(typesDict) self.assert_(p.canValidate()) p.validate() p.set("bool_type", True) self.assertValidationError( ValidationError.WRONG_TYPE, p.set, "bool_type", "foo") # create with dictionary p = Policy.createPolicy(self.getTestDictionary("types_dictionary.paf"), "", True) self.assert_(p.canValidate()) p.set("bool_type", True) self.assertValidationError( ValidationError.WRONG_TYPE, p.set, "bool_type", "foo") # assign a dictionary after invalid modifications p = Policy() p.set("bool_type", "foo") p.setDictionary(typesDict) ve = ValidationError("Dictionary_1.py", 1, "testSelfValidation") p.validate(ve.cpp) self.assert_(ve.getErrors("bool_type") == ValidationError.WRONG_TYPE) try: p.validate() except ValidationError as ve: self.assert_(ve.getErrors("bool_type") == ValidationError.WRONG_TYPE) self.assert_(ve.getParamCount() == 1) p.set("bool_type", True) p.set("int_type", 1) p.validate() # switch dictionaries oldD = p.getDictionary() p.setDictionary(valuesDict) try: p.validate() except ValidationError as ve: self.assert_(ve.getErrors("bool_type") == ValidationError.UNKNOWN_NAME) p.set("string_range_type", "moo") try: p.set("string_range_type", "victor") except ValidationError as ve: self.assert_(ve.getErrors("string_range_type") == ValidationError.VALUE_OUT_OF_RANGE) p.setDictionary(oldD) p.remove("string_range_type") p.validate()
def testCtor(self): policy = Policy.createPolicy(os.path.join(exampledir, "ccdassembly-joboffice.paf")) spolicy = policy.getPolicy("schedule") sched = DataTriggeredScheduler(self.bb, spolicy, self.logger) self.assert_(sched.nametmpl is None) self.assertEquals(sched.defaultName, "Job") self.assertEquals(sched.nameNumber, 1) self.assertEquals(len(sched.triggers), 1) self.assertEquals(len(sched.inputdata), 1)
def testDefaults(self): p = Policy.createPolicy(self.getTestDictionary("defaults_dictionary_good.paf"), "", True) self.assert_(p.valueCount("bool_set_count") == 1) self.assert_(p.getBool("bool_set_count") == True) self.assert_(p.valueCount("int_range_count") == 3) self.assert_(p.getDouble("deep.sub_double") == 1.) self.assert_(p.get("indirect4.string_type") == "foo") try: p = Policy.createPolicy(self.getTestDictionary("defaults_dictionary_bad_1.paf"), "", True) except ValidationError as ve: self.assert_(ve.getErrors("double") == ValidationError.WRONG_TYPE) self.assert_(ve.getErrors("int_range_count") == ValidationError.NOT_AN_ARRAY) self.assert_(ve.getErrors("bool_set_count") == ValidationError.TOO_MANY_VALUES) self.assert_(ve.getErrors("deep.sub_double") == ValidationError.WRONG_TYPE) self.assert_(ve.getParamCount() == 4)
def testDefaults(self): p = Policy.createPolicy(self.getTestDictionary("defaults_dictionary_good.paf"), "", True) self.assertEqual(p.valueCount("bool_set_count"), 1) self.assertIs(p.getBool("bool_set_count"), True) self.assertEqual(p.valueCount("int_range_count"), 3) self.assertEqual(p.getDouble("deep.sub_double"), 1.) self.assertEqual(p.get("indirect4.string_type"), "foo") try: p = Policy.createPolicy(self.getTestDictionary("defaults_dictionary_bad_1.paf"), "", True) except ValidationError as ve: self.assertEqual(ve.getErrors("double"), ValidationError.WRONG_TYPE) self.assertEqual(ve.getErrors("int_range_count"), ValidationError.NOT_AN_ARRAY) self.assertEqual(ve.getErrors("bool_set_count"), ValidationError.TOO_MANY_VALUES) self.assertEqual(ve.getErrors("deep.sub_double"), ValidationError.WRONG_TYPE) self.assertEqual(ve.getParamCount(), 4)
def _shallowPolicyNodeResolve(pname, policy, repository, logger=None): if not policy.exists(pname): return [] nodes = policy.getArray(pname) if policy.isFile(pname): for i in range(len(nodes)): try: if not os.path.isabs(nodes[i]): nodes[i] = os.path.join(repository, nodes[i]) nodes[i] = Policy.createPolicy(nodes[i], False) except lsst.pex.exceptions.Exception: if logger: logger.log(Log.WARN, "problem finding/loading " + nodes[i]) nodes[i] = None return nodes
def __init__(self, blackboard, policy, logger=None): """ create the scheduler @param blackboard the blackboard that this scheduler will update. @param policy the "schedule" policy used to configure this scheduler @param logger a log to use for messages """ Scheduler.__init__(self, blackboard, logger, True) defpol = DefaultPolicyFile("ctrl_sched", "DataTriggeredScheduler_dict.paf", "policies") defpol = Policy.createPolicy(defpol, defpol.getRepositoryPath(), False) policy.mergeDefaults(defpol) self.triggers = [] trigps = policy.getArray("trigger") for trigp in trigps: self.triggers.append(Trigger.fromPolicy(trigp)) self.inputdata = [] inpps = policy.getArray("job.input") for dsp in inpps: self.inputdata.append(Trigger.fromPolicy(dsp, True)) self.outputdata = [] outpps = policy.getArray("job.output") for dsp in outpps: self.outputdata.append(Trigger.fromPolicy(dsp, True)) self.jobIdConf = None if policy.exists("job.identity"): self.jobIdConf = policy.getPolicy("job.identity") self.nametmpl = None pol = policy.get("job.name") self.defaultName = pol.getString("default") if pol.exists("template"): self.nametmpl = pol.getString("template") self.nameNumber = pol.getInt("initCounter") self.jobRetries = None if policy.exists("job.retries"): self.jobRetries = policy.getInt("job.retries")
def testSampleCode(self): policyFile = DefaultPolicyFile("pex_policy", "defaults_dictionary_complete.paf", "tests/dictionary") defaults = Policy.createPolicy(policyFile, policyFile.getRepositoryPath(), True) policy = Policy() policy.mergeDefaults(defaults) self.assert_(policy.canValidate()) policy = Policy() policy.mergeDefaults(defaults, False) self.assert_(not policy.canValidate()) # even if not keeping it around for future validation, validate the merge now policy = Policy() policy.set("bad", "worse") self.assertValidationError(ValidationError.UNKNOWN_NAME, policy.mergeDefaults, defaults, False) self.assert_(not policy.canValidate())
def fromPolicy(policy): """ create an IntegerIDFilter from an "id" policy """ if not StringIDFilter._dictionary: pdf = DefaultPolicyFile("ctrl_sched", "StringIDFilter_dict.paf", "policies") StringIDFilter._dictionary = Policy.createPolicy(pdf) p = Policy(policy, True) if StringIDFilter._dictionary: p.mergeDefaults(StringIDFilter._dictionary) name = "unknown" vals = None if policy.exists("name"): name = policy.getString("name") if policy.exists("value"): vals = policy.getArray("value") return StringIDFilter(name, vals)
def testSampleCode(self): policyFile = DefaultPolicyFile("pex_policy", "defaults_dictionary_complete.paf", "tests/dictionary") defaults = Policy.createPolicy(policyFile, policyFile.getRepositoryPath(), True) policy = Policy() policy.mergeDefaults(defaults) self.assertTrue(policy.canValidate()) policy = Policy() policy.mergeDefaults(defaults, False) self.assertFalse(policy.canValidate()) # even if not keeping it around for future validation, validate the merge now policy = Policy() policy.set("bad", "worse") self.assertValidationError(ValidationError.UNKNOWN_NAME, policy.mergeDefaults, defaults, False) self.assertFalse(policy.canValidate())
def launchDC3a(policyFile, runid, visitFiles, colls, opts, logger): if not os.environ.has_key(pkgdirvar): raise pexExcept.LsstException("%s env. var not set (setup %s)" % (pkgdirvar, dc3apkg)) if opts.repos is None: opts.repos = os.path.join(os.environ[pkgdirvar], "pipeline") policy = Policy.createPolicy(policyFile, opts.repos) broker = policy.get("eventBrokerHost") logger.log(Log.DEBUG, "Using event broker on %s" % broker) recvr = events.EventReceiver(broker, loggingEventTopic) runOrca(policyFile, runid, opts, logger) waitForReady(policy, runid, recvr, opts.pipeverb, logger) runEventGen(policy, visitFiles, colls, opts, broker, logger)
def launchMos(policyFile, runid, visitFiles, colls, opts, logger): if not os.environ.has_key(pkgdirvar): raise pexExcept.LsstException("%s env. var not set (setup %s)" % (pkgdirvar, mospkg)) if opts.repos is None: opts.repos = os.path.join(os.environ[pkgdirvar], "pipeline") policy = Policy.createPolicy(policyFile, opts.repos) broker = policy.get("eventBrokerHost") logger.log(Log.DEBUG, "Using event broker on %s" % broker) print >> sys.stderr, "Using event broker on %s" % broker recvr = events.EventReceiver(broker, loggingEventTopic) runOrca(policyFile, runid, opts, logger) waitForReady(policy, runid, recvr, opts.pipeverb, logger) runEventGen(policy, visitFiles, colls, opts, broker, logger)
def fromPolicy(policy): """ create an IntegerIDFilter from an "id" policy """ if not IntegerIDFilter._dictionary: pdf = DefaultPolicyFile("ctrl_sched", "IntegerIDFilter_dict.paf", "policies") IntegerIDFilter._dictionary = Policy.createPolicy(pdf) p = Policy(policy, True) if IntegerIDFilter._dictionary: p.mergeDefaults(IntegerIDFilter._dictionary) name = "unknown" min = lim = vals = None if policy.exists("name"): name = policy.getString("name") if policy.exists("min"): min = policy.getInt("min") if policy.exists("lim"): lim = policy.getInt("lim") if policy.exists("value"): vals = policy.getArray("value") return IntegerIDFilter(name, min, lim, vals)
def extractPipelineFilenames(wfname, prodPolicyFile, repository=".", logger=None): """ extract all non-pipeline policy files in the given production policy file. @param wfname the name of the workflow of interest @param prodPolicyFile the production-level policy file @param repository the policy repository @param logger if provided, use this Log to record any warnings about missing or bad files; otherwise, problems are silently ignored. """ prodPolicy = Policy.createPolicy(prodPolicyFile, False) out = [] wfs = ProvenanceSetup._shallowPolicyNodeResolve("workflow", prodPolicy, repository, logger) if not wfs: return out for wfp in wfs: if wfp is None: continue if not wfp.exists("shortName") or wfp.get("shortName") != wfname: continue pipes = ProvenanceSetup._shallowPolicyNodeResolve("pipeline", wfp, repository) for pipe in pipes: if not pipe.exists("definition") or not pipe.isFile("definition"): continue pipe = pipe.get("definition").getPath() out.append(pipe) pipe = os.path.join(repository, pipe) if not os.path.exists(pipe): if logger: logger.log(Log.WARN, "Policy file not found in repository: "+pipe) continue out += list(ProvenanceSetup.extractIncludedFilenames(pipe, repository)) return out
def recordPolicy(self, policyFile): """Record the contents of the given Policy as part of provenance.""" md5 = hashlib.md5() f = open(policyFile, 'r') for line in f: md5.update(line) f.close() # self._realRecordPolicyFile(self._rundb, policyFile, md5) self._realRecordPolicyFile(self._globalDb, policyFile, md5) p = Policy.createPolicy(policyFile, False) for key in p.paramNames(): type = p.getTypeName(key) val = p.str(key) # works for arrays, too val = re.sub(r'\0', r'', val) # extra nulls get included # self._realRecordPolicyContents(self._rundb, key, type, val) self._realRecordPolicyContents(self._globalDb, key, type, val) self._policyKeyId += 1 self._policyFileId += 1
def _listFilenames(fileset, policy, basename, repository, stopname=None, logger=None): if stopname and basename and not stopname.startswith(basename): stopname = None for name in policy.names(True): fullname = basename and ".".join([basename, name]) or name if stopname and fullname == stopname: continue if policy.isFile(name): files = policy.getArray(name) for file in files: file = file.getPath() if file not in fileset: fileset.add(file) file = os.path.join(repository, file) if not os.path.exists(file): if logger: logger.log(logger.WARN, "Policy file not found in repository: %s" % file) continue try: if logger and logger.sends(Log.DEBUG): logger.log(Log.DEBUG, "opening log file: %s" % file) fpolicy = Policy.createPolicy(file, False) ProvenanceSetup._listFilenames(fileset, fpolicy, fullname, repository, stopname, logger) except lsst.pex.exceptions.Exception as ex: if logger: logger.log(Log.WARN, "problem loading %s: %s" % (file, str(ex))) continue elif policy.isPolicy(name): pols = policy.getArray(name) for pol in pols: ProvenanceSetup._listFilenames(fileset, pol, fullname, repository, stopname, logger)
def testSetAdd(self): p = Policy.createPolicy(self.getTestDictionary("defaults_dictionary_good.paf"), "", True) self.assertTrue(p.canValidate()) self.assertValidationError(ValidationError.TOO_MANY_VALUES, p.add, "bool_set_count", True) self.assertEqual(p.valueCount("bool_set_count"), 1) self.assertValidationError(ValidationError.VALUE_DISALLOWED, p.set, "bool_set_count", False) self.assertIs(p.getBool("bool_set_count"), True) p.set("int_range_count", -7) self.assertValidationError(ValidationError.VALUE_OUT_OF_RANGE, p.add, "int_range_count", 10) # add & set don't check against minOccurs, but validate() does try: p.validate() except ValidationError as ve: self.assertEqual(ve.getErrors("int_range_count"), ValidationError.NOT_AN_ARRAY) self.assertEqual(ve.getErrors("required"), ValidationError.MISSING_REQUIRED) p.add("int_range_count", -8) p.set("required", "foo") p.validate()
def launchDC2(policyFile, runid, exposureFiles): if not os.environ.has_key(pkgdirvar): raise RuntimeError("DC2PIPE_DIR env. var not set (setup dc2pipe)") # load the launching policy file if not os.path.exists(policyFile): raise RuntimeError(policyFile + ": policy file not found") pol = Policy.createPolicy(policyFile) if cl.opts.policyRepository is not None: pol.set("policyRepository", cl.opts.policyRepository) # find the policy repository defRepository = os.path.join(os.environ[pkgdirvar], "pipeline") repository = pol.get("policyRepository", defRepository) if not os.path.exists(repository): raise RuntimeError(repository + ": directory not found") if not os.path.isdir(repository): raise RuntimeError(repository + ": not a directory") # set the exposure lists if len(exposureFiles) == 0: exposureFiles = pol.getArray("exposureList", []) if len(exposureFiles) == 0: raise RuntimeError("No exposure list files specified in policy") # determine the parent of the working directories home = pol.get("workingHome", "/share/DC2root") if not os.path.exists(home): raise RuntimeError(home + ": working home directory not found") if not cl.opts.forceRunId and os.path.exists(os.path.join(home, runid)): raise RuntimeError("Run ID already used (use -f to override)") # deploy each pipeline: create nodelist.scr, copy over policy files, etc. pipepol = pol.get("pipelines") pipelines = pipepol.policyNames(True) workingdir = {} masternode = {} envscript = {} willrun = [] for pipeline in pipelines: ppol = pipepol.get(pipeline) if ppol.get("launch", 1) != 0: (masternode[pipeline], workingdir[pipeline], envscript[pipeline]) \ = prepPipeline(pipeline, ppol, runid, home, repository) willrun.append(pipeline) # create the database tables for this run if cl.opts.createDB: createDatabase(runid) # now launch each pipeline for pipeline in willrun: ppol = pipepol.get(pipeline) launchPipeline(pipeline, runid, masternode[pipeline], workingdir[pipeline], envscript[pipeline]) # send input data events for efile in exposureFiles: if not os.path.isabs(efile): if os.path.exists(efile) and not efile.startswith("."): efile = os.path.join(".", efile) elif os.path.exists( os.path.join(os.environ[pkgdirvar], "exposureLists", efile)): efile = os.path.join(os.environ[pkgdirvar], "exposureLists", efile) if not os.path.exists(efile): logger.log(Log.WARN, "Exposure list file not found: " + efile) logger.log(Log.DEBUG, "Pausing for 15s, waiting for setup...") time.sleep(15) logger.log(Log.INFO, "Sending exposure data from " + efile) logger.log(Log.DEBUG, "executing: %s < %s" % (eventgenerator, efile)) with file(efile) as expfile: if subprocess.call(eventgenerator.split(), stdin=expfile) != 0: raise RuntimeError("Failed to execute eventgenerator")
def setUp(self): self.policyfile = os.path.join(proddir, "examples", "types.paf") self.policy = Policy.createPolicy(self.policyfile, False)
def setUp(self): self.policyfile = os.path.join(proddir,"examples","types.paf") self.policy = Policy.createPolicy(self.policyfile, False)
def __init__(self, rootdir, policy=None, defPolicyFile=None, log=None, runId=None, brokerHost=None, brokerPort=None, forDaemon=False, fromSubclass=False): """ create the JobOffice @param rootdir the root directory where job offices may set up its blackboard data. This JobOffice will create a subdirectory here for its data with a name set by the "name" policy paramter. @param policy the policy to use to configure this JobOffice @param defPolicyFile the DefaultPolicyFile to use for defaults. If this points to a dictionary, a policy validation will be done. If None, an internally identified default policy file will be used. @param log a logger to use; if None, the default logger will will be used. A child log will be created. @param runId the run ID to restrict our attention to. If not None, incoming events will be restricted to the given runId. @param brokerHost the machine where the event broker is running. If None (default), the host given in the policy is used. This parameter is for carrying an override from the command line. @param brokerPort the port to use to connect to the event broker. If None (default), the port given in the policy is used. This parameter is for carrying an override from the command line. @param forDaemon if true, the creation of the Event channels will be delayed until run() is called. This allows the caller to fork as needed without losing the connections with the event broker. This also means that some public functions (other than run() and start()) will not work properly until ensureReady() is called. @param fromSubclass the flag indicating that this constructor is being properly called. Calls to this constructor from a subclass constructor should set this to True. """ self._checkAbstract(fromSubclass, "_BasicJobOffice") # start by establishing policy data if not defPolicyFile: defPolicyFile = DefaultPolicyFile("ctrl_sched", "baseJobOffice_dict.paf", "policies") defaults = Policy.createPolicy(defPolicyFile, defPolicyFile.getRepositoryPath(), True) if not policy: policy = Policy() self.policy = policy if defaults.canValidate(): self.policy.mergeDefaults(defaults.getDictionary()) else: self.policy.mergeDefaults(defaults) # instantiate parent class name = self.policy.get("name") persistDir = self.policy.get("persist.dir") % { "schedroot": rootdir, "name": name } if not os.path.exists(persistDir): os.makedirs(persistDir) JobOffice.__init__(self, persistDir, log, runId, True) self.setName(name) # logger self.log = Log(self.log, self.name) # initialize some data from policy self.initialWait = self.policy.get("listen.initialWait") self.emptyWait = self.policy.get("listen.emptyWait") self.dataTopics = self.policy.getArray("listen.dataReadyEvent") self.jobTopic = self.policy.get("listen.pipelineEvent") self.stopTopic = self.policy.get("listen.stopEvent") self.jobOfficeTopic = self.policy.get("listen.jobOfficeEvent") self.jobOfficeStatusTopic = self.policy.get("listen.jobOfficeStatus") self.highWatermark = self.policy.get("listen.highWatermark") # initialize the event system self.jobReadyEvRcvr = self.dataEvRcvrs = None self.jobDoneEvRcvr = self.jobAcceptedEvRcvr = None self.brokerHost = brokerHost self.brokerPort = brokerPort if not self.brokerPort and self.policy.exists("listen.brokerHostPort"): self.brokerPort = self.policy.get("listen.brokerHostPort") if not self.brokerHost and (not self.brokerPort or self.brokerPort > 0): self.brokerHost = self.policy.get("listen.brokerHostName") self.dataEvRcvrs = None self.jobReadyEvRcvr = None self.jobDoneEvRcvr = None self.jobAcceptedEvRcvr = None self.jobAssignEvTrx = None self.jobOfficeRcvr = None if not forDaemon: self._setEventPipes()
def testRead(self): ps = PolicyString(self.data) p = Policy.createPolicy(ps) self.assertEqual(p.get("int"), 7) self.assertEqual(p.get("dbl"), -1.0)
def openItem(self, filename): out = PolicyBlackboardItem() out._props = Policy.createPolicy(filename) return out
def __init__(self, rootdir, policy=None, defPolicyFile=None, log=None, runId=None, brokerHost=None, brokerPort=None, forDaemon=False, fromSubclass=False): """ create the JobOffice @param rootdir the root directory where job offices may set up its blackboard data. This JobOffice will create a subdirectory here for its data with a name set by the "name" policy paramter. @param policy the policy to use to configure this JobOffice @param defPolicyFile the DefaultPolicyFile to use for defaults. If this points to a dictionary, a policy validation will be done. If None, an internally identified default policy file will be used. @param log a logger to use; if None, the default logger will will be used. A child log will be created. @param runId the run ID to restrict our attention to. If not None, incoming events will be restricted to the given runId. @param brokerHost the machine where the event broker is running. If None (default), the host given in the policy is used. This parameter is for carrying an override from the command line. @param brokerPort the port to use to connect to the event broker. If None (default), the port given in the policy is used. This parameter is for carrying an override from the command line. @param forDaemon if true, the creation of the Event channels will be delayed until run() is called. This allows the caller to fork as needed without losing the connections with the event broker. This also means that some public functions (other than run() and start()) will not work properly until ensureReady() is called. @param fromSubclass the flag indicating that this constructor is being properly called. Calls to this constructor from a subclass constructor should set this to True. """ self._checkAbstract(fromSubclass, "_BasicJobOffice") # start by establishing policy data if not defPolicyFile: defPolicyFile = DefaultPolicyFile("ctrl_sched", "baseJobOffice_dict.paf", "policies") defaults = Policy.createPolicy(defPolicyFile, defPolicyFile.getRepositoryPath(), True) if not policy: policy = Policy() self.policy = policy if defaults.canValidate(): self.policy.mergeDefaults(defaults.getDictionary()) else: self.policy.mergeDefaults(defaults) # instantiate parent class name = self.policy.get("name") persistDir = self.policy.get("persist.dir") % {"schedroot": rootdir, "name": name } if not os.path.exists(persistDir): os.makedirs(persistDir) JobOffice.__init__(self, persistDir, log, runId, True) self.setName(name) # logger self.log = Log(self.log, self.name) # initialize some data from policy self.initialWait = self.policy.get("listen.initialWait") self.emptyWait = self.policy.get("listen.emptyWait") self.dataTopics = self.policy.getArray("listen.dataReadyEvent") self.jobTopic = self.policy.get("listen.pipelineEvent") self.stopTopic = self.policy.get("listen.stopEvent") self.jobOfficeTopic = self.policy.get("listen.jobOfficeEvent") self.jobOfficeStatusTopic = self.policy.get("listen.jobOfficeStatus") self.highWatermark = self.policy.get("listen.highWatermark") # initialize the event system self.jobReadyEvRcvr = self.dataEvRcvrs = None self.jobDoneEvRcvr = self.jobAcceptedEvRcvr = None self.brokerHost = brokerHost self.brokerPort = brokerPort if not self.brokerPort and self.policy.exists("listen.brokerHostPort"): self.brokerPort = self.policy.get("listen.brokerHostPort") if not self.brokerHost and (not self.brokerPort or self.brokerPort > 0): self.brokerHost = self.policy.get("listen.brokerHostName") self.dataEvRcvrs = None self.jobReadyEvRcvr = None self.jobDoneEvRcvr = None self.jobAcceptedEvRcvr = None self.jobAssignEvTrx = None self.jobOfficeRcvr = None if not forDaemon: self._setEventPipes()
def launchDC2(policyFile, runid, exposureFiles): if not os.environ.has_key(pkgdirvar): raise RuntimeError("DC2PIPE_DIR env. var not set (setup dc2pipe)") # load the launching policy file if not os.path.exists(policyFile): raise RuntimeError(policyFile + ": policy file not found") pol = Policy.createPolicy(policyFile) if cl.opts.policyRepository is not None: pol.set("policyRepository", cl.opts.policyRepository); # find the policy repository defRepository = os.path.join(os.environ[pkgdirvar], "pipeline") repository = pol.get("policyRepository", defRepository) if not os.path.exists(repository): raise RuntimeError(repository + ": directory not found"); if not os.path.isdir(repository): raise RuntimeError(repository + ": not a directory"); # set the exposure lists if len(exposureFiles) == 0: exposureFiles = pol.getArray("exposureList", []) if len(exposureFiles) == 0: raise RuntimeError("No exposure list files specified in policy") # determine the parent of the working directories home = pol.get("workingHome", "/share/DC2root") if not os.path.exists(home): raise RuntimeError(home + ": working home directory not found") if not cl.opts.forceRunId and os.path.exists(os.path.join(home, runid)): raise RuntimeError("Run ID already used (use -f to override)") # deploy each pipeline: create nodelist.scr, copy over policy files, etc. pipepol = pol.get("pipelines") pipelines = pipepol.policyNames(True) workingdir = {} masternode = {} envscript = {} willrun = [] for pipeline in pipelines: ppol = pipepol.get(pipeline) if ppol.get("launch", 1) != 0: (masternode[pipeline], workingdir[pipeline], envscript[pipeline]) \ = prepPipeline(pipeline, ppol, runid, home, repository) willrun.append(pipeline) # create the database tables for this run if cl.opts.createDB: createDatabase(runid) # now launch each pipeline for pipeline in willrun: ppol = pipepol.get(pipeline) launchPipeline(pipeline, runid, masternode[pipeline], workingdir[pipeline], envscript[pipeline]) # send input data events for efile in exposureFiles: if not os.path.isabs(efile): if os.path.exists(efile) and not efile.startswith("."): efile = os.path.join(".", efile) elif os.path.exists(os.path.join(os.environ[pkgdirvar], "exposureLists",efile)): efile = os.path.join(os.environ[pkgdirvar], "exposureLists",efile) if not os.path.exists(efile): logger.log(Log.WARN, "Exposure list file not found: " + efile) logger.log(Log.DEBUG, "Pausing for 15s, waiting for setup...") time.sleep(15) logger.log(Log.INFO, "Sending exposure data from " + efile) logger.log(Log.DEBUG, "executing: %s < %s" % (eventgenerator, efile)) with file(efile) as expfile: if subprocess.call(eventgenerator.split(), stdin=expfile) != 0: raise RuntimeError("Failed to execute eventgenerator")
def testRead(self): ps = PolicyString(self.data) p = Policy.createPolicy(ps) self.assertEquals(p.get("int"), 7) self.assertEquals(p.get("dbl"), -1.0)
def testSimpleLoad(self): # n = mwid.Citizen_census(0) p = Policy.createPolicy( os.path.join(proddir, "examples", "EventTransmitter_policy.paf")) self.assertEqual(p.get("transmitter.serializationFormat"), "deluxe") p = None
def testSimpleLoad(self): # n = mwid.Citizen_census(0) p = Policy.createPolicy("examples/EventTransmitter_policy.paf") self.assertEquals(p.get("transmitter.serializationFormat"), "deluxe") p = None