protected function useResponse(Request $request, Response $response, $unserializeResult = true)
{
$this->transport->expects($this->once())->method('receiveResponse')->will($this->returnValue($response));
if ($unserializeResult && ($request->isExpectingResult() || $response->getType() === MessageTypes::ERROR)) {
$contentType = $response->getHeaders()->get('content-type');
$this->serializer->expects($this->once())->method($response->getType() === MessageTypes::ERROR ? 'unserializeError' : 'unserializeResult')->with($request->getMethodName(), $response->getResultBody(), $contentType)->will($this->returnValue($response->getResultBody()));
}
}
public function testArgumentsShouldBeUnserializedUsingRequestContentType()
{
$request = new Request(MessageTypes::ONE_WAY, 'owc', array('zia'));
$request->getHeaders()->set('content-type', 'application/wookieb');
$this->useRequest($request);
$this->rpcTarget->expects($this->once())->method('owc')->with('zia')->will($this->returnValue('OK'));
$response = new Response(MessageTypes::ONE_WAY_ACK);
$this->useResponse($request, $response);
$this->object->handleCall();
}
public function testHeadersForwarding()
{
$this->object->setForwardedHeaders(array('custom-header'));
$request = new Request(MessageTypes::PING);
$request->getHeaders()->set('request-id', '1234567890')->set('custom-header', 'some value')->set('next-custom-header', 'next value');
$this->useRequest($request);
$response = new Response(MessageTypes::PONG);
$response->getHeaders()->set('request-id', '1234567890')->set('custom-header', 'some value');
$this->useResponse($request, $response);
$this->object->handleCall();
}
protected function useResponse(Request $request, Response $response, $filter = null)
{
if ($request->isExpectingResult()) {
$this->serializer->expects($this->once())->method($response->getType() === MessageTypes::ERROR ? 'serializeError' : 'serializeResult')->with($request->getMethodName(), $this->equalTo($response->getResultBody(), 0, 0), $response->getHeaders()->get('content-type'))->will($this->returnValue($response->getResultBody()));
} else {
$this->serializer->expects($this->never())->method('serializeResult');
}
if (!$filter) {
$filter = function () {
};
}
$this->transport->expects($this->once())->method('sendResponse')->with($response)->will($this->returnCallback($filter));
}
/**
* {@inheritDoc}
*/
public function receiveRequest()
{
try {
$message = $this->socket->recvMulti();
} catch (\Exception $e) {
throw new TransportException('Unable to receive request', null, $e);
}
$this->waitingForResponse = true;
$requestType = $message[0];
if (!MessageTypes::isValid($requestType)) {
throw new FormatException('Invalid request type "' . $requestType . '"', $message);
}
$request = new Request($requestType);
$request->setHeaders(new Headers(Parser::parseHeaders(@$message[1])));
if ($requestType !== MessageTypes::PING) {
if (empty($message[2])) {
throw new FormatException('Method name is empty', $message);
}
$request->setMethodName($message[2]);
$arguments = array_slice($message, 3);
$request->setArgumentsBody($arguments);
}
return $request;
}
/**
* {@inheritDoc}
*/
public function sendRequest(Request $request)
{
$message = array($request->getType(), (string) $request->getHeaders());
if ($request->getType() !== MessageTypes::PING) {
$message[] = $request->getMethodName();
foreach ($request->getArgumentsBody() as $argument) {
$message[] = $argument;
}
}
try {
$this->socket->sendMulti($message);
} catch (\ZMQSocketException $e) {
throw new TransportException('Cannot send request', 0, $e);
}
}
private function handleError(Response $response, Request $request)
{
$responseData = $this->serializer->unserializeError($request->getMethodName(), $response->getResultBody(), $response->getHeaders()->get('Content-Type'));
if ($responseData instanceof \Exception) {
$this->replaceExceptionTrace($responseData);
throw $responseData;
}
if ($request->getType() === MessageTypes::PING) {
$msg = 'Error caught during ping';
} else {
$msg = 'Error caught during execution of method "' . $request->getMethodName() . '"';
}
throw new ErrorResponseException($msg, $responseData);
}
public function testUsingCustomHeadersThatOverrideDefaultHeaders()
{
$defaultHeaders = new Headers(array('custom-header' => 'custom header value', 'next-custom-header' => 'next custom header value'));
$this->object->setDefaultHeaders($defaultHeaders);
$headers = new Headers(array('custom-header' => 'content'));
$request = new Request(MessageTypes::PING, null, null, $headers);
$request->setHeaders(new Headers(array('custom-header' => 'content', 'next-custom-header' => 'next custom header value')));
$this->useRequest($request);
$response = new Response(MessageTypes::PONG);
$this->useResponse($request, $response);
$this->object->ping($headers);
}
private function runMethodForRequest(Request $request)
{
$methodType = self::$messageTypeToMethodType[$request->getType()];
$method = $this->getMethod($request->getMethodName(), $methodType);
$arguments = $this->serializer->unserializeArguments($request->getMethodName(), $request->getArgumentsBody(), $request->getHeaders()->get('content-type'));
$response = new Response();
$headers = clone $this->headers;
$response->setHeaders($headers);
switch ($methodType) {
case MethodTypes::BASIC:
try {
$result = $method->call($arguments, $request, $headers);
$this->createResponse(MessageTypes::RESPONSE, $result, $response, $request);
} catch (\Exception $e) {
$this->createResponse(MessageTypes::ERROR, $e, $response, $request);
}
$this->transport->sendResponse($response);
break;
case MethodTypes::ONE_WAY:
$this->createResponse(MessageTypes::ONE_WAY_ACK, null, $response, $request);
$this->transport->sendResponse($response);
$method->call($arguments, $request);
break;
case MethodTypes::PUSH:
$self = $this;
$ackCalled = false;
$result = null;
$transport = $this->transport;
// hack for php 5.3 which makes "createResponse" accessible from closure
$createResponseMethod = new \ReflectionMethod($this, 'createResponse');
$createResponseMethod->setAccessible(true);
$ack = function ($result = null) use($self, &$ackCalled, $response, $request, $transport, $createResponseMethod) {
if ($ackCalled) {
return;
}
$ackCalled = true;
$createResponseMethod->invoke($self, MessageTypes::PUSH_ACK, $result, $response, $request);
$transport->sendResponse($response);
};
try {
$result = $method->call($arguments, $request, $headers, $ack);
$ack($result);
} catch (\Exception $e) {
// we cannot send error message when ack was called before that moment
if ($ackCalled) {
throw $e;
}
$ackCalled = true;
$this->createResponse(MessageTypes::ERROR, $e, $response, $request);
$self->transport->sendResponse($response);
}
break;
}
}
