def build_app(service_list, tns, name):
app = Application(service_list,
tns,
Wsdl11(),
Soap11(),
Soap11(),
name=name)
app.transport = 'http://schemas.xmlsoap.org/soap/http'
return app
def test_multiple_return(self):
class SomeNotSoComplexModel(ComplexModel):
s = String
class SomeService(ServiceBase):
@srpc(_returns=[Integer, String])
def some_call():
return 1, 's'
app = Application([SomeService], 'tns', Wsdl11(), HttpRpc(), HttpRpc())
from rpclib.server.wsgi import WsgiMethodContext
initial_ctx = WsgiMethodContext(app, {
'QUERY_STRING': '',
'PATH_INFO': '/some_call',
}, 'some-content-type')
from rpclib.server import ServerBase
server = ServerBase(app)
try:
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
server.get_out_object(ctx)
server.get_out_string(ctx)
except ValueError:
pass
else:
raise Exception("Must Fail")
def test_primitive_only(self):
class SomeComplexModel(ComplexModel):
i = Integer
s = String
class SomeService(ServiceBase):
@srpc(SomeComplexModel, _returns=SomeComplexModel)
def some_call(scm):
return SomeComplexModel(i=5, s='5x')
app = Application([SomeService], 'tns', Wsdl11(), HttpRpc(), HttpRpc())
from rpclib.server.wsgi import WsgiMethodContext
initial_ctx = WsgiMethodContext(app, {
'QUERY_STRING': '',
'PATH_INFO': '/some_call',
}, 'some-content-type')
from rpclib.server import ServerBase
server = ServerBase(app)
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
print "!", ctx.in_object
server.get_out_object(ctx)
try:
server.get_out_string(ctx)
except:
pass
else:
raise Exception("Must Fail")
def test_complex(self):
class CM(ComplexModel):
i = Integer
s = String
class CCM(ComplexModel):
c = CM
i = Integer
s = String
class SomeService(ServiceBase):
@srpc(CCM, _returns=CCM)
def some_call(ccm):
return CCM(c=ccm.c, i=ccm.i, s=ccm.s)
app = Application([SomeService], 'tns', Wsdl11(), HttpRpc(), HttpRpc())
from rpclib.server.wsgi import WsgiMethodContext
initial_ctx = WsgiMethodContext(app, {
'QUERY_STRING': '',
'PATH_INFO': '/some_call',
}, 'some-content-type')
from rpclib.server import ServerBase
server = ServerBase(app)
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
server.get_out_object(ctx)
server.get_out_string(ctx)
def test_basic(self):
class SomeService(ServiceBase):
@srpc(String(pattern='a'))
def some_method(s):
pass
application = Application(
[SomeService],
interface=Wsdl11(),
in_protocol=Soap11(validator='soft'),
out_protocol=Soap11(),
name='Service',
tns='tns',
)
ctx = MethodContext(application)
ctx.in_string = [
u"""
<SOAP-ENV:Envelope xmlns:ns0="tns"
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
<SOAP-ENV:Body>
<ns0:some_method>
<ns0:s>OK</ns0:s>
</ns0:some_method>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
"""
]
from rpclib.server import ServerBase
server = ServerBase(application)
server.get_in_object(ctx)
self.assertEquals(isinstance(ctx.in_error, ValidationError), True)
def setUp(self):
self.app = Application([TestService], 'tns', Wsdl11(), Soap11(),
Soap11())
self.srv = TestService()
self.app.interface.build_interface_document('URL')
self.wsdl_str = self.app.interface.get_interface_document()
self.wsdl_doc = etree.fromstring(self.wsdl_str)
def test_single_method(self):
try:
app = Application([MultipleMethods1, MultipleMethods2], 'tns',
Wsdl11(), Soap11(), Soap11())
app.interface.build_interface_document('url')
raise Exception('must fail.')
except ValueError:
pass
def __get_binding_application(self, binding_service):
'''Builds an instance of rpclib.Application
The Application built is populated with an instance of a Service Class
based on ServiceBase
@param A class based on ServiceBase
'''
binding_application = Application([binding_service],
rpclib.interface.wsdl.Wsdl11,
rpclib.protocol.soap.Soap11,
tns='binding_application')
# The lxml Element nsmap is being overridden to remove the unneeded
# namespaces
binding_application.nsmap = XSDGenerator.model_schema_nsmap
binding_application.prefmap = \
dict([(b,a) for a,b in XSDGenerator.model_schema_nsmap.items()])
binding_application.call_routes = {}
return binding_application
def wsgi_soap11_application(services,
tns='rpclib.simple.soap',
validator=None):
"""Wraps `services` argument inside a WsgiApplication that uses Wsdl 1.1 as
interface document and Soap 1.1 and both input and output protocols.
"""
application = Application(services,
tns,
interface=Wsdl11(),
in_protocol=Soap11(validator=validator),
out_protocol=Soap11())
return WsgiApplication(application)
def test_call(self):
queue = set()
class MessageService(ServiceBase):
@srpc(String)
def send_message(s):
queue.add(s)
application = Application([MessageService], 'some_tns',
interface=Wsdl11(), in_protocol=Soap11(), out_protocol=Soap11())
server = NullServer(application)
server.service.send_message("zabaaa")
assert set(["zabaaa"]) == queue
def setUp(self):
class SomeService(ServiceBase):
@srpc(String(pattern='a'))
def some_method(s):
pass
@srpc(String(pattern='a', max_occurs=2))
def some_other_method(s):
pass
self.application = Application(
[SomeService],
interface=Wsdl11(),
in_protocol=HttpRpc(validator='soft'),
out_protocol=Soap11(),
name='Service',
tns='tns',
)
def test_multiple_methods(self):
in_protocol = Soap11()
out_protocol = Soap11()
# for the sake of this test.
in_protocol.supports_fanout_methods = True
out_protocol.supports_fanout_methods = True
app = Application([MultipleMethods1, MultipleMethods2],
'tns',
Wsdl11(),
in_protocol,
out_protocol,
supports_fanout_methods=True)
app.interface.build_interface_document('url')
mm = app.interface.service_method_map['{tns}multi']
def find_class_in_mm(c):
found = False
for s, _ in mm:
if s is c:
found = True
break
return found
assert find_class_in_mm(MultipleMethods1)
assert find_class_in_mm(MultipleMethods2)
def find_function_in_mm(f):
i = 0
found = False
for _, d in mm:
i += 1
if d.function is f:
found = True
print i
break
return found
assert find_function_in_mm(MultipleMethods1.multi)
assert find_function_in_mm(MultipleMethods2.multi)
def test_fanout(self):
arr = set()
class MessageService1(ServiceBase):
@srpc()
def send_message():
arr.add(1)
class MessageService2(ServiceBase):
@srpc()
def send_message():
arr.add(2)
application = Application([MessageService1,MessageService2], 'some_tns',
interface=Wsdl11(), in_protocol=Soap11(), out_protocol=Soap11(),
supports_fanout_methods=True)
server = NullServer(application)
server.service.send_message()
assert set([1,2]) == arr
def test_nested_flatten(self):
class CM(ComplexModel):
i = Integer
s = String
class CCM(ComplexModel):
c = CM
i = Integer
s = String
class SomeService(ServiceBase):
@srpc(CCM, _returns=String)
def some_call(ccm):
return repr(ccm)
app = Application([SomeService], 'tns', Wsdl11(), HttpRpc(), HttpRpc())
from rpclib.server.wsgi import WsgiMethodContext
initial_ctx = WsgiMethodContext(
app, {
'QUERY_STRING': 'ccm_i=1&ccm_s=s&ccm_c_i=3&ccm_c_s=cs',
'PATH_INFO': '/some_call',
}, 'some-content-type')
from rpclib.server import ServerBase
server = ServerBase(app)
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
assert ctx.in_error is None
server.get_out_object(ctx)
assert ctx.out_error is None
server.get_out_string(ctx)
print ctx.out_string
assert ctx.out_string == ["CCM(i=1, c=CM(i=3, s='cs'), s='s')"]
def test_wsdl(self):
app = Application(
[TestService],
'tns',
rpclib.interface.wsdl.Wsdl11(),
rpclib.protocol.soap.Soap11(),
rpclib.protocol.soap.Soap11(),
)
app.interface.build_interface_document('punk')
wsdl = app.interface.get_interface_document()
elt = etree.fromstring(wsdl)
simple_type = elt.xpath('//xs:simpleType',
namespaces=app.interface.nsmap)[0]
print(etree.tostring(elt, pretty_print=True))
print(simple_type)
self.assertEquals(simple_type.attrib['name'], 'DaysOfWeekEnum')
self.assertEquals(simple_type[0].tag, "{%s}restriction" % _ns_xsd)
self.assertEquals([e.attrib['value'] for e in simple_type[0]], vals)
def test_nested_flatten_with_multiple_values_2(self):
class CM(ComplexModel):
i = Integer
s = String
class CCM(ComplexModel):
c = CM.customize(max_occurs=2)
i = Integer
s = String
class SomeService(ServiceBase):
@srpc(CCM, _returns=String)
def some_call(ccm):
return repr(ccm)
app = Application([SomeService], 'tns', Wsdl11(), HttpRpc(), HttpRpc())
from rpclib.server.wsgi import WsgiMethodContext
initial_ctx = WsgiMethodContext(
app, {
'QUERY_STRING': 'ccm_i=1&ccm_s=s&ccm_c_i=3&ccm_c_s=cs',
'PATH_INFO': '/some_call',
}, 'some-content-type')
from rpclib.server import ServerBase
server = ServerBase(app)
ctx, = server.generate_contexts(initial_ctx)
try:
server.get_in_object(ctx)
except:
pass
else:
raise Exception(
"Must fail with: Exception: HttpRpc deserializer "
"does not support non-primitives with max_occurs > 1")
def test_multiple(self):
class SomeService(ServiceBase):
@srpc(String(max_occurs='unbounded'), _returns=String)
def some_call(s):
return '\n'.join(s)
app = Application([SomeService], 'tns', Wsdl11(), HttpRpc(), HttpRpc())
from rpclib.server.wsgi import WsgiMethodContext
initial_ctx = WsgiMethodContext(app, {
'QUERY_STRING': 's=1&s=2',
'PATH_INFO': '/some_call',
}, 'some-content-type')
from rpclib.server import ServerBase
server = ServerBase(app)
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
server.get_out_object(ctx)
server.get_out_string(ctx)
assert ctx.out_string == ['1\n2']
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
#
import logging
logging.basicConfig(level=logging.DEBUG)
logging.getLogger('rpclib.protocol.xml').setLevel(logging.DEBUG)
logger = logging.getLogger('rpclib.test.interop.server.soap_http_basic')
from rpclib.server.wsgi import WsgiApplication
from rpclib.test.interop.server._service import services
from rpclib.application import Application
from rpclib.protocol.soap import Soap11
from rpclib.interface.wsdl import Wsdl11
soap_application = Application(services, 'rpclib.test.interop.server',
Wsdl11(), Soap11(validator='lxml'), Soap11())
if __name__ == '__main__':
try:
from wsgiref.simple_server import make_server
from wsgiref.validate import validator
wsgi_application = WsgiApplication(soap_application)
server = make_server('0.0.0.0', 9753, validator(wsgi_application))
logger.info('Starting interop server at %s:%s.' % ('0.0.0.0', 9753))
logger.info('WSDL is at: /?wsdl')
server.serve_forever()
except ImportError:
print("Error: example server code requires Python >= 2.5")
if "session-id" not in cookie:
raise UnauthenticatedError()
session_cookie = cookie["session-id"].value
session_id = tuple(base64.urlsafe_b64decode(session_cookie).split("\0", 1))
if not session_id in session_db:
raise AuthenticationError(session_id[0])
ctx.udc = session_id[0] # user name
UserService.event_manager.add_listener('method_call', _on_method_call)
if __name__=='__main__':
from rpclib.util.wsgi_wrapper import run_twisted
logging.basicConfig(level=logging.DEBUG)
logging.getLogger('rpclib.protocol.xml').setLevel(logging.DEBUG)
logging.getLogger('twisted').setLevel(logging.DEBUG)
application = Application([UserService],
tns='rpclib.examples.authentication',
interface=Wsdl11(),
in_protocol=Soap11(validator='lxml'),
out_protocol=Soap11()
)
twisted_apps = [
(WsgiApplication(application), 'app'),
]
sys.exit(run_twisted(twisted_apps, 7789))
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
#
import logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger('rpclib.protocol.xml')
logger.setLevel(logging.DEBUG)
from rpclib.application import Application
from rpclib.test.interop.server._service import services
from rpclib.protocol.soap import Soap11
from rpclib.protocol.http import HttpRpc
from rpclib.interface.wsdl import Wsdl11
httprpc_soap_application = Application(services,
'rpclib.test.interop.server.httprpc.soap', Wsdl11(), HttpRpc(), Soap11())
from rpclib.server.wsgi import WsgiApplication
if __name__ == '__main__':
try:
from wsgiref.simple_server import make_server
from wsgiref.validate import validator
wsgi_application = WsgiApplication(httprpc_soap_application)
server = make_server('0.0.0.0', 9756, validator(wsgi_application))
logger.info('Starting interop server at %s:%s.' % ('0.0.0.0', 9756))
logger.info('WSDL is at: /?wsdl')
server.serve_forever()
@param name the name to say hello to
@param the number of times to say hello
@return the completed array
'''
for i in range(times):
yield 'Hello, %s' % name
if __name__ == '__main__':
try:
from wsgiref.simple_server import make_server
except ImportError:
print("Error: example server code requires Python >= 2.5")
logging.basicConfig(level=logging.DEBUG)
logging.getLogger('rpclib.protocol.xml').setLevel(logging.DEBUG)
application = Application([HelloWorldService],
'rpclib.examples.hello.http',
interface=Wsdl11(),
in_protocol=HttpRpc(),
out_protocol=XmlObject())
server = make_server('127.0.0.1', 7789, WsgiApplication(application))
print("listening to http://127.0.0.1:7789")
print("wsdl is at: http://localhost:7789/?wsdl")
server.serve_forever()
def setUp(self):
self.app = Application([MultipleReturnService], 'tns', Wsdl11(),
Soap11(), Soap11())
self.app.interface.build_interface_document('url')
freebusy = []
for fb_request in fb_requests:
calendar_folder = fb_request["folder"]
if calendar_folder is None:
log.warn("no calendar folder found for '%s'" % user_email)
fb_response \
= ExchangeService._freebusy_lookup_error_response()
else:
fb_response \
= ExchangeService._freebusy_response(calendar_folder,
timezone,
freebusy_view_options)
freebusy.append(fb_response)
else:
freebusy = None
if suggestions_view_options is not None:
suggestions \
= ExchangeService._suggestions_response(timezone,
suggestions_view_options)
else:
suggestions = None
return (freebusy, suggestions)
EwsApp = Application([ExchangeService], EWS_M_NS,
name="ExchangeApplication",
interface=Wsdl11(), in_protocol=Soap11(), out_protocol=Soap11())
AsController = WsgiApplication(EwsApp)
def build_app(service_list, tns, name):
app = Application(service_list, tns, Wsdl11(), Soap11(), Soap11(), name=name)
app.transport = "http://schemas.xmlsoap.org/soap/http"
return app
time.sleep(seconds)
client = make_service_client(replyto, self)
client.woke_up('good morning', msgid=msgid)
Thread(target=run).start()
@srpc(String, _is_callback=True)
def woke_up(message):
pass
if __name__ == '__main__':
try:
from wsgiref.simple_server import make_server
except ImportError:
print("Error: example server code requires Python >= 2.5")
application = Application([SleepingService],
'rpclib.examples.async',
interface=Wsdl11(),
in_protocol=Soap11(),
out_protocol=Soap11())
server = make_server('127.0.0.1', 7789, WsgiApplication(application))
print("listening to http://127.0.0.1:7789")
print("wsdl is at: http://localhost:7789/?wsdl")
server.serve_forever()
def delete_user(userid):
global user_database
del user_database[userid]
@srpc(_returns=Array(User))
def list_users():
global user_database
return user_database.values()
if __name__ == '__main__':
try:
from wsgiref.simple_server import make_server
except ImportError:
print("Error: example server code requires Python >= 2.5")
application = Application([UserManager],
'rpclib.examples.complex',
interface=Wsdl11(),
in_protocol=Soap11(),
out_protocol=Soap11())
server = make_server('127.0.0.1', 7789, WsgiApplication(application))
print("listening to http://127.0.0.1:7789")
print("wsdl is at: http://localhost:7789/?wsdl")
server.serve_forever()
def test_rpc(self):
import sqlalchemy
from sqlalchemy import sql
class KeyValuePair(TableSerializer, self.DeclarativeBase):
__tablename__ = 'key_value_store'
__namespace__ = 'punk'
key = Column(sqlalchemy.String(100), nullable=False, primary_key=True)
value = Column(sqlalchemy.String, nullable=False)
self.metadata.create_all(self.engine)
import hashlib
session = self.Session()
for i in range(1, 10):
key = str(i)
m = hashlib.md5()
m.update(key)
value = m.hexdigest()
session.add(KeyValuePair(key=key, value=value))
session.commit()
from rpclib.service import ServiceBase
from rpclib.model.complex import Array
from rpclib.model.primitive import String
class Service(ServiceBase):
@rpc(String(max_occurs='unbounded'),
_returns=Array(KeyValuePair),
_in_variable_names={
'keys': 'key'
}
)
def get_values(ctx, keys):
session = self.Session()
return session.query(KeyValuePair).filter(sql.and_(
KeyValuePair.key.in_(keys)
)).order_by(KeyValuePair.key)
application = Application([Service],
interface=Wsdl11(),
in_protocol=HttpRpc(),
out_protocol=Soap11(),
name='Service', tns='tns'
)
from rpclib.server.wsgi import WsgiMethodContext
ctx = WsgiMethodContext(application, {
'QUERY_STRING': 'key=1&key=2&key=3',
'PATH_INFO': '/get_values',
}, 'some-content-type')
from rpclib.server import ServerBase
server = ServerBase(application)
server.get_in_object(ctx)
server.get_out_object(ctx)
server.get_out_string(ctx)
i = 0
for e in ctx.out_document[0][0][0]:
i+=1
key = str(i)
m = hashlib.md5()
m.update(key)
value = m.hexdigest()
_key = e.find('{%s}key' % KeyValuePair.get_namespace())
_value = e.find('{%s}value' % KeyValuePair.get_namespace())
print((_key, _key.text))
print((_value, _value.text))
self.assertEquals(_key.text, key)
self.assertEquals(_value.text, value)
@param name the name to say hello to
@param the number of times to say hello
@return the completed array
'''
for i in xrange(times):
yield 'Hello, %s' % name
if __name__ == '__main__':
try:
from wsgiref.simple_server import make_server
except ImportError:
print "Error: example server code requires Python >= 2.5"
logging.basicConfig(level=logging.DEBUG)
logging.getLogger('rpclib.protocol.xml').setLevel(logging.DEBUG)
application = Application([HelloWorldService],
'rpclib.examples.hello.soap',
interface=Wsdl11(),
in_protocol=Soap11(),
out_protocol=Soap11())
server = make_server('127.0.0.1', 7789, WsgiApplication(application))
print "listening to http://127.0.0.1:7789"
print "wsdl is at: http://localhost:7789/?wsdl"
server.serve_forever()
raise Fault("Client.FileName", "File '%s' not found" % file_path)
document = open(file_path, 'rb').read()
# the service automatically loads the data from the file.
# alternatively, The data could be manually loaded into memory
# and loaded into the Attachment like:
# document = Attachment(data=data_from_file)
return [document]
if __name__ == '__main__':
try:
from wsgiref.simple_server import make_server
except ImportError:
print("Error: example server code requires Python >= 2.5")
application = Application([DocumentArchiver],
'rpclib.examples.binary',
interface=Wsdl11(),
in_protocol=HttpRpc(),
out_protocol=HttpRpc())
logging.basicConfig(level=logging.DEBUG)
server = make_server('127.0.0.1', 7789, WsgiApplication(application))
print("listening to http://127.0.0.1:7789")
print("wsdl is at: http://localhost:7789/?wsdl")
server.serve_forever()
self.session.close()
def _on_method_call(ctx):
ctx.udc = UserDefinedContext()
def _on_method_return_object(ctx):
# we don't do this in UserDefinedContext.__del__ simply to be able to alert
# the client in case the commit fails.
ctx.udc.session.commit()
application = Application([UserManagerService],
'rpclib.examples.user_manager',
interface=Wsdl11(),
in_protocol=Soap11(),
out_protocol=Soap11())
application.event_manager.add_listener('method_call', _on_method_call)
application.event_manager.add_listener('method_return_object',
_on_method_return_object)
if __name__ == '__main__':
try:
from wsgiref.simple_server import make_server
except ImportError:
print "Error: example server code requires Python >= 2.5"
wsgi_app = WsgiApplication(application)
server = make_server('127.0.0.1', 7789, wsgi_app)
def send_location(clientid):
print "Asking the RMI Server about ", clientid
push_property = Pyro4.Proxy("PYRONAME:property.id")
a = push_property.scanProplist(clientid)
yield str(a)
if __name__ == '__main__':
try:
from wsgiref.simple_server import make_server
except ImportError:
print "Error: server requires Python >= 2.5"
logging.basicConfig(level=logging.INFO)
logging.getLogger('rpclib.protocol.xml').setLevel(logging.DEBUG)
application = Application([MessageService],
'org.temporary.soap',
interface=Wsdl11(),
in_protocol=Soap11(),
out_protocol=Soap11())
port = int(os.environ.get('PORT', 5007))
server = make_server('0.0.0.0', port, WsgiApplication(application))
print "listening to http://0.0.0.0:%s" % port
print "wsdl is at: http://0.0.0.0:%s/?wsdl" % port
server.serve_forever()
_returns=String,
_in_variable_names={
'_to': 'to',
'_from': 'from',
'_message': 'message'
},
_out_variable_name='return')
def send_email(_to, _from, _message):
# do email sending here
return repr((_to, _from, _message, 'sent!'))
if __name__ == '__main__':
try:
from wsgiref.simple_server import make_server
except ImportError:
print("Error: example server code requires Python >= 2.5")
application = Application([EmailManager],
'rpclib.examples.events',
interface=Wsdl11(),
in_protocol=Soap11(),
out_protocol=Soap11())
server = make_server('127.0.0.1', 7789, WsgiApplication(application))
print("listening to http://127.0.0.1:7789")
print("wsdl is at: http://localhost:7789/?wsdl")
server.serve_forever()