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()
