markerInfo = calculateMarkerFacts(corners[markerIndex], foundId, "EYE_CAM") else: log(f"no marker found") cv2.waitKey(0) cv2.destroyAllWindows() raise SystemExit(0) else: # initialize cams initThread = threading.Thread(target=initServer, args={}) initThread.setName("initServer") initThread.start() # start the watchDog for clientConnections navThread = threading.Thread(target=watchDog.watchDog, args={}) navThread.setName("connectionWatchDog") navThread.start() print(f"start listening on port {config.MY_RPC_PORT}") myConfig = {"allow_all_attrs": True, "allow_pickle": True} listener = ThreadedServer(rpcReceive.arucoListener, port=config.MY_RPC_PORT, protocol_config=myConfig) listener.start()
elif os.path.isfile(f): os.remove(f) logger.info(name + u":删除成功!") except OSError: logger.warning(name + u":删除失败!") if __name__ == u'__main__': # 系统文件分隔符 sep = os.sep # 脚本当前所在路径,用GB18030解码以解决中文路径问题 c_path = os.path.split(os.path.realpath(__file__))[0].decode(u"GB18030") # 加载日志配置 setup_logging(path=os.path.join(c_path, u"config/logging.json")) logger = logging.getLogger(__name__) # 加载配置文件 config_file = os.path.join(c_path, u"config/client.conf") cf = read_conf(path=config_file) # 获取本机ip system = platform.system() ip = get_ip() ip = u"" if not ip else ip[0] # 获取服务器连接 connection = None connection = get_conn() service = ThreadedServer(Client, port=9999, auto_register=False) service.start()
import rpyc from rpyc.utils.server import ThreadedServer import json class MyService(rpyc.Service): def exposed_calculateMidpoint(self, data): pts = json.loads(data) return json.dumps({ "x": (pts["x1"] + pts["y1"]) / 2, "y": (pts["x2"] + pts["y2"]) / 2, }) t = ThreadedServer(MyService, port=8080) t.start()
stderr=out, env=new_env) p.wait() returncode = p.returncode data = {} data['sid'] = sid data['nodeip'] = localip if returncode == 0: data['status'] = 0 if returncode != 0: data['status'] = 1 baseurl = "http://" + manserver changenode = httpclient(baseurl + '/api/task/flow/node/status', headers=header, method="POST", data=data) if changenode: out.write("%s 修改节点状态成功\n" % ctime()) else: out.write("%s 修改节点状态失败\n" % ctime()) def exposed_taskresult(self, sid): with open(logdir + "/" + sid + ".log", "r") as log: return log.read() if __name__ == '__main__': setup_logger(quiet=True, logfile=logdir + "/" + logfile) rpycServer = ThreadedServer(RPyCService, port=port, auto_register=False) rpycServer.start()
[data["name"], data["faculty_id"]]) self.db_conn.commit() cur.close() return std_response(True, "Department added successfully") except Exception as err: print(err) return std_response(False, "Task failed") elif data["op"] == "university": try: cur.execute( "INSERT INTO public.universities(name, s_name) VALUES (%s, %s);", [data["name"], data["s_name"]]) self.db_conn.commit() cur.close() return std_response(True, "University added successfully") except Exception as err: print(err) return std_response(False, "Task failed") else: return std_response(False, message="Operation doesn't match") port = services["user_service"] rypc_server = ThreadedServer(User_service, port=port, protocol_config={ 'allow_public_attrs': True, "allow_pickle": True }) rypc_server.start()
sys.exit(0) def loadFromFile(): if os.path.isfile('my_json'): print("file found") PrimaryBackUpService.exposed_BackUpServer.file_table = json.load( open("my_json")) class PrimaryBackUpService(rpyc.Service): class exposed_BackUpServer(): file_table = {} def exposed_getFileTable(self): file_table_string = json.dumps(self.file_table) print("File table requested by MasterServer") return file_table_string def exposed_updateFileTable(self, __file_table__): self.__class__.file_table = json.loads(__file_table__) print("File table is updated") if __name__ == "__main__": loadFromFile() signal.signal(signal.SIGINT, int_handler) print("Primary BackUp Server is running") t = ThreadedServer(PrimaryBackUpService, port=8100) t.start()
import rpyc class HelloWorldServer(rpyc.Service): def on_connect(self): pass def on_disconnect(self): pass def exposed_say_hello(self): return "Hello, World!" def exposed_say_hi(self): return "Hi" # Launch the server if __name__ == "__main__": from rpyc.utils.server import ThreadedServer t = ThreadedServer(HelloWorldServer, port=18861) print("Launching the Server") t.start()
def run(self): ThreadedServer(self.service, port=self.port, hostname=self.host).start()
import rpyc import socket from constRPYC import * from rpyc.utils.server import ThreadedServer class DBList(rpyc.Service): value = [] def exposed_append(self, data): self.value = self.value + [data] print("Appended value = ", data) return self.value def exposed_value(self): return self.value def exposed_delete(self, data): if data in self.value: print("Deleted value = " + data) self.value.remove(data) return self.value if __name__ == "__main__": server = ThreadedServer(DBList, port=20202) conn_dir = rpyc.connect(DIR_SERVER, DIR_PORT) my_address = socket.gethostbyname(socket.gethostname()) print(conn_dir.root.exposed_unregister("DBList")) print(conn_dir.root.exposed_register("DBList", my_address, 20202)) server.start()
import rpyc from prover import generate_transfer_proof class ProofService(rpyc.Service): def on_connect(self, conn): # code that runs when a connection is created # (to init the service, if needed) print('Connected to proof service!') pass def on_disconnect(self, conn): # code that runs after the connection has already closed # (to finalize the service, if needed) print('Disconnected from proof service!') pass def exposed_proof(self, txs): print('Received request for zksnark proof.') root, proof = generate_transfer_proof(txs) return proof if __name__ == "__main__": from rpyc.utils.server import ThreadedServer t = ThreadedServer(ProofService, port=18861) print("Starting rpyc proof service.") print("Listening on 0.0.0.0:18861") t.start()
def exposed_get_block_size(self): return self.__class__.block_size def exposed_get_minions(self): return self.__class__.minions def calc_num_blocks(self, size): return int(math.ceil(float(size) / self.__class__.block_size)) def exists(self, file): return file in self.__class__.file_table def alloc_blocks(self, dest, num): blocks = [] for i in range(0, num): block_uuid = uuid.uuid1() nodes_ids = random.sample(self.__class__.minions.keys(), self.__class__.replication_factor) blocks.append((block_uuid, nodes_ids)) self.__class__.file_table[dest].append((block_uuid, nodes_ids)) return blocks if __name__ == "__main__": set_conf() signal.signal(signal.SIGINT, int_handler) t = ThreadedServer(MasterService, port=2131) t.start()
def exposed_checker(self, args): print(args) if '+' in args: return add(args[0], args[2]) elif '-' in args: return sub(args[0], args[2]) elif '/' in args: print('fjslka1') conn = rpyc.connect("localhost", 12346) x = conn.root.div(args[0], args[2]) conn.close() return x elif '*' in args: conn = rpyc.connect("localhost", 12346) x = conn.root.mul(args[0], args[2]) conn.close() return x elif '**' in args: conn = rpyc.connect("localhost", 12347) x = conn.root.power(args[0], args[2]) conn.close() return x if __name__ == "__main__": server = ThreadedServer(Delegator, port=12345) print('Start delegate server') server.start() print('Stop server')
def main(): """Master Controller main function.""" server = ThreadedServer(MasterControllerService, port=5000) server.start()
import rpyc from constRPYC import * #- from rpyc.utils.server import ThreadedServer class Directory(rpyc.Service): registry={} def exposed_register(Self, server_name, ip_adress,port_number): self.registry[server_name] = (ip_adress, port_number) print(self.registry) return "Resgistration OK" def exposed_lookup(Self, server_name): print(self.registry) return self.registry[server_name] if __name__ == "__main__": server = ThreadedServer(Directory,port = DIR_PORT) server.start{}
executors = { 'default': ThreadPoolExecutor(c_pt if c_pt is not None else 10), 'processpool': ProcessPoolExecutor(c_pp if c_pp is not None else 5) } job_defaults = { 'coalesce': True if c_jc == 'True' else False, 'max_instances': False if c_jmi is not None and c_jmi == 'False' else 1000, 'misfire_grace_time': c_mgt if c_mgt is not None else 3000 #600秒的任务超时容错 } scheduler = BackgroundScheduler(executors=executors, job_defaults=job_defaults, timezone=utc) scheduler.add_jobstore(CronjobDbJobStore(), "default") scheduler.start() print(scheduler.get_jobs()) protocol_config = {'allow_public_attrs': True} c_sport = CronjobConfigModel.objects.get(key='server_port').value server = ThreadedServer( SchedulerService, port=int(c_sport) if c_sport is not None else 12345, protocol_config=protocol_config) try: server.start() except (KeyboardInterrupt, SystemExit): pass finally: scheduler.shutdown()
#!/usr/bin/env python3 import uuid import os from rpyc.utils.server import ThreadedServer from mainserverService import Mainserver if __name__ == "__main__": main_port = input("Input the port for the Mainserver: ") sub = ThreadedServer(Mainserver(), port = int(main_port), protocol_config={ 'allow_public_attrs': True, }) print("IP: localhost") print("Port: ", main_port) print("Starting main server service...") sub.start()
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Sat May 16 04:05:24 2020 @author: Alaa """ import rpyc from rpyc.utils.server import ThreadedServer class MyService(rpyc.Service): def exposed_echo(self, message): print(message) def exposed_add(self, x, y): print('Result is: {}'.format(x + y)) if __name__ == "__main__": server = ThreadedServer(MyService, port=18830) server.start()
] score = 1.0 / np.sum(means) return score x0 = [x, y, spacing, spring] args = (number, r, axis_angle) opt = fmin(roi_optimize, x0, args=args, maxiter=1000) print 'Final result ', opt return [ int(number), float(opt[0]), float(opt[1]), float(r), float(opt[2]), float(axis_angle), float(opt[3]) ] if __name__ == "__main__": print 'Starting fake camera service' #service = CameraService() CameraService.backend_init() t = ThreadedServer( CameraService, port = 18861, listener_timeout=50.0, protocol_config = {"allow_public_attrs" : True, \ "allow_pickle" : True} ) t.start() CameraService.backend_terminate()
if __name__ == "__main__": Config.initialize() if hasattr(sys, "frozen"): app = esky.Esky(sys.executable, Config.update_config["update_url"]) Config.logger.info("SPOTlight control worker %s started..." % app.active_version) app.cleanup() try: spotlight_collection = collection.Collection( Config.db_client.spotlight, "Devices") spotlight_collection.update_one( {"device_id": Config.service_config["device_id"]}, {"$set": { "control_app_version": app.active_version }}) except Exception, e: Config.handle_access_db_error(e) else: Config.logger.info("SPOTlight control worker started...") Updater.start() server = ThreadedServer( DecisionService, hostname=Config.service_config["control_service_address"], port=Config.service_config["control_service_port"], logger=Config.service_logger, authenticator=None) server.start() Config.logger.info("SPOTlight control worker shutting down...")
from components.adas.LaneKeepAssistant import LaneKeepAssistant from components.services.AbstractComponentService import AbstractComponentService class LKAService(rpyc.Service, AbstractComponentService): ALIASES = ["LaneKeepAssistant"] def on_connect(self, conn): self.lka = LaneKeepAssistant.get_instance() def on_disconnect(self, conn): self.exposed_stop() def exposed_start(self): __steer_service = rpyc.connect_by_service("STEERINGDRIVER") steer = __steer_service.root self.lka.enable_disable_driver(True, steer) self.started = True def exposed_stop(self): self.lka.enable_disable_driver(False, None) self.started = False if __name__ == "__main__": from rpyc.utils.server import ThreadedServer server = ThreadedServer(LKAService(), port=11133, auto_register=True) server.start()
# coding:utf-8 import time from rpyc.core.service import SlaveService from rpyc.utils.server import ThreadedServer # SlaveService是一种允许客户端任意的调用服务器端的模块和代码的服务 server = ThreadedServer(SlaveService, auto_register=False, hostname='localhost', port=9999) server.start()
import rpyc from server_list import * my_name = 'CalcServer' my_ip = '172.31.16.204' my_port = 4010 c = rpyc.connect("172.31.91.81", 4001) registrado = c.root.exposed_register(my_name, my_ip, my_port) if registrado: var = input("Deseja iniciar o servidor? Sim ou Não: ") if var.capitalize() == 'Sim': print('Server Startado') from rpyc.utils.server import ThreadedServer t = ThreadedServer(MyServer, port=4010, protocol_config={ 'allow_public_attrs': True, }) print("O servidor CalcServer foi iniciado e está executando") print("Aguardando conexões...") t.start() else: print("Ok!")
except PermissionError: return "Permission denied :(" except OSError: return "Couldn't read from the file" except ValueError: return "The given file name was not a string" return file_content def exposed_put_file(self, file_name, file_content): """ Let the client put a string in a file on the server :param file_name: the file's name :param file_content: the file's content :return: A status message """ try: with open(join(self.ROOT_FOLDER, file_name), "w") as file: file.write(file_content) return "The file was added successfully" except PermissionError: return "Permission denied :(" except OSError: return "Couldn't write in the file" except ValueError: return "The given file name was not a string" if __name__ == "__main__": t = ThreadedServer(RPyCServer, port=25565) t.start()
return self.data class MyClient(object): @classmethod def conn(cls): connections = rpyc.connect('localhost', 15111) connections.root.save_data(123) print connections.root.get_data() if __name__ == '__main__': import threading import time server = ThreadedServer(MyService, port=15111) client = MyClient() def start(): print '*************************************' print '*************************************' print '*****************RpyC****************' print '************ **************' print '*************************************' print '***************start server**********' print '*************************************' print '*************************************\n\n' server.start() threading.Thread(target=start).start()
print("[-] Block not found {}".format(uuid)) return None with open(data_addr) as f: return f.read() def exposed_push(self,data,storages,uuid): with open(DATA_DIR+str(uuid),'w') as f: print("[+] Writing data to {}".format(DATA_DIR+str(uuid))) f.write(data) if len(storages)>0: print("[~] Forwarding to other storages") self.forward(data,storages,uuid) def exposed_delete(self, uuid): if os.path.isfile(DATA_DIR+str(uuid)): print("[+] Removing {}".format(DATA_DIR+str(uuid))) os.remove(DATA_DIR+str(uuid)) def forward(self,data,storages,uuid): print "8888: forwarding to:" print uuid, storages storage = storages[0] storages = storages[1:] host,port = storage conn = rpyc.connect(host,port=port) storage = conn.root.Storage() storage.push(data,storages,uuid) if __name__ == "__main__": if not os.path.isdir(DATA_DIR): os.mkdir(DATA_DIR) t = ThreadedServer(StorageService, port = 8888) t.start()
import argparse import pyconfig import logging import yaml parser = argparse.ArgumentParser() parser.add_argument("--config", help="The config file to load", default="config.yaml", type=str) args = parser.parse_args() logging.basicConfig() logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) logger.info("loading config file") with open (args.config, "r") as f: config = yaml.load(f) logger.info("setting up default values") for key, value in config.items(): pyconfig.set(key, value) import service from rpyc.utils.server import ThreadedServer t = ThreadedServer(service.FreedomService, hostname = config['host'], port = config['port'], logger=logger, protocol_config = {"allow_public_attrs" : True}) t.start()
log = "file size:" + str(math.ceil( file.st_size / 1024)) + "KB\n" logging.critical("file size:" + str(math.ceil(file.st_size / 1024)) + "KB") modification_time = datetime.utcfromtimestamp( file.st_mtime + 3 * 60 * 60).strftime('%Y-%m-%d %H:%M:%S') logging.critical("Most recent content modification:" + modification_time) log += "Most recent content modification:" + modification_time return log except Exception as e: logging.error(e) logging.error("unable to connect to the chosen minion.") continue else: logging.error("File does not exist at storage servers") except: logging.error("There is no such file") return "There is no such file" if __name__ == "__main__": t = ThreadedServer(MasterService(), port=2131, protocol_config={ 'allow_public_attrs': True, }) t.start()
def setUp(self): self.server = ThreadedServer(SlaveService, port=18878, auto_register=False) self.server.logger.quiet = False self.server._start_in_thread()
class ledService(rpyc.Service): def on_connect(self, conn): # Do nothing when somebody connects pass def on_disconnect(self, conn): # Do nothing when somebody disconnects pass def exposed_blink( self, ledName, ledMode): # We expect a ledname and a blinking mode for it global ledModes ledModes[ledName.lower()] = ledMode.lower( ) # We set it globally so that our bgHandler can do the blinking logging.info("Setting led {} to {}".format(ledName, ledMode)) return True # -------------------------- Main ------------------------ if __name__ == "__main__": setupIO() runBootScript() # Start the background handler for the leds and buttons bgHandler_thread = threading.Thread(target=bgHandler) bgHandler_thread.start() # Start listening on a tcpport for commands. The commands are handled by ledService t = ThreadedServer(ledService, port=TCP_PORT) t.start()
# -*- coding;utf-8 -*- import time from rpyc import Service from rpyc.utils.server import ThreadedServer import sys class TimeService(Service): def exposed_get_time(self): return time.ctime() def exposed_get_name(self): name = 'Goun' return name def exposed_get_sys(self): return __file__ s = ThreadedServer(TimeService, port=12233, auto_register=False) s.start()