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()
def launch():
server = SimpleXMLRPCServer(("localhost", 8000))
server.register_instance(Test())
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()
