interface/modules/zend_modules/library/Zend/Json/Server/Server.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Json\Server;
  11
  12 use ReflectionFunction;
  13 use ReflectionMethod;
  14 use Zend\Server\AbstractServer;
  15 use Zend\Server\Definition;
  16 use Zend\Server\Method;
  17 use Zend\Server\Reflection;
  18
  19 class Server extends AbstractServer
  20 {
  21     /**#@+
  22      * Version Constants
  23      */
  24     const VERSION_1 = '1.0';
  25     const VERSION_2 = '2.0';
  26     /**#@-*/
  27
  28     /**
  29      * Flag: whether or not to auto-emit the response
  30      * @var bool
  31      */
  32     protected $returnResponse = false;
  33
  34     /**
  35      * Inherited from Zend\Server\AbstractServer
  36      *
  37      * @var bool Flag; allow overwriting existing methods when creating server definition
  38      */
  39     protected $overwriteExistingMethods = true;
  40
  41     /**
  42      * Request object
  43      * @var Request
  44      */
  45     protected $request;
  46
  47     /**
  48      * Response object
  49      * @var Response
  50      */
  51     protected $response;
  52
  53     /**
  54      * SMD object
  55      * @var Smd
  56      */
  57     protected $serviceMap;
  58
  59     /**
  60      * SMD class accessors
  61      * @var array
  62      */
  63     protected $smdMethods;
  64
  65     /**
  66      * Attach a function or callback to the server
  67      *
  68      * @param  string|array|callable $function   Valid PHP callback
  69      * @param  string                $namespace  Ignored
  70      * @throws Exception\InvalidArgumentException if function invalid or not callable
  71      * @return Server
  72      */
  73     public function addFunction($function, $namespace = '')
  74     {
  75         if (!is_string($function) && (!is_array($function) || (2 > count($function)))) {
  76             throw new Exception\InvalidArgumentException('Unable to attach function; invalid');
  77         }
  78
  79         if (!is_callable($function)) {
  80             throw new Exception\InvalidArgumentException('Unable to attach function; does not exist');
  81         }
  82
  83         $argv = null;
  84         if (2 < func_num_args()) {
  85             $argv = func_get_args();
  86             $argv = array_slice($argv, 2);
  87         }
  88
  89         $class = null;
  90         if (is_string($function)) {
  91             $method = Reflection::reflectFunction($function, $argv, $namespace);
  92         } else {
  93             $class  = array_shift($function);
  94             $action = array_shift($function);
  95             $reflection = Reflection::reflectClass($class, $argv, $namespace);
  96             $methods = $reflection->getMethods();
  97             $found   = false;
  98             foreach ($methods as $method) {
  99                 if ($action == $method->getName()) {
 100                     $found = true;
 101                     break;
 102                 }
 103             }
 104             if (!$found) {
 105                 $this->fault('Method not found', Error::ERROR_INVALID_METHOD);
 106                 return $this;
 107             }
 108         }
 109
 110         $definition = $this->_buildSignature($method, $class);
 111         $this->_addMethodServiceMap($definition);
 112
 113         return $this;
 114     }
 115
 116     /**
 117      * Register a class with the server
 118      *
 119      * @param  string $class
 120      * @param  string $namespace Ignored
 121      * @param  mixed $argv Ignored
 122      * @return Server
 123      */
 124     public function setClass($class, $namespace = '', $argv = null)
 125     {
 126         if (2 < func_num_args()) {
 127             $argv = func_get_args();
 128             $argv = array_slice($argv, 2);
 129         }
 130
 131         $reflection = Reflection::reflectClass($class, $argv, $namespace);
 132
 133         foreach ($reflection->getMethods() as $method) {
 134             $definition = $this->_buildSignature($method, $class);
 135             $this->_addMethodServiceMap($definition);
 136         }
 137         return $this;
 138     }
 139
 140     /**
 141      * Indicate fault response
 142      *
 143      * @param  string $fault
 144      * @param  int $code
 145      * @param  mixed $data
 146      * @return Error
 147      */
 148     public function fault($fault = null, $code = 404, $data = null)
 149     {
 150         $error = new Error($fault, $code, $data);
 151         $this->getResponse()->setError($error);
 152         return $error;
 153     }
 154
 155     /**
 156      * Handle request
 157      *
 158      * @param  Request $request
 159      * @return null|Response
 160      * @throws Exception\InvalidArgumentException
 161      */
 162     public function handle($request = false)
 163     {
 164         if ((false !== $request) && (!$request instanceof Request)) {
 165             throw new Exception\InvalidArgumentException('Invalid request type provided; cannot handle');
 166         } elseif ($request) {
 167             $this->setRequest($request);
 168         }
 169
 170         // Handle request
 171         $this->_handle();
 172
 173         // Get response
 174         $response = $this->_getReadyResponse();
 175
 176         // Emit response?
 177         if (!$this->returnResponse) {
 178             echo $response;
 179             return;
 180         }
 181
 182         // or return it?
 183         return $response;
 184     }
 185
 186     /**
 187      * Load function definitions
 188      *
 189      * @param  array|Definition $definition
 190      * @throws Exception\InvalidArgumentException
 191      * @return void
 192      */
 193     public function loadFunctions($definition)
 194     {
 195         if (!is_array($definition) && (!$definition instanceof Definition)) {
 196             throw new Exception\InvalidArgumentException('Invalid definition provided to loadFunctions()');
 197         }
 198
 199         foreach ($definition as $key => $method) {
 200             $this->table->addMethod($method, $key);
 201             $this->_addMethodServiceMap($method);
 202         }
 203     }
 204
 205     public function setPersistence($mode)
 206     {
 207     }
 208
 209     /**
 210      * Set request object
 211      *
 212      * @param  Request $request
 213      * @return Server
 214      */
 215     public function setRequest(Request $request)
 216     {
 217         $this->request = $request;
 218         return $this;
 219     }
 220
 221     /**
 222      * Get JSON-RPC request object
 223      *
 224      * @return Request
 225      */
 226     public function getRequest()
 227     {
 228         if (null === ($request = $this->request)) {
 229             $this->setRequest(new Request\Http());
 230         }
 231         return $this->request;
 232     }
 233
 234     /**
 235      * Set response object
 236      *
 237      * @param  Response $response
 238      * @return Server
 239      */
 240     public function setResponse(Response $response)
 241     {
 242         $this->response = $response;
 243         return $this;
 244     }
 245
 246     /**
 247      * Get response object
 248      *
 249      * @return Response
 250      */
 251     public function getResponse()
 252     {
 253         if (null === ($response = $this->response)) {
 254             $this->setResponse(new Response\Http());
 255         }
 256         return $this->response;
 257     }
 258
 259     /**
 260      * Set return response flag
 261      *
 262      * If true, {@link handle()} will return the response instead of
 263      * automatically sending it back to the requesting client.
 264      *
 265      * The response is always available via {@link getResponse()}.
 266      *
 267      * @param  bool $flag
 268      * @return Server
 269      */
 270     public function setReturnResponse($flag = true)
 271     {
 272         $this->returnResponse = ($flag) ? true : false;
 273         return $this;
 274     }
 275
 276     /**
 277      * Retrieve return response flag
 278      *
 279      * @return bool
 280      */
 281     public function getReturnResponse()
 282     {
 283         return $this->returnResponse;
 284     }
 285
 286     // overloading for SMD metadata
 287     /**
 288      * Overload to accessors of SMD object
 289      *
 290      * @param  string $method
 291      * @param  array $args
 292      * @return mixed
 293      */
 294     public function __call($method, $args)
 295     {
 296         if (preg_match('/^(set|get)/', $method, $matches)) {
 297             if (in_array($method, $this->_getSmdMethods())) {
 298                 if ('set' == $matches[1]) {
 299                     $value = array_shift($args);
 300                     $this->getServiceMap()->$method($value);
 301                     return $this;
 302                 } else {
 303                     return $this->getServiceMap()->$method();
 304                 }
 305             }
 306         }
 307         return null;
 308     }
 309
 310     /**
 311      * Retrieve SMD object
 312      *
 313      * @return Smd
 314      */
 315     public function getServiceMap()
 316     {
 317         if (null === $this->serviceMap) {
 318             $this->serviceMap = new Smd();
 319         }
 320         return $this->serviceMap;
 321     }
 322
 323     /**
 324      * Add service method to service map
 325      *
 326      * @param  Method\Definition $method
 327      * @return void
 328      */
 329     protected function _addMethodServiceMap(Method\Definition $method)
 330     {
 331         $serviceInfo = array(
 332             'name'   => $method->getName(),
 333             'return' => $this->_getReturnType($method),
 334         );
 335         $params = $this->_getParams($method);
 336         $serviceInfo['params'] = $params;
 337         $serviceMap = $this->getServiceMap();
 338         if (false !== $serviceMap->getService($serviceInfo['name'])) {
 339             $serviceMap->removeService($serviceInfo['name']);
 340         }
 341         $serviceMap->addService($serviceInfo);
 342     }
 343
 344     /**
 345      * Translate PHP type to JSON type
 346      *
 347      * @param  string $type
 348      * @return string
 349      */
 350     protected function _fixType($type)
 351     {
 352         return $type;
 353     }
 354
 355     /**
 356      * Get default params from signature
 357      *
 358      * @param  array $args
 359      * @param  array $params
 360      * @return array
 361      */
 362     protected function _getDefaultParams(array $args, array $params)
 363     {
 364         $defaultParams = array_slice($params, count($args));
 365         foreach ($defaultParams as $param) {
 366             $value = null;
 367             if (array_key_exists('default', $param)) {
 368                 $value = $param['default'];
 369             }
 370             $args[$param['name']] = $value;
 371         }
 372         return $args;
 373     }
 374
 375     /**
 376      * Get method param type
 377      *
 378      * @param  Method\Definition $method
 379      * @return string|array
 380      */
 381     protected function _getParams(Method\Definition $method)
 382     {
 383         $params = array();
 384         foreach ($method->getPrototypes() as $prototype) {
 385             foreach ($prototype->getParameterObjects() as $key => $parameter) {
 386                 if (!isset($params[$key])) {
 387                     $params[$key] = array(
 388                         'type'     => $parameter->getType(),
 389                         'name'     => $parameter->getName(),
 390                         'optional' => $parameter->isOptional(),
 391                     );
 392                     if (null !== ($default = $parameter->getDefaultValue())) {
 393                         $params[$key]['default'] = $default;
 394                     }
 395                     $description = $parameter->getDescription();
 396                     if (!empty($description)) {
 397                         $params[$key]['description'] = $description;
 398                     }
 399                     continue;
 400                 }
 401                 $newType = $parameter->getType();
 402                 if (!is_array($params[$key]['type'])) {
 403                     if ($params[$key]['type'] == $newType) {
 404                         continue;
 405                     }
 406                     $params[$key]['type'] = (array) $params[$key]['type'];
 407                 } elseif (in_array($newType, $params[$key]['type'])) {
 408                     continue;
 409                 }
 410                 array_push($params[$key]['type'], $parameter->getType());
 411             }
 412         }
 413         return $params;
 414     }
 415
 416     /**
 417      * Set response state
 418      *
 419      * @return Response
 420      */
 421     protected function _getReadyResponse()
 422     {
 423         $request  = $this->getRequest();
 424         $response = $this->getResponse();
 425
 426         $response->setServiceMap($this->getServiceMap());
 427         if (null !== ($id = $request->getId())) {
 428             $response->setId($id);
 429         }
 430         if (null !== ($version = $request->getVersion())) {
 431             $response->setVersion($version);
 432         }
 433
 434         return $response;
 435     }
 436
 437     /**
 438      * Get method return type
 439      *
 440      * @param  Method\Definition $method
 441      * @return string|array
 442      */
 443     protected function _getReturnType(Method\Definition $method)
 444     {
 445         $return = array();
 446         foreach ($method->getPrototypes() as $prototype) {
 447             $return[] = $prototype->getReturnType();
 448         }
 449         if (1 == count($return)) {
 450             return $return[0];
 451         }
 452         return $return;
 453     }
 454
 455     /**
 456      * Retrieve list of allowed SMD methods for proxying
 457      *
 458      * @return array
 459      */
 460     protected function _getSmdMethods()
 461     {
 462         if (null === $this->smdMethods) {
 463             $this->smdMethods = array();
 464             $methods = get_class_methods('Zend\\Json\\Server\\Smd');
 465             foreach ($methods as $method) {
 466                 if (!preg_match('/^(set|get)/', $method)) {
 467                     continue;
 468                 }
 469                 if (strstr($method, 'Service')) {
 470                     continue;
 471                 }
 472                 $this->smdMethods[] = $method;
 473             }
 474         }
 475         return $this->smdMethods;
 476     }
 477
 478     /**
 479      * Internal method for handling request
 480      *
 481      * @return void
 482      */
 483     protected function _handle()
 484     {
 485         $request = $this->getRequest();
 486
 487         if($request->isParseError()){
 488             return $this->fault('Parse error', Error::ERROR_PARSE);
 489         }
 490
 491         if (!$request->isMethodError() && (null === $request->getMethod())) {
 492             return $this->fault('Invalid Request', Error::ERROR_INVALID_REQUEST);
 493         }
 494
 495         if ($request->isMethodError()) {
 496             return $this->fault('Invalid Request', Error::ERROR_INVALID_REQUEST);
 497         }
 498
 499         $method = $request->getMethod();
 500         if (!$this->table->hasMethod($method)) {
 501             return $this->fault('Method not found', Error::ERROR_INVALID_METHOD);
 502         }
 503
 504         $params        = $request->getParams();
 505         $invokable     = $this->table->getMethod($method);
 506         $serviceMap    = $this->getServiceMap();
 507         $service       = $serviceMap->getService($method);
 508         $serviceParams = $service->getParams();
 509
 510         if (count($params) < count($serviceParams)) {
 511             $params = $this->_getDefaultParams($params, $serviceParams);
 512         }
 513
 514         //Make sure named parameters are passed in correct order
 515         if (is_string(key($params))) {
 516             $callback = $invokable->getCallback();
 517             if ('function' == $callback->getType()) {
 518                 $reflection = new ReflectionFunction($callback->getFunction());
 519             } else {
 520
 521                 $reflection = new ReflectionMethod(
 522                     $callback->getClass(),
 523                     $callback->getMethod()
 524                 );
 525             }
 526
 527             $orderedParams = array();
 528             foreach ($reflection->getParameters() as $refParam) {
 529                 if (array_key_exists($refParam->getName(), $params)) {
 530                     $orderedParams[$refParam->getName()] = $params[$refParam->getName()];
 531                 } elseif ($refParam->isOptional()) {
 532                     $orderedParams[$refParam->getName()] = null;
 533                 } else {
 534                     return $this->fault('Invalid params', Error::ERROR_INVALID_PARAMS);
 535                 }
 536             }
 537             $params = $orderedParams;
 538         }
 539
 540         try {
 541             $result = $this->_dispatch($invokable, $params);
 542         } catch (\Exception $e) {
 543             return $this->fault($e->getMessage(), $e->getCode(), $e);
 544         }
 545
 546         $this->getResponse()->setResult($result);
 547     }
 548 }