def serve():
container_number = int(sys.argv[1])
port_number = int(sys.argv[2])
server = xmlrpc.server.SimpleXMLRPCServer(("0.0.0.0", port_number), allow_none=True)
print("Container", container_number, "Listening on port", port_number, "...")
server.register_function(Predict, "Predict")
server.serve_forever()
def handle_server(server):
print('Server RPC di 127.0.0.1 di port 6667')
server.register_function(add_pasien, "add_pasien")
server.register_function(get_pasien, "get_pasien")
server.serve_forever()
def listen(use_new_keys=False):
"""
Listens on TIMESERVER_PORT for xml-rpc calls to functions:
- get_signed_time(nonces)
"""
# Set the timeserver's signing key.
print('Loading timeserver signing key.')
timeserver.set_timeserver_key(load_timeserver_key(use_new_keys))
print('Timeserver signing key loaded.')
# Create server
server = xmlrpc.server.SimpleXMLRPCServer(
(demo.TIMESERVER_HOST, demo.TIMESERVER_PORT),
requestHandler=RequestHandler) #, allow_none=True)
#server.register_introspection_functions()
# Add a function to the Timeserver's xml-rpc interface.
# Register function that can be called via XML-RPC, allowing a Primary to
# request the time for its Secondaries.
server.register_function(timeserver.get_signed_time, 'get_signed_time')
server.register_function(timeserver.get_signed_time_ber,
'get_signed_time_ber')
print('Timeserver will now listen on port ' + str(demo.TIMESERVER_PORT))
server.serve_forever()
def listen():
"""
Listens on SECONDARY_SERVER_PORT for xml-rpc calls to functions
"""
global listener_thread
# Create server
server = xmlrpc.server.SimpleXMLRPCServer(
(demo.SECONDARY_SERVER_HOST, demo.SECONDARY_SERVER_PORT),
requestHandler=RequestHandler,
allow_none=True)
#server.register_introspection_functions()
# Register function that can be called via XML-RPC, allowing a Primary to
# send metadata and images to the Secondary.
server.register_function(secondary_ecu.receive_msg_from_primary,
'receive_msg_from_primary')
print(' Secondary will now listen on port ' +
str(demo.SECONDARY_SERVER_PORT))
if listener_thread is not None:
print('Sorry - there is already a Secondary thread listening.')
return
else:
print(' Starting Secondary Listener Thread: will now listen on port ' +
str(demo.SECONDARY_SERVER_PORT))
listener_thread = threading.Thread(target=server.serve_forever)
listener_thread.setDaemon(True)
listener_thread.start()
def serve():
container_number = int(sys.argv[1]) # first argument
port_number = int(sys.argv[2]) # second argument
server = xmlrpc.server.SimpleXMLRPCServer(("0.0.0.0", port_number))
print("Container", container_number, "Listening on port", port_number,
"...")
server.register_function(Predict, "Predict")
server.serve_forever()
def setup(host, port):
manager = Meter.Manager()
server = xmlrpc.server.SimpleXMLRPCServer((host, port),
requestHandler=RequestHandler, logRequests=False)
server.register_introspection_functions()
for method in (manager.login, manager.get_job, manager.submit_reading,
manager.get_status):
server.register_function(method)
return manager, server
def setup(host, port):
manager = Meter.Manager()
server = xmlrpc.server.SimpleXMLRPCServer((host, port),
requestHandler=RequestHandler,
logRequests=False)
server.register_introspection_functions()
for method in (manager.login, manager.get_job, manager.submit_reading,
manager.get_status):
server.register_function(method)
return manager, server
def main(port=8000, address='', quiet=False):
'if __name__ == __main__'
with Server((address, port), xmlrpc.server.SimpleXMLRPCRequestHandler,
not quiet) as server:
server.register_function(judge)
if not quiet:
print('Serving XML-RPC on', address or 'localhost', 'port', port)
try:
server.serve_forever()
except KeyboardInterrupt:
print()
if not quiet:
print("Keyboard interrupt received, exiting.")
def serve():
"""Starts a server listening for Slaves requesting or submitting work"""
def get_work_pickled(cores_max):
return tuple(map(pickle.dumps, get_work(cores_max)))
def submit_work_pickled(*args):
submit_work(*tuple(map(pickle.loads, args)))
return True
# pickling over xml over rpc, yeah
# we need to pickle because xmlrpcserver only understands few types
# Dunno if this server can serve multiple requests concurrently
server = xmlrpc.server.SimpleXMLRPCServer(("kirk.zulan.net", 8000), use_builtin_types=True)
print("Listening on port 8000...")
server.register_function(get_work_pickled, "get_work_pickled")
server.register_function(submit_work_pickled, "submit_work_pickled")
server.serve_forever()
def getsensorCO(): for i in range(0, len(sensor)): if sensor[i]["topik"] == "sensor/suhu": return json.dumps(sensor[i]) server.register_function(getAllsensor, 'getAllsensor') server.register_function(getsensorsuhu, 'getsensorsuhu') server.register_function(getsensorkelembaban, 'getsensorkelembaban') server.register_function(getsensorCO, 'getsensorCO') server.serve_forever()
def start_server():
global started
global server
if started is None:
import xmlrpc.server
import threading
server = xmlrpc.server.SimpleXMLRPCServer(('127.0.0.1', 0), allow_none=True)
server.register_function(in_main_thread(interactive.run),
'run')
host, port = server.server_address
path = server_address_file()
if not path.parent.exists():
path.parent.mkdir(parents=True)
started = host, port
write_server_address()
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
server_thread = thread
def start(self):
''' starts the network server for secure file up-/downloads '''
if not (self._args.port > 0 and self._args.port < 65536):
print("Please choose a valid port number.", file=sys.stderr)
sys.exit(1)
# create the storage directory if it does not exist
if not os.path.isdir("%s-storage" % self._path):
os.mkdir("%s-storage" % self._path)
ctx = self._makectx()
server = xmlrpc.server.SimpleXMLRPCServer(
(self._args.address, self._args.port), bind_and_activate=False)
server.socket = ctx.wrap_socket(server.socket, server_side=True)
server.server_bind()
server.server_activate()
print("Server listening on %s:%s..."
% (self._args.address, self._args.port), file=sys.stderr)
server.register_multicall_functions()
server.register_function(self.upload, "upload")
server.register_function(self.download, "download")
server.serve_forever()
def serve_forever(self):
self.register_zeroconf()
addr = ("0.0.0.0", self.port)
server = xmlrpc.server.SimpleXMLRPCServer(addr)
print("serving on", addr)
frzr = FreezerInstance()
db = FreezerDB()
server.register_function(db.read_all, "read_all")
server.register_function(db.read_albums, "read_albums")
server.register_function(frzr.zip_album)
server.register_function(frzr.search, name="search")
server.serve_forever()
try:
while True:
time.sleep(0.1)
except KeyboardInterrupt:
pass
finally:
print("\nUnregistering...")
self.close()
def listen():
"""
Listens on DIRECTOR_SERVER_PORT for xml-rpc calls to functions:
- submit_vehicle_manifest
- submit_ecu_manifest
- register_ecu_serial
Note that you must also run host() in order to serve the metadata files via
http.
"""
global director_service_thread
# Create server
server = xmlrpc.server.SimpleXMLRPCServer(
(demo.DIRECTOR_SERVER_HOST, demo.DIRECTOR_SERVER_PORT),
requestHandler=RequestHandler,
allow_none=True)
#server.register_introspection_functions()
# Register function that can be called via XML-RPC, allowing a Primary to
# submit a vehicle version manifest.
server.register_function(
director_service_instance.register_vehicle_manifest,
'submit_vehicle_manifest')
# In the longer term, this won't be exposed: it will only be reached via
# register_vehicle_manifest. For now, during development, however, this is
# exposed.
server.register_function(director_service_instance.register_ecu_manifest,
'submit_ecu_manifest')
server.register_function(director_service_instance.register_ecu_serial,
'register_ecu_serial')
if director_service_thread is not None:
print('Sorry - there is already a Director service thread listening.')
return
else:
print(' Starting Director Services Thread: will now listen on port ' +
str(demo.DIRECTOR_SERVER_PORT))
director_service_thread = threading.Thread(target=server.serve_forever)
director_service_thread.setDaemon(True)
director_service_thread.start()
else:
string2 = string2.zfill(len(string1))
place = 0
carry = 0
products = []
for val2 in reversed(string2):
curr_product = ['0' for _ in range(place)]
for val1 in reversed(string1):
product = int(val1) * int(val2) + carry
curr_product.append(str(product % 10))
carry = product // 10
curr_product.append(str(carry))
products.append(''.join(curr_product)[::-1])
place += 1
final_product = '0'
for product in products:
final_product = adder_server.network_add(final_product, product)
return final_product
if __name__ == '__main__':
server = xmlrpc.server.SimpleXMLRPCServer(("0.0.0.0", 8001),
allow_none=True)
server.register_instance(Multiplier())
server.register_function(Multiplier.network_multiply)
server.register_function(Multiplier.set_adder_server)
server.serve_forever()
def perkalian(a, b):
return (a * b)
def pembagian(a, b):
return (a / b)
def prima(a):
if a == 2:
hasil = "adalah bilangan prima"
elif a > 2:
for i in range(2, a):
if (a % i) == 0:
hasil = "bukan bilangan prima"
break
else:
hasil = "adalah bilangan prima"
else:
hasil = "bukan bilangan prima!"
return (hasil)
server.register_function(prima, 'prima')
server.register_function(pembagian, 'pembagian')
server.register_function(perkalian, 'perkalian')
server.register_function(pengurangan, 'pengurangan')
server.register_function(penjumlahan, 'penjumlahan')
server.serve_forever()
for i in data_sensor:
if(i["sensor"] == par):
temp.append(i)
json_sensor = json.dumps(temp)
return json_sensor
def handle_message(mqttc, obj, msg):
topic = msg.topic
payload = msg.payload.decode("ascii")
sensor = topic.replace("/sensor/","")
print("Sensor : ",sensor,"\t, Payload : ",payload)
data_baru = {
"sensor" : sensor,
"data" : payload
}
data_sensor.append(data_baru)
def handle_thread():
sub.on_message = handle_message
sub.loop_forever()
# register fungsinya
server.register_function(getALL, "getALL")
server.register_function(getSensor, "getSensor")
t=Thread(target=handle_thread, args=())
# Start thread baru
t.start()
# Running server RPC
server.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()
#fungsi perkalian
def perkalian(a, b):
return (a * b)
#fungsi pengecekan bilangan prima
def isPrima(a):
if a > 1:
for i in range(2, a):
temp = a % i
if temp == 0 & a == 2:
return False
else:
return True
break
i = i + 1
else:
return False
# register fungsinya
server.register_multicall_functions()
server.register_function(penjumlahan, "penjumlahan")
server.register_function(pengurangan, "pengurangan")
server.register_function(perkalian, "perkalian")
server.register_function(pembagian, "pembagian")
server.register_function(isPrima, "isPrima")
# Running server RPC
server.serve_forever()
def serve_forever(self, signals=None):
"""
\param signals which signals will cause normal exit
"""
if signals is not None:
for s in signals:
self._logger.debug("Registering %s for %s signal...", _interrupt_raiser, s)
signal.signal(s, _interrupt_raiser)
self._logger.info("Starting %d worker(s) listening on \"%s:%d\"...", self._worker_count, *self._addr)
with self._hub.context(capacity=self._capacity()):
class XMLRPCServer(xmlrpc.server.SimpleXMLRPCServer):
def __init__(self, *args, **kwargs):
super(XMLRPCServer, self).__init__(*args, **kwargs)
self.request_timeout = False
def handle_request(self):
self.request_timeout = False
super(XMLRPCServer, self).handle_request()
def handle_timeout(self):
self.request_timeout = True
server = XMLRPCServer(addr=self._addr, allow_none=True)
server.timeout = self._query_interval
server.register_function(self._add_task, name='add_task')
self._logger.debug("Starting threads...")
workers = []
for i in range(self._worker_count):
thread = threading.Thread(target=self._worker, args=(i,))
thread.start()
workers.append(thread)
self._logger.debug("%d workers were started.", self._worker_count)
self._logger.debug("Starting xmlrpc server...")
try:
self._logger.debug("Entering task handling loop...")
while True:
if not server.request_timeout:
self._logger.debug("Waiting for request...")
server.handle_request()
if not server.request_timeout:
self._logger.debug("Request was handled.")
if self._need_registration.is_set():
self._logger.debug("Registration is needed...")
try:
self._logger.debug("Trying to register machine...")
self._hub.register_machine(capacity=self._capacity())
self._logger.debug("Machine was successfully registered.")
self._need_registration.clear()
except Exception as e:
self._logger.exception("Unable to register due to %s.", e)
else:
self._logger.debug("Trying to ping...")
try:
if not self._hub.ping():
self._need_registration.set()
self._logger.debug("Pinged.")
except Exception as e:
self._logger.exception("Unable to ping due to %s.", e)
self._need_registration.set()
except (KeyboardInterrupt, _InterruptedError) as e:
self._logger.debug("Exiting.")
self._quit.set()
self._logger.debug("Joining workers...")
for worker in workers:
worker.join()
self._logger.info("Completed.")
#!/usr/bin/python
import xmlrpc.server
import sys
import os
savepath = sys.argv[1]
if not os.path.exists(savepath):
os.makedirs(savepath)
def save(data, name):
with open(os.path.join(savepath, name), "w) as DATA_PATH:
DATA_PATH.write(data)
return True
server = xmlrpc.server.SimpleXMLRPCServer(("0.0.0.0", 5000))
print("Listening on port 5000")
server.register_function(save, "save")
server.serve_forever()
# create an SSL context
self.context = ssl.SSLContext(ssl_version)
self.context.load_cert_chain(certfile=certfile, keyfile=keyfile)
xmlrpc.server.SimpleXMLRPCDispatcher.__init__(self, allow_none,
encoding)
# call TCPServer constructor
socketserver.TCPServer.__init__(self, addr, requestHandler,
bind_and_activate)
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def get_request(self):
newsocket, fromaddr = self.socket.accept()
# create a server-side SSL socket
sslsocket = self.context.wrap_socket(newsocket, server_side=True)
return sslsocket, fromaddr
def browser_function(url):
browsercmd="iexplore.exe -k "+url
#browsercmd="firefox "+url
os.system(browsercmd)
server = SecureXMLRPCServer(('localhost', 8000), 'cert.pem')
server.register_introspection_functions()
server.register_function(browser_function, 'browse')
server.serve_forever()
import xmlrpc.server
class Adder:
@staticmethod
def network_add(string1, string2):
if len(string1) <= len(string2):
string1 = string1.zfill(len(string2))
else:
string2 = string2.zfill(len(string1))
zipped = zip(reversed(string1), reversed(string2))
carry = 0
final_sum = []
for val1, val2 in zipped:
curr_sum = int(val1) + int(val2) + carry
final_sum.append(str(curr_sum % 10))
carry = curr_sum // 10
final_sum.append(str(carry))
return ''.join(final_sum)[::-1].lstrip('0')
if __name__ == '__main__':
server = xmlrpc.server.SimpleXMLRPCServer(("0.0.0.0", 8000))
server.register_instance(Adder())
server.register_function(Adder.network_add)
server.serve_forever()
# import xmlrpc
import xmlrpc.server
# inisiasi servernya
server = xmlrpc.server.SimpleXMLRPCServer(("0.0.0.0", 1409))
# Definisikan procedure/fungsi yang akan dipanggil di client
def penjumlahan(a, b):
return (a + b)
# Daftarkan fungsi yang akan dipanggil client
server.register_function(penjumlahan, 'penjumlahan')
# Jalankan server
server.serve_forever()
self.context = ssl.SSLContext(ssl_version)
self.context.load_cert_chain(certfile=certfile, keyfile=keyfile)
xmlrpc.server.SimpleXMLRPCDispatcher.__init__(self, allow_none,
encoding)
socketserver.TCPServer.__init__(self, addr, requestHandler,
bind_and_activate)
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def get_request(self):
newsocket, fromaddr = self.socket.accept()
sslsocket = self.context.wrap_socket(newsocket, server_side=True)
return sslsocket, fromaddr
def test(arg):
#print(arg)
return arg
server = SecureXMLRPCServer(('localhost', 8000), 'cert.pem')
server.register_introspection_functions()
server.register_function(pow)
server.register_function(test)
server.serve_forever()
# Import library xmlrpc
import xmlrpc.server
# Inisiasi server
server = xmlrpc.server.SimpleXMLRPCServer(("0.0.0.0", 7778))
# Definisi procedure atau fungsi
def penjumlahan(a, b):
return (a + b)
# register fungsinya
server.register_function(penjumlahan, "penjumlahan")
# Running server RPC
server.serve_forever()
def serve_forever(self):
self.register_zeroconf()
addr = ("0.0.0.0", self.port)
with xmlrpc.server.SimpleXMLRPCServer(addr,
allow_none=True,
logRequests=False) as server:
print("Listening on", addr)
server.register_function(self._get_nick, "get_nick")
server.register_function(self._update_remote_info,
"update_remote_info")
server.register_function(self._files_exist, "files_exist")
server.register_function(self._receive, "receive")
server.register_function(self._permission_needed,
"permission_needed")
server.register_function(self._get_permission, "get_permission")
server.register_function(self._prevent_overwriting,
"prevent_overwriting")
server.register_function(self._abort_transfer, "abort_transfer")
server.register_function(self._abort_request, "abort_request")
server.register_function(self._update_progress, "update_progress")
server.register_function(self._ping, "ping")
server.serve_forever()
Moving = True
move1 = abs(dm1)
if dm1 > 0:
dir1 = "a".encode('ASCII')
else:
dir1 = "c".encode('ASCII')
move2 = abs(dm2)
if dm2 > 0:
dir2 = "b".encode('ASCII')
else:
dir2 = "d".encode('ASCII')
while Moving:
print("{move1}, {move2} ".format(move1=move1, move2=move2), end="\r")
Moving = False
if move1:
ser.write(dir1)
move1 -= 1
Moving = True
ser.read()
if move2:
ser.write(dir2)
move2 -= 1
Moving = True
ser.read()
return True
server = xmlrpc.server.SimpleXMLRPCServer(("0.0.0.0", 5000))
print("Listening on port 5000")
server.register_function(move, "move")
server.serve_forever()
@author: Cid Santiago
"""
import xmlrpc.server, sys
def soma(a, b):
return a + b
def sub(a, b):
return a - b
def mult(a, b):
return a * b
def div(a, b):
return a / b
server = xmlrpc.server.SimpleXMLRPCServer(('localhost', 7890))
print('Servidor ativo na porta 7890...\n')
server.register_function(soma, 'soma')
server.register_function(sub, 'sub')
server.register_function(mult, 'mult')
server.register_function(div, 'div')
server.serve_forever()
def xmlrpc_get_object_size(serialized_file):
img_bgr = get_img_bgr(serialized_file)
return object_size.get_size(img_bgr)
def xmlrpc_is_paper_present(serialized_file):
img_bgr = get_img_bgr(serialized_file)
return paper_detection.is_paper(img_bgr)
class PersistentService:
def __init__(self):
self.x = 0
def getX(self):
self.x += 1
return self.x
with xmlrpc.server.SimpleXMLRPCServer(('localhost', PORT)) as server:
print("serving at port", PORT)
server.register_introspection_functions()
server.register_function(xmlrpc_get_object_size, "getObjectSize")
server.register_function(xmlrpc_is_paper_present, "isPaperPresent")
server.register_instance(PersistentService())
server.register_multicall_functions()
try:
server.serve_forever()
finally:
server.server_close()
__sender_done.set()
return True
def is_sender_done():
__sender_done.wait()
__sender_done.clear()
return True
def get_results():
return __results
# Register functions
server.register_function(mark_sender_ready)
server.register_function(is_receiver_ready)
server.register_function(mark_sender_done)
server.register_function(get_results)
# Convenience functions
def clear_processes():
os.system("pkill iperf")
os.system("pkill netserver")
os.system("pkill netperf")
os.system("pkill perf")
os.system("pkill sar")
def run_iperf(cpu, port, window):
data.append(data_baru)
with open('data.json', 'w') as f:
json.dump(data, f)
print("Topik : " + topic + " || Payload : " + payload)
conn.subscribe("/sensor/#")
conn.on_message = handle_message
conn.loop_forever()
def get_all():
return data
def get_sensor(jenis):
for i in range(0, len(data)):
if jenis == data[i][jenis]:
return data[i]
server.register_function(get_all, 'sensor')
server.register_function(get_sensor, 'jenis_sensor')
server.serve_forever()
while True:
sub = mqtt_client.Client()
conn = sub.connect("127.0.0.1", 1883)
t = Thread(target=handle_publisher, args=(conn, ))
t.start()
with open('DB' + str(porta) + '/' + str(name) + '.txt', "r") as handle:
data = handle.read()
return data
except FileNotFoundError as e:
return False
global porta
porta = input('Digite a porta que deseja utilizar:\n')
try:
os.mkdir("DB" + str(porta))
except:
print("Pasta já existente!:)\n")
# Recebendo informações do proxy
end_proxy = input(
"Digite o endereço do servidor proxy (http://<ip>:<porta>): ")
proxy = xmlrpc.client.ServerProxy(end_proxy)
# Registrando datanode no namenode
proxy.dnRegister(porta)
server = xmlrpc.server.SimpleXMLRPCServer(('localhost', int(porta)))
print('Datanode ' + str(porta) + ' ativo na porta ' + str(porta) + '...\n')
server.register_function(createFile, 'createFile')
server.register_function(updateFile, 'updateFile')
server.register_function(deleteFile, 'deleteFile')
server.register_function(readFile, 'readFile')
server.serve_forever()
| pygame.HWSURFACE if options.fullscreen else pygame.DOUBLEBUF)
pygame.display.set_caption("Evolving springbot")
pygame.mouse.set_visible(not options.fullscreen)
# Create server
try:
server = xmlrpc.server.SimpleXMLRPCServer(('', options.port))
except socket.error as err:
print(err)
sys.exit(1)
if options.verbose:
print("Server listening on port %d" % (options.port))
# Register functions
server.register_function(fitness_test)
server.register_function(quit)
# Starts the pygame QUIT listening thread
if SHOW_GRAPHICS:
thread = threading.Thread(target=eventListener,
name="pygame event listener")
thread.start()
draw_waiting("WAITING FOR CONNECTIONS")
# Start server
try:
server.serve_forever()
except KeyboardInterrupt:
quit()
count = float(num2)
count2 = float(num3)
except ValueError:
return "ErrType"
if str == "Круг" :
if count > 0:
c = circle(count)
return c.reckon()
else:
return "ErrZero"
if str == "Прямоугольник" :
if ((count > 0) and (count2 > 0)) :
r = rectangle(count,count2)
return r.reckon()
else :
return "ErrZero"
if str == "Квадрат" :
if count > 0:
s = square(count)
return s.reckon()
else:
return "ErrZero"
server.register_function(evaluate)
server.register_introspection_functions()
print("[Соединение с сервером успешно установлено]")
print("[Сервер в ожидании выражения]")
server.serve_forever()
def server():
server = xmlrpc.server.SimpleXMLRPCServer(("0.0.0.0", 8081))
print("start service get power on 0.0.0.0 8081...")
server.register_function(get_power, "get_power")
server.serve_forever()
def download(currentPath, name):
with open(currentPath + name, 'rb') as f:
return xmlrpc.client.Binary(f.read())
def help():
return 'ls\ncd <Ruta>\ncreate <Nombre del archivo>\nread <Nombre del archivo>\nwrite <Nombre del archivo> <Texto a escribir>\nrename <Nombre> <Nuevo nombre>\nrm <Nombre>\nmkdir <Nombre>\nrmdir <Nombre>\nupload <Ruta del archivo local>\ndownload <Nombre>'
class RequestHandler(xmlrpc.server.SimpleXMLRPCRequestHandler):
rpc_paths = ('/mis_archivos', )
with xmlrpc.server.SimpleXMLRPCServer(('192.168.1.76', 8000),
requestHandler=RequestHandler) as server:
server.register_function(create)
server.register_function(read)
server.register_function(write)
server.register_function(rename)
server.register_function(remove)
server.register_function(rmdir)
server.register_function(createdir)
server.register_function(ls)
server.register_function(cd)
server.register_function(help)
server.register_function(upload)
server.register_function(download)
server.serve_forever()
# TO-DO : Implement Print Finger Tables
def printFingerTable():
pass
if __name__ == '__main__':
nodeHost = input('Please Enter Node IP : ')
nodePort = int(input('Please Enter Port Number : '))
nodeId = input('Please Enter Node Id : ')
nodeURL = 'http://' + nodeHost + ':' + str(nodePort) + '/'
node = Node([], None, None, [], nodeURL, nodeId)
server = SimpleXMLRPCServer((nodeHost, nodePort))
server.register_function(join, 'join')
server.register_function(join_done, 'join_done')
listener = threading.Thread(target=server.serve_forever)
listener.start()
# if nodeId == 'node-0' :
# server.register_function(join,'join')
# server.register_function(join_done,'join_done')
# server.serve_forever()
if nodeId != 'node-0':
targetURL = input('Please enter target URL : ')
with xmlrpc.client.ServerProxy(targetURL) as proxy:
node.unwrap(proxy.join(nodeURL))
print('Successor of Node ', nodeId, ': ', node.successor)
print('Predecessor of Node ', nodeId, ': ', node.successor)
