def test_multiple_return_sd_0(self):
class SomeService(ServiceBase):
@srpc(_returns=Iterable(Integer))
def some_call():
return 1, 2
app = Application([SomeService], 'tns', JsonObject(), JsonObject(),
Wsdl11())
server = ServerBase(app)
initial_ctx = MethodContext(server)
initial_ctx.in_string = ['{"some_call":{}}']
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
server.get_out_object(ctx)
server.get_out_string(ctx)
assert list(ctx.out_string) == ['{"some_callResponse": {"some_callResult": {"integer": [1, 2]}}}' ]
server = ServerBase(app)
initial_ctx = MethodContext(server)
initial_ctx.in_string = ['{"some_call":[]}']
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
server.get_out_object(ctx)
server.get_out_string(ctx)
assert list(ctx.out_string) == ['{"some_callResponse": {"some_callResult": {"integer": [1, 2]}}}']
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', JsonObject(), JsonObject(),
Wsdl11())
server = ServerBase(app)
initial_ctx = MethodContext(server)
initial_ctx.in_string = ['{"some_call":{"ccm": {"c":{"i":3, "s": "3x"}, "i":4, "s": "4x"}}}']
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
server.get_out_object(ctx)
server.get_out_string(ctx)
ret = json.loads(''.join(ctx.out_string))
print ret
assert ret['some_callResponse']['some_callResult']['i'] == 4
assert ret['some_callResponse']['some_callResult']['s'] == '4x'
assert ret['some_callResponse']['some_callResult']['c']['i'] == 3
assert ret['some_callResponse']['some_callResult']['c']['s'] == '3x'
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 serve_forever(self):
while True:
last = self.session.query(WorkerStatus).with_lockmode("update") \
.filter_by(worker_id=self.id).one()
task_queue = self.session.query(TaskQueue) \
.filter(TaskQueue.id > last.task_id) \
.order_by(TaskQueue.id)
for task in task_queue:
initial_ctx = MethodContext(self.app)
initial_ctx.in_string = [task.data]
initial_ctx.transport.consumer_id = self.id
initial_ctx.transport.task_id = task.id
for ctx in self.generate_contexts(initial_ctx, 'utf8'):
self.get_in_object(ctx)
if ctx.in_error:
self.get_out_string(ctx)
logging.error(''.join(ctx.out_string))
continue
self.get_out_object(ctx)
if ctx.out_error:
self.get_out_string(ctx)
logging.error(''.join(ctx.out_string))
continue
self.get_out_string(ctx)
logging.debug(''.join(ctx.out_string))
last.task_id = task.id
self.session.commit()
time.sleep(10)
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',
)
server = ServerBase(application)
ctx = MethodContext(server)
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>
"""]
server.get_in_object(ctx)
self.assertEquals(isinstance(ctx.in_error, ValidationError), True)
def serve_forever(self):
while True:
last = self.session.query(WorkerStatus).with_lockmode("update") \
.filter_by(worker_id=self.id).one()
task_queue = self.session.query(TaskQueue) \
.filter(TaskQueue.id > last.task_id) \
.order_by(TaskQueue.id)
for task in task_queue:
initial_ctx = MethodContext(self.app)
initial_ctx.in_string = [task.data]
initial_ctx.transport.consumer_id = self.id
initial_ctx.transport.task_id = task.id
for ctx in self.generate_contexts(initial_ctx, 'utf8'):
self.get_in_object(ctx)
if ctx.in_error:
self.get_out_string(ctx)
logging.error(''.join(ctx.out_string))
continue
self.get_out_object(ctx)
if ctx.out_error:
self.get_out_string(ctx)
logging.error(''.join(ctx.out_string))
continue
self.get_out_string(ctx)
logging.debug(''.join(ctx.out_string))
last.task_id = task.id
self.session.commit()
time.sleep(10)
def test_invalid_input(self):
class SomeService(ServiceBase):
@srpc()
def yay():
pass
app = Application([SomeService], 'tns', JsonObject(), JsonObject(), Wsdl11())
server = ServerBase(app)
initial_ctx = MethodContext(server)
initial_ctx.in_string = ['{"some_call": {"yay": ]}}']
ctx, = server.generate_contexts(initial_ctx)
assert ctx.in_error.faultcode == 'Client.JsonDecodeError'
def test_invalid_request(self):
class SomeService(ServiceBase):
@srpc(Integer, String, DateTime)
def yay(i,s,d):
print i,s,d
pass
app = Application([SomeService], 'tns', JsonObject(validator='soft'), JsonObject(), Wsdl11())
server = ServerBase(app)
initial_ctx = MethodContext(server)
initial_ctx.in_string = ['{"some_call": {"yay": []}}']
ctx, = server.generate_contexts(initial_ctx)
print ctx.in_error
assert ctx.in_error.faultcode == 'Client.ResourceNotFound'
print
def serve_forever(self):
while True:
ctx.in_string = self.soap_socket.recv()
ctx = MethodContext(self.app)
self.get_in_object(ctx)
if ctx.in_error:
ctx.out_object = ctx.in_error
else:
self.get_out_object(ctx)
if ctx.out_error:
ctx.out_object = ctx.out_error
self.get_out_string(ctx, ctx.out_object)
self.soap_socket.send("".join(ctx.out_string))
def test_invalid_number(self):
class SomeService(ServiceBase):
@srpc(Integer, String, DateTime)
def yay(i,s,d):
print i,s,d
pass
app = Application([SomeService], 'tns', JsonObject(validator='soft'),
JsonObject(), Wsdl11())
server = ServerBase(app)
initial_ctx = MethodContext(server)
initial_ctx.in_string = ['{"yay": ["s", "B"]}']
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
assert ctx.in_error.faultcode == 'Client.ValidationError'
def test_multiple_dict_array(self):
class SomeService(ServiceBase):
@srpc(Iterable(String), _returns=Iterable(String))
def some_call(s):
return s
app = Application([SomeService], 'tns', JsonObject(), JsonObject(), Wsdl11())
server = ServerBase(app)
initial_ctx = MethodContext(server)
initial_ctx.in_string = ['{"some_call":{"s":["a","b"]}}']
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
server.get_out_object(ctx)
server.get_out_string(ctx)
assert list(ctx.out_string) == ['{"some_callResponse": {"some_callResult": {"string": ["a", "b"]}}}']
def test_missing_value(self):
class SomeService(ServiceBase):
@srpc(Integer, String, Mandatory.DateTime)
def yay(i,s,d):
print i,s,d
pass
app = Application([SomeService], 'tns', JsonObject(validator='soft'),
JsonObject(), Wsdl11())
server = ServerBase(app)
initial_ctx = MethodContext(server)
initial_ctx.in_string = ['{"yay": [1, "B"]}']
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
print ctx.in_error.faultstring
assert ctx.in_error.faultcode == 'Client.ValidationError'
assert ctx.in_error.faultstring.endswith("frequency constraints.")
def __init__(self, url, app, name, out_header):
self.url = url
self.app = app
self.ctx = MethodContext()
self.ctx.method_name = name
self.ctx.service_class = self.app.get_service_class(name)
self.ctx.service = self.app.get_service(self.ctx.service_class)
self.ctx.service.out_header = out_header
self.ctx.descriptor = self.ctx.service.get_method(self.ctx.method_name)
def test_multiple_dict_complex_array(self):
class CM(ComplexModel):
i = Integer
s = String
class CCM(ComplexModel):
c = CM
i = Integer
s = String
class ECM(CCM):
d = DateTime
class SomeService(ServiceBase):
@srpc(Iterable(ECM), _returns=Iterable(ECM))
def some_call(ecm):
return ecm
app = Application([SomeService], 'tns', JsonObject(), JsonObject(), Wsdl11())
server = ServerBase(app)
initial_ctx = MethodContext(server)
initial_ctx.in_string = ['{"some_call": {"ecm": [{"c": {"i":3, "s": "3x"}, "i":4, "s": "4x", "d": "2011-12-13T14:15:16Z"}]}}']
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
server.get_out_object(ctx)
print ctx.in_object
server.get_out_string(ctx)
ret = json.loads(''.join(ctx.out_string))
print ret
assert ret['some_callResponse']
assert ret['some_callResponse']['some_callResult']
assert ret['some_callResponse']['some_callResult']['ECM']
assert ret['some_callResponse']['some_callResult']['ECM'][0]
assert ret['some_callResponse']['some_callResult']['ECM'][0]["c"]
assert ret['some_callResponse']['some_callResult']['ECM'][0]["c"]["i"] == 3
assert ret['some_callResponse']['some_callResult']['ECM'][0]["c"]["s"] == "3x"
assert ret['some_callResponse']['some_callResult']['ECM'][0]["i"] == 4
assert ret['some_callResponse']['some_callResult']['ECM'][0]["s"] == "4x"
assert ret['some_callResponse']['some_callResult']['ECM'][0]["d"] == "2011-12-13T14:15:16+00:00"
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', JsonObject(), JsonObject(),
Wsdl11())
server = ServerBase(app)
initial_ctx = MethodContext(server)
initial_ctx.in_string = ['{"some_call":[]}']
ctx, = server.generate_contexts(initial_ctx)
server.get_in_object(ctx)
server.get_out_object(ctx)
server.get_out_string(ctx)
assert list(ctx.out_string) == ['{"some_callResponse": {"some_callResult": {"i": 5, "s": "5x"}}}']
def serve_forever(self):
while True:
in_string = self.soap_socket.recv()
ctx = MethodContext()
in_object = self.get_in_object(ctx, in_string)
if ctx.in_error:
out_object = ctx.in_error
else:
out_object = self.get_out_object(ctx, in_object)
if ctx.out_error:
out_object = ctx.out_error
out_string = self.get_out_string(ctx, out_object)
self.soap_socket.send(''.join(out_string))
def __call__(self, *args, **kwargs):
initial_ctx = MethodContext(self)
initial_ctx.method_request_string = self.__key
initial_ctx.in_header = self.__in_header
initial_ctx.in_object = args
initial_ctx.transport.type = NullServer.transport
contexts = self.app.in_protocol.generate_method_contexts(initial_ctx)
cnt = 0
retval = None
logger.warning( "%s start request %s" % (_big_header, _big_footer) )
for ctx in contexts:
if cnt == 0:
p_ctx = ctx
else:
ctx.descriptor.aux.initialize_context(ctx, p_ctx, error=None)
# do logging.getLogger('rpclib.server.null').setLevel(logging.CRITICAL)
# to hide the following
logger.warning( "%s start context %s" % (_small_header, _small_footer) )
self.app.process_request(ctx)
logger.warning( "%s end context %s" % (_small_header, _small_footer) )
if ctx.out_error:
raise ctx.out_error
else:
if len(ctx.descriptor.out_message._type_info) == 0:
_retval = None
elif len(ctx.descriptor.out_message._type_info) == 1:
_retval = ctx.out_object[0]
# workaround to have the context disposed of when the caller is
# done with the return value. the context is sometimes needed to
# fully construct the return object (e.g. when the object is a
# sqlalchemy object bound to a session that's defined in the
# context object).
try:
_retval.__ctx__ = ctx
except AttributeError:
# not all objects let this happen. (eg. built-in types
# like str, but they don't need the context anyway).
pass
else:
_retval = ctx.out_object
# same as above
try:
_retval[0].__ctx__ = ctx
except AttributeError:
pass
if cnt == 0:
retval = _retval
cnt += 1
logger.warning( "%s end request %s" % (_big_header, _big_footer) )
return retval
def __init__(self, app, req_env, content_type):
MethodContext.__init__(self, app)
self.transport = WsgiTransportContext(req_env, content_type)
"""Holds the WSGI-specific information"""
def __init__(self, app, req_env, content_type):
MethodContext.__init__(self, app)
self.transport = WsgiTransportContext(req_env, content_type)
"""Holds the WSGI-specific information"""
def __init__(self, transport, req_env, content_type):
MethodContext.__init__(self, transport)
self.transport = HttpTransportContext(transport, req_env, content_type)
"""Holds the WSGI-specific information"""
