Python Worker.stop方法代码示例

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import stop [as 别名]
 def test_thread_safe(self):
     """
     These tests are related to:
     http://stackoverflow.com/q/3752618
     
     I'm not even sure if these tests are correct.
     """
     from worker import Worker
     
     with self.subTest("one-time listener"):
         a = Worker().start()
         @a.listen("test")
         def handler(event):
             a.unlisten(handler)
         a.fire("test")
         a.stop().join()
         self.assertNotIn(handler, a.listener_pool)
         self.assertEqual(a.listeners.get("test", []), [])
         
     with self.subTest("add listener in listener callback"):
         a = Worker().start()
         @a.listen("test")
         def _(event):
             @a.listen("test")
             def _(event):
                 pass
         a.fire("test")
         a.stop().join()
         self.assertEqual(len(a.listeners.get("test", [])), 2)

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import stop [as 别名]
 def stop(self, force = True):
     """
     Stops all modules and shuts down the manager.
     """
     self.log().debug("Stopping")
     self.stopModules()
     Worker.stop(self, force)

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import stop [as 别名]
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.worker = None
        self.statusBar().showMessage('ready')
        self.resize(250, 150)
        self.move(300, 300)
        self.setWindowTitle('刷起来')
        self.setWindowIcon(QIcon('icon.ico'))
        self.imagesPath = "./images/tp14/"
        self.toolBar = self.addToolBar('')

        GameStatus().window = self

        yaoguaifaxian_action = QAction(QIcon('./images/ui/yaoguaifaxian.jpg'), '妖怪发现', self)
        yaoguaifaxian_action.triggered.connect(self.yaoguaifaxian)

        exit_action = QAction(QIcon('./images/ui/exit.png'), '停止', self)
        exit_action.setShortcut('Ctrl+Q')
        exit_action.triggered.connect(self.stop_loop)


        self.toolBar.addAction(yaoguaifaxian_action)
        self.toolBar.addAction(exit_action)

        txt = QTextBrowser()
        txt.setContentsMargins(5, 5, 5, 5)
        self.setCentralWidget(txt)
        self.show()

    def add_text(self, text):
        self.centralWidget().append(text)
        sb = self.centralWidget().verticalScrollBar()
        sb.setValue(sb.maximum())
        print(text)

    def closeEvent(self, *args, **kwargs):
        self.stop_loop()
        print("关闭程序")

    def status_changed(self):
        if self.worker is None:
            self.statusBar().showMessage("就绪。")
        elif self.worker.stopped():
            self.statusBar().showMessage("已停止。")
        else:
            self.statusBar().showMessage("当前次数： " + str(self.worker.cnt))

    def yaoguaifaxian(self):
        if self.worker is not None and not self.worker.stopped():
            return

        self.worker = Worker(self.imagesPath)
        GameStatus().game_stage = GameStage.Yaoguaifaxian
        self.worker.start()

    def stop_loop(self):
        if self.worker is None:
            return
        self.worker.stop()

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import stop [as 别名]
 def test_event(self):
     from worker import Worker
     
     access = {}
     
     a = Worker().start()
     b = Worker(parent=a).start()
     c = Worker(parent=b).start()
     
     @a.listen("MY_BUBBLE")
     def _(event):
         access["bubble"] = event.target
         
     @c.listen("MY_BROADCAST")
     def _(event):
         access["broadcast"] = event.target
         
     a.broadcast("MY_BROADCAST")
     c.bubble("MY_BUBBLE")
     
     time.sleep(1)
     
     self.assertEqual(access, {
         "bubble": c,
         "broadcast": a
     })
     
     a.stop().join()

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import stop [as 别名]
 def test_detached(self):
     """child will detached from parent when finished"""
     from worker import Worker
     a = Worker().start()
     b = Worker(parent=a).start()
     b.stop().join()
     time.sleep(1)
     self.assertNotIn(b, a.children)
     a.stop().join()

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import stop [as 别名]
 def stop(self):
   if self._running:
     Worker.stop(self)
     self._save()
     if self._lastfm:
       self._lastfm.stop()
     if self._echonest:
       self._echonest.stop()
     self._running = False

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import stop [as 别名]
def main():
    url, max_workers, retry = parse_args()
    enable_pretty_logging()
    connection = Connection.use_connection(url or read_url())
    worker = Worker(connection, max_workers, retry)
    try:
        worker.run()
    except KeyboardInterrupt:
        worker.stop()
        worker.report()

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import stop [as 别名]
def handleCommand(cmd, workers):
	cmd = cmd.strip().lower()
	if(cmd == '-a'):
		w = Worker()
		workers.append(w)
		w.start()
	elif(cmd == '-q'):
		exit(0)
	else:
		workerID = int(cmd.split()[1])
		w = workers.pop(workerID)
		w.stop()

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import stop [as 别名]
 def test_child_thread(self):
     from worker import Worker
     
     parent = Worker()
     child = Worker(parent=parent)
     
     parent.start()
     child.start()
     
     parent.stop().join()
     
     self.assertFalse(parent.is_running())
     self.assertFalse(child.is_running())

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import stop [as 别名]
 def test_daemon(self):
     from worker import current, Worker
     
     with self.subTest("main thread is not deamon"):
         self.assertFalse(current().is_daemon())
     
     with self.subTest("thread is not daemon by default"):
         thread = Worker().start()
         self.assertFalse(thread.is_daemon())
         thread.stop().join()
     
     with self.subTest("should inherit parent if not set"):
         a = Worker(daemon=True).start()
         self.assertTrue(a.is_daemon())
         
         b = Worker(parent=a).start()
         self.assertTrue(b.is_daemon())
         
         a.stop().join()
         
     with self.subTest("parent will wait non-daemon child thread"):
         a = Worker().start()
         b = Worker(parent=a).start()
         a.stop().join()
         self.assertFalse(b.is_running())
         
     with self.subTest("parent won't wait daemon child thread"):
         def blocker():
             time.sleep(1)
         a = Worker().start()
         b = Worker(blocker, parent=a, daemon=True).start()
         a.stop().join()
         self.assertTrue(b.is_running())
         b.join()

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import stop [as 别名]
    def spawn_worker(self):
        sleep(0.1)
        worker = Worker(self.pid, self.app.server, self.app.args)

        pid = os.fork()

        if pid != 0:
            # parent process
            self.workers[pid] = worker
            return pid

        # child process
        try:
            worker.run()
            sys.exit(0)
        except Exception as e:
            print e
        finally:
            worker.stop(self.app.args.grace)

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import stop [as 别名]
    def spawn_worker(self):
        sleep(0.1)
        worker = Worker(self.pid, self.app.server, self.app.args)

        pid = os.fork()

        if pid != 0:
            # parent process
            self.workers[pid] = worker
            return pid

        # child process
        try:
            worker.init_worker()
            worker.run()
            sys.exit(0)
        except Exception as e:
            self.logger.exception('Exception: %s', e)
        finally:
            worker.stop()

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import stop [as 别名]
class StreamConsumer(object):

    def __init__(self, callback, url, auth):
        self.callback = callback
        self.url = url
        self.auth = auth

    def start(self):
        self.worker = Worker(self.url, self.auth, self.callback)
        self.worker.start()
        while not self.worker.stopped():
            try:
                time.sleep(1)
            except KeyboardInterrupt:
                print "\n"
                print "Exiting..."
                self.worker.stop()
                self.worker.join()
                raise
            except:
                raise

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import stop [as 别名]
class DownloadManager:
	"""Create a download manager used in GUI. Manage threads."""

	def __init__(self):
		"""Construct."""
		self.download_thread = None
		self.analyze_threads = ThreadSafeSet()
		self.library_thread = None
		self.library_err_count = None
		self.batch_analyzer = None
		
		thread = current()
		
		download_ch.sub(thread)
		
		@thread.listen("DOWNLOAD_ERROR")
		def _(event):
			_err, mission = event.data
			mission_manager.drop("view", mission)

		@thread.listen("DOWNLOAD_FINISHED")
		def _(event):
			"""After download, execute command."""
			if event.target is not self.download_thread:
				return
				
			cmd = event.data.module.config.get("runafterdownload")
			default_cmd = setting.get("runafterdownload")
			
			commands = []
			
			if cmd:
				commands.append(cmd)
				
			if default_cmd and default_cmd not in commands:
				commands.append(default_cmd)
			
			for command in commands:
				command += " " + quote(path_join(
					profile(event.data.module.config["savepath"]),
					safefilepath(event.data.title)
				))
				try:
					await_(subprocess.call, command, shell=True) # nosec
				except (OSError, subprocess.SubprocessError):
					traceback.print_exc()
					
		@thread.listen("DOWNLOAD_FINISHED")
		@thread.listen("DOWNLOAD_ERROR")
		def _(event):
			"""After download, continue next mission"""
			if event.target is self.download_thread:
				self.download_thread = None
				self.start_download()
				
		@thread.listen("DOWNLOAD_INVALID")
		def _(event):
			"""Something bad happened"""
			if event.target is self.download_thread:
				self.download_thread = None
				print("停止下載")

	def start_download(self):
		"""Start downloading."""
		if self.download_thread:
			return

		mission = mission_manager.get("view", lambda m: m.state in ("ANALYZED", "PAUSE", "ERROR", "UPDATE"))
		if mission:
			print("Start download " + mission.title)
			def do_download():
				debug_log("do_download")
				with load_episodes(mission):
					download(mission, profile(mission.module.config["savepath"]))
					
			self.download_thread = Worker(do_download).start()
		else:
			print("所有任務已下載完成")

	def stop_download(self):
		"""Stop downloading."""
		if self.download_thread:
			self.download_thread.stop()
			self.download_thread = None
			print("Stop downloading")
			
	def start_analyze(self, mission, on_finished=None):
		"""Start analyzing"""
		if mission.state not in ("ANALYZE_INIT", "INIT"):
			print(
				"Invalid state to analyze: {state}".format(state=mission.state))
			return
			
		@create_worker
		def analyze_thread():
			err = None
			with load_episodes(mission):
				try:
					Analyzer(mission).analyze()
				except BaseException as _err:
#.........这里部分代码省略.........

# 需要导入模块: from worker import Worker [as 别名]
# 或者: from worker.Worker import stop [as 别名]
class BatchAnalyzer:
	def __init__(
		self,
		gen_missions,
		stop_on_error=True,
		on_item_finished=None,
		on_finished=None
	):
		self.thread = Worker(self.analyze)
		self.gen_missions = gen_missions
		self.on_finished = on_finished
		self.on_item_finished = on_item_finished
		self.stop_on_error = stop_on_error
		self.cooldown = {}
		
	def start(self):
		self.thread.start()
		return self
		
	def stop(self):
		self.thread.stop()
		return self
		
	def get_cooldown(self, mission):
		if not hasattr(mission.module, "rest_analyze"):
			return 0
		pre_ts = self.cooldown.get(mission.module.name)
		if pre_ts is None:
			return 0
		cooldown = mission.module.rest_analyze - (time() - pre_ts)
		return cooldown if cooldown > 0 else 0
		
	def analyze(self):
		err = None
		try:
			self.do_analyze()
		except WorkerExit:
			raise
		except BaseException as _err:
			err = _err
			raise
		finally:
			if self.on_finished:
				self.on_finished(err)
			
	def do_analyze(self):
		for mission in self.gen_missions:
			err = None
			try:
				sleep(self.get_cooldown(mission))
				with load_episodes(mission):
					Analyzer(mission).analyze()
			except WorkerExit:
				raise
			except BaseException as _err: # pylint: disable=broad-except
				err = _err
				if self.stop_on_error and (not callable(self.stop_on_error) or self.stop_on_error(err)):
					err.mission = mission
					raise
			finally:
				if self.on_item_finished:
					self.on_item_finished(err, mission)
				self.cooldown[mission.module.name] = time()