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 run(self):
se = SimpleXMLRPCServer(
(shared.config.get('bitmessagesettings', 'apiinterface'),
shared.config.getint('bitmessagesettings', 'apiport')),
MySimpleXMLRPCRequestHandler, True, True)
se.register_introspection_functions()
se.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 Network(object):
def __init__(self, config,log):
self.log = log
xmlport = config.getValue("xmlport")
xmlhost = config.getValue("xmlhost")
udpport = config.getValue("udpport")
udphost = config.getValue("udphost")
self.xml = SimpleXMLRPCServer((xmlhost, xmlport))
self.udp = netServer(udphost,udpport,log)
log.StartupMessage("* Attempting to start XML-RPC Server")
self.udp.serve_forever()
self.xmlThread = Thread( target = self.startXMLRPCServer )
self.xmlThread.setDaemon( True )
self.xmlThread.start()
log.StartupMessage( " XML-RPC Server is up at port %d" % xmlport)
def register_function(self,func,funcname):
self.xml.register_function(func,funcname)
self.udp.register_function(func,funcname)
self.log.Notice("Registered funtion %s for network access" % funcname)
def stopServices(self):
self.udp.stopServer()
self.udp.join()
self.log.StartupMessage("* Attempting to stop XML-RPC Server")
self.xml.server_close()
#self.xmlThread.join()
def startXMLRPCServer(self):
self.xml.serve_forever()
def main():
try:
opts, args = getopt.getopt(sys.argv[1:], "hs:p:", ["help"])
serv = "localhost"
port = 8088
for opt, val in opts:
if opt in ("-h", "--help"):
usage()
sys.exit(0)
elif opt == "-s":
serv = val
elif opt == "-p":
port = int(val)
server = SimpleXMLRPCServer((serv, port), RequestHandler, True, True)
server.register_introspection_functions()
server.serve_forever()
except getopt.GetoptError as err:
print str(err)
usage()
sys.exit(1)
except ValueError:
usage()
sys.exit(1)
except KeyboardInterrupt:
sys.exit(0)
class ServerThread( threading.Thread ) :
def __init__( self, case ) :
self.case = case
threading.Thread.__init__( self )
print "starting local Ophidian server..."
self.ProblemServer = ophidian.ProblemServer()
self.ProblemServer.RunDir = 'RunDir'
# check the run directory for cached problems
self.ProblemServer.InitProblemList()
# load the first problem, if it exists, exit otherwise
if self.ProblemServer.ProblemList.__contains__(case) :
self.ProblemServer.ProblemList = [case]
print "Loading CUBE data for problem " + case
self.ProblemServer.LoadProblem( case )
print "Starting server..."
self.server = SimpleXMLRPCServer(('127.0.0.1', 8000 ))
self.server.register_function(self.ProblemServer.GetProblem)
self.server.register_function(self.ProblemServer.GetBlock)
self.server.register_function(self.ProblemServer.CheckInBlock)
else :
print "No problems found. Ophidian server shutting down."
def run( self ) :
print "Now serving problem " + self.ProblemServer.Problem.problemname
self.server.serve_forever()
def run(self):
class RequestHandler(SimpleXMLRPCRequestHandler):
rpc_paths = ('/RPC2',)
#create a server
server = SimpleXMLRPCServer(("localhost",8045),requestHandler = RequestHandler)
server.register_introspection_functions()
def transmit_orbited(channel, message):
"""
@param channel: The stomp channel to send to
@param message: The message that needs to be transmitted
"""
self.orbited.send_data(channel, message)
return ""
server.register_function(transmit_orbited, 'transmit')
server.serve_forever()
def run(self):
class RequestHandler(SimpleXMLRPCRequestHandler):
rpc_paths = ('/RPC2', )
#create a server
server = SimpleXMLRPCServer(("localhost", 8045),
requestHandler=RequestHandler)
server.register_introspection_functions()
def transmit_orbited(channel, message):
"""
@param channel: The stomp channel to send to
@param message: The message that needs to be transmitted
"""
self.orbited.send_data(channel, message)
return ""
server.register_function(transmit_orbited, 'transmit')
server.serve_forever()
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()
class RPCServer(Thread) :
def __init__(self) :
Thread.__init__(self)
self.n = 0
self.uniqueRequests = []
self.numDoneSent = 0
self.server = SimpleXMLRPCServer(("0.0.0.0", port))
self.server.register_function(self.nextInput, "nextInput")
self.lock = Lock()
def nextInput(self, ip) :
self.lock.acquire()
if self.uniqueRequests.count(ip) == 0 : self.uniqueRequests.append(ip)
if self.n >= len(input_files) :
self.numDoneSent += 1
if self.numDoneSent >= len(self.uniqueRequests) : shutdown(1)
self.lock.release()
return -1
rtn = self.n
self.n += 1
self.lock.release()
return rtn
def run(self) :
self.server.serve_forever()
def getId():
if cursor.execute("SELECT * FROM Notes").fetchall():
id = cursor.execute("SELECT Id FROM Notes").fetchall()[-1][0] + 1
return id
return 0
def update( searchBy, valueToSearch, changeWhich, newValue):
cursor.execute("UPDATE Notes set {} = ? where {} = ?".format(searchBy, changeWhich),
(newValue, valueToSearch,))
cursor.execute("UPDATE Notes set Date = ? where {} = ?".format(changeWhich),
(datetime.datetime.now(), valueToSearch,))
connection.commit()
return True
def add( name, id, tel, mail):
cursor.execute("INSERT INTO Notes VALUES(?,?,?,?,?)", (id, name, tel, mail, datetime.datetime.now(),))
connection.commit()
return True
server = SimpleXMLRPCServer(("localhost", 8002))
server.register_function(get_all)
server.register_function(search)
server.register_function(delete)
server.register_function(reset)
server.register_function(getId)
server.register_function(update)
server.register_function(add)
server.serve_forever()
def run(self):
se = SimpleXMLRPCServer((shared.config.get('bitmessagesettings', 'apiinterface'), shared.config.getint(
'bitmessagesettings', 'apiport')), MySimpleXMLRPCRequestHandler, True, True)
se.register_introspection_functions()
se.serve_forever()
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()
'''
_logger.error('StatusCollector has died. Exiting program.')
# Stop the XML-RPC server to exit serve_forever
global stopping
stopping = True
serverXMLRPC.server_close()
# Instantiate the StatusCollector and start the XML-RPC server
try:
# Create our StatusCollector which talks to the Spectracom
collector = StatusCollector('timeserver', '/data/hcr/spectracom_log',
onStatusCollectorFailure)
# The main thread is devoted to just running the XML-RPC server. This
# will finish when a SIGINT is received (i.e., via ^C) or a SIGTERM
# is received (e.g., via a 'kill' command).
serverXMLRPC.serve_forever()
except socket.error as e:
# Ignore socket.error if we're stopping the server, otherwise
# complain and exit
if (not stopping):
_logger.error('Exiting on XML-RPC server socket error: %s' % (e))
serverXMLRPC.server_close()
# Perform a clean shutdown of the XML-RPC server
serverXMLRPC.shutdown()
# Unregister with procmap
procmapUnregister()
_logger.info('Finished ' + time.asctime())
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()
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()
