def _processRemotingMessage(self, amf_request, ro_request, **kwargs):
ro_response = amf3.generate_acknowledgement(ro_request)
amf_response = remoting.Response(ro_response,
status=remoting.STATUS_OK)
try:
service_name = ro_request.operation
if hasattr(ro_request, 'destination') and ro_request.destination:
service_name = '%s.%s' % (ro_request.destination, service_name)
service_request = self.gateway.getServiceRequest(
amf_request, service_name)
except gateway.UnknownServiceError:
return defer.succeed(
remoting.Response(self.buildErrorResponse(ro_request),
status=remoting.STATUS_ERROR))
deferred_response = defer.Deferred()
def eb(failure):
errMesg = "%s: %s" % (failure.type, failure.getErrorMessage())
if self.gateway.logger:
self.gateway.logger.error(errMesg)
self.gateway.logger.info(failure.getTraceback())
ro_response = self.buildErrorResponse(
ro_request, (failure.type, failure.value, failure.tb))
deferred_response.callback(
remoting.Response(ro_response, status=remoting.STATUS_ERROR))
def response_cb(result):
ro_response.body = result
res = remoting.Response(ro_response)
if self.gateway.logger:
self.gateway.logger.debug("AMF Response: %r" % (res, ))
deferred_response.callback(res)
def process_cb(result):
d = defer.maybeDeferred(self.gateway.callServiceRequest,
service_request, *ro_request.body,
**kwargs)
d.addCallback(response_cb).addErrback(eb)
d = defer.maybeDeferred(self.gateway.preprocessRequest,
service_request, *ro_request.body, **kwargs)
d.addCallback(process_cb).addErrback(eb)
return deferred_response
def _processRemotingMessage(self, amf_request, ro_request, **kwargs):
ro_response = amf3.generate_acknowledgement(ro_request)
amf_response = remoting.Response(ro_response, status=remoting.STATUS_OK)
try:
service_name = ro_request.operation
if hasattr(ro_request, 'destination') and ro_request.destination:
service_name = '%s.%s' % (ro_request.destination, service_name)
service_request = self.gateway.getServiceRequest(amf_request, service_name)
except gateway.UnknownServiceError, e:
return defer.succeed(remoting.Response(self.buildErrorResponse(ro_request), status=remoting.STATUS_ERROR))
def __call__(self, request, *args, **kwargs):
"""
Calls the underlying service method.
@return: A C{Deferred} that will contain the AMF L{Response}.
@rtype: C{twisted.internet.defer.Deferred}
"""
try:
service_request = self.gateway.getServiceRequest(
request, request.target)
except gateway.UnknownServiceError:
return defer.succeed(self.buildErrorResponse(request))
response = remoting.Response(None)
deferred_response = defer.Deferred()
def eb(failure):
errMesg = "%s: %s" % (failure.type, failure.getErrorMessage())
if self.gateway.logger:
self.gateway.logger.error(errMesg)
self.gateway.logger.info(failure.getTraceback())
deferred_response.callback(
self.buildErrorResponse(
request, (failure.type, failure.value, failure.tb)))
def response_cb(result):
response.body = result
deferred_response.callback(response)
def preprocess_cb(result):
d = defer.maybeDeferred(self._getBody, request, response,
service_request, **kwargs)
d.addCallback(response_cb).addErrback(eb)
def auth_cb(result):
if result is not True:
response.status = remoting.STATUS_ERROR
response.body = remoting.ErrorFault(
code='AuthenticationError',
description='Authentication failed')
deferred_response.callback(response)
return
d = defer.maybeDeferred(self.gateway.preprocessRequest,
service_request, *args, **kwargs)
d.addCallback(preprocess_cb).addErrback(eb)
# we have a valid service, now attempt authentication
d = defer.maybeDeferred(self.authenticateRequest, request,
service_request, **kwargs)
d.addCallback(auth_cb).addErrback(eb)
return deferred_response
def test_response(self):
r = remoting.Response('€±')
self.assertEqual(
repr(r),
"<Response status=/onResult>u'\\u20ac\\xb1'</Response>"
)
def test_response(self):
"""
Test encoding of request body.
"""
msg = remoting.Envelope(pyamf.AMF0)
msg['/1'] = remoting.Response(body=[1, 2, 3])
self.assertEqual(len(msg), 1)
x = msg['/1']
self.assertTrue(isinstance(x, remoting.Response))
self.assertEqual(x.envelope, msg)
self.assertEqual(x.body, [1, 2, 3])
self.assertEqual(x.status, 0)
self.assertEqual(x.headers, msg.headers)
self.assertEqual(
remoting.encode(msg).getvalue(),
'\x00\x00\x00\x00'
'\x00\x01\x00\x0b/1/onResult\x00\x04null\x00\x00\x00\x00\n\x00\x00'
'\x00\x03\x00?\xf0\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00'
'\x00\x00\x00\x00@\x08\x00\x00\x00\x00\x00\x00'
)
def _processCommandMessage(self, amf_request, ro_request, **kwargs):
"""
@raise ServerCallFailed: Unknown Command operation.
@raise ServerCallFailed: Authorization is not supported in RemoteObject.
"""
ro_response = generate_acknowledgement(ro_request)
if ro_request.operation == messaging.CommandMessage.PING_OPERATION:
ro_response.body = True
return remoting.Response(ro_response)
elif ro_request.operation == messaging.CommandMessage.LOGIN_OPERATION:
raise ServerCallFailed("Authorization is not supported in RemoteObject")
elif ro_request.operation == messaging.CommandMessage.DISCONNECT_OPERATION:
return remoting.Response(ro_response)
else:
raise ServerCallFailed("Unknown Command operation %s" % ro_request.operation)
def eb(failure):
errMesg = "%s: %s" % (failure.type, failure.getErrorMessage())
self.gateway.logger.error(errMesg)
self.gateway.logger.info(failure.getTraceback())
ro_response = self.buildErrorResponse(
ro_request, (failure.type, failure.value, failure.tb))
deferred_response.callback(
remoting.Response(ro_response, status=remoting.STATUS_ERROR))
def response_cb(result):
ro_response.body = result
res = remoting.Response(ro_response)
if self.gateway.logger:
self.gateway.logger.debug("AMF Response: %r" % (res, ))
deferred_response.callback(res)
def test_response(self):
msg = remoting.Envelope(pyamf.AMF0)
msg['/1'] = remoting.Response(['spam'])
self.assertEqual(remoting.encode(msg, strict=True).getvalue(),
'\x00\x00\x00\x00\x00\x01\x00\x0b/1/onResult\x00\x04null\x00\x00'
'\x00\x0c\n\x00\x00\x00\x01\x02\x00\x04spam')
def test_stream_pos(self):
"""
Ensure that the stream pointer is placed at the beginning.
"""
msg = remoting.Envelope(pyamf.AMF0, pyamf.ClientTypes.Flash6)
msg['/1'] = remoting.Response(body=[1, 2, 3])
stream = remoting.encode(msg)
self.assertEquals(stream.tell(), 0)
class AMF0RequestProcessor(amf0.RequestProcessor):
"""
A Twisted friendly implementation of
L{amf0.RequestProcessor<pyamf.remoting.amf0.RequestProcessor>}
"""
def __call__(self, request, *args, **kwargs):
"""
Calls the underlying service method.
@return: A C{Deferred} that will contain the AMF L{Response}.
@rtype: C{twisted.internet.defer.Deferred}
"""
try:
service_request = self.gateway.getServiceRequest(request, request.target)
except gateway.UnknownServiceError, e:
return defer.succeed(self.buildErrorResponse(request))
response = remoting.Response(None)
deferred_response = defer.Deferred()
def eb(failure):
self.gateway.logger.debug(failure.printTraceback())
deferred_response.callback(self.buildErrorResponse(
request, (failure.type, failure.value, failure.tb)))
def response_cb(result):
self.gateway.logger.debug("AMF Response: %r" % result)
response.body = result
deferred_response.callback(response)
def preprocess_cb(result):
d = defer.maybeDeferred(self._getBody, request, response, service_request, **kwargs)
d.addCallback(response_cb).addErrback(eb)
def auth_cb(result):
if result is not True:
response.status = remoting.STATUS_ERROR
response.body = remoting.ErrorFault(code='AuthenticationError',
description='Authentication failed')
deferred_response.callback(response)
return
d = defer.maybeDeferred(self.gateway.preprocessRequest, service_request, *args, **kwargs)
d.addCallback(preprocess_cb).addErrback(eb)
# we have a valid service, now attempt authentication
d = defer.maybeDeferred(self.authenticateRequest, request, service_request, **kwargs)
d.addCallback(auth_cb).addErrback(eb)
return deferred_response
def __call__(self, request, *args, **kwargs):
"""
Processes an AMF0 request.
@param request: The request to be processed.
@type request: L{Request<pyamf.remoting.Request>}
@return: The response to the request.
@rtype: L{Response<pyamf.remoting.Response>}
"""
response = remoting.Response(None)
try:
service_request = self.gateway.getServiceRequest(
request, request.target)
except gateway.UnknownServiceError:
return self.buildErrorResponse(request)
# we have a valid service, now attempt authentication
try:
authd = self.authenticateRequest(request, service_request, *args,
**kwargs)
except (SystemExit, KeyboardInterrupt):
raise
except:
return self.buildErrorResponse(request)
if not authd:
# authentication failed
response.status = remoting.STATUS_ERROR
response.body = remoting.ErrorFault(
code='AuthenticationError',
description='Authentication failed')
return response
# authentication succeeded, now fire the preprocessor (if there is one)
try:
self.gateway.preprocessRequest(service_request, *args, **kwargs)
except (SystemExit, KeyboardInterrupt):
raise
except:
return self.buildErrorResponse(request)
try:
response.body = self._getBody(request, response, service_request,
*args, **kwargs)
return response
except (SystemExit, KeyboardInterrupt):
raise
except:
return self.buildErrorResponse(request)
def test_encode_bytearray(self):
from pyamf.amf3 import ByteArray
stream = ByteArray()
stream.write('12345678')
msg = remoting.Envelope(pyamf.AMF0)
msg['/1'] = remoting.Response([stream])
self.assertEqual(remoting.encode(msg).getvalue(),
'\x00\x00\x00\x00\x00\x01\x00\x0b/1/onResult\x00\x04null'
'\x00\x00\x00\x00\n\x00\x00\x00\x01\x11\x0c\x1112345678')
def test_xml_amf3(self):
from pyamf.util import ET
msg = remoting.Envelope(pyamf.AMF0, pyamf.ClientTypes.Flash9)
xml_str = '<root><sections><section /><section /></sections></root>'
msg['/1'] = remoting.Response(body=ET.fromstring(xml_str),
envelope=msg)
buf = remoting.encode(msg)
self.assertEquals(
buf.getvalue(), '\x00\x03\x00\x00\x00\x01\x00\x0b/1'
'/onResult\x00\x04null\x00\x00\x00\x00\x11\x0bq<root><sections>'
'<section /><section /></sections></root>')
def _processRemotingMessage(self, amf_request, ro_request, **kwargs):
ro_response = generate_acknowledgement(ro_request)
service_name = get_service_name(ro_request)
service_request = self.gateway.getServiceRequest(
amf_request, service_name)
# fire the preprocessor (if there is one)
self.gateway.preprocessRequest(service_request, *ro_request.body,
**kwargs)
ro_response.body = self.gateway.callServiceRequest(
service_request, *ro_request.body, **kwargs)
return remoting.Response(ro_response)
def buildErrorResponse(self, request, error=None):
"""
Builds an error response.
@param request: The AMF request
@type request: L{Request<pyamf.remoting.Request>}
@return: The AMF response
@rtype: L{Response<pyamf.remoting.Response>}
"""
if error is not None:
cls, e, tb = error
else:
cls, e, tb = sys.exc_info()
return remoting.Response(build_fault(cls, e, tb),
status=remoting.STATUS_ERROR)
def __call__(self, request, *args, **kwargs):
"""
Processes an AMF0 request.
@param request: The request to be processed.
@type request: L{Request<pyamf.remoting.Request>}
@return: The response to the request.
@rtype: L{Response<pyamf.remoting.Response>}
"""
response = remoting.Response(None)
try:
service_request = self.gateway.getServiceRequest(
request, request.target)
except gateway.UnknownServiceError, e:
return self.buildErrorResponse(request)
def test_timezone(self):
"""
Ensure that the timezone offsets work as expected
"""
import datetime
d = datetime.datetime(2009, 9, 24, 15, 52, 12)
td = datetime.timedelta(hours=-5)
msg = remoting.Envelope(pyamf.AMF0)
msg['/1'] = remoting.Response(body=[d])
stream = remoting.encode(msg, timezone_offset=td).getvalue()
self.assertEqual(stream, '\x00\x00\x00\x00\x00\x01\x00\x0b/1/onResult'
'\x00\x04null\x00\x00\x00\x00\n\x00\x00\x00\x01\x0bBr>\xdd5\x06'
'\x00\x00\x00\x00')
def __call__(self, amf_request, **kwargs):
"""
Processes an AMF3 Remote Object request.
@param amf_request: The request to be processed.
@type amf_request: L{Request<pyamf.remoting.Request>}
@return: The response to the request.
@rtype: L{Response<pyamf.remoting.Response>}
"""
ro_request = amf_request.body[0]
try:
return self._getBody(amf_request, ro_request, **kwargs)
except (KeyboardInterrupt, SystemExit):
raise
except:
return remoting.Response(self.buildErrorResponse(ro_request),
status=remoting.STATUS_ERROR)
def _processRemotingMessage(self, amf_request, ro_request, **kwargs):
ro_response = generate_acknowledgement(ro_request)
service_name = ro_request.operation
if hasattr(ro_request, 'destination') and ro_request.destination:
service_name = '%s.%s' % (ro_request.destination, service_name)
service_request = self.gateway.getServiceRequest(amf_request,
service_name)
# fire the preprocessor (if there is one)
self.gateway.preprocessRequest(service_request, *ro_request.body,
**kwargs)
ro_response.body = self.gateway.callServiceRequest(service_request,
*ro_request.body, **kwargs)
return remoting.Response(ro_response)
def message_to_pyamf(msg, packet, status):
"""Converts an AmFast Message to a PyAmf Response.
arguments:
===========
* msg - amfast.remoting.Message
* packet - pyamf.remoting.Envelope
* status - string
Returns pyamf.remoting.Response
"""
message = pyamf_remoting.Response(msg.body)
message.envelope = packet
for k, v in pyamf_remoting.STATUS_CODES.iteritems():
if v == status:
message.status = k
break
return message
def setUp(self):
import gzip
env = remoting.Envelope(pyamf.AMF3)
r = remoting.Response(['foo' * 50000] * 200)
env['/1'] = r
response = remoting.encode(env).getvalue()
buf = util.BufferedByteStream()
x = gzip.GzipFile(fileobj=buf, mode='wb')
x.write(response)
x.close()
self.canned_response = buf.getvalue()
BaseServiceTestCase.setUp(self)
self.headers['Content-Encoding'] = 'gzip'
def __call__(self, amf_request, **kwargs):
"""
Processes an AMF3 Remote Object request.
@param amf_request: The request to be processed.
@type amf_request: L{Request<pyamf.remoting.Request>}
@return: The response to the request.
@rtype: L{Response<pyamf.remoting.Response>}
"""
ro_request = amf_request.body[0]
try:
body = self._getBody(amf_request, ro_request, **kwargs)
except (KeyboardInterrupt, SystemExit):
raise
except:
fault = self.buildErrorResponse(ro_request)
if hasattr(self.gateway, 'onServiceError'):
self.gateway.onServiceError(ro_request, fault)
elif self.logger:
self.logger.exception(
'Unexpected error while processing request %r',
get_service_name(ro_request))
body = remoting.Response(fault, status=remoting.STATUS_ERROR)
ro_response = body.body
dsid = ro_request.headers.get('DSId', None)
if not dsid or dsid == 'nil':
dsid = generate_random_id()
ro_response.headers.setdefault('DSId', dsid)
return body
def eb(failure):
self.gateway.logger.debug(failure.printTraceback())
ro_response = self.buildErrorResponse(ro_request, (failure.type, failure.value, failure.tb))
deferred_response.callback(remoting.Response(ro_response, status=remoting.STATUS_ERROR))
def response_cb(result):
self.gateway.logger.debug("AMF Response: %r" % result)
ro_response.body = result
deferred_response.callback(remoting.Response(ro_response))
def execute_single(self, request):
body = remoting.ErrorFault(code='TypeError',
description='foobar')
return remoting.Response(status=remoting.STATUS_ERROR,
body=body)
def _processAsyncMessage(self, amf_request, ro_request, **kwargs):
ro_response = generate_acknowledgement(ro_request)
ro_response.body = True
return remoting.Response(ro_response)
def response_cb(result):
ro_response.body = result
res = remoting.Response(ro_response)
deferred_response.callback(res)
