def __init__(self, processor, shared, peer):
super(RemoteReporter, self).__init__()
self.name = 'Reporter-' + peer
# Binding shared objects
self.dir = shared.settings['Main']['Temporary directory'] + sep + \
hex(int(monotonic() * 100))[2:]
self.queue = shared.queue
# Current running job, not nessesary self.cur
self.curproc = processor.getcur
self.pid = processor.getpid
# Socket creation
tcp = socket()
tcp.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
tcp.settimeout(10) # OPTIMIZE: Find optimal timeout
tcp.bind(('0.0.0.0', 50000))
tcp.listen(1)
try:
self.tcp, addr = tcp.accept()
except timeout:
tcp.close()
self._alive = False
return
self.tcp.settimeout(10)
# Setting socket for file transfer
self.filetransfer = FileTransfer(socket=self.tcp, blocksize=10240)
tcp.close()
# Receive job class as it is
try:
sjob = loads(self.tcp.recv(4096).decode('utf-8'))
except timeout:
error('Timeout while obtainig job')
self.stop()
return
self.job = Job(*sjob)
# Equivalents of local and remote dirs
self.eqdirs = dict()
# Receive nessesary files and attach their with local paths to job
for name, rpath in self.job.files.items():
rdir = dirname(rpath)
ldir = self.dir + sep + hex(hash(rdir))[3:]
self.eqdirs[ldir] = rdir
lpath = ldir + sep + basename(rpath)
# Make directory
try:
makedirs(ldir, exist_ok=True)
self.tcp.send(
make_header(RR_GET, rpath) + rpath.encode('utf-8'))
# Receive file to local path
self.filetransfer.recvfile(lpath)
except:
exception('Error while obtaining job files')
self.stop()
return
# Attach local path to job
debug("Replaced " + name + " from " + rpath + " to " + lpath)
self.job.files[name] = lpath
# Put job into the queue
self.queue.put(self.job)
shared.inform('add', self.job)
def __init__(self, processor, shared, peer):
super(RemoteReporter, self).__init__()
self.name = 'Reporter-' + peer
# Binding shared objects
self.dir = shared.settings['Main']['Temporary directory'] + sep + \
hex(int(monotonic() * 100))[2:]
self.queue = shared.queue
# Current running job, not nessesary self.cur
self.curproc = processor.getcur
self.pid = processor.getpid
# Socket creation
tcp = socket()
tcp.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
tcp.settimeout(10) # OPTIMIZE: Find optimal timeout
tcp.bind(('0.0.0.0', 50000))
tcp.listen(1)
try:
self.tcp, addr = tcp.accept()
except timeout:
tcp.close()
self._alive = False
return
self.tcp.settimeout(10)
# Setting socket for file transfer
self.filetransfer = FileTransfer(socket=self.tcp,blocksize=10240)
tcp.close()
# Receive job class as it is
try:
sjob = loads(self.tcp.recv(4096).decode('utf-8'))
except timeout:
error('Timeout while obtainig job')
self.stop()
return
self.job = Job(*sjob)
# Equivalents of local and remote dirs
self.eqdirs = dict()
# Receive nessesary files and attach their with local paths to job
for name, rpath in self.job.files.items():
rdir = dirname(rpath)
ldir = self.dir + sep + hex(hash(rdir))[3:]
self.eqdirs[ldir] = rdir
lpath = ldir + sep + basename(rpath)
# Make directory
try:
makedirs(ldir, exist_ok=True)
self.tcp.send(make_header(RR_GET, rpath) + rpath.encode('utf-8'))
# Receive file to local path
self.filetransfer.recvfile(lpath)
except:
exception('Error while obtaining job files')
self.stop()
return
# Attach local path to job
debug("Replaced " + name + " from " + rpath + " to " + lpath)
self.job.files[name] = lpath
# Put job into the queue
self.queue.put(self.job)
shared.inform(
'add', self.job)
def __init__(self, shared, peer):
super(RemoteReceiver, self).__init__()
self.peer = peer
self.name = 'Receiver-' + self.peer
# Binding shared objects
self.queue = shared.queue
self.inform = shared.inform
self.sendto = shared.udpsocket.sendto
# Socket creation
self.tcp = socket()
self.tcp.settimeout(10) # OPTIMIZE: Find optimal timeout
sleep(1) # OPTIMIZE: Find optimal sleep before connection
try:
self.tcp.connect((peer, 50000))
except:
error('Unable to connect remote worker ' + self.peer)
self.stop()
return
self.filetransfer = FileTransfer(self.tcp, blocksize=10240)
self.job = self.queue.get()
debug("Job extracted: " + str(self.job.id))
def __init__(self, shared, peer):
super(RemoteReceiver, self).__init__()
self.peer = peer
self.name = 'Receiver-' + self.peer
# Binding shared objects
self.queue = shared.queue
self.inform = shared.inform
self.sendto = shared.udpsocket.sendto
# Socket creation
self.tcp = socket()
self.tcp.settimeout(10) # OPTIMIZE: Find optimal timeout
sleep(1) # OPTIMIZE: Find optimal sleep before connection
try:
self.tcp.connect((peer, 50000))
except:
error('Unable to connect remote worker ' + self.peer)
self.stop()
return
self.filetransfer = FileTransfer(self.tcp, blocksize=10240)
self.job = self.queue.get()
debug("Job extracted: " + str(self.job.id))
class RemoteReceiver(LogableThread):
def __init__(self, shared, peer):
super(RemoteReceiver, self).__init__()
self.peer = peer
self.name = 'Receiver-' + self.peer
# Binding shared objects
self.queue = shared.queue
self.inform = shared.inform
self.sendto = shared.udpsocket.sendto
# Socket creation
self.tcp = socket()
self.tcp.settimeout(10) # OPTIMIZE: Find optimal timeout
sleep(1) # OPTIMIZE: Find optimal sleep before connection
try:
self.tcp.connect((peer, 50000))
except:
error('Unable to connect remote worker ' + self.peer)
self.stop()
return
self.filetransfer = FileTransfer(self.tcp, blocksize=10240)
self.job = self.queue.get()
debug("Job extracted: " + str(self.job.id))
def exception(self):
exception('''Something stopped this thread by raising
exception, job returned into queue''')
self.stop()
self.queue.put(self.job)
self.inform('error', str(self.job.id))
def run(self):
# Sending job object as it is
jpack = dumps(
[self.job.type, self.job.files, self.job.params, self.job.id])
self.tcp.send(jpack.encode('utf-8'))
try:
hn, other = gethostbyaddr(self.peer)
self.inform('start', self.job, hn)
except:
exception('Can not resolve remote worker name!')
self.inform('start', self.job, self.peer)
# Waiting for response from remote host
while self._alive:
req, data = receive_data(self.tcp)
if req == RR_GET: # Get file
self.filetransfer.sendfile(data.decode('utf8'))
elif req == RR_TRANSFER: # Transfer file
self.tcp.send(make_header(RR_OK))
self.filetransfer.recvfile(data.decode('utf8'))
elif req == RR_WAIT: # Wait some seconds and req again
self.tcp.send(make_header(RR_OK))
sleep(unpack(data, 'I')[0])
elif req == RR_STREAM: # Start streaming
self.tcp.send(make_header(RR_OK))
self.filetransfer.recvfile(
data.decode('utf8'), lambda: True
if self._alive else False)
self.inform('done', str(self.job.id))
elif req == RR_DONE: # All Done, job completed
if self.job.id > 0:
try:
kill(self.job.id, 9)
except:
warning('Can not kill job:' + str(self.job.id))
self.stop()
else:
raise Exception('Unexpected response:' + req)
if self._alive is False: # Sharing process end
debug('Closing ' + self.name)
self.tcp.close()
class RemoteReporter(LogableThread):
def __init__(self, processor, shared, peer):
super(RemoteReporter, self).__init__()
self.name = 'Reporter-' + peer
# Binding shared objects
self.dir = shared.settings['Main']['Temporary directory'] + sep + \
hex(int(monotonic() * 100))[2:]
self.queue = shared.queue
# Current running job, not nessesary self.cur
self.curproc = processor.getcur
self.pid = processor.getpid
# Socket creation
tcp = socket()
tcp.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
tcp.settimeout(10) # OPTIMIZE: Find optimal timeout
tcp.bind(('0.0.0.0', 50000))
tcp.listen(1)
try:
self.tcp, addr = tcp.accept()
except timeout:
tcp.close()
self._alive = False
return
self.tcp.settimeout(10)
# Setting socket for file transfer
self.filetransfer = FileTransfer(socket=self.tcp, blocksize=10240)
tcp.close()
# Receive job class as it is
try:
sjob = loads(self.tcp.recv(4096).decode('utf-8'))
except timeout:
error('Timeout while obtainig job')
self.stop()
return
self.job = Job(*sjob)
# Equivalents of local and remote dirs
self.eqdirs = dict()
# Receive nessesary files and attach their with local paths to job
for name, rpath in self.job.files.items():
rdir = dirname(rpath)
ldir = self.dir + sep + hex(hash(rdir))[3:]
self.eqdirs[ldir] = rdir
lpath = ldir + sep + basename(rpath)
# Make directory
try:
makedirs(ldir, exist_ok=True)
self.tcp.send(
make_header(RR_GET, rpath) + rpath.encode('utf-8'))
# Receive file to local path
self.filetransfer.recvfile(lpath)
except:
exception('Error while obtaining job files')
self.stop()
return
# Attach local path to job
debug("Replaced " + name + " from " + rpath + " to " + lpath)
self.job.files[name] = lpath
# Put job into the queue
self.queue.put(self.job)
shared.inform('add', self.job)
def stop(self):
self._alive = False
self.tcp.close()
if self.job is self.curproc():
killpg(self.pid(), 9)
elif self.job in self.queue:
self.queue.remove(self.job)
rmtree(self.dir, True)
def exception(self):
exception('''Something stopped thread by rising exception,
remote job has been canceled''')
self.stop()
def run(self):
# While job still in queue, receiver must wait
while self.job in self.queue:
self.tcp.send(make_header(RR_WAIT, calcsize('I')) + pack('I', 10))
debug("Got message after RR_WAIT sent: " +
encode(self.tcp.recv(RR_HEADERSIZE), 'hex'))
sleep(10) # OPTIMIZE: Find optimal sleep interval
# Job leaved queue, lets search it in processor
# If output file has defined, stream it while job is in process
if 'ofile' in self.job.files:
if self.job == self.curproc():
ldir, name = self.job.files['ofile'].rsplit(sep, 1)
# Split and translate path to remote dir
# Request sending log step by step to remote path
ddir = (self.eqdirs[ldir] + sep + name).encode('utf-8')
self.tcp.send(make_header(RR_STREAM, ddir) + ddir)
# Send log
answer, data = receive_data(self.tcp)
if answer != RR_OK:
error('Unexpected answer ' + str(answer) + ' with data: ' +
str(data) +
' occured! next 40 bytes will be printed:')
try:
ans = self.tcp.recv(40)
except:
pass
debug(encode(ans, 'hex'))
debug(ans)
raise Exception('Unexpected answer during log streaming:' +
str(answer))
self.filetransfer.sendfile(
self.job.files['ofile'],
sbs=True,
alive=lambda: True
if self.job is self.curproc() else False)
# Else just wait until job will be done
else:
while self.job == self.curproc():
self.tcp.send(
make_header(RR_WAIT, calcsize('I')) + pack('I', 10))
answer, data = receive_data(self.tcp)
if answer != RR_OK:
raise Exception('Unexpected answer during log streaming:' +
str(answer))
sleep(10) # OPTIMIZE: Find optimal sleep interval
# After job completion send results back
for lpath in self.job.files.values():
# Split path
ldir, name = lpath.rsplit(sep, 1)
# Translate local dir to remote dir,
# request and send file
ddir = self.eqdirs[ldir] + sep + name
self.tcp.send(
make_header(RR_TRANSFER, ddir) + ddir.encode('utf-8'))
answer, data = receive_data(self.tcp)
if answer != RR_OK:
raise Exception('Unexpected answer: ' + str(answer) +
' Instead of RR_OK!')
self.filetransfer.sendfile(lpath)
# Close connection
self.tcp.send(make_header(RR_DONE))
self.stop()
class RemoteReceiver(LogableThread):
def __init__(self, shared, peer):
super(RemoteReceiver, self).__init__()
self.peer = peer
self.name = 'Receiver-' + self.peer
# Binding shared objects
self.queue = shared.queue
self.inform = shared.inform
self.sendto = shared.udpsocket.sendto
# Socket creation
self.tcp = socket()
self.tcp.settimeout(10) # OPTIMIZE: Find optimal timeout
sleep(1) # OPTIMIZE: Find optimal sleep before connection
try:
self.tcp.connect((peer, 50000))
except:
error('Unable to connect remote worker ' + self.peer)
self.stop()
return
self.filetransfer = FileTransfer(self.tcp, blocksize=10240)
self.job = self.queue.get()
debug("Job extracted: " + str(self.job.id))
def exception(self):
exception(
'''Something stopped this thread by raising
exception, job returned into queue''')
self.stop()
self.queue.put(self.job)
self.inform('error', str(self.job.id))
def run(self):
# Sending job object as it is
jpack = dumps([
self.job.type,
self.job.files,
self.job.params,
self.job.id
])
self.tcp.send(jpack.encode('utf-8'))
try:
hn, other = gethostbyaddr(self.peer)
self.inform('start', self.job, hn)
except:
exception('Can not resolve remote worker name!')
self.inform('start', self.job, self.peer)
# Waiting for response from remote host
while self._alive:
req, data = receive_data(self.tcp)
if req == RR_GET: # Get file
self.filetransfer.sendfile(data.decode('utf8'))
elif req == RR_TRANSFER: # Transfer file
self.tcp.send(make_header(RR_OK))
self.filetransfer.recvfile(data.decode('utf8'))
elif req == RR_WAIT: # Wait some seconds and req again
self.tcp.send(make_header(RR_OK))
sleep(unpack(data, 'I')[0])
elif req == RR_STREAM: # Start streaming
self.tcp.send(make_header(RR_OK))
self.filetransfer.recvfile(data.decode('utf8'), lambda: True if self._alive else False)
self.inform('done', str(self.job.id))
elif req == RR_DONE: # All Done, job completed
if self.job.id > 0:
try:
kill(self.job.id, 9)
except:
warning('Can not kill job:' + str(self.job.id))
self.stop()
else:
raise Exception('Unexpected response:' + req)
if self._alive is False: # Sharing process end
debug('Closing ' + self.name)
self.tcp.close()
class RemoteReporter(LogableThread):
def __init__(self, processor, shared, peer):
super(RemoteReporter, self).__init__()
self.name = 'Reporter-' + peer
# Binding shared objects
self.dir = shared.settings['Main']['Temporary directory'] + sep + \
hex(int(monotonic() * 100))[2:]
self.queue = shared.queue
# Current running job, not nessesary self.cur
self.curproc = processor.getcur
self.pid = processor.getpid
# Socket creation
tcp = socket()
tcp.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
tcp.settimeout(10) # OPTIMIZE: Find optimal timeout
tcp.bind(('0.0.0.0', 50000))
tcp.listen(1)
try:
self.tcp, addr = tcp.accept()
except timeout:
tcp.close()
self._alive = False
return
self.tcp.settimeout(10)
# Setting socket for file transfer
self.filetransfer = FileTransfer(socket=self.tcp,blocksize=10240)
tcp.close()
# Receive job class as it is
try:
sjob = loads(self.tcp.recv(4096).decode('utf-8'))
except timeout:
error('Timeout while obtainig job')
self.stop()
return
self.job = Job(*sjob)
# Equivalents of local and remote dirs
self.eqdirs = dict()
# Receive nessesary files and attach their with local paths to job
for name, rpath in self.job.files.items():
rdir = dirname(rpath)
ldir = self.dir + sep + hex(hash(rdir))[3:]
self.eqdirs[ldir] = rdir
lpath = ldir + sep + basename(rpath)
# Make directory
try:
makedirs(ldir, exist_ok=True)
self.tcp.send(make_header(RR_GET, rpath) + rpath.encode('utf-8'))
# Receive file to local path
self.filetransfer.recvfile(lpath)
except:
exception('Error while obtaining job files')
self.stop()
return
# Attach local path to job
debug("Replaced " + name + " from " + rpath + " to " + lpath)
self.job.files[name] = lpath
# Put job into the queue
self.queue.put(self.job)
shared.inform(
'add', self.job)
def stop(self):
self._alive = False
self.tcp.close()
if self.job is self.curproc():
killpg(self.pid(), 9)
elif self.job in self.queue:
self.queue.remove(self.job)
rmtree(self.dir, True)
def exception(self):
exception('''Something stopped thread by rising exception,
remote job has been canceled''')
self.stop()
def run(self):
# While job still in queue, receiver must wait
while self.job in self.queue:
self.tcp.send(make_header(RR_WAIT, calcsize('I'))+pack('I', 10))
debug("Got message after RR_WAIT sent: " + encode(self.tcp.recv(RR_HEADERSIZE), 'hex'))
sleep(10) # OPTIMIZE: Find optimal sleep interval
# Job leaved queue, lets search it in processor
# If output file has defined, stream it while job is in process
if 'ofile' in self.job.files:
if self.job == self.curproc():
ldir, name = self.job.files['ofile'].rsplit(sep, 1)
# Split and translate path to remote dir
# Request sending log step by step to remote path
ddir = (self.eqdirs[ldir] + sep + name).encode('utf-8')
self.tcp.send(make_header(
RR_STREAM, ddir) + ddir)
# Send log
answer,data = receive_data(self.tcp)
if answer != RR_OK:
error('Unexpected answer ' + str(answer) + ' with data: ' + str(data) + ' occured! next 40 bytes will be printed:')
try:
ans = self.tcp.recv(40)
except:
pass
debug(encode(ans, 'hex'))
debug(ans)
raise Exception('Unexpected answer during log streaming:' + str(answer))
self.filetransfer.sendfile(self.job.files['ofile'], sbs=True,
alive=lambda: True if self.job is self.curproc() else False
)
# Else just wait until job will be done
else:
while self.job == self.curproc():
self.tcp.send(make_header(RR_WAIT, calcsize('I'))+pack('I', 10))
answer, data = receive_data(self.tcp)
if answer != RR_OK:
raise Exception('Unexpected answer during log streaming:' + str(answer))
sleep(10) # OPTIMIZE: Find optimal sleep interval
# After job completion send results back
for lpath in self.job.files.values():
# Split path
ldir, name = lpath.rsplit(sep, 1)
# Translate local dir to remote dir,
# request and send file
ddir = self.eqdirs[ldir] + sep + name
self.tcp.send(make_header(
RR_TRANSFER, ddir) + ddir.encode('utf-8'))
answer, data = receive_data(self.tcp)
if answer != RR_OK:
raise Exception('Unexpected answer: ' + str(answer) + ' Instead of RR_OK!')
self.filetransfer.sendfile(lpath)
# Close connection
self.tcp.send(make_header(RR_DONE))
self.stop()
