def __init__(self, soapPort, soapProxy, espmlFile): """ Initialize the SOAP system server and add the functions it supports to it. """ self._server = SOAPpy.SOAPServer(("", soapPort)) self._server.registerFunction(self.execute) self._registry = SOAPpy.SOAPProxy(soapProxy) self._registerSystem(espmlFile)
def run(self): dem = demote.demote(self._conf.user) dem() server = SOAPpy.SOAPServer((self._hostname, self._conf.soap2file_port)) server.registerFunction(writeToFile) server.registerFunction(createDirectory) server.registerFunction(renamePath) server.serve_forever()
def main(): """ Main function for running the server. """ logging.basicConfig(format=LOG_FORMAT, level=logging.INFO) logger.info('Starting UAServer') global bindport global db global user_schema for ii in range(1, len(sys.argv)): if sys.argv[ii] in ("-h", "--help"): usage() sys.exit() elif sys.argv[ii] in ('-t', "--type"): # type is ignored ii += 1 elif sys.argv[ii] in ('-p', "--port"): bindport = int(sys.argv[ii + 1] ) ii += 1 else: pass register_location(appscale_info.get_private_ip(), bindport) connect_to_postgres(zk_client) init_table(pg_connection_wrapper) ip = "0.0.0.0" server = SOAPpy.SOAPServer((ip, bindport)) logger.info('Serving on {}'.format(bindport)) # To debug this service, uncomment the 2 lines below. #server.config.dumpSOAPOut = 1 #server.config.dumpSOAPIn = 1 # Register soap functions. server.registerFunction(does_user_exist, funcName='does_user_exist') server.registerFunction(get_all_users, funcName='get_all_users') server.registerFunction(get_user_data, funcName='get_user_data') server.registerFunction(add_admin_for_app, funcName='add_admin_for_app') server.registerFunction(commit_new_user, funcName='commit_new_user') server.registerFunction(commit_new_token, funcName='commit_new_token') server.registerFunction(delete_user, funcName='delete_user') server.registerFunction(change_password, funcName='change_password') server.registerFunction(disable_user, funcName='disable_user') server.registerFunction(enable_user, funcName='enable_user') server.registerFunction(is_user_enabled, funcName='is_user_enabled') server.registerFunction(is_user_cloud_admin, funcName='is_user_cloud_admin') server.registerFunction(set_cloud_admin_status, funcName='set_cloud_admin_status') server.registerFunction(get_capabilities, funcName='get_capabilities') server.registerFunction(set_capabilities, funcName='set_capabilities') while 1: server.serve_forever()
def netServ(): ssl_context = SSL.Context() ssl_context.load_cert('server.pem') server = SOAPpy.SOAPServer((N.host, N.port), ssl_context=ssl_context) server.registerFunction(etatChaudiere) server.registerFunction(eteindreChaudiere) server.registerFunction(allumerChaudiere) server.registerFunction(etatTemperature) while 1: try: server.serve_forever() except: continue time.sleep(0.1)
def __init__(self, soapPort): """ Initialize the SOAP registry server and add the functions it supports to it. """ self._server = SOAPpy.SOAPServer(("", soapPort)) self._server.registerFunction(self.register) self._server.registerFunction(self.unRegister) self._server.registerFunction(self.update) self._server.registerFunction(self.listSystems) difdbi.DBOpen(logging) self._db = difdbi.cachedDb() signal.signal(signal.SIGTERM, self.signalHandler) logging.info("Registry successfully started.")
def main(): mq_prontos = MQManager(lprontos) t1 = Thread(target=mq_prontos.subscribeTo, args=('Prontos',)) t1.daemon = True t1.start() mq_pendetes = MQManager(lpendentes) t2 = Thread(target=mq_pendetes.publishIn, args=('Pendentes',)) t2.daemon = True t2.start() t3 = Thread(target=atualizarProntos, args=()) t3.daemon = True t3.start() server = SOAPpy.SOAPServer((cfg.ws_machine_ip, 8080)) server.registerFunction(Comprar, 'lojao','Comprar') server.registerFunction(Pesquisar, 'lojao','Pesquisar') server.serve_forever()
def __init__(self, soapPort, consumerAddress, consumerPort): global gConsumerAddress gConsumerAddress = "http://" + consumerAddress + ":" + str( consumerPort) # Need to initialize the SOAP Server and Register Function .. but worry about this later. self._server = SOAPpy.SOAPServer(("", soapPort)) self._server.registerFunction(self.queryOpenID) self._server.registerFunction(self.checkOpenID) # Initializing the HTTP Server SocketServer.TCPServer.__init__(self, (consumerAddress, consumerPort), OpenIDRequestHandler) openidhttpserver = thread.start_new_thread(self.serve_forever, ()) #the next call is blocking! print "openID Auth Check SOAP and HTTP Server Started" self._server.serve_forever()
if not page.exists(): raise NoSuchPage, page.name page.delete() return "Strona usunięta." class NoSuchPage(Exception): """Wyjątek zgłaszany w momencie próby pobrania strony, która nie istnieje.""" pass DEFAULT_PORT = 8002 NAMESPACE = 'urn:BittyWiki' if __name__ == '__main__': WIKI_BASE = 'wiki/' api = BittyWikiAPI(WIKI_BASE) port = DEFAULT_PORT if len(sys.argv) > 1: port = sys.argv[1] try: port = int(port) except ValueError: #Nie podano poprawnego numeru portu. Poinformuj użytkownika o składni wywołania. print 'Użycie: "%s [numer portu]"' % sys.argv[0] sys.exit(1) print "Uruchamiam niezależny serwer SOAP na porcie %s." % port handler = SOAPpy.SOAPServer(('localhost', port)) handler.registerObject(api, NAMESPACE) handler.serve_forever()
def usage(): """ Prints usage of this program """ print "args: --help or -h for this menu" ################################ # MAIN ################################ if __name__ == "__main__": for args_index in range(1, len(sys.argv)): if sys.argv[args_index] in ("-h", "--help"): usage() sys.exit() INTERNAL_IP = appscale_info.get_private_ip() SERVER = SOAPpy.SOAPServer((INTERNAL_IP, constants.APP_MANAGER_PORT)) SERVER.registerFunction(start_app) SERVER.registerFunction(stop_app) SERVER.registerFunction(stop_app_instance) SERVER.registerFunction(restart_app_instances_for_app) file_io.set_logging_format() while 1: try: SERVER.serve_forever() except SSL.SSLError: pass
# -*- coding: utf-8 -*- """ Created on Thu Mar 01 19:38:14 2018 @author: lukish.rajesh.yadav """ import SOAPpy def hello(): return "Hello World" class A: def B(self): return 'Method inside class has returned this!' server = SOAPpy.SOAPServer(("localhost", 8080)) server.registerClass(A) server.registerFunction(A) server.serve_forever()
return False return True def usage(): """ Prints usage of this program """ print "args: --help or -h for this menu" ################################ # MAIN ################################ if __name__ == "__main__": for ii in range(1, len(sys.argv)): if sys.argv[ii] in ("-h", "--help"): usage() sys.exit() server = SOAPpy.SOAPServer((DEFAULT_IP, constants.APP_MANAGER_PORT)) server.registerFunction(start_app) server.registerFunction(stop_app) server.registerFunction(stop_app_instance) file_io.set_logging_format() while 1: try: server.serve_forever() except SSL.SSLError: pass
# socket.gethostbyname(socket.gethostname()) ip = "0.0.0.0" if super_secret == "": FILE = open(SECRET_LOCATION, 'r') super_secret = FILE.read() # Secure Socket Layer if encrypt == 1: ssl_context = SSL.Context() cert_location = CERT_LOCATION key_location = KEY_LOCATION ssl_context.load_cert(cert_location, key_location) server = SOAPpy.SOAPServer((ip, bindport), ssl_context=ssl_context) else: server = SOAPpy.SOAPServer((ip, bindport)) #Register Functions server.registerFunction(add_class) server.registerFunction(add_instance) server.registerFunction(does_user_exist) server.registerFunction(does_app_exist) server.registerFunction(get_key_block) server.registerFunction(get_all_apps) server.registerFunction(get_all_users) server.registerFunction(get_user_data) server.registerFunction(get_app_data) server.registerFunction(get_tar)
def main(argv): from os import getpid global status args = argv[1:] debug = False port = DEFAULT_PORT username = DEFAULT_USERNAME pid_file = PID_FILE log_file = LOG_FILE while args: if args[0] == '-D': debug = True args = args[1:] elif args[0] == '-C' and len(args) > 1: args = file(args[1]).read().split() + args[2:] elif args[0] == '-p' and len(args) > 1: port = int(args[1]) args = args[2:] elif args[0] == '-u' and len(args) > 1: username = args[1] args = args[2:] elif args[0] == '-pid' and len(args) > 1: pid_file = args[1] args = args[2:] elif args[0] == '-log' and len(args) > 1: log_file = args[1] args = args[2:] elif args[0] == '-db' and len(args) > 1: db_options['db'] = args[1] args = args[2:] elif args[0] == '-user' and len(args) > 1: db_options['user'] = args[1] args = args[2:] elif args[0] == '-host' and len(args) > 1: db_options['host'] = args[1] args = args[2:] else: usage() config = SOAPpy.SOAPConfig() #config.dumpSOAPIn = True server = SOAPpy.SOAPServer(('0.0.0.0', port), namespace = NS, config = config, RequestHandler = RESTRequestHandler) status = Status() for g in generators: # Create function names of the form # next_{}_set # # for example: # next_mcid_set() # next_tracking_number_set() # server.registerFunction(g.soap_set, funcName = 'next_%s_set' % g.name, namespace = NS) setattr(status, '%s_requests' % g.name, 0) status.uid = status.gid = 0 status.log_file = None status.version = __version__ if not debug: try: from os import _exit, setuid, setgid, fork, dup2, open, close, \ O_RDONLY, O_WRONLY, O_APPEND, O_CREAT from pwd import getpwnam except ImportError: pass else: pw = getpwnam(username) status.user = username pid = fork() if pid: print >>file(pid_file, 'w'), pid _exit(0) fd = open('/dev/null', O_RDONLY) dup2(fd, 0) fd = open(log_file, O_WRONLY | O_APPEND | O_CREAT) dup2(fd, 1) dup2(fd, 2) close(fd) setgid(pw.pw_gid) setuid(pw.pw_uid) status.uid = pw.pw_uid status.gid = pw.pw_gid status.log_file = log_file status.port = port status.db_host = db_options['host'] status.db_user = db_options['user'] status.db = db_options['db'] status.pid = getpid() status.started = datetime.utcnow() status.requests = 0 server.serve_forever()
return pass_string def test_float(self, pass_float): print(type(pass_float)) return pass_float def test_tuple(self, pass_tuple): print(type(pass_tuple), pass_tuple) return pass_tuple def test_list(self, pass_list): print(type(pass_list), pass_list) return pass_list def test_dictionary(self, pass_dictionary): print(type(pass_dictionary), pass_dictionary) return pass_dictionary def quit(self): self.run = 0 server = SOAPpy.SOAPServer(("localhost", 9999)) SOAPpy.Config.simplify_objects = 1 access_object = test_service() server.registerObject(access_object) while access_object.run: server.handle_request()
#!/usr/bin/env python2.5 from phamerator_manage_db import * from db_conf import * import SOAPpy, sys def get_phage_name(PhageID, username, password, server, database): c = db_conf(username=username, password=password, server=server, db=database).get_cursor() name = get_phage_name_from_PhageID(c, PhageID) print 'PhageID -> %s' % name return name port = int(sys.argv[1]) server = SOAPpy.SOAPServer(("hatfull12.bio.pitt.edu", port)) server.registerFunction(get_phage_name) server.serve_forever()
def main(): """ Main function for running the server. """ logging.basicConfig(format=LOG_FORMAT, level=logging.INFO) logging.info('Starting UAServer') global app_schema global bindport global datastore_type global db global ERROR_CODES global user_schema for ii in range(1, len(sys.argv)): if sys.argv[ii] in ("-h", "--help"): usage() sys.exit() elif sys.argv[ii] in ('-t', "--type"): datastore_type = sys.argv[ii + 1] ii += 1 elif sys.argv[ii] in ('-p', "--port"): bindport = int(sys.argv[ii + 1]) ii += 1 else: pass db = appscale_datastore.DatastoreFactory.getDatastore(datastore_type) ERROR_CODES = appscale_datastore.DatastoreFactory.error_codes() valid_datastores = appscale_datastore.DatastoreFactory.valid_datastores() if datastore_type not in valid_datastores: raise Exception('{} not in valid datastores ({})'.format( datastore_type, valid_datastores)) # Keep trying until it gets the schema. timeout = 5 while 1: try: user_schema = db.get_schema(USER_TABLE) except AppScaleDBConnectionError as db_error: time.sleep(timeout) continue if user_schema[0] in ERROR_CODES: user_schema = user_schema[1:] Users.attributes_ = user_schema else: time.sleep(timeout) continue try: app_schema = db.get_schema(APP_TABLE) except AppScaleDBConnectionError as db_error: time.sleep(timeout) continue if app_schema[0] in ERROR_CODES: app_schema = app_schema[1:] Apps.attributes_ = app_schema else: time.sleep(timeout) continue break ip = "0.0.0.0" server = SOAPpy.SOAPServer((ip, bindport)) logging.info('Serving on {}'.format(bindport)) # To debug this service, uncomment the 2 lines below. #server.config.dumpSOAPOut = 1 #server.config.dumpSOAPIn = 1 # Register soap functions. server.registerFunction(add_instance) server.registerFunction(does_user_exist) server.registerFunction(does_app_exist) server.registerFunction(get_key_block) server.registerFunction(get_all_apps) server.registerFunction(get_all_users) server.registerFunction(get_user_data) server.registerFunction(get_app_data) server.registerFunction(get_tar) server.registerFunction(get_token) server.registerFunction(get_version) server.registerFunction(add_admin_for_app) server.registerFunction(commit_new_user) server.registerFunction(commit_new_app) server.registerFunction(commit_tar) server.registerFunction(commit_new_token) server.registerFunction(delete_instance) server.registerFunction(delete_all_apps) server.registerFunction(delete_user) server.registerFunction(delete_app) server.registerFunction(change_password) server.registerFunction(disable_app) server.registerFunction(enable_app) server.registerFunction(is_app_enabled) server.registerFunction(disable_user) server.registerFunction(enable_user) server.registerFunction(is_user_enabled) server.registerFunction(is_user_cloud_admin) server.registerFunction(set_cloud_admin_status) server.registerFunction(get_capabilities) server.registerFunction(set_capabilities) while 1: server.serve_forever()
def usage(): """ Prints usage of this program """ print "args: --help or -h for this menu" ################################ # MAIN ################################ if __name__ == "__main__": for ii in range(1, len(sys.argv)): if sys.argv[ii] in ("-h", "--help"): usage() sys.exit() internal_ip = socket.gethostbyname(socket.gethostname()) server = SOAPpy.SOAPServer((internal_ip, constants.APP_MANAGER_PORT)) server.registerFunction(start_app) server.registerFunction(stop_app) server.registerFunction(stop_app_instance) server.registerFunction(restart_app_instances_for_app) file_io.set_logging_format() while 1: try: server.serve_forever() except SSL.SSLError: pass
import SOAPpy from xml.dom import minidom def listSystems(inputFile): xmldoc = minidom.parse("/home/sasank/public_html/query_response.xml") print xmldoc.toxml() return xmldoc.toxml() server = SOAPpy.SOAPServer(("", 9111)) SOAPpy.Config.debug = 1 server.registerFunction(listSystems) server.serve_forever()
def main(argv): global status, mcids, tracking_numbers, proxy, mcid_cache, tn_cache, tns_cache_path, mcid_cache_path args = argv[1:] debug = False username = DEFAULT_USERNAME port = DEFAULT_PORT try: socket.gethostbyname(DEFAULT_HOST) host = DEFAULT_HOST except socket.error: host = '127.0.0.1' pid_file = PID_FILE log_file = LOG_FILE url = DEFAULT_URL appliance = None use_cache = False while args: if args[0] == '-D': debug = True args = args[1:] elif args[0] == '-C' and len(args) > 1: args = file(args[1]).read().split() + args[2:] elif args[0] == '-p' and len(args) > 1: port = int(args[1]) args = args[2:] elif args[0] == '-h' and len(args) > 1: host = args[1] args = args[2:] elif args[0] == '-u' and len(args) > 1: username = args[1] args = args[2:] elif args[0] == '-pid' and len(args) > 1: pid_file = args[1] args = args[2:] elif args[0] == '-log' and len(args) > 1: log_file = args[1] args = args[2:] elif args[0] == '-url' and len(args) > 1: url = args[1] args = args[2:] elif args[0] == '-usecache' and len(args) > 1: use_cache = True mcid_cache_path = os.path.join(args[1], mcid_cache_path) tns_cache_path = os.path.join(args[1], tns_cache_path) args = args[2:] elif not args[0].startswith('-') and not appliance: appliance = args[0] args = args[1:] else: usage() if not appliance: appliance = socket.getfqdn() if use_cache: print "Using cache for mcids and tracking numbers: loading archived sets" f = open(mcid_cache_path, 'r') mcid_cache = pickle.load(f) print "Loaded " + str(len(mcid_cache)) + " mcid sets" mcids = infinite_sequence(next_mcid_cache, appliance) f.close() f = open(tns_cache_path, 'r') tn_cache = pickle.load(f) f.close() print "Loaded " + str(len(tn_cache)) + " tracking number sets" tracking_numbers = infinite_sequence(next_tn_cache, appliance) else: proxy = SOAPpy.SOAPProxy(url, namespace='http://www.medcommons.net/globals') mcids = infinite_sequence(proxy.next_mcid_set, appliance) tracking_numbers = infinite_sequence(proxy.next_tracking_number_set, appliance) status = Status() status.port = port status.host = host status.uid = status.gid = 0 status.url = url status.requests = status.mcid_requests = 0 status.tracking_number_requests = 0 status.version = __version__ config = SOAPpy.SOAPConfig() #config.dumpSOAPIn = True server = SOAPpy.SOAPServer((host, port), namespace=NS2, config=config, RequestHandler=RESTRequestHandler) server.registerFunction(next_mcid_str, namespace=NS2) server.registerFunction(next_mcid, namespace=NS2) server.registerFunction(next_tracking_number_str, namespace=NS2) server.registerFunction(next_tracking_number, namespace=NS2) # backwards compatibility server.registerFunction(next_mcid_str, path='mcid', namespace=NS1) server.registerFunction(next_mcid, path='mcid', namespace=NS1) # On unix root, try to setuid to the 'mc_locals' account for # least privilege # if not debug: try: from os import _exit, setuid, setgid, fork, dup2, \ O_RDONLY, O_WRONLY, O_APPEND, O_CREAT from pwd import getpwnam except ImportError: pass else: pw = getpwnam(username) status.user = username pid = fork() if pid: print >> file(pid_file, 'w'), pid _exit(0) fd = os.open('/dev/null', O_RDONLY) dup2(fd, 0) fd = os.open(log_file, O_WRONLY | O_APPEND | O_CREAT) dup2(fd, 1) dup2(fd, 2) os.close(fd) setgid(pw.pw_gid) setuid(pw.pw_uid) status.gid = pw.pw_gid status.uid = pw.pw_uid status.started = datetime.utcnow() server.serve_forever()
alignmentType=alignmentType, blastThreshold=blastThreshold, clustalwThreshold=clustalwThreshold) def get_scores(self, query, subject): self.c = db_conf.db_conf(username=self.username, password=self.password, server=self.server, db=self.database).get_cursor() self.db = pham.db(c=self.c) return phamerator_manage_db.get_scores(self.c, query, subject) def get_fasta_from_pham(self, phamName): self.c = db_conf.db_conf(username=self.username, password=self.password, server=self.server, db=self.database).get_cursor() self.db = pham.db(c=self.c) return phamerator_manage_db.get_fasta_from_pham(self.c, phamName) ################################################################### server = SOAPpy.SOAPServer(("hatfull12.bio.pitt.edu", 31415)) SOAP = phageSOAP() server.registerObject(SOAP) print "\n>hello matt...how are we doing today?\n" os.system("/usr/games/fortune") print "\n>server started\n" server.serve_forever()
import SOAPpy def hello(): return "Hello World" server = SOAPpy.SOAPServer(("localhost", 8888)) server.registerFunction(hello) server.serve_forever()
def __init__(self, rpcip, rpcport, keyfile, certfile, allowed_ipdict): self.rpcip = rpcip self.rpcport = rpcport threading.Thread.__init__(self) self.setDaemon(True) self.requestQueue = queue.Queue() self.resultQueue = queue.Queue() SOAPpy.Config.debug = 0 SOAPpy.Config.dumpFaultInfo = 0 # --- BEGIN PUBLISHED FUNCTIONS --- def getToonList(accountName): """ Retrieve a list of toons owned by the given account. accountName is the account name string as stored on the OTP server. Returns a list of (DOID,name) tuples. """ assert self.requestQueue.empty() assert self.resultQueue.empty() if not isinstance(accountName, str): raise RPCException("Argument accountName was not a string.") c = SOAPpy.GetSOAPContext() self.requestQueue.put(GetToonIdListRequest(self.resultQueue, \ c.connection.getpeername()[0], \ accountName)) idList = self.resultQueue.get() if isinstance(idList, TimeoutException): raise RPCException("Request timed out.") resultList = [] for doid in idList: if doid > 0: toonname = self.getToonName(doid) resultList.append((doid, toonname)) return resultList def getToonSlots(accountName): """ Identical to getToonList, but also returns empty toon slots. Retrieve a list of toons owned by the given account. accountName is the account name string as stored on the OTP server. Returns a list of (DOID,name) tuples. """ assert self.requestQueue.empty() assert self.resultQueue.empty() if not isinstance(accountName, str): raise RPCException("Argument accountName was not a string.") c = SOAPpy.GetSOAPContext() self.requestQueue.put(GetToonIdListRequest(self.resultQueue, \ c.connection.getpeername()[0], \ accountName)) idList = self.resultQueue.get() if isinstance(idList, TimeoutException): raise RPCException("Request timed out.") resultList = [] id = 0 for doid in idList: if doid > 0: toonname = self.getToonName(doid) resultList.append((doid, toonname)) else: resultList.append((id, "%s" % id)) id += 1 return resultList def giveToonBeansRAT(toonID, beanAmount): """ Only for Recruit-a-Toon program. Give jellybeans to the toon specified. toonID is the DOID of the recipient toon. beanAmount is the number of beans to give (0 < beanAmount <= 100). Returns None on success, faults on failure. """ assert self.requestQueue.empty() assert self.resultQueue.empty() if not isinstance(toonID, int): raise RPCException("Argument toonID was not an int.") if not isinstance(beanAmount, int): raise RPCException("Argument beanAmount was not an int.") if toonID < 1: raise RPCException("Argument toonID was non-positive.") if beanAmount > 100: raise RPCException( "Attempted to give a toon more than 100 jellybeans at once" ) if beanAmount < 1: raise RPCException( "Attempted to give a toon a non-positive jellybean amount") c = SOAPpy.GetSOAPContext() self.requestQueue.put(GiveToonBeansRATRequest(self.resultQueue, \ c.connection.getpeername()[0], \ toonID, \ beanAmount)) result = self.resultQueue.get() return def giveToonBeansCS(toonID, beanAmount): """ Only for Customer Service requests. Give jellybeans to the toon specified. toonID is the DOID of the recipient toon. beanAmount is the number of beans to give (0 < beanAmount <= 100). Returns None on success, faults on failure. """ assert self.requestQueue.empty() assert self.resultQueue.empty() if not isinstance(toonID, int): raise RPCException("Argument toonID was not an int.") if not isinstance(beanAmount, int): raise RPCException("Argument beanAmount was not an int.") if toonID < 1: raise RPCException("Argument toonID was non-positive.") if beanAmount > 100: raise RPCException( "Attempted to give a toon more than 100 jellybeans at once" ) if beanAmount < 1: raise RPCException( "Attempted to give a toon a non-positive jellybean amount") c = SOAPpy.GetSOAPContext() self.requestQueue.put(GiveToonBeansCSRequest(self.resultQueue, \ c.connection.getpeername()[0], \ toonID, \ beanAmount)) result = self.resultQueue.get() return def getToonPicId(toonID): """ Retrieve the picture ID for a given toon. toonID is the toon's DOID """ assert self.requestQueue.empty() assert self.resultQueue.empty() if not isinstance(toonID, int): raise RPCException("Argument toonID was not an int.") if toonID < 1: raise RPCException("Argument toonID was non-positive.") c = SOAPpy.GetSOAPContext() self.requestQueue.put(GetToonPicIdRequest(self.resultQueue, \ c.connection.getpeername()[0], \ toonID)) picid = self.resultQueue.get() if isinstance(picid, TimeoutException): raise RPCException("Request timed out.") return picid def getToonDNA(toonID): """ Retrieve the DNA for a given toon. toonID is the toon's DOID """ assert self.requestQueue.empty() assert self.resultQueue.empty() if not isinstance(toonID, int): raise RPCException("Argument toonID was not an int.") if toonID < 1: raise RPCException("Argument toonID was non-positive.") c = SOAPpy.GetSOAPContext() self.requestQueue.put(GetToonDNARequest(self.resultQueue, \ c.connection.getpeername()[0], \ toonID)) dna = self.resultQueue.get() if isinstance(dna, TimeoutException): raise RPCException("Request timed out.") return dna # --- END PUBLISHED FUNCTIONS --- self.SOAPServer = SOAPpy.SOAPServer(addr=(self.rpcip,self.rpcport),\ namespace="ToontownRPC",\ key_file=keyfile,\ cert_file=certfile,\ allowed_ipdict=allowed_ipdict) self.SOAPServer.registerFunction(getToonList) self.SOAPServer.registerFunction(getToonSlots) self.SOAPServer.registerFunction(giveToonBeansRAT) self.SOAPServer.registerFunction(giveToonBeansCS) self.SOAPServer.registerFunction(getToonPicId) self.SOAPServer.registerFunction(getToonDNA) self.start()
import SOAPpy import utils import sys import signal toSend = utils.readFile(sys.argv[1]) counter = 0 utils.startServerTestSetup("SoapServer", sys.argv[1], int(sys.argv[2])) server = SOAPpy.SOAPServer(("0.0.0.0", 5001)) def mytxt(): global counter counter += 1 if counter >= int(sys.argv[2]): print('exiting') signal.signal(signal.SIGALRM, utils.kill_server) signal.setitimer(signal.ITIMER_REAL, 1) return toSend server.registerFunction(mytxt) server.serve_forever()
import SOAPpy def hello(): return "Hello World" server = SOAPpy.SOAPServer(("localhost", 6666)) server.registerFunction(hello) server.serve_forever()
# -*-coding: utf-8-*- import SOAPpy import pika from threading import Thread soap_server = SOAPpy.SOAPServer(('localhost', 8080))
'--debug', help="enable debug mode", action="store_true", default=False) parser.add_option('-p', '--port', help="which port to serve content on", type='int', default=5000) parser.add_option('-g', '--gpu', help="use gpu mode", action='store_true', default=False) opts, args = parser.parse_args() ImagenetClassifier.default_args.update({'gpu_mode': opts.gpu}) classifier = ImagenetClassifier(**ImagenetClassifier.default_args) classifier.net.forward() result = classifier.classify_image(image) #cnis, preproc_time, roi_file_images=detect_cni(path) return result server = SOAPpy.SOAPServer(("127.0.0.1", 5000)) server.registerFunction(ocr) server.registerFunction(ocr_cartegirse_direct) server.registerFunction(classify) server.registerFunction(classify_image_direct) server.registerFunction(classify_image_string) server.serve_forever()
def __init__(self, host=DEFAULT_HOST, port=DEFAULT_PORT, ssl=True): """ Initialize a new instance of the infrastructure manager service. Args: host Hostname to which the service should bind (Optional). Defaults to 0.0.0.0. port Port of the service (Optional). Default to 17444. ssl True if SSL should be engaged or False otherwise (Optional). Defaults to True. When engaged, this implementation expects to find the necessary SSL certificates in the /etc/appscale/certs directory. """ self.host = host self.port = port secret = None while True: try: secret = utils.get_secret(self.APPSCALE_DIR + 'secret.key') break except Exception: logging.info('Waiting for the secret key to become available') utils.sleep(5) logging.info('Found the secret set to: {0}'.format(secret)) SOAPpy.Config.simplify_objects = True if ssl: logging.info('Checking for the certificate and private key') cert = self.APPSCALE_DIR + 'certs/mycert.pem' key = self.APPSCALE_DIR + 'certs/mykey.pem' while True: if os.path.exists(cert) and os.path.exists(key): break else: logging.info('Waiting for certificates') utils.sleep(5) ssl_context = SSL.Context() ssl_context.load_cert(cert, key) self.server = SOAPpy.SOAPServer((host, port), ssl_context=ssl_context) else: self.server = SOAPpy.SOAPServer((host, port)) parent_dir = os.path.dirname(os.path.realpath(sys.argv[0])) config_file = os.path.join(parent_dir, self.CONFIG_FILE) if os.path.exists(config_file): with open(config_file) as file_handle: params = json.load(file_handle) if params.has_key(PersistentStoreFactory.PARAM_STORE_TYPE): logging.info( 'Loading infrastructure manager configuration from ' + config_file) i = InfrastructureManager(params) else: i = InfrastructureManager() else: i = InfrastructureManager() self.server.registerFunction(i.describe_operation) self.server.registerFunction(i.run_instances) self.server.registerFunction(i.terminate_instances) self.server.registerFunction(i.attach_disk) system_manager = SystemManager() self.server.registerFunction(system_manager.get_cpu_usage) self.server.registerFunction(system_manager.get_disk_usage) self.server.registerFunction(system_manager.get_memory_usage) self.server.registerFunction(system_manager.get_service_summary) self.server.registerFunction(system_manager.get_swap_usage) self.server.registerFunction(system_manager.get_loadavg) self.started = False
def main(argv): global db dbname = 'db/mcids' type = None args = argv[1:] debug = False port = 1080 while args: if args[0] == '-db' and len(args) > 1: dbname = args[1] args = args[2:] elif args[0] == '-D': debug = True args = args[1:] elif args[0] == '-p' and len(args) > 1: port = int(args[1]) args = args[2:] elif type is None and not args[0].startswith('-'): type = args[0] args = args[1:] else: usage(dbname) db = sql.connect(dbname) generator.load(type) # This is set up so the very next allocation from the SOAP service # will result in a database write. That way, you can start and # stop the SOAP service, and as long as there weren't any SOAP calls, # we're not allocating blocks of MCIDs. # for i in xrange(generator.iterations): generator.next_mcid() config = SOAPpy.SOAPConfig() #config.dumpSOAPIn = True server = SOAPpy.SOAPServer(("mcid.internal", port), namespace = NS, config = config, RequestHandler = RESTRequestHandler) server.registerFunction(generator.next_mcid_str, path='mcid', namespace=NS) server.registerFunction(generator.next_mcid, path='mcid', namespace=NS) # On unix root, try to setuid to the 'mcid_server' account for # least privilege # if not debug: try: from os import _exit, setuid, setgid, fork, dup2, open, close, \ O_RDONLY, O_WRONLY, O_APPEND, O_CREAT from pwd import getpwnam except ImportError: pass else: pw = getpwnam('mcid_server') pid = fork() if pid: print >>file(PID_FILE, 'w'), pid _exit(0) fd = open('/dev/null', O_RDONLY) dup2(fd, 0) fd = open(LOG_FILE, O_WRONLY | O_APPEND | O_CREAT) dup2(fd, 1) dup2(fd, 2) close(fd) setgid(pw.pw_gid) setuid(pw.pw_uid) server.serve_forever()
user_schema = user_schema[1:] Users.attributes_ = user_schema else: time.sleep(timeout) continue app_schema = db.get_schema(APP_TABLE) if app_schema[0] in ERROR_CODES: app_schema = app_schema[1:] Apps.attributes_ = app_schema else: time.sleep(timeout) continue break ip = "0.0.0.0" server = SOAPpy.SOAPServer((ip, bindport)) logging.info('Serving on {}'.format(bindport)) # To debug this service, uncomment the 2 lines below. #server.config.dumpSOAPOut = 1 #server.config.dumpSOAPIn = 1 # Register soap functions. server.registerFunction(add_instance) server.registerFunction(does_user_exist) server.registerFunction(does_app_exist) server.registerFunction(get_key_block) server.registerFunction(get_all_apps) server.registerFunction(get_all_users) server.registerFunction(get_user_data) server.registerFunction(get_app_data)
def sub(x, y): """This function subtracts two numbers""" return x - y def mul(x, y): """This function multiplies two numbers""" return x * y def div(x, y): """This function divides two numbers""" if x == 0 and y == 0: return 'got you 0/0 = error :P' else: return x / y def hello(): return "Hello Mick" server = SOAPpy.SOAPServer(("boktor.blaauwgeers.net", 7000)) server.registerFunction(hello) server.registerFunction(add) server.registerFunction(sub) server.registerFunction(mul) server.registerFunction(div) server.serve_forever()