if imie == str(osoba).split()[0]: wyszukane_kontakty += self.wypisz_kontakt(osoba) if wyszukane_kontakty != '': return wyszukane_kontakty else: return 'Nie ma takiego kontaktu' if imie == '' and nazwisko != '': # po nazwisku wyszukane_kontakty = '' for osoba in self.kontakty: if nazwisko == str(osoba).split()[1]: wyszukane_kontakty += self.wypisz_kontakt(osoba) if wyszukane_kontakty != '': return wyszukane_kontakty else: return 'Nie ma takiego kontaktu' return '' if __name__ == "__main__": server = SimpleXMLRPCServer(("localhost", 8888)) kontakty_serwer = KontaktySerwer() server.register_function(kontakty_serwer.wypisz_liste) server.register_function(kontakty_serwer.dodaj_kontakt) server.register_function(kontakty_serwer.usun_kontakt) server.register_function(kontakty_serwer.wyszukaj_kontakt) server.serve_forever()
from xmlrpc.server import SimpleXMLRPCServer def sub(n1, n2): return n1 - n2 server = SimpleXMLRPCServer(("localhost", 8002)) print("Listening on port 8002...") server.register_function(sub, "sub") server.serve_forever()
if len(sys.argv) != 2: # sys.argv[0] exe file itself port = 5011 else: port = int(sys.argv[1]) if my_config.debug_mode: ''' import time img_file_source = '/tmp1/00ed40ec-681c-42c3-afca-ca906ff11ecb.1.jpg' for i in range(3): # about one second in 171 server print('start:', time.time()) confidence, img_file_mask_tmp, img_file_crop_optic_disc, img_file_draw_circle = \ detect_optic_disc_mask(img_file_source, True) print('end:', time.time()) ''' img_file_source = '/media/ubuntu/data2/posterior_2020_4_27/add_posterior/original/0aac4dc7cd8eccc36b4396ad8ff65bfd1604f675#0f6c2bdb-0490-4714-879b-4ab1a33db917.13.jpg' img_file_blood_vessel_seg = '/media/ubuntu/data2/posterior_2020_4_27/add_posterior/blood_vessel_seg_result1/0aac4dc7cd8eccc36b4396ad8ff65bfd1604f675#0f6c2bdb-0490-4714-879b-4ab1a33db917.13.jpg' confidence, img_file_mask_tmp, img_file_crop_optic_disc, img_file_draw_circle, img_file_blood_vessel_seg_posterior = \ detect_optic_disc(img_file_source, True, img_file_blood_vessel_seg) server = SimpleXMLRPCServer(("localhost", port)) print("Listening on port: ", str(port)) server.register_function(detect_optic_disc, "detect_optic_disc") server.serve_forever() print('OK')
from xmlrpc.server import SimpleXMLRPCServer import xmlrpc.client def file_upload(filedata): # initialize 'file_upload' function in server with open("uploaded_file_ftp.txt",'wb') as handle: data1=filedata.data #convert from byte to binary IMPORTANT! handle.write(data1) handle.close() return True #IMPORTANT # must have return value # else error messsage: "cannot marshal None unless allow_none is enabled" def file_download(): # create a function 'file_download' handle = open("ZeroMQ-4.0.4_miru1.0-x64.exe",'rb') # initialize the handle with ZeroMQ, read binary return xmlrpc.client.Binary(handle.read()) # give the output in binary form that can be read by client handle.close() server = SimpleXMLRPCServer(('192.168.1.8',8000)) # initialize the network and port print ("Listening on port 8000") # the output when the server is running server.register_function(file_upload,'file_upload') # registered the file_download function with new initialize 'download' server.register_function(file_download,'download') # registered the file_download function with new initialize 'download' server.serve_forever() # server will run forever, until we interrupt it
simple_server.register_function(getattr(self, func_name), func_name) @add_handle def get_string(self, str_just_test): return "get is :%s" % str_just_test def pack_response(self, *args, **kwargs): ret_obj = {'isok': True} ret_obj.update(kwargs) return json.dumps(ret_obj) def unpack_request(self, req_str): return json.loads(req_str) @add_handle def cmd(self, request): req = self.unpack_request(request) cmd_str = req['cmd_str'] cmd_list = cmd_str.split(' ', 1) command = cmd_list[0] args = cmd_list[1] if len(cmd_list) > 1 else '' resp_str = self._cmd(command, args) return self.pack_response(result=resp_str) if __name__ == '__main__': s = SimpleXMLRPCServer(('0.0.0.0', 8080)) _is = IstaServer(s) s.serve_forever()
from xmlrpc.server import SimpleXMLRPCServer from xmlrpc.server import SimpleXMLRPCRequestHandler # Restrict to a particular path. class RequestHandler(SimpleXMLRPCRequestHandler): rpc_paths = ('/RPC2', ) # Create server with SimpleXMLRPCServer(('localhost', 8000), requestHandler=RequestHandler) as server: server.register_introspection_functions() # Register pow() function; this will use the value of # pow.__name__ as the name, which is just 'pow'. server.register_function(pow) # Register a function under a different name def adder_function(x, y): return x + y server.register_function(adder_function, 'add') # Register an instance; all the methods of the instance are # published as XML-RPC methods (in this case, just 'mul'). class MyFuncs: def mul(self, x, y): return x * y server.register_instance(MyFuncs())
def file_upload(filedata): # buka file with open("hasil_upload.txt", 'wb') as handle: # convert from byte to binary IMPORTANT! data1 = filedata.data # tulis file tersebut handle.write(data1) return True # IMPORTANT # must have return value # else error messsage: "cannot marshal None unless allow_none is enabled" # buat server server = SimpleXMLRPCServer(('127.0.0.1', 5003)) # buat server serta register fungsi register_introspection_functions() # with SimpleXMLRPCServer(("127.0.0.1", 5003), requestHandler=RequestHandler) as server: # server.register_introspection_functions() # tulis pesan server telah berjalan print("Listening on port 5003") # register fungsi server.register_function(file_upload, 'file') # jalankan server server.serve_forever()
# simple xmlrpc server. serving content of a directory from xmlrpc.server import SimpleXMLRPCServer import logging import os logging.basicConfig(level=logging.INFO) server = SimpleXMLRPCServer( ('localhost', 5678), logRequests=True, ) def listdir(dir_name): # dir_name absolute/relative path logging.info("list content of dir: {}".format(dir_name)) try: return os.listdir(dir_name) except OSError: return "no such file or directory!" # the client must access via "dir()" instead of "listdir()" # server.register_function(listdir, 'dir') # namespace is allowed server.register_function(listdir, 'dir.list') try: server.serve_forever() except KeyboardInterrupt: print("exit...")
from xmlrpc.server import SimpleXMLRPCServer import datetime, socket, random, array #xmlrpclib, # Create server server = SimpleXMLRPCServer(("localhost", 8888), allow_none=True) # Register an instance; all the methods of the instance are # published as XML-RPC methods class MyFuncs: def add(self, x, y): return x + y def addOneDay(self, now): now = datetime.datetime.strptime(str(now), "%Y%m%dT%H:%M:%S") return now + datetime.timedelta(1) def getHostName(self, android): host = socket.gethostname() return "android: " + android + "\nhost: " + host def testStruct(self, inMap): city = inMap["City"] map = {"City": city, "Temperature": 24} return map def testArray(self, inArray): sum = 0 for i in inArray:
# -*- coding: utf-8 -*- from xmlrpc.server import SimpleXMLRPCServer from xmlrpc.server import SimpleXMLRPCRequestHandler import sqlite3 import datetime connection = sqlite3.connect('microblog2.db') # Conexao do banco de dados cursor = connection.cursor() # Cursor para executar queries # Permite varios usuarios class RequestHandler(SimpleXMLRPCRequestHandler): rpc_paths = ('/RPC2',) # Cria o Elemento Servidor server = SimpleXMLRPCServer(("localhost", 8592), requestHandler=RequestHandler) server.register_introspection_functions() # Id para os posts idpost = 0 # Cria tabela Topico try: cursor.execute("CREATE TABLE topico (username varchar(50) PRIMARY KEY, sod int, cc int, cd int)") except: cursor.execute("DROP TABLE topico") # dropa a tabela caso ela ja exista cursor.execute("CREATE TABLE topico (username varchar(50) PRIMARY KEY, sod int, cc int, cd int)") # Cria tabela Post try: cursor.execute("CREATE TABLE post (username varchar(50) PRIMARY KEY, sod int, cc int, cd int)")
from xmlrpc.server import SimpleXMLRPCServer class funciones_remota: def suma(self, x, y): return x + y def resta(self, x, y): return x - y def multi(self, x, y): return x * y def div(self, x, y): return x / y def pot(self, x, y): return x**y server = SimpleXMLRPCServer(("192.168.8.180", 8001)) server.register_instance(funciones_remota(), "funciones") print("Hola amigos, soy el servidor y estoy corriendo por el puerto 8001") server.serve_forever()
#!/usr/bin/env python3 # encoding: utf-8 # # Copyright (c) 2008 Doug Hellmann All rights reserved. # """ """ #end_pymotw_header from xmlrpc.server import SimpleXMLRPCServer import os server = SimpleXMLRPCServer(('localhost', 9000)) def list_contents(dir_name): "Expose a function with an alternate name" return os.listdir(dir_name) server.register_function(list_contents, 'dir') try: print('Use Control-C to exit') server.serve_forever() except KeyboardInterrupt: print('Exiting')
from xmlrpc.server import SimpleXMLRPCServer import xmlrpc.client import paho.mqtt.client as mqtt ip = "127.0.0.1" mqttPort = 1883 rpcPort = 8889 topikPub = "/status/1" opStatus = "" server = SimpleXMLRPCServer((ip, rpcPort), allow_none=True) clientMqtt = mqtt.Client(client_id="pub1", clean_session=False) def status(pulsa): if pulsa == "sukses": opStatus = "Transaksi berhasil" else: opStatus = "Transaksi gagal" print("Connect to ", ip) clientMqtt.connect(ip, port=mqttPort) print("Publish to ", topikPub) clientMqtt.loop_start() clientMqtt.publish(topikPub, payload=opStatus, qos=2) clientMqtt.loop_stop() server.register_function(status, "status") server.serve_forever()
#!/usr/bin/env python # -*- coding: utf-8 -*- from xmlrpc.server import SimpleXMLRPCServer import torchani import torch print("Starting TorchANI XML-RPC server ...") address = ('localhost', 50000) server = SimpleXMLRPCServer(address) class TorchANI(object): """Provide the TorchANI calculation functions""" def __init__(self): if torch.cuda.is_available(): self.device = torch.device("cuda") else: self.device = torch.device("cpu") self.model = torchani.models.ANI2x(periodic_table_index=True).to( self.device) def calc(self, s, c, update_forces=False, model_index=3): coordinates = torch.tensor([c], requires_grad=True, device=self.device).float() species = torch.tensor([s], device=self.device) m1 = self.model.species_converter((species, coordinates)) m2 = self.model.aev_computer(m1) m3 = self.model.neural_networks[model_index](m2)[1] if update_forces:
#endregion # region test code if my_config.debug_mode: img_source = '/tmp1/img4.jpg' if os.path.exists(img_source): filename_CAM1 = server_cam(0, img_source, pred=1, cam_relu=True, preprocess=True, blend_original_image=True) # filename_CAM1 = server_cam(1, img_source, pred=1) # filename_CAM1 = server_grad_cam(0, img_source, pred=1) # filename_CAM1 = server_gradcam_plusplus(0, img_source, pred=1) print(filename_CAM1) #endregion #region start service # server = SimpleXMLRPCServer(("localhost", port)) server = SimpleXMLRPCServer(("0.0.0.0", port)) print("Listening on port: ", str(port)) server.register_function(server_cam, "server_cam") server.register_function(server_gradcam_plusplus, "server_gradcam_plusplus") server.serve_forever() #endregion
def __init__(self, ip="localhost", puerto=5500, tipo="main"): #Server Control self.server = SimpleXMLRPCServer((ip, puerto), requestHandler=RequestHandler, allow_none=True) self.server.register_introspection_functions() self.ip = ip self.puerto = puerto self.tipo = tipo self.servers = {} self.filesPermission = {} self.filesBusy = {} self.filesList = [] #Tkinter self.root = tkinter.Tk() self.root.wm_title("archivos - " + tipo) scrollbar = tkinter.Scrollbar(self.root, orient=tkinter.VERTICAL) self.TextoBox = tkinter.Text(self.root, height=8, width=80, yscrollcommand=scrollbar.set) self.TextoBox2 = tkinter.Text(self.root, height=8, width=80, yscrollcommand=scrollbar.set) scrollbar.config(command=self.yview) scrollbar.pack(side=tkinter.RIGHT, fill=tkinter.Y) self.TextoBox.pack(side=tkinter.LEFT, fill=tkinter.Y) self.TextoBox.config(state=tkinter.DISABLED) self.TextoBox2.pack(side=tkinter.LEFT, fill=tkinter.Y) self.TextoBox2.config(state=tkinter.DISABLED) frame = tkinter.Frame(self.root) frame.pack() self.list = tkinter.Listbox(self.root, selectmode=tkinter.SINGLE, yscrollcommand=scrollbar.set) self.list.pack(fill=tkinter.BOTH, expand=1) self.buttonShowFile = tkinter.Button(frame, text='Show File', command=self.showInfo) self.buttonShowFile.grid(row=2, columnspan=1) self.buttonShowBusy = tkinter.Button(frame, text='Select Busy Files', command=self.showBusy) self.buttonShowBusy.grid(row=3, columnspan=1) self.buttonUpdate = tkinter.Button(frame, text='Update Files', command=self.updateFilesAll) self.buttonUpdate.grid(row=4, columnspan=1) self.buttonCancel = tkinter.Button(frame, text='Cancel', command=self.cancelAction) self.buttonCancel.grid(row=5, columnspan=1) self.buttonShowBusy.config(state=tkinter.DISABLED) tkinter.Label(frame, text='Estado').grid(row=1, column=0) self.answer = tkinter.StringVar() self.answer.set("Ready") tkinter.Label(frame, textvariable=self.answer).grid(row=1, column=1)
self.keyframes=keyframes self.start_time=0 times=keyframes[1] t=0 for i in range(len(times)): tmp=max(times[i]) if(tmp>t): t=tmp time.sleep(t+1) def get_transform(self, name): '''get transform with given name''' return self.transforms[name].tolist() def set_transform(self, effector_name, transform): '''solve the inverse kinematics and control joints use the results ''' self.set_transforms(effector_name, np.asmatrix(transform)) if __name__ == '__main__': agent = ServerAgent() server = SimpleXMLRPCServer(('127.0.0.1', 9000), logRequests=True, allow_none=True) server.register_function(pow) server.register_instance(agent) server_thread = threading.Thread(target=server.serve_forever) server_thread.start() agent.run()
def _start(self): """ 供内部用来启动XML-RPC服务器 """ s = SimpleXMLRPCServer(("", get_port(self.url)), logRequests=False) s.register_instance(self) s.serve_forever()
def __init__(self, address): self._data = {} self._serv = SimpleXMLRPCServer(address, allow_none=True) for name in self._rpc_methods_: self._serv.register_function(getattr(self, name))
from xmlrpc.server import SimpleXMLRPCServer def add(x, y): return x + y serv = SimpleXMLRPCServer(('', 15000)) serv.register_function(add) serv.serve_forever()
# gunakan xmlrpc bagian server # import SimpleXMLRPCServer dan SimpleXMLRPCRequestHandler from xmlrpc.server import SimpleXMLRPCServer from xmlrpc.server import SimpleXMLRPCRequestHandler # buat kelas requesthandler from com.frogobox.config import * class RequestHandler(SimpleXMLRPCRequestHandler): # batasi pada path /RPC2 saja rpc_paths = (BASE_CONFIG_PATH) # buat server serta register fungsi register_introspection_functions() rpcServer = SimpleXMLRPCServer((BASE_CONFIG_IP_ADDRESS, BASE_CONFIG_PORT), requestHandler=RequestHandler) rpcServer.register_introspection_functions() # Buatlah fungsi kalkulasi dasar (tambah, kurang, kali, bagi, pangkat), # anda dapat memilih ataupun menggunakan ketiga cara berikut: # cara 1 untuk memasukkan fungsi dalam rpcServer adalah dengan langsung memasukkan namanya # fungsi pow() merupakan fungsi build in pada pyhton, tinggal dipanggil saja # cara 2 untuk register fungsi: buat fungsinya kemudian register # a. buat fungsi def plusMath(number1, number2): return number1 + number2 def minusMath(number1, number2):
def init_reducer(address, port, reducer_num): print("Reducer {} ready!".format(reducer_num)) server = SimpleXMLRPCServer((address, port), allow_none=True) server.register_function(get_map_wordcount, "get_map_wordcount") server.register_function(get_map_inverted_index, "get_map_inverted_index") server.serve_forever()
from xmlrpc.server import SimpleXMLRPCServer from xmlrpc.server import SimpleXMLRPCRequestHandler class RequestHandler(SimpleXMLRPCRequestHandler): rpc_paths = ('/RPC2', ) with SimpleXMLRPCServer(('0.0.0.0', 12345), requestHandler=RequestHandler) as server: server.register_introspection_functions() server.register_function(pow) @server.register_function(name='somma') def adder_function(x, y): return x + y @server.register_function def multiply(x, y): return x * y print('Server UP, in ascolto sul porto 12345 ...') server.serve_forever()
#!/usr/local/bin/python import time import subprocess from xmlrpc.server import SimpleXMLRPCServer def is_even(n): return n % 2 == 0 def spike_cpu(duration_seconds): subprocess.run(["dd", "if=/dev/zero", "of=/dev/null"]) time.sleep(duration_seconds) return duration_seconds server = SimpleXMLRPCServer(("0.0.0.0", 80)) print("Listening on port 80...") server.register_function(is_even, "is_even") server.register_function(spike_cpu, "spike_cpu") print("Press CTRL+C to end ..") server.serve_forever()
def getMasterIpAddress(): return socket.gethostbyname(socket.gethostname()) def registerIP(ip_address): with open("botnet_list.txt", "a") as file: file.write(ip_address + "\n") def unregisterIP(ip_address): ip_list = [] with open("botnet_list.txt", "r") as file: ip_list = file.readlines() ip_list = [x.strip() for x in ip_list] ip_list.remove(ip_address) with open("botnet_list.txt", "w") as file: for ip in ip_list: file.write(ip + "\n") if __name__ == '__main__': server = SimpleXMLRPCServer((getMasterIpAddress(), 8000), requestHandler=RequestHandler, allow_none=True) server.register_introspection_functions() server.register_function(registerIP, "register_ip") server.register_function(unregisterIP, "unregister_ip") server.serve_forever()
level=logging.DEBUG) console = logging.StreamHandler() console.setLevel(logging.INFO) logging.getLogger('').addHandler(console) hostname = socket.gethostname() IpAddress = socket.gethostbyname(hostname) # Restrict to a particular path. class RequestHandler(SimpleXMLRPCRequestHandler): rpc_paths = ('/RPC2', ) # Create server with SimpleXMLRPCServer((IpAddress, 8000), requestHandler=RequestHandler) as server: server.register_introspection_functions() class Server: def __init__(self): self.userId = '' self.userPass = '' self.mysqlHost = 'localhost' self.mysqlUser = '******' self.mysqlPass = '******' pass def do_register(self, userid, userpass): ret = '' self.userId = userid self.userPass = userpass
if __name__ == '__main__': from threading import Thread import socket socket.setdefaulttimeout(10) try: from xmlrpc.server import SimpleXMLRPCServer except ImportError: from SimpleXMLRPCServer import SimpleXMLRPCServer IP = '127.0.0.1' PORT = int(sys.argv[1]) server = SimpleXMLRPCServer((IP, PORT), allow_none=True) server.register_function(get_modules_search_paths, 'getModulesSearchPaths') server.register_function(get_module_path, 'getModulePath') server.register_function(get_classes_from_module, 'getClassesFromModule') server.register_function(get_variables, 'getVariables') server.register_function(get_global_variables, 'getGlobalVariables') server.register_function(get_standard_libraries_names, 'getStandardLibrariesNames') server.register_function(get_standard_library_path, 'getStandardLibraryPath') server.register_function(get_site_packages_libraries_names, 'getSitePackagesLibrariesNames') server.register_function(get_robot_version, 'getRobotVersion') server.register_function(start_library_auto_discovering, 'startLibraryAutoDiscovering') server.register_function(start_keyword_auto_discovering,
import sys from instrucciones import * from xmlrpc.server import SimpleXMLRPCServer from xmlrpc.server import SimpleXMLRPCRequestHandler HOST=sys.argv[1]; PORT=int(sys.argv[2]) class RequestHandler(SimpleXMLRPCRequestHandler): # Escucha a todos los solicitantes http rpc_paths = ('/RPC2',) # Ruta principal # Crea el servidor RPC with SimpleXMLRPCServer((HOST,PORT),requestHandler=RequestHandler) as server: print("Servidor a la escucha") server.register_introspection_functions() server.register_instance(Instrucciones()) # La clase se registra con todos sus metodos de forma xml server.serve_forever()
def __init__(self, host="localhost", port=8000): threading.Thread.__init__(self) self.host = host self.port = port self.localServer = SimpleXMLRPCServer((self.host, self.port), allow_none=True)
def __init__(self, local=LOCAL, localport=LOCALPORT, remotes=REMOTES, devicefile=DEVICEFILE, interface_id=INTERFACE_ID, eventcallback=False, systemcallback=False, resolveparamsets=False): LOG.debug("ServerThread.__init__") threading.Thread.__init__(self) # Member self._interface_id = interface_id self._local = local self._localport = int(localport) self._devicefile = devicefile self.remotes = remotes self.eventcallback = eventcallback self.systemcallback = systemcallback self.resolveparamsets = resolveparamsets self.proxies = {} # Create proxies to interact with CCU / Homegear LOG.debug("__init__: Creating proxies") for remote, host in self.remotes.items(): # Initialize XML-RPC try: socket.inet_pton(socket.AF_INET, host['ip']) except Exception as err: LOG.warning("Skipping proxy: %s" % str(err)) continue if 'path' not in host: host['path'] = "" LOG.info("Creating proxy %s. Connecting to http://%s:%i%s" % (remote, host['ip'], host['port'], host['path'])) host['id'] = "%s-%s" % (self._interface_id, remote) try: self.proxies[host['id']] = LockingServerProxy( "http://%s:%i%s" % (host['ip'], host['port'], host['path']), callbackip=host.get('callbackip', None), callbackport=host.get('callbackport', None), skipinit=not host.get('connect', True)) except Exception as err: LOG.warning("Failed connecting to proxy at http://%s:%i%s" % (host['ip'], host['port'], host['path'])) LOG.debug("__init__: Exception: %s" % str(err)) raise Exception try: host['type'] = BACKEND_UNKNOWN #if "Homegear" in self.proxies[host['id']].getVersion(): # LOG.debug("__init__: Host is Homegear") # host['type'] = BACKEND_HOMEGEAR #else: # LOG.debug("__init__: Host is CCU") # host['type'] = BACKEND_CCU except Exception as err: LOG.warning("__init__: Failed to detect backend type: %s" % str(err)) host['type'] = BACKEND_UNKNOWN if not self.proxies: LOG.warning("No proxies available. Aborting.") raise Exception self._rpcfunctions = RPCFunctions( devicefile=self._devicefile, proxies=self.proxies, remotes=self.remotes, eventcallback=self.eventcallback, systemcallback=self.systemcallback, resolveparamsets=self.resolveparamsets) # Setup server to handle requests from CCU / Homegear LOG.debug("ServerThread.__init__: Setting up server") self.server = SimpleXMLRPCServer((self._local, self._localport), requestHandler=RequestHandler, logRequests=False) self._localport = self.server.socket.getsockname()[1] self.server.register_introspection_functions() self.server.register_multicall_functions() LOG.debug("ServerThread.__init__: Registering RPC functions") self.server.register_instance(self._rpcfunctions, allow_dotted_names=True)