Beispiel #1
0
    def loadDiskTaskQueue(self):
        """Load task queue from disk using the shelve reserved for the queue."""

        if not self.shelve.has_key("taskQueue"):
            logging.info("Unable to read task queue from disk db, starting fresh")
            return

        logging.info("Reading task queue from disk")
        readTasks   = 0
        failedTasks = 0
        taskDicts = self.shelve["taskQueue"]
        for taskDict in taskDicts:
            try:
                task = modelManager.getModelFromTaskDict(taskDict)
            except model_manager.InvalidModelError, e:
                emailAddress = taskDict["emailAddress"]
                subject = config.lostTaskEmailSubject.generate(full_name=taskDict["modelFullName"], 
                        visibleId=taskDict["visibleId"])
                body = config.lostTaskEmailTemplate.generate()
                emailObject = Email(emailAddress, subject, body)
                logging.info("Invalid model-version pair, notifying %s", emailAddress)
                npsgd.email_manager.backgroundEmailSend(Email(emailAddress, subject, body))
                failedTasks += 1
                continue
            
            readTasks += 1
            self.taskQueue.putTask(task)
Beispiel #2
0
    def loadConfirmationMap(self):
        """Load confirmation map ([code, modelDict] pairs) from shelve reserved for the queue."""

        if not self.shelve.has_key("confirmationMap"):
            logging.info("Unable to read confirmation map from disk db, starting fresh")
            return

        logging.info("Reading confirmation map from disk")
        confirmationMapEntries = self.shelve["confirmationMap"]

        readCodes = 0
        failedCodes = 0
        for code, taskDict in confirmationMapEntries.iteritems():
            try:
                task = modelManager.getModelFromTaskDict(taskDict)
            except model_manager.InvalidModelError, e:
                emailAddress = taskDict["emailAddress"]
                subject = config.confirmationFailedEmailSubject.generate(full_name=taskDict["modelFullName"], 
                        visibleId=taskDict["visibleId"])
                body = config.confirmationFailedEmailTemplate.generate(code=code)
                emailObject = Email(emailAddress, subject, body)
                logging.info("Invalid model-version pair, notifying %s", emailAddress)
                npsgd.email_manager.backgroundEmailSend(Email(emailAddress, subject, body))
                failedCodes += 1
                continue

            readCodes += 1
            self.confirmationMap.putRequestWithCode(task, code)
Beispiel #3
0
    def post(self):
        """Post handler for model requests from the web daemon.

        Attempts to build a model from its known models (essentially performing
        parameter verification) then places a request in the queue if it succeeds.
        Additionally, it will send out an e-mail to the user for confirmation of
        the request
        """

        if not self.checkSecret():
            return

        task_json = tornado.escape.json_decode(self.get_argument("task_json"))
        task = modelManager.getModelFromTaskDict(task_json)
        task.taskId = glb.newTaskId()
        code = glb.confirmationMap.putRequest(task)

        emailAddress = task.emailAddress
        logging.info("Generated a request for %s, confirmation %s required", emailAddress, code)
        subject = config.confirmEmailSubject.generate(task=task)
        body = config.confirmEmailTemplate.generate(code=code, task=task, expireDelta=config.confirmTimeout)
        emailObject = Email(emailAddress, subject, body)
        npsgd.email_manager.backgroundEmailSend(emailObject)
        glb.syncShelve()
        self.write(tornado.escape.json_encode({
            "response": {
                "task" : task.asDict(),
                "code" : code
            }    
        }))