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)