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()
