def __init__(self, port, functions, inst=None, log=False):
self.server = server.SimpleXMLRPCServer(('localhost', port),
logRequests=log)
for i in functions.keys():
self.server.register_function(functions[i], i)
if inst:
self.server.register_instance(inst)
self.server.register_introspection_functions()
def __init__(self, server_ip=server_ip, server_port=server_port):
'''
Initializes the ratServer. Starts up and listens forever.
:param server_ip: The IP of the server. Use "0.0.0.0" to listen on all ports
:param server_port: The port of the server. Default is 4000
'''
self.rat_server = server.SimpleXMLRPCServer((server_ip, server_port),
allow_none=True)
self.list_of_clients = []
def __init__(self, ip=None, port=8000):
super(RpcSvr, self).__init__()
from xmlrpc import server
if not ip:
import socket
ip = socket.gethostbyname_ex(socket.gethostname())[-1][-1]
self._svr = server.SimpleXMLRPCServer((ip, port))
self._svr.register_introspection_functions()
self._thd = None
def main():
Server = server.SimpleXMLRPCServer(("localhost", 8000))
print("Listening on port 8000...")
Server.register_function(TheUltimateNonsenseFight2017PythonVersion, 'Game')
Server.register_function(Fight, 'Fight')
Server.serve_forever()
def s8081(): try: #This is XML-RPC program. This part runs until the machine gets into trouble. server = xmlrpc_server.SimpleXMLRPCServer((My_Ip_Address(), 8081)) server.register_function(response8081) server.register_introspection_functions() server.serve_forever() except: #Since it is restarted by calling the response function, #it seems that exception handling is unnecessary.
def start(self, thread_pool=None):
self.server = SimpleXMLRPCServer.SimpleXMLRPCServer(
(self.host, self.port), allow_none=True)
self.server.register_function(self.dispatch_call)
if thread_pool is not None:
t1 = Task.FuncTask2(self.monitor_shutdown)
thread_pool.addTask(t1)
t2 = Task.FuncTask2(self.server.serve_forever, poll_interval=0.1)
thread_pool.addTask(t2)
else:
self.server.serve_forever(poll_interval=0.1)
def __init__(self):
super(ServerAgent, self).__init__()
self.posture_classifier = 'robot_pose.pkl'
self.posture = 'unknown'
self.server = SimpleXMLRPCServer.SimpleXMLRPCServer(('localhost', 8888), requestHandler=RequestHandler, allow_none=True)
self.server.register_introspection_functions()
self.server.register_multicall_functions()
self.server.register_instance(self)
self.thread = threading.Thread(target=self.server.serve_forever)
self.thread.start()
print('RPC Server is ready')
def s8080():
try:
#This is XML-RPC program. This part runs until the machine gets into trouble.
server = xmlrpc_server.SimpleXMLRPCServer((My_Ip_Address(), 8080))
server.register_function(response8080)
server.register_introspection_functions()
server.serve_forever()
except:
#It is executed when some trouble occurs
#in the machine while executing the above XML-RPC program.
print("SYSTEM FAILURE DETECTED!")
sp.run(['sudo','shutdown','now'])
def run_rpc(ip, port, obj):
# webサーバのループとasyncioのループをうまく共存させる方法がわからないため
# スレッドを立てる方法でなんとかしている。
# もっとスッキリできるといいのだが...
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.connect((ip, port))
s.close()
return False # 問題無く接続できれば（=ポートが使用中であれば）失敗を返す
except socket.error:
pass
server = xmlrpc_server.SimpleXMLRPCServer((ip, port),
allow_none=True,
logRequests=False)
server.register_instance(obj)
server.register_introspection_functions()
threading.Thread(target=server.serve_forever, daemon=True).start()
return True
def _Open(self, hostname, port):
"""Opens the RPC communication channel for clients.
Args:
hostname (str): hostname or IP address to connect to for requests.
port (int): port to connect to for requests.
Returns:
bool: True if the communication channel was successfully opened.
"""
try:
self._xmlrpc_server = SimpleXMLRPCServer.SimpleXMLRPCServer(
(hostname, port), logRequests=False, allow_none=True)
except SocketServer.socket.error as exception:
logger.warning((
'Unable to bind a RPC server on {0:s}:{1:d} with error: '
'{2!s}').format(hostname, port, exception))
return False
self._xmlrpc_server.register_function(
self._callback, self._RPC_FUNCTION_NAME)
return True
if gui: # gui mode
import ui.gui as pylot_gui
pylot_gui.main(agents, rampup, interval, duration, tc_xml_filename, log_msgs, VERSION, output_dir, test_name)
elif opt.web: # web mode
import ui.web as pylot_web
pylot_web.main(agents, rampup, interval, duration, tc_xml_filename, log_msgs,opt.web,output_dir)
elif opt.port: # xml-rpc listener mode
import xmlrpc.server as SimpleXMLRPCServer
import ui.blocking as pylot_blocking
class RemoteStarter:
def start(self):
return pylot_blocking.main(agents, rampup, interval, duration, tc_xml_filename, log_msgs, output_dir, test_name)
rs = RemoteStarter()
server = SimpleXMLRPCServer.SimpleXMLRPCServer(('localhost', port))
server.register_instance(rs)
print('Pylot - listening on port %s' %(port))
print('waiting for xml-rpc start command...\n')
server.serve_forever()
elif blocking: # blocked output mode (stdout blocked until test finishes, then result is returned)
import ui.blocking as pylot_blocking
try:
pylot_blocking.main(agents, rampup, interval, duration, tc_xml_filename, log_msgs, output_dir, test_name)
except KeyboardInterrupt:
print('\nInterrupt')
sys.exit(1)
from xmlrpc import server
def fun_add(a,b):
totle = a + b
return totle
if __name__ == '__main__':
s = server.SimpleXMLRPCServer(('0.0.0.0', 8092)) #开启xmlrpcserver
s.register_function(fun_add) #注册函数fun_add
print("server is online...")
s.serve_forever() #开启循环等待
# Register the motor power command function.
RobotMotorPower.init()
server.register_function(RobotMotorPower.set,'setRobotMotorPower')
# We define a custom server request handler, capable of both handling GET and XML-RPC requests.
class RequestHandler(SimpleXMLRPCServer.SimpleXMLRPCRequestHandler, SimpleHTTPServer.SimpleHTTPRequestHandler):
rpc_paths = ('/RobotControlService',)
def do_GET(self):
SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
# Start running the server ...
if __name__ == "__main__":
# Create our XML-RPC server.using out custom request handler that is also able to serve web pages over GET.
port = 8080
server = SimpleXMLRPCServer.SimpleXMLRPCServer(("0.0.0.0", port), RequestHandler)
# Register the XML-RPC methods ...
registerRobotXmlRpcMethods(server)
# Start to server.
server.serve_forever()
def main(argv):
parser = argparse.ArgumentParser()
parser.add_argument("--serial-port",
"-s",
help="The path to the serial port to connect to",
type=str,
nargs="?",
default=DEFAULT_SERIAL)
parser.add_argument("--port",
"-p",
help="Port for the RPC Server",
type=int,
nargs="?",
default=1411)
parser.add_argument("--audio",
"-a",
help="Should audio be played by this instance.",
action="store_true")
parser.add_argument("--no-ping", "-n", action="store_false")
parser.add_argument("--dummy-serial", "-d", action="store_true")
parser.add_argument("--no-gpio", "-g", action="store_true")
args = parser.parse_args()
if args.dummy_serial:
monkeypatch_serial()
server = xrpcserve.SimpleXMLRPCServer(("localhost", args.port),
requestHandler=RequestHandler,
allow_none=True)
server.register_introspection_functions()
if not args.no_gpio:
setup_gpio()
with TankSerial(args.serial_port) as tank:
# Handle the pinging
if args.no_ping:
ping_event = threading.Event()
def ping():
ping_event.set()
tank.ping()
server.register_function(ping)
rpc_timeout_thread = threading.Thread(target=rpc_timeout,
args=(ping_event, tank),
daemon=True)
rpc_timeout_thread.start()
else:
def ping():
pass
server.register_function(ping)
server.register_function(print)
# Register everything from the tank
server.register_instance(tank, allow_dotted_names=True)
# Run Audio
audio_handler = AudioHandler(args.audio)
server.register_function(audio_handler.play_sound)
server.serve_forever()
def server(address="121.0.0.1", port=8888):
client = xmlrpc_server.SimpleXMLRPCServer((address, port), allow_none=True)
# client.register_function(Set)
client.register_introspection_functions()
client.serve_forever()
n, pid = running_games[port]
pid.terminate()
return 1
return 0
def killGame(port):
cleanUpGames()
if port in running_games:
n, pid = running_games[port]
pid.kill()
return 1
return 0
def log(port):
if port in last_log:
return open(last_log[port], 'r').read()
return ""
with server.SimpleXMLRPCServer(("", SERVER_PORT), requestHandler=RequestHandler) as server:
server.register_introspection_functions()
server.register_function(games)
server.register_function(cleanUpGames)
server.register_function(runningGames)
server.register_function(startGame)
server.register_function(stopGame)
server.register_function(killGame)
server.register_function(log)
server.serve_forever()
def set_delay(self, sec, duration=10.0):
""" Set network delay, return with the call's result. """
self.proc = mp.Process(target=self.delay, args=(sec, duration))
self.proc.start()
return True
def remove_delay(self):
""" Remove network delay, return with the call's result. """
if self.proc is not None and self.proc.is_alive():
self.proc.terminate()
return True
if __name__ == "__main__":
if sys.platform == "win32":
handler = WinDelayHandler()
elif sys.platform == "darwin":
handler = MacDelayHandler()
else:
handler = LinuxDelayHandler()
# Fix network collapse on certain Linux distros.
subprocess.call([
"ip", "link", "set",
handler.get_interface_name(), "qlen", "1000"
])
server = rpc.SimpleXMLRPCServer(("0.0.0.0", 8000))
server.register_function(handler.set_delay, "set_delay")
server.register_function(handler.remove_delay, "remove_delay")
server.serve_forever()
def __init__(self, server_ip=server_ip, server_port=server_port):
self.rat_server = server.SimpleXMLRPCServer((server_ip, server_port),
allow_none=True)
self.list_of_clients = []
def main():
# remove node during migration.
def stop_monitoring(nodename):
with ILock("controller"):
stopped_nodes.append(nodename)
#node_exit(nodes[nodename], 'Migrated')
def set_vr1_amplitude(value):
with ILock("controller"):
global amplitude1
amplitude1 = value
def set_vr2_amplitude(value):
with ILock("controller"):
global amplitude2
amplitude2 = value
# Downlink monitors
def get_vr1tx_split1_downlink():
with ILock("controller"):
return values['vr1tx-split1']['rate0'] * 8 + values[
'vr1tx-split1']['rate1'] * 8
def get_vr1tx_split2_downlink():
with ILock("controller"):
return values['vr1tx-split2']['rate'] * 32
def get_vr1tx_split3_downlink():
with ILock("controller"):
return values['vr1tx-split3']['rate'] * 32
def get_vr2tx_downlink():
with ILock("controller"):
return values['vr2tx']['tx_iq_rate'] * 32
def get_usrp_vr1_downlink():
with ILock("controller"):
return values['usrp']['vr1_iq_txrate'] * 32
def get_usrp_vr2_downlink():
with ILock("controller"):
return values['usrp']['vr2_iq_txrate'] * 32
# Uplink monitors
def get_vr1tx_split1_uplink():
with ILock("controller"):
return values['vr1tx-split1']['iq_rxrate'] * 32
def get_vr2tx_uplink():
with ILock("controller"):
return values['vr2tx']['iq_rxrate'] * 32
def get_usrp_vr1_uplink():
with ILock("controller"):
return values['usrp']['vr1_iq_rxrate'] * 32
def get_usrp_vr2_uplink():
with ILock("controller"):
return values['usrp']['vr2_iq_rxrate'] * 32
server = xmlserver.SimpleXMLRPCServer(("127.0.0.1", 44444),
allow_none=True,
logRequests=False)
server.register_function(stop_monitoring)
server.register_function(set_vr1_amplitude)
server.register_function(set_vr2_amplitude)
server.register_function(get_vr1tx_split1_downlink)
server.register_function(get_vr1tx_split2_downlink)
server.register_function(get_vr1tx_split3_downlink)
server.register_function(get_vr2tx_downlink)
server.register_function(get_usrp_vr1_downlink)
server.register_function(get_usrp_vr2_downlink)
server.register_function(get_vr1tx_split1_uplink)
server.register_function(get_vr2tx_uplink)
server.register_function(get_usrp_vr1_uplink)
server.register_function(get_usrp_vr2_uplink)
server_thread = threading.Thread(target=server.serve_forever)
server_thread.daemon = True
server_thread.start()
# We expect two agents (tx and rx).
# Observation: we dont check if the agents connectict are in fact the ones that we want.
#while len(nodes) < len(valid_nodes):
# print('-- Nodes connected: {}/{}'.format(len(nodes), len(valid_nodes)))
# gevent.sleep(2)
while True:
with ILock("controller"):
for node in nodes.values():
if node.name not in stopped_nodes:
print("Getting info from: " + node.name)
controller.blocking(False).node(node).radio.get_parameters(
getters[node.name])
else:
values[node.name] = {k: 0.0 for k in getters[node.name]}
if node.name == 'usrp':
controller.node(nodes['usrp']).radio.set_parameters({
'amplitude1':
amplitude1,
'amplitude2':
amplitude2
})
gevent.sleep(2)