class NodeManager(core.Agent): """ The class responsible to create nodes. """ name = 'manager' """ the registered name in the :class:`addressing.AddressBook` """ def __init__(self, graph): """ Creates a new node_manager :param graph: the graph to pass to the agents :type graph: storage.GraphWrapper """ self.graph = graph self.failures = [] self.group = Group() def setup_node(self, node, greenlet): greenlet.link_value(node.deactivate_node) node.graph = self.graph self.group.add(greenlet) def unset_node(self, node, greenlet): del node.graph self.group.discard(greenlet) if isinstance(greenlet.value, core.GreenletExit): self.graph.remove_node(node.id) print 'Removing', node.id def create_node(self, cls, parameters): """ Creates a new node. :param cls: the factory creating the new node. :type cls: callable :param parameters: the parameters that are forwarded to the node for creation :type parameters: dict :return: the actual identifier :rtype: int | str """ node = cls(**parameters) identifier = self.graph.add_node() node.start(self._address_book, self._node_db, identifier) return identifier def simulation_ended(self): self.group.join()
class FTPPool(object): def __init__(self, addr, user, pwd, min_=1, max_=0, stat=None): self.addr = addr self.user = user self.pwd = pwd self.pool = set() self.busy = Group() self.stat = stat self.max_ = max_ for _ in xrange(min_): self.pool.add(self._connect()) def _connect(self): ftp = FTP(self.addr) try: ftp.login(self.user, self.pwd) except error_temp as e: print e return return ftp def _get_ftp(self): if self.pool: ftp = self.pool.pop() else: while self.max_ and len(self.busy) > self.max_: sleep(0.1) while True: ftp = self._connect() if ftp: break return ftp def _release_ftp(self, gr, ftp): if gr.successful(): self.pool.add(ftp) else: ftp.close() del ftp self.busy.discard(gr) if self.stat: self.stat.set_busy(len(self.busy)) def spawn_ftp(self, func, *a, **kw): ftp = self._get_ftp() gr = spawn(func, ftp, *a, **kw) gr.link(lambda g: self._release_ftp(g, ftp)) self.busy.add(gr) if self.stat: self.stat.set_busy(len(self.busy)) def wait(self): self.busy.join() def break_all(self): self.busy.kill()
class GeventThreadController(Thread): def __init__(self, name, sleep=0.2, debug=False): Thread.__init__(self) self.name = name self._q_wait_to_run = queue.Queue() self._q_wait_to_stop = queue.Queue() self._is_stop = False self._greenlets = Group() self._sleep = sleep self._isdebug = debug def run(self): self._is_stop = False self._debug("{} start".format(self.name)) while not self._is_stop: if not self._q_wait_to_stop.empty(): self._stop_greenlet(self._q_wait_to_stop.get()) elif not self._q_wait_to_run.empty(): self._start_greenlet(self._q_wait_to_run.get()) else: gevent.sleep(self._sleep) # Stoping thread self._greenlets.kill() self._debug("{} stop".format(self.name)) def stop(self): self.stop_nowait() self.join() def stop_nowait(self): self._is_stop = True def append(self, name, green_create_task, *args, **kwargs): if hasattr(green_create_task, '__call__'): self._q_wait_to_run.put(tuple((name, green_create_task, args, kwargs))) else: raise TypeError("must be \'function\' or \'GreenClassPack\', not {}".format(type(green_create_task))) def stop_greenlet(self, gr_mame): self._q_wait_to_stop.put(gr_mame) def __getitem__(self, gr_mame): gr_obj = self._get_greenlet(gr_mame) if gr_obj: return gr_obj raise IndexError def _start_greenlet(self, gr_create_task_tuple): gr_task_name = gr_create_task_tuple[0] gr_create_task = gr_create_task_tuple[1] args = gr_create_task_tuple[2] kwargs = gr_create_task_tuple[3] gr_obj = gr_create_task(*args, **kwargs) if isinstance(gr_obj, Greenlet) and not self._get_greenlet(gr_task_name): gevent.spawn(self._task_hndler, gr_obj, gr_task_name) else: self._debug("Error form {0}.{1}: must be \'gevent.Greenlet\', not {2}. Or same greenlet already runnig" .format(self.name, gr_task_name, type(gr_obj))) def _stop_greenlet(self, gr_task_name): gr_obj = self._get_greenlet(gr_task_name) if gr_obj: gr_obj.kill() def _get_greenlet(self, name_str): gr_name = "{0}.{1}".format(self.name, name_str) for gr_obj in self._greenlets: if gr_name == gr_obj.name: return gr_obj return None def _task_hndler(self, gr_obj, gr_name): gr_obj.name = "{0}.{1}".format(self.name, gr_name) self._greenlets.add(gr_obj) self._debug("{0}.{1}: starting".format(self.name, gr_name)) gr_obj.start() gr_obj.join() self._greenlets.discard(gr_obj) self._debug("{0}.{1} is stop".format(self.name, gr_name)) def _debug(self, log_str): if self._isdebug: print(log_str)