def initSlaveNodes(self):
self.logger.info('Connecting with remote servers...')
for thread in self.threadList:
thread.stop()
for conn in self.connList:
conn.close()
sleep(10)
self.connList = []
self.threadList = []
self.crawlerList = []
random.shuffle(self.accounts)
for serverID, server in enumerate(self.serverPool):
conn = rpyc.connect(server[0],
server[1],
config={"allow_pickle": True})
bgThread = rpyc.BgServingThread(conn)
accountList = self.accounts[serverID * len(self.accounts) /
len(self.serverPool):(serverID + 1) *
len(self.accounts) /
len(self.serverPool)]
crawler = conn.root.Crawler(serverID, self.threadCount,
self.dbConfig, accountList,
self.fetchNewJob)
self.connList.append(conn)
self.threadList.append(bgThread)
self.crawlerList.append(crawler)
def cmd_transfer(addr, port, full_dir_file_name, cmd_name, timeout_s):
print("connect server")
while (1):
try:
f = rpyc.connect(addr, port)
f.root.setCallback(check_and_read)
bgsrv = rpyc.BgServingThread(f)
availfiles.append(full_dir_file_name)
f.root.newfiles_add(full_dir_file_name)
f.root.save_file(addr, full_dir_file_name)
f.root.pass_cmd(cmd_name, timeout_s)
f.root.files_remove(full_dir_file_name)
bgsrv.stop()
f.close()
break
except Exception, e:
# print e
print "."
import time
time.sleep(1)
def login(self,retry = True):
'''
Log in to the controller. First try to reach the controller via the standard service registry,
if that fails try to access it via the supplied hostname/port arguments. If that fails, sleep a
little and try again.
'''
while True:
try:
self.conn = rpyc.connect_by_service(const.ctrlServiceName,config = {"allow_public_attrs" : True})
break
except:
try:
self.conn = rpyc.connect(self.ctrlrHost,self.ctrlrPort,config = {"allow_public_attrs" : True})
break
except:
if retry == False:
return False
time.sleep(5)
continue
self.bgsrv = rpyc.BgServingThread(self.conn,self.handleBgServingThreadException)
resp = self.conn.root.login(self.hostAddress,self.callback,self.riapsApps)
if type(resp) == tuple and resp[0] == 'dbase': # Expected response: (redis) database host:port pair
if self.depm != None:
self.depm.doCommand(('setDisco',) + resp[1:])
return True
else:
pass # Ignore any other response
return False
def __init__(self):
threading.Thread.__init__(self)
conn = rpyc.connect("localhost", 12345)
self.bgsrv = rpyc.BgServingThread(conn, self.backgroundStoppedCb)
self.bgsrv.SLEEP_INTERVAL = 0.025 #to make the GUI more reactive
self.bgsrvRunning = True
self.c = conn.root
def _connect(self, server):
conn = server.connect(service=rpyc.VoidService)
bgsrv = rpyc.BgServingThread(conn)
conn.ping(timeout=15)
return self.ConnType(conn, bgsrv)
def connect(self):
fn_server_public = os.path.expanduser(constants.FN_SERVER_CERT_PUBLIC)
xt_server_cert = self.config.get_vault_key("xt_server_cert")
use_public_half = False # cannot get the public half approach to work
try:
# write CERT file JIT
if use_public_half:
_, public_half = xt_server_cert.split("END PRIVATE KEY-----\n")
file_utils.write_text_file(fn_server_public, public_half)
else:
file_utils.write_text_file(fn_server_public, xt_server_cert)
self.conn = rpyc.ssl_connect(self.ip,
port=self.port,
keyfile=None,
certfile=fn_server_public)
if self.conn:
# magic step: allows our callback to work correctly!
# this must always be executed (even if self.conn is already true)
self.bgsrv = rpyc.BgServingThread(self.conn)
console.diag(" now running BgServingThread")
finally:
# delete the CERT file
#os.remove(fn_server_public)
pass
connected = not (not self.conn)
return connected
def __init__(self, rpyc_hosts, thrill_hosts):
# connect to rpyc servers
self._conn = [rpyc.connect(*hp) for hp in rpyc_hosts]
# set up background serving threads
self._bgthr = [rpyc.BgServingThread(conn) for conn in self._conn]
# make async objects to create Thrill contexts
anetrefs = [rpyc.async(conn.root.Create) for conn in self._conn]
def on_connect(self, conn: rpyc.Connection) -> None:
"""Initializes thread for the incoming connection.
Args:
conn: An incoming connection.
"""
self._bg_threads[conn] = rpyc.BgServingThread(conn)
def test_rpyc(self):
p1, p2 = PipeStream.create_pair()
client = rpyc.connect_stream(p1)
server = rpyc.connect_stream(p2)
server_thread = rpyc.spawn(server.serve_all)
assert client.root.get_service_name() == "VOID"
t = rpyc.BgServingThread(client)
assert server.root.get_service_name() == "VOID"
t.stop()
client.close()
server.close()
server_thread.join()
async def startup():
global conn, bgsrv, scheduler
try:
conn = rpyc.connect("localhost", 12345)
# create a bg thread to process incoming events
bgsrv = rpyc.BgServingThread(conn)
scheduler = conn.root
except ConnectionRefusedError as e:
logger.error("请先执行 rpc_server.py,否则无法使用web")
raise
await database.connect()
def connect_on_client(self, launcher_args):
""" connect on a client that would be running a bind payload """
launcher=network.conf.launchers["connect"](connect_on_bind_payload=True)
try:
launcher.parse_args(shlex.split(launcher_args))
except LauncherError as e:
launcher.arg_parser.print_usage()
return
stream=launcher.iterate().next()
self.handler.display_info("Connecting ...")
conn=rpyc.utils.factory.connect_stream(stream, PupyService.PupyBindService, {})
bgsrv=rpyc.BgServingThread(conn)
bgsrv.SLEEP_INTERVAL=0.001 # consume ressources but faster response ...
def __init__(self, name, callback=None, address="localhost", port=18812):
self._name = name
conn = None
while conn is None:
try:
service = classpartial(MessagingClientService, name, callback)
conn = rpyc.connect(address, port, service=service)
self._conn = conn
except Exception as e:
print(e, file=sys.stderr)
print("Retry in 5sec...")
time.sleep(5)
rpyc.BgServingThread(self._conn)
def __init__(self, mach, porta):
import rpyc, data, erros, sys, time
errors = erros.logger("cliente_erros.log")
errors.calee = "cliente.py"
try:
self.con = rpyc.connect(mach, port=porta)
self.bgsrv = rpyc.BgServingThread(self.con)
except:
errors.reg("Server not available, check connection", 3)
sys.exit()
self.fetcher = data.Fetcher(1)
self.fetcher.work_start()
self.datalogger = True
def __init__(self, host, port, normalize_imgs=True, force_cpu=False):
""" A simple FID-client that talks to the FID server and posts fid calculation requests
:param host: the FID-server hostname or ip
:param port: the FID-server port
:param normalize_imgs: whether to normalize the images
:param force_cpu: force calculations on CPU (not recommended)
:returns: FIDClient Object
:rtype: object
"""
self.cfg = {'allow_pickle': True, "sync_request_timeout": 180}
self.conn = rpyc.connect(host, port, config=self.cfg)
self.bgsrv = rpyc.BgServingThread(self.conn)
self.fid = self.conn.root.FID(normalize=normalize_imgs,
force_cpu=force_cpu)
def login(self, retry=True):
self.logger.info("login()")
self.conn = None
while True:
try:
addrs = rpyc.utils.factory.discover(GLAClient.SERVICENAME)
for host, port in addrs:
try:
self.conn = rpyc.connect(
host, port, config={"allow_public_attrs": True})
except socket.error as e:
self.logger.error("%s.%s: %s" %
(str(host), str(port), str(e)))
pass
if self.conn: break
except DiscoveryError:
self.logger.error("discovery of %s failed" %
(GLAClient.SERVICENAME))
pass
if self.conn: break
if self.host and self.port:
try:
self.conn = rpyc.connect(
self.host,
self.port,
config={"allow_public_attrs": True})
except socket.error as e:
self.logger.error("%s.%s: %s" %
(str(host), str(port), str(e)))
pass
if self.conn: break
if retry == False:
return False
else:
time.sleep(5)
continue
self.bgsrv = rpyc.BgServingThread(self.conn,
self.handleBgServingThreadException)
resp = None
try:
resp = self.conn.root.login(self.name, self.callback)
except:
traceback.print_exc()
pass
return type(resp) == tuple and resp[0] == 'ok'
def __init__(self, self_play=False, player=1):
assert player == 1 or player == 2
self.action_space = spaces.Discrete(7)
self.observation_space = spaces.Box(low=-np.inf,
high=np.inf,
shape=(69, 26, 26),
dtype=float)
self.player = player
self.self_play = self_play
self.sct = mss.mss()
self.state = {
'stats': {
'kills': 0,
'deaths': 0,
'assists': 0,
'minion_kills': 0,
'health': 100,
'opponent_health': 100
},
'positions': defaultdict(lambda: None)
}
self.champion = 'Ashe'
self.opponent = 'Veigar'
self.opponent_template = cv2.imread(self.opponent + '.jpg', 0)
self.start_time = time.time()
self.away_time = time.time()
performDetect(initOnly=True,
configPath="./cfg/yolov3-tiny_obj.cfg",
weightPath="yolov3-tiny_obj_last.weights",
metaPath="./cfg/obj.data")
if self_play:
self.service = Service()
if player == 1:
self.conn = rpyc.OneShotServer(self.service, port=18861)
self.server = Thread(target=self.conn.start)
self.server.start()
else:
self.champion = 'Veigar'
self.opponent = 'Ashe'
self.conn = rpyc.connect("localhost",
18861,
service=self.service)
self.bgsrv = rpyc.BgServingThread(self.conn)
def connectToServer(ID=None, clientType="NONE"):
'''
Try to connect to the server and launch the BG thread service
'''
if not ID:
ID = getpass.getuser()
global server_conn
global bgsrv
try:
server_conn = rpyc.connect(
HComMayaUtils.readIni()["SERVER"].replace(" ", ""),
int(str(HComMayaUtils.readIni()["PORT"]).replace(" ", "")),
service=HCom_ClientService,
config={"allow_pickle": True})
except Exception as e:
print("ERROR: Can not connect to server: " + str(e))
return False, False
else:
if ID in server_conn.root.getAllClients().keys():
ask = QtGui.QMessageBox()
ask.setText("User ID already registered on the server")
ask.setIcon(QtGui.QMessageBox.Critical)
ask.exec_()
server_conn.close()
return False
MayaGlobals.HCOMCLIENT = [server_conn, ID]
global server_id
server_id = ID
bgsrv = rpyc.BgServingThread(server_conn)
result = server_conn.root.registerClient(ID, clientType)
if result:
return ID
else:
return False
def _connect(self, port):
self._logger.debug(f'Trying to connect on port {port}')
for i in range(self.patience):
try:
self._logger.debug(f'Attempt no: {i}')
conn = rpyc.connect(host="localhost",
port=port,
service=rpyc.VoidService)
bgsrv = rpyc.BgServingThread(conn)
conn.ping()
return self.ConnType(conn, bgsrv)
except ConnectionRefusedError:
time.sleep(2)
raise ConnectionRefusedError
def connect_to_controller(self, box_name=None, ip_addr=None, port=None):
'''
establish communication with the XT controller process on the specified box.
return True if connection established, False otherwise.
'''
connected = False
console.diag("init_controler: box_name={}".format(box_name))
if self.conn == box_name:
connected = True
else:
if ip_addr:
box_addr = ip_addr
else:
info = box_information.get_box_addr(self.config, box_name,
self.store)
box_addr = info["box_addr"]
controller_port = info["controller_port"]
self.token = info["box_secret"]
ip_addr = self.core.get_ip_addr_from_box_addr(box_addr)
port = controller_port if controller_port else constants.CONTROLLER_PORT
# the controller should now be running - try to connect
try:
console.diag(" connecting to controller")
self.connect(box_name, ip_addr, port=port)
console.diag(" connection successful!")
# magic step: allows our callback to work correctly!
# this must always be executed (even if self.conn is already true)
bgsrv = rpyc.BgServingThread(self.conn)
console.diag(" now running BgServingThread")
connected = True
except BaseException as ex:
#self.report_controller_init_failure(box_name, box_addr, self.port, ex)
# most common reasons for failure: not yet running (backend service) or finished running
pass
return connected
def connect_to_moose_server(self, host, port, pid, filename):
try:
DEBUG("Connecting to Moose server on " + host + ":" + str(port))
connection = rpyc.classic.connect(host, port)
INFO("Connected to Moose server on " + host + ":" + str(port))
modelname = self.unique_modelname(filename)
connection.modules.moose.loadModel(filename, modelname)
INFO("Loaded " + modelname)
self.current_model = self.models[modelname] = \
{ "conn" : connection
, "moose" : connection.modules.moose
, "pid" : pid
, "host" : host
, "port" : port
, "model" : connection.modules.moose.element(modelname)
, "service" : connection.root
, "thread" : rpyc.BgServingThread(connection)
}
except socket.error as serr:
if serr.errno != errno.ECONNREFUSED:
raise serr
DEBUG("Failed to connect to Moose server on " + host + ":" + str(port))
QTimer.singleShot(1000, lambda : self.connect_to_moose_server(host, port, pid, filename))
def connectToServer(ID=None, clientType="NONE"):
'''
Try to connect to the server and launch the BG thread service
'''
if not ID:
ID = getpass.getuser()
global server_conn
global bgsrv
try:
server_conn = rpyc.connect(HComHoudiniUtils.readIni()["SERVER"],
int(HComHoudiniUtils.readIni()["PORT"]),
service=HCom_ClientService,
config={"allow_pickle": True})
except Exception as e:
print("ERROR: Can not connect to server: " + str(e))
return False, False
else:
if ID in server_conn.root.getAllClients().keys():
hou.ui.displayMessage("User ID already registered on the server")
server_conn.close()
return False
hou.session.HCOMCLIENT = [server_conn, ID]
global server_id
server_id = ID
bgsrv = rpyc.BgServingThread(server_conn)
result = server_conn.root.registerClient(ID, clientType)
if result:
return ID
else:
return False
from sklearn.neural_network import MLPClassifier
from random import randint
import rpyc
import pandas as pd
conn = rpyc.classic.connect(
'169.254.229.60') # host name or IP address of the EV3
bgsrv = rpyc.BgServingThread(conn) #sleep removed
sensors = conn.modules['ev3dev2.sensor.lego']
motor = conn.modules['ev3dev2.motor']
distancia = sensors.UltrasonicSensor()
color = sensors.ColorSensor()
llantaIzq = motor.LargeMotor(motor.OUTPUT_D)
llantaDer = motor.LargeMotor(motor.OUTPUT_A)
llantas = motor.MoveTank(motor.OUTPUT_A, motor.OUTPUT_D)
rampa = motor.Motor(motor.OUTPUT_B)
accion = " "
degrees = 0
maxDegrees = 10
def Caminar(Speed):
llantas.on(Speed, Speed)
def setup(self):
self.conn = rpyc.connect_thread(remote_service=MyService)
self.bgserver = rpyc.BgServingThread(self.conn)
def test_rpyc(self):
assert self.client.root.get_service_name() == "VOID"
t = rpyc.BgServingThread(self.client)
assert self.server.root.get_service_name() == "VOID"
t.stop()
import rpyc
import time
c = rpyc.classic.connect("localhost")
t = rpyc.BgServingThread(c)
start = time.time()
for i in range(100):
c.execute("newObj = %d" % (i))
stop = time.time()
print "added %d simple objects one by one, %f seconds" % (100, stop - start)
t.stop()
def _connect_rpc(worker):
conn = rpyc.connect(worker.kuyruk.config.MANAGER_HOST,
worker.kuyruk.config.MANAGER_PORT,
service=_worker_service_class(worker),
config={"allow_pickle": True})
rpyc.BgServingThread(conn)._thread.join()
def init_conn(host):
conn = rpyc.classic.connect(host)
t = rpyc.BgServingThread(conn)
return conn
def login(self, retry=True):
'''
Log in to the controller. First try to reach the controller via the standard service registry,
if that fails try to access it via the supplied hostname/port arguments. If that fails, sleep a
little and try again.
'''
while True:
self.conn = None
try:
addrs = rpyc.utils.factory.discover(const.ctrlServiceName)
for host, port in addrs:
try:
if Config.SECURITY:
self.conn = rpyc.ssl_connect(
host,
port,
keyfile=self.keyFile,
certfile=self.certFile,
cert_reqs=ssl.CERT_REQUIRED,
ca_certs=self.certFile,
config={"allow_public_attrs": True})
else:
self.conn = rpyc.connect(
host,
port,
config={"allow_public_attrs": True})
except socket.error:
pass
if self.conn: break
except DiscoveryError:
pass
if self.conn: break
if self.ctrlrHost and self.ctrlrPort:
try:
if Config.SECURITY:
self.conn = rpyc.ssl_connect(
self.ctrlrHost,
self.ctrlrPort,
keyfile=self.keyFile,
certfile=self.certFile,
cert_reqs=ssl.CERT_REQUIRED,
ca_certs=self.certFile,
config={"allow_public_attrs": True})
else:
self.conn = rpyc.connect(
self.ctrlrHost,
self.ctrlrPort,
config={"allow_public_attrs": True})
except socket.error:
pass
if self.conn: break
if retry == False:
return False
else:
time.sleep(5)
continue
self.bgsrv = rpyc.BgServingThread(self.conn,
self.handleBgServingThreadException)
resp = None
try:
resp = self.conn.root.login(self.hostAddress, self.callback,
self.riapsApps)
except:
pass
if type(resp) == tuple and resp[
0] == 'dbase': # Expected response: (redis) database host:port pair
if self.depm != None:
self.depm.doCommand(('setDisco', ) + resp[1:])
return True
else:
pass # Ignore any other response
return False
import rpyc
import time
count = 0
def callbackFunc(x):
global count
count += 1
print x, time.time()
if __name__ == "__main__":
conn = rpyc.connect("localhost", 12000)
#rpyc.BgServingThread.SERVE_INTERVAL = 0.01
rpyc.BgServingThread.SLEEP_INTERVAL = 0.0001
bgsrv = rpyc.BgServingThread(conn)
test = conn.root.RemoteCallbackTest(callbackFunc)
print test
test.start()
print "doing other things while the callback is being called"
while count < 100:
time.sleep(0.1)
print "done"
def run(self):
"""Run the managing loop. Check rqt stack for simulation request. Select the candidate \
server for simulation. Start simulation."""
logging.info("Start Sim Manager main loop")
# Continue while not asked for termination or when there are candidates in the list
# and a server to process them
while (not self.mng_stop) or (self.rqt and self.server_dispo):
if self.rqt:
# Select a candidate server
server_hash = self.__select_candidate()
if server_hash != 0:
# We found a server
self.server_dispo = True
logging.info(
"Starting sim service on server: " +
str(self.cloud_state[server_hash]["address"]) + ":" +
str(self.cloud_state[server_hash]["port"]))
# Connect to candidate server
try:
conn = rpyc.connect(
self.cloud_state[server_hash]["address"],
self.cloud_state[server_hash]["port"])
except Exception as e:
logging.error("Exception when connecting:" + str(e))
pass
# Update the cloud_state list
self.mutex_cloud_state.acquire()
self.cloud_state[server_hash]["n_threads"] += 1
self.mutex_cloud_state.release()
# Create serving thread to handle answer
try:
bgt = rpyc.BgServingThread(conn)
except Exception as e:
logging.error("Exception in serving thread:" + str(e))
pass
self.mutex_conn_list.acquire()
self.conn_list.append({
"server": server_hash,
"conn": conn,
"thread": bgt
})
self.mutex_conn_list.release()
# Create asynchronous handle
async_simulation = rpyc. async (
conn.root.exposed_simulation)
try:
# Call asynchronous service
res = async_simulation(self.rqt[-1])
# Assign asynchronous callback
res.add_callback(self.response_sim)
except Exception as e:
logging.error("Exception from server:" + str(e))
pass
# Clear request from list: TODO: check if async_simulation don't need it anymore!
self.mutex_rqt.acquire()
self.rqt.pop()
self.mutex_rqt.release()
else:
self.server_dispo = False
time.sleep(self.mng_prun_t)
else:
time.sleep(self.mng_prun_t)
logging.info("Simulation Manager has terminated properly!")
self.terminated = True
