class ForkDetector(threading.Thread):
def __init__(self, spawmer):
threading.Thread.__init__(self)
open(_QUEUE_PATH_, _QUEUE_CHAR_)
self.msgQueue = MessageQueue(_QUEUE_PATH_, _QUEUE_CHAR_, 0666, True)
self.spawmer = spawmer
self.eventHandler = publish_subscribe.eventHandler.EventHandler()
self.pidToattach = []
self.eventHandler.subscribe("debugger.attached", self.attached)
def ObtenerID(self, msg):
struct = unpack('<li', msg)
return struct[1]
def CrearRespuesta(self, pid):
msg = pack('<li', pid, 0)
return msg
def salir(self):
respuesta = pack('<li', 1, 1)
self.msgQueue.push(respuesta)
def attached(self, data):
pid = data
if pid in self.pidToattach:
self.pidToattach.remove(pid)
respuesta = self.CrearRespuesta(pid)
self.msgQueue.push(respuesta)
def run(self):
while (True):
msg = self.msgQueue.pull(type=1)
pid = self.ObtenerID(msg)
if pid == 1:
del self.msgQueue
return 0
self.pidToattach.append(pid)
self.eventHandler.publish("debugger.attach", pid)
class ForkDetector(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
open(_QUEUE_PATH_,'a')
self.PID_of_forked = []
self.PID_of_forked_lock = threading.Lock()
self.ev = publish_subscribe.eventHandler.EventHandler(name="ForkDetector")
self.ev.subscribe('spawner.spawn_and_attach_completed', self.respondToForkedProcess)
try:
self.msgQueue = MessageQueue(_QUEUE_PATH_, _QUEUE_CHAR_, 0666, True)
except:
self.ev.publish("ERROR.forkDetector", {'info':"MSQ ya existente"})
self.msgQueue = MessageQueue(_QUEUE_PATH_, _QUEUE_CHAR_, 0666, False)
def respondToForkedProcess(self, data):
pid = data['pid']
self.PID_of_forked_lock.acquire()
if pid in self.PID_of_forked:
msg = self.CrearMensaje(pid, 0)
self.msgQueue.push(msg)
self.PID_of_forked.remove(pid)
self.PID_of_forked_lock.release()
def ObtenerPID(self, msg):
# print msg.encode('hex_codec')
# print len(msg)
struct = unpack(_STRUCT_FORMAT_, msg)
# print struct
return struct[1]
def CrearMensaje(self, mtype ,pid):
msg = pack(_STRUCT_FORMAT_, mtype, pid)
return msg
def finalizar(self):
if hasattr(self, 'msgQueue'):
msg = pack(_STRUCT_FORMAT_, 1, 0)
# print msg.encode('hex_codec')
# print sys.getsizeof(msg)
self.msgQueue.push(msg)
def run(self):
salir = False
try:
while (not salir):
msg = self.msgQueue.pull(type=1)
pid = self.ObtenerPID(msg)
if pid == 0:
salir = True
else:
self.PID_of_forked_lock.acquire()
self.PID_of_forked.append(pid)
self.PID_of_forked_lock.release()
self.ev.publish("spawner.add-debugger-and-attach.ForkDetector", {'pid': pid, "continue": True})
except Exception as inst:
print type(inst)
print traceback.format_exc()
self.msgQueue = None
finally:
del self.msgQueue
os.remove(_QUEUE_PATH_)
syslog.syslog(syslog.LOG_INFO, "Init 'inbound' process. Creating queues. Arguments: Path: %s Char_in_id: %s GroupId: %i Localhost: %s NetworkName: %s PID: %s" % (
path, hex(ord(char_id_in)), group_id, localhost_name, network_name, pid))
userland_inbound_queue = MessageQueue(path, char_id_in, 0644, True)
userland_outbound_queue = MessageQueue(path, char_id_out, 0644, True)
localhost_name = ":".join([localhost_name, pid])
driver = Driver(localhost_name, path, char_id_out, group_id, network_name, userland_inbound_queue)
head_process = Popen(["python", "outbound.py", path, char_id_out, str(group_id), localhost_name])
try:
while True:
try:
syslog.syslog(syslog.LOG_INFO, "Pushing 'BrokenLink' in the output queue.")
userland_outbound_queue.push(driver.create_linkbroken_msj())
driver.clean()
syslog.syslog(syslog.LOG_INFO, "Construction the ring")
previous_node = ring.tail(network_name, group_id, localhost_name, driver)
syslog.syslog(syslog.LOG_INFO, "External node %s connected to me" % str(previous_node.getpeername()))
addr_attempts = 0
syslog.syslog(syslog.LOG_INFO, "Pushing 'LeaderElection' in the output queue.")
userland_outbound_queue.push(driver.create_leader_proposal_msj())
syslog.syslog(syslog.LOG_INFO, "Connection ready. Forwarding the messages.")
passage.passage_inbound_messages(previous_node, userland_inbound_queue, userland_outbound_queue, driver)
except InvalidMessage, e:
syslog.syslog(syslog.LOG_CRIT, "%s\n%s" % (traceback.format_exc(), str(e)))
remote_leader_name, = struct.unpack('>%is' % (remote_leader_name_len), msg[7:])
if localhost_name == remote_leader_name:
syslog.syslog(syslog.LOG_DEBUG, "FIND recieved from %s (myself: %s). Dropping..." % (remote_leader_name, localhost_name))
continue
else:
keep = False
if time.time()-i > LISTEN_TIMEOUT and keep:
raise socket.timeout()
syslog.syslog(syslog.LOG_INFO, "FIND recieved from %s. Sending FIND beacon..." % remote_leader_name)
sender.sendto(leader_beacon, (network_name, get_port.BEACON_SERVICE))
syslog.syslog(syslog.LOG_INFO, "Pushing 'BreakLinkForced' in the output queue.")
userland_outbound_queue.push(create_breaklink_msj())
userland_outbound_queue.push(create_breaklink_msj())
time.sleep(0.1)
break
except socket.timeout:
syslog.syslog(syslog.LOG_INFO, "Again.")
if time.time() - start_time >= LEADER_REELECTION_MINIMUN:
syslog.syslog(syslog.LOG_INFO, "Pushing 'LeaderElection' (reelection) in the output queue.")
userland_outbound_queue.push(inbound.create_leader_proposal_msj(localhost_name))
start_time = time.time()
except KeyboardInterrupt:
syslog.syslog(syslog.LOG_INFO, "Interruption:\n%s" % traceback.format_exc())
sys.exit(0)
