PHP RPC::encodeResponseForFailure方法代码示例

 /**
  * Process a call originating from the given request. Uses the
  * {@link RPC#invokeAndEncodeResponse(Object, java.lang.reflect.Method, Object[])}
  * method to do the actual work.
  * <p>
  * Subclasses may optionally override this method to handle the payload in any
  * way they desire (by routing the request to a framework component, for
  * instance). The {@link HttpServletRequest} and {@link HttpServletResponse}
  * can be accessed via the {@link #getThreadLocalRequest()} and
  * {@link #getThreadLocalResponse()} methods.
  * </p>
  * This is public so that it can be unit tested easily without HTTP.
  *
  * @param payload the UTF-8 request payload
  * @return a string which encodes either the method's return, a checked
  *         exception thrown by the method, or an
  *         {@link IncompatibleRemoteServiceException}
  * @throws SerializationException if we cannot serialize the response
  * @throws UnexpectedException if the invocation throws a checked exception
  *           that is not declared in the service method's signature
  * @throws RuntimeException if the service method throws an unchecked
  *           exception (the exception will be the one thrown by the service)
  */
 public function processCall($payload)
 {
     try {
         $this->logger->debug('Processing Call start', $this);
         $rpcRequest = RPC::decodeRequest($payload, $this->getMappedClassLoader(), $this);
         //FOCUS: this method is used only in PHP implementation of GWT RemoteServiceServlet
         $this->onAfterRequestDecoded($rpcRequest);
         $target = $this->getRPCTargetResolverStrategy()->resolveRPCTarget($rpcRequest->getMethod()->getDeclaringMappedClass());
         return RPC::invokeAndEncodeResponse($target, $rpcRequest->getMethod(), $rpcRequest->getParameters(), $rpcRequest->getSerializationPolicy(), $rpcRequest->getMappedClassLoader());
     } catch (IncompatibleRemoteServiceException $ex) {
         $this->logger->log(LoggerLevel::getLevelError(), 'An IncompatibleRemoteServiceException was thrown while processing this call.', $ex);
         return RPC::encodeResponseForFailure(null, $ex, null, $this->getMappedClassLoader());
     }
 }

 /**
  * Returns a string that encodes the result of calling a service method, which
  * could be the value returned by the method or an exception thrown by it.
  *
  * <p>
  * If the serializationPolicy parameter is not <code>null</code>, it is
  * used to determine what types can be encoded as part of this response. If
  * this parameter is <code>null</code>, then only subtypes of
  * {@link com.google.gwt.user.client.rpc.IsSerializable IsSerializable} or
  * types which have custom field serializers may be encoded.
  * </p>
  *
  * <p>
  * This method does no security checking; security checking must be done on
  * the method prior to this invocation.
  * </p>
  *
  * @param Object $target instance on which to invoke the serviceMethod
  * @param MappedMethod $serviceMethod the method to invoke
  * @param array $args arguments used for the method invocation
  * @param SerializationPolicy $serializationPolicy determines the serialization policy to be used
  * @return strinta string which encodes either the method's return or a checked
  *         exception thrown by the method
  *
  * @throws NullPointerException if the serviceMethod or the
  *           serializationPolicy are <code>null</code>
  * @throws SecurityException if the method cannot be accessed or if the number
  *           or type of actual and formal arguments differ
  * @throws SerializationException if an object could not be serialized by the
  *           stream
  * @throws UnexpectedException if the serviceMethod throws a checked exception
  *           that is not declared in its signature
  */
 public static function invokeAndEncodeResponse($target, MappedMethod $serviceMethod, $args, SerializationPolicy $serializationPolicy, MappedClassLoader $mappedClassLoader)
 {
     //Object $target,
     //ReflectionMethod $serviceMethod, array $args,
     //SerializationPolicy $serializationPolicy
     if ($serviceMethod === null) {
         throw new NullPointerException("Not found matches serviceMethod (TIP: did you map your service method correctly?");
     }
     if ($serializationPolicy === null) {
         throw new NullPointerException("serializationPolicy");
     }
     /*String*/
     $responsePayload = '';
     try {
         /*Object*/
         $result = $serviceMethod->invoke($target, $args);
         $responsePayload = RPC::encodeResponseForSuccess($serviceMethod, $result, $serializationPolicy, $mappedClassLoader);
         //} catch (IllegalAccessException $xe) {
         //      SecurityException securityException = new SecurityException(
         //          formatIllegalAccessErrorMessage(target, serviceMethod));
         //      securityException.initCause(e);
         //      throw securityException;
         //    } catch (IllegalArgumentException e) {
         //      SecurityException securityException = new SecurityException(
         //          formatIllegalArgumentErrorMessage(target, serviceMethod, args));
         //      securityException.initCause(e);
         //      throw securityException;
     } catch (Exception $ex) {
         //      // Try to encode the caught exception
         //      //
         //      Throwable cause = e.getCause();
         //
         $responsePayload = RPC::encodeResponseForFailure($serviceMethod, $ex, $serializationPolicy, $mappedClassLoader);
     }
     return $responsePayload;
     //}
     //catch (Exception $ex) {
     //print_r($ex) ;
     //}
 }

 public function processCall($payload)
 {
     $this->checkPermutationStrongName();
     try {
         $rpcRequest = RPC::decodeRequest($payload, Classes::classOf($this->delegate), $this);
         $this->onAfterRequestDeserialized($rpcRequest);
         return RPC::invokeAndEncodeResponse($this->delegate, $rpcRequest->getMethod(), $rpcRequest->getParameters(), $rpcRequest->getSerializationPolicy(), $rpcRequest->getFlags());
     } catch (IncompatibleRemoteServiceException $ex) {
         echo $ex;
         /*log(
         	 "An IncompatibleRemoteServiceException was thrown while processing this call.",
         	 ex);
         	 */
         return RPC::encodeResponseForFailure(null, $ex);
     } catch (RpcTokenException $ex) {
         //log("An RpcTokenException was thrown while processing this call.",
         //tokenException);
         return RPC::encodeResponseForFailure(null, $ex);
     }
 }

 /**
  * @param string $payload
  * @return string|null
  * @throws \IllegalArgumentException
  */
 public function processCall($payload)
 {
     try {
         $this->logger->debug('Processing Call start');
         /** @var \RPCRequest $rpcRequest */
         $rpcRequest = \RPC::decodeRequest($payload, $this->getMappedClassLoader(), $this);
         $this->onAfterRequestDecoded($rpcRequest);
         /** @var \RPCTargetResolverStrategy|Object $target */
         $target = $this->getRPCTargetResolverStrategy()->resolveRPCTarget($rpcRequest->getMethod()->getDeclaringMappedClass());
         $this->pixie->vulnService->goDown(preg_replace('/Impl$/', '', get_class($target)));
         $this->pixie->vulnService->goDown($rpcRequest->getMethod()->getName());
         if ($target instanceof IGWTService) {
             $target->setContext($this->pixie->vulnService->getConfig()->getCurrentContext());
             $target->setRequest($this->request);
         }
         return RPC::invokeAndEncodeResponse($target, $rpcRequest->getMethod(), $rpcRequest->getParameters(), $rpcRequest->getSerializationPolicy(), $rpcRequest->getMappedClassLoader());
     } catch (\IncompatibleRemoteServiceException $ex) {
         $this->logger->log(\LoggerLevel::getLevelError(), 'An IncompatibleRemoteServiceException was thrown while processing this call.', $ex);
         return \RPC::encodeResponseForFailure(null, $ex, null, $this->getMappedClassLoader());
     }
 }