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 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)
