def main(): print ("init") server = SimpleXMLRPCServer(('0.0.0.0', int(SLAVE_DAEMON_PORT))) server.register_introspection_functions() server.register_instance(Node()) print ("starting server") server.serve_forever()
def main(): print("init") server = SimpleXMLRPCServer(('0.0.0.0', int(SLAVE_DAEMON_PORT))) server.register_introspection_functions() server.register_instance(Node()) print("starting server") server.serve_forever()
class Receptive_XML_RPC(Thread): def __init__(self, my_host, my_port, GUI_functions): Thread.__init__(self) self.host = my_host # server XMLRPC i = 0 while 1: try: self.server = SimpleXMLRPCServer((self.host, my_port + i)) break except: i += 1 self.port = my_port + i # functions callable by the GUI self.server.register_instance(GUI_functions) # getPort -------------------- def getPort(self): return self.port # getClass -------------------- def getClass(self, host, port): return Emissive_XML_RPC(host, port) # kill -------------------- def kill(self): # Send a message to awake it. try: url = str(self.host) + ":"+str(self.port) newServer = xmlrpclib.Server(url) newServer.isAlive() except : pass # run -------------------- def run(self): """ Receive messages from the GUI and process them""" while globalvars.ALIVE: self.server.handle_request() print "End of Xml connection..."
class servidor: """main class""" configuraciones = {'puerto':6051, 'version_cliente':0.1,'version_server':0.1} def __init__(self): #self.leer_configuraciones() #oldstderr=sys.stderr sys.stderr=file('infoserver.log', 'w') self.server = SimpleXMLRPCServer(("", self.configuraciones['puerto'])) cpu_datos = allocate_lock() cpu_datos.acquire() cpu_da = [0,0] cpu_datos.release() self.server.register_instance(sesiones(cpu_datos,cpu_da)) a = cpu_datos,cpu_da start_new_thread(cpu_funcion, a) def run(self): self.server.serve_forever()
l = conf.readlines() self.ip, self.puerto = l[0][:-1], int(l[1][:-1]) conf.close() except Exception, e: dlg = wx.MessageDialog(self,'Error al abrir archivo de configuracion: ' + str(e),'Error',wx.ICON_ERROR) try: dlg.ShowModal() finally: dlg.Destroy() self.Destroy() # inicio del servidorPozo try: s = SimpleXMLRPCServer((self.ip, self.puerto)) s.register_introspection_functions() s.register_instance(servidorPozo(self)) thread.start_new_thread(s.serve_forever, tuple()) except Exception, e: dlg = wx.MessageDialog(self,'Error al iniciar servidorPozo: ' + str(e),'Error',wx.ICON_ERROR) try: dlg.ShowModal() finally: dlg.Destroy() self.Destroy() # inicio del cliente del servidor central try: c = open("sc.conf") dirSc = c.readline()[:-1] c.close() self.cliente = clientePozoDeServidorCentral(dirSc)
def runServer(port): server = SimpleXMLRPCServer(("", port)) server.register_instance(Functions()) server.register_introspection_functions() server.register_multicall_functions() server.serve_forever()
def launch(): server = SimpleXMLRPCServer(("localhost", 8000)) server.register_instance(Test()) server.serve_forever()
def dispatchForever(x): server = SimpleXMLRPCServer((IP, PORT), allow_none=1, logRequests = False) sys.__stdout__.write( "Listening on port %s:%s...\n" % (IP,PORT) ) server.register_instance(HaStitch()) server.serve_forever()
#call the function if it is exposed if func is not None: result = func(*params) if result[0].value.has_key('value'): return result[0].value['value'].value else: raise Exception( 'Return type is not currently supported by Marionette Server' ) if __name__ == '__main__': server = SimpleXMLRPCServer(("localhost", 21777), requestHandler=SimpleXMLRPCRequestHandler, allow_none=True) server.register_introspection_functions() args = ParseArgs.ParseArgs(sys.argv) app = NescApp.NescApp(args.buildDir, args.motecom, tosbase=False, localCommOnly=True) myFunctions = MarionetteServer(app) server.register_instance(myFunctions, allow_dotted_names=True) try: server.serve_forever() finally: server.server_close()
def raises_exception(self, msg): "Always raises a RuntimeError with the message passed in" raise RuntimeError(msg) def sum(self, obj): return obj['a'] + obj['b'] def send_back_binary(self, bin): """Accepts single Binary argument, and unpacks and repacks it to return it.""" data = bin.data print('send_back_binary({!r})'.format(data)) response = Binary(data) return response if __name__ == '__main__': server = SimpleXMLRPCServer(('localhost', 9000), logRequests=True, allow_none=True) server.register_introspection_functions() server.register_multicall_functions() server.register_instance(ExampleService()) try: print('Use Control-C to exit') server.serve_forever() except KeyboardInterrupt: print('Exiting')
if match is None: raise Exception('The function called must be part of the app object') try: func = eval(method) except: raise Exception('Method %s is does not exist' % method) #call the function if it is exposed if func is not None: result = func(*params) if result[0].value.has_key('value'): return result[0].value['value'].value else: raise Exception('Return type is not currently supported by Marionette Server') if __name__ == '__main__': server = SimpleXMLRPCServer(("localhost", 21777), requestHandler=SimpleXMLRPCRequestHandler, allow_none = True) server.register_introspection_functions() args = ParseArgs.ParseArgs(sys.argv) app = NescApp.NescApp(args.buildDir, args.motecom, tosbase=False, localCommOnly=True) myFunctions = MarionetteServer(app) server.register_instance(myFunctions, allow_dotted_names = True) try: server.serve_forever() finally: server.server_close()
return -1 self.table[id] = ip print("add success") return 0 def get(self, id): if (id in self.table): return self.table[id] else: print("Nothing") def dele(self, id): if ((id in self.table) == -1): print("error") return -1 else: del self.table[id] return 0 def download_all(self): return self.table if __name__ == "__main__": port = "1234" server = Server() s = SimpleXMLRPCServer(("0.0.0.0", int(port))) print("start service...") s.register_instance(server) s.serve_forever()
class NodeCom(Thread): """ class for communication with the node """ def __init__(self, my_node): """ NodeCom initialization """ Thread.__init__(self) # connected node self.my_node = my_node #-----Step 1: create TCP socket to signal presence to the node #print "Step 1" #f = file("Debug.txt", 'a') #f.write("Step 1\n") #f.close() # connection node_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) node_socket.connect( (self.my_node.node_host, int(self.my_node.node_port)) ) # create XMLRPC server while 1: try: #self.server = SimpleXMLRPCServer( (self.my_node.my_host, self.my_node.my_port_node)) self.server = SimpleXMLRPCServer( addr=(self.my_node.my_host, self.my_node.my_port_node), logRequests=0) #print "SimpleXMLRPCServer()" #f = file("Debug.txt", 'a') #f.write("SimpleXMLRPCServer() OK\n") #f.close() break except: # may be the port is already used time.sleep(0.2) self.my_node.my_port_node = random.randint(1000,25000) #print "port for SimpleXMLRPCServer already used" #f = file("Debug.txt", 'a') #f.write("port for SimpleXMLRPCServer already used\n") #f.close() # send message msg = "openGUI;XML_RPC;"+str(self.my_node.my_host)+";"+str(self.my_node.my_port_node) node_socket.send(msg) #print "send openGUI msg" #f = file("Debug.txt", 'a') #f.write("send openGUI msg\n") #f.close() # waiting for answer answer = node_socket.recv(1024) node_socket.close() #-----Step 2: open an openGUI #print "Step 2 : [%s]" %answer #f = file("Debug.txt", 'a') #f.write("Step 2 return [" + answer+"] \n") #f.close() if answer and answer <> "refuse": # create client port_XML_GUI = string.split(answer,';')[1] host_XML_GUI = "http://" + self.my_node.node_host + ":" + port_XML_GUI self.client = xmlrpclib.Server(host_XML_GUI) #print "create xml rpc client (%s)" %host_XML_GUI #-----Step 3: open an OpenMedia #print "Step 3" # connection node_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) node_socket.connect( (self.my_node.node_host, int(self.my_node.node_port)) ) # send message msg = "openMedia;module2d_Chat;XML_RPC;"+str(self.my_node.my_host)+";"+str(self.my_node.my_port_node)+";1" node_socket.send(msg) #print "openMedia msg" # waiting for answer answer = node_socket.recv(1024) node_socket.close() #print "answer received : [%s]" %answer # ---------------------------------------- self.alive = (answer and answer <> "refuse") def run(self): # attribute CallableFunction to server functions = CallableFunction(self.my_node) self.server.register_instance(functions) while self.alive: self.server.handle_request() #print 'End of XML Server ...' # ----------------------------------------- def getInfos(self, id, var, addVar): return self.client.getInfos(id, var, addVar) def kill (self,auto = 0): self.alive = 0 my_url = 'http://%s:%s'% (self.my_node.my_host,self.my_node.my_port_node) self.myclient = xmlrpclib.Server(my_url) if auto == 1: self.myclient.Null() return 1 def kill(self): """ kill XML Server thread""" #print "connection.kill()" self.alive = 0 # send a connection message in order to block out "accept" function kill_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) i = 1 while 1: try: kill_sock.bind( (self.my_node.my_host, self.my_node.my_port_node + i) ) break except: i += 1 kill_sock.connect( (self.my_node.my_host, self.my_node.my_port_node) ) kill_sock.close() def killAllThread(self): """ kill all thread """ # kill XML Server thread self.kill()
from SimpleXMLRPCServer import SimpleXMLRPCServer from idaex import * from idaaut import * # from idc import * # from idautils import * uuts.SetLogFile("f:/tmp/tmp/RunLogS.txt") idaaut.SetErrorObjFile("f:/tmp/tmp/RunErrObjS.txt", "f:/tmp/tmp/RunConErrObjS.txt") uuts.DefGlobal = lambda : globals() def TestFn(a): print a return 1 server = SimpleXMLRPCServer(("localhost", 21111)) print "Listening on port 21111..." server.register_multicall_functions() server.register_function(TestFn) server.register_instance(Interface(True)) EnumMgr().DelAllEnums() StructsMgr().DelAllStructs() server.serve_forever()
return True except Exception, e: print "actualizarPagoMegaManager excepcion: ", e self.conexion.rollback() return False def actualizarRecargaManualMegaManager(self, idRecarga, estado): try: self.conexion.ejecutarSQL( "update creditosManualesXmaquinas set enviadoMegaManager = '%s' where id=%s" % (estado, idRecarga)) self.conexion.commit() return True except Exception, e: print "actualizarRecargaMegaManager excepcion: ", e self.conexion.rollback() return False os.chdir(os.getcwd()) # leer ip y puerto de sc.conf conf = open("sc.conf") l = conf.readlines() ip, puerto = l[0][:-1], int(l[1][:-1]) conf.close() # definicion del servidor y puesta en marcha s = SimpleXMLRPCServer((ip, puerto), allow_none=True) s.register_introspection_functions() s.register_instance(servidorCentral()) s.serve_forever()