Python job.Job类代码示例

 def test_run_too_soon(self):
     job = Job(name='testsuite-job', username='digits-testsuite')
     job.status = Status.WAIT
     job.status = Status.RUN
     # Status.WAIT should be removed so the len should be 2 rather
     # than 3.
     assert len(job.status_history) == 2, 'history length should be 2'

    def notify(self, evt):
        Job.notify(self, evt)
        log.debug("Notified of event: %s" % str(evt.__class__))
        if isinstance(evt, simple.ConnectCompleteEvent) and \
            evt.getSource() == self.connect_job:
            self.conn = evt.getConnection()
            self.run()
        elif isinstance(evt, simple.ConnectFailedEvent) and \
              evt.getSource() == self.connect_job:
            log.error("Failed to connect to agent")
            print "Failed to connect to agent"
            self.getAgent().setState(agent.STOPPING)

        elif isinstance(evt, agent.MessageReceivedEvent) and \
              isinstance(evt.getMessage(), message.Response):

            if isinstance(evt.getMessage(), agent.OkResponse) and \
               self.key == evt.getMessage().getRequestKey():
                print "Shutdown Acknowledged"
                self.getAgent().setState(agent.STOPPING)

            elif isinstance(evt.getMessage(), agent.DeniedResponse) and \
               self.key == evt.getMessage().getRequestKey():
                print "Shutdown Denied"
                self.getAgent().setState(agent.STOPPING)

    def test_run_timeout(self):

        from job_dictator import JobDictator
        from job import Job
        from worker import Worker

        dictator = JobDictator()
        dictator.client = mock.MagicMock()
        dictator.client.keys.return_value = ["job-", "jm-"]
        job = Job("running", "something")
        job.run_started_on = datetime.now() - timedelta(minutes=10)
        worker = Worker("job-", None)
        dictator.client.get.side_effect = [pickle.dumps(job), pickle.dumps(worker)]
        self.request_mock.get = mock.MagicMock()
        dictator.settings = mock.MagicMock()
        dictator.settings.job_timeout = 1
        dictator.headers = mock.MagicMock()
        returner = mock.MagicMock()
        returner.content = "status:ok"
        self.request_mock.get.return_value = returner
        dictator.pull = mock.MagicMock()

        dictator.aladeen()

        assert dictator.client.keys.call_count == 2
        assert dictator.client.get.call_count == 2
        assert dictator.client.set.call_count == 1
        assert dictator.client.publish.call_count == 1
        assert dictator.pull.call_count == 0
        assert pickle.loads(dictator.client.set.call_args_list[0][0][1]).state == "broken"

def search(query):
    job = Job(query) #use name prep from job init
    result = cache.get(job.hashtag)
    if not result:
        result = json.dumps(job.execute()) 
        cache.add(job.hashtag, result)
    return result

    def testJobExecuteOnce(self):
        work_data = [1.111111] * 5
        test_job = Job(0, 0, work_data)

        test_job.execute_next()

        self.assertEqual(int(test_job.work_data[0]), 1112)

        def Move(self, pv_src_obj, pv_source_range, pv_dest_obj,
                 pv_dest_range, move_options):
            pv_dest = None
            pv_src = cfg.om.get_by_path(pv_src_obj)
            if pv_src:
                if pv_dest_obj != '/':
                    pv_dest_t = cfg.om.get_by_path(pv_dest_obj)
                    if not pv_dest_t:
                        raise dbus.exceptions.DBusException(
                            interface_name, 'pv_dest_obj (%s) not found' %
                            pv_src_obj)
                    pv_dest = pv_dest_t.lvm_id

                rc, out, err = cmdhandler.pv_move_lv(
                    move_options,
                    self.lvm_id,
                    pv_src.lvm_id,
                    pv_source_range,
                    pv_dest,
                    pv_dest_range)

                if rc == 0:
                    # Create job object for monitoring
                    job_obj = Job(self.lvm_id, None)
                    cfg.om.register_object(job_obj)
                    cfg.kick_q.put("wake up!")
                    return job_obj.dbus_object_path()
                else:
                    raise dbus.exceptions.DBusException(
                        interface_name,
                        'Exit code %s, stderr = %s' % (str(rc), err))
            else:
                raise dbus.exceptions.DBusException(
                    interface_name, 'pv_src_obj (%s) not found' % pv_src_obj)

def main():
	pygame.init()
	fpsClock = pygame.time.Clock()
	size = 1920, 1200
	background = pygame.image.load("go.jpg")
	screen = pygame.display.set_mode(size)
	screen.blit(background,(0,0))
	width = 0

	while 1:
		for event in pygame.event.get():
			if event.type == pygame.QUIT:
				sys.exit()
			elif event.type==pygame.KEYDOWN:
				if event.key==pygame.K_ESCAPE:
					sys.exit()
									
		pseudoJob = Job(0)
		myjob = pseudoJob.getData()
		
		for n in range(0, len(myjob)):
			drawing(width, myjob[n], screen)
			if (n != len(myjob) -1):
				width += (myjob[n].node * myjob[n].core) / 5
			else:
				width = 0
		print myjob[0].qtime
		pygame.display.flip()
		fpsClock.tick(30)

 def test_run_too_soon(self):
     job = Job('test')
     job.status = Status.WAIT
     job.status = Status.RUN
     # Status.WAIT should be removed so the len should be 2 rather
     # than 3.
     assert len(job.status_history) == 2, 'history length should be 2'

 def do_job(self, line):
     conn = self.conn()
     if conn:
         #print "Line = %s" % line
         r = cmd.Cmd.parseline(self, line)
         print "job = " , r
         if r[0] and r[1]:
             print "Sending JOB : %s" % r[0]
             conn.send('job')
             ## On doit recevoir  Ok send your job
             print "Srv => ", conn.recv()
             j=Job()
             j.name=r[0]
             j.cmd=r[1]
             conn.send(j)
             ## On doit recevoir Job receiveing ou erreur "
             print "Srv => ", conn.recv()
             ## On doit recevoir Job job finish"
             print "Srv => ", conn.recv()
             ## On doit recevoir le job
             j = conn.recv()
             ## On doit recevoir Invite de fin OK see your soon"
             print "Srv => ", conn.recv()
             ## la connexion doit se terminer
             ## Affichage du resultat
             j.pr()
         else:
             print "Job incorrecte [%s] [%s]" % (r[0], r[1])
     else:
         print "Not connected"
     ## Dans tout les cas la connexion est ferme
     conn=None

 def create_job(self,filename,**kwargs):
     """Create a job and try to set the source. Returns bool success."""
     job = Job(**kwargs)
     # Get the default material
     job.material = self.get_material()
     try:
         job.set_source(filename)
         self.job = job
         self.session.add(self.job)
         msg = 'Loaded %s'%os.path.basename(job.name or 'File')
         self.get_window('inkcut').set_title("*%s - Inkcut"%job.name)
         self.flash(msg)
         self.on_plot_feed_distance_changed(self.get_widget('plot-properties','plot-feed'))
         self._update_ui()
         return False
     except Exception, err:
         # update the ui with job info
         log.debug(traceback.format_exc())
         msg = Gtk.MessageDialog(type=Gtk.MessageType.ERROR,
             buttons=Gtk.ButtonsType.OK,
             message_format="Issue loading file")
         msg.format_secondary_text(err)
         msg.run()
         msg.destroy()
         return False

    def test_submit_job_to_ptburn_with_audio(self, label_patch, required_files,
                                             glob_patch):

        required_files.return_value = True
        label = Mock(sermon_title="title", date=datetime.date(2014,1,1),
           day="SUN, AM", minister="H.L. Sheppard")
        label.get_label_key.return_value = "010114PM"
        glob_patch.return_value = ["one.mp3", "two.mp3"]
        
        new_job = Job(1, self.connection)
        new_job.printonly = False
        new_job.label = label
        new_job.submit_job_to_ptburn("/audio/", "/labels/","/tmp/")

        self.assertTrue(os.path.exists("/tmp/JOB_1.jrq"))
        job_file = open("/tmp/JOB_1.jrq").readlines()
        self.assertEquals(len(job_file), 11)
        self.assertTrue("JobID = 1\n" in job_file)
        self.assertTrue("VolumeName = 010114PM\n" in job_file)
        self.assertTrue("AudioFile = one.mp3\n" in job_file)
        self.assertTrue("AudioFile = two.mp3\n" in job_file)
        self.assertTrue("CloseDisc = YES\n" in job_file)
        self.assertTrue("Copies = 1\n" in job_file)
        self.assertTrue("PrintLabel = /labels/cd-label.std\n" in job_file)
        self.assertTrue("MergeField = title\n" in job_file)
        self.assertTrue("MergeField = 01/01/2014\n" in job_file)
        self.assertTrue("MergeField = SUN, AM\n" in job_file)
        self.assertTrue("MergeField = H.L. Sheppard\n" in job_file)

def test():
    print "Start test"
    global dbName
    dbName = "test.db"

    clear()
    jobs = loadJobs()
    assert len(jobs) == 0

    newJob = Job("test")
    addNewJob(newJob)
    jobs = loadJobs()
    assert len(jobs) == 1
    assert jobs.index(newJob) >= 0

    newJob = jobs[newJob.id]
    newJob.recipeRef = "new test"
    saveJobs(jobs)
    jobs = loadJobs()
    assert newJob.recipeRef == jobs[newJob.id].recipeRef

    clear()
    jobs = loadJobs()
    assert len(jobs) == 0

    print "End test"

 def load(self,source=None,source_filename=None,selected_nodes=None):
     # Check if similar job exists
     jobs = self.session.query(Job).filter(Job.source_filename == unicode(source_filename)).all()
     if len(jobs)==0:
         job = Job(source=source,source_filename=source_filename,selected_nodes=selected_nodes)
         job.material = self.session.query(Material).first()
         if job.load():
             # update the ui with job info
             self.job = job
             self._flash(0,'%s loaded'%os.path.basename(job.source_filename or 'File'))
             self._update_preview()
             return True
         else:
             msg = gtk.MessageDialog(type=gtk.MESSAGE_ERROR,
                 buttons=gtk.BUTTONS_CLOSE,
                 message_format=job.messages.pop())
             msg.set_title('Error opening file')
             msg.run()
             msg.destroy()
             return False
     else:
         # open a new job or
         msg = gtk.MessageDialog(type=gtk.MESSAGE_ERROR,
             buttons=gtk.BUTTONS_CLOSE,
             message_format='A similar job was already found, do you want to load that?')
         msg.set_title('File Already Found opening file')
         msg.run()
         msg.destroy()
         return False

 def _add_gc_job(self):
     job = Job()
     job.name = 'gc'
     job.job_func= self.gc
     job.set_frequency(10, 'minutes')
     self._add_job(job)
     self.instantiate(job)

	def __init__(self,doc):
		Job.__init__(self, doc)
		try:
			self.format = self.format
		except AttributeError:
			self.format = "json"
		try:
			self.coll_type = self.coll_type
		except AttributeError:
			self.coll_type = None
		
		self._dict_values = {}
		self._dict_values["sources"] = {
							"filename": "%s/export_%s_sources_%s.%s" %(self.project_name, self.name, self.date, self.format),
							"format": self.format,
							"fields": 'url,origin,date.date',
							}
		self._dict_values["logs"] = {
							"filename": "%s/export_%s_logs_%s.%s" %(self.project_name,self.name, self.date, self.format), 
							"format":self.format,
							"fields": 'url,code,scope,status,msg',
							}
		self._dict_values["results"] = {
							"filename": "%s/export_%s_results_%s.%s" %(self.project_name,self.name, self.date, self.format), 
							"format":self.format,
							"fields": 'url,domain,title,content.content,outlinks.url,crawl_date',
							}