/**
* Build a method signature
*
* @param Reflection\AbstractFunction $reflection
* @param null|string|object $class
* @return Method\Definition
* @throws Exception\RuntimeException on duplicate entry
*/
protected function _buildSignature(Reflection\AbstractFunction $reflection, $class = null)
{
$ns = $reflection->getNamespace();
$name = $reflection->getName();
$method = empty($ns) ? $name : $ns . '.' . $name;
if (!$this->overwriteExistingMethods && $this->table->hasMethod($method)) {
throw new Exception\RuntimeException('Duplicate method registered: ' . $method);
}
$definition = new Method\Definition();
$definition->setName($method)->setCallback($this->_buildCallback($reflection))->setMethodHelp($reflection->getDescription())->setInvokeArguments($reflection->getInvokeArguments());
foreach ($reflection->getPrototypes() as $proto) {
$prototype = new Method\Prototype();
$prototype->setReturnType($this->_fixType($proto->getReturnType()));
foreach ($proto->getParameters() as $parameter) {
$param = new Method\Parameter(array('type' => $this->_fixType($parameter->getType()), 'name' => $parameter->getName(), 'optional' => $parameter->isOptional()));
if ($parameter->isDefaultValueAvailable()) {
$param->setDefaultValue($parameter->getDefaultValue());
}
$prototype->addParameter($param);
}
$definition->addPrototype($prototype);
}
if (is_object($class)) {
$definition->setObject($class);
}
$this->table->addMethod($definition);
return $definition;
}
/**
* Cache a file containing the dispatch list.
*
* Serializes the server definition stores the information
* in $filename.
*
* Returns false on any error (typically, inability to write to file), true
* on success.
*
* @param string $filename
* @param \Zend\Server\Server $server
* @return bool
*/
public static function save($filename, Server $server)
{
if (!is_string($filename) || !file_exists($filename) && !is_writable(dirname($filename))) {
return false;
}
$methods = $server->getFunctions();
if ($methods instanceof Definition) {
$definition = new Definition();
foreach ($methods as $method) {
if (in_array($method->getName(), static::$skipMethods)) {
continue;
}
$definition->addMethod($method);
}
$methods = $definition;
}
ErrorHandler::start();
$test = file_put_contents($filename, serialize($methods));
ErrorHandler::stop();
if (0 === $test) {
return false;
}
return true;
}
/**
* Handle an xmlrpc call (actual work)
*
* @param Request $request
* @return Response
* @throws Server\Exception\RuntimeException
* Zend\XmlRpc\Server\Exceptions are thrown for internal errors; otherwise,
* any other exception may be thrown by the callback
*/
protected function handleRequest(Request $request)
{
$method = $request->getMethod();
// Check for valid method
if (!$this->table->hasMethod($method)) {
throw new Server\Exception\RuntimeException('Method "' . $method . '" does not exist', 620);
}
$info = $this->table->getMethod($method);
$params = $request->getParams();
$argv = $info->getInvokeArguments();
if (0 < count($argv) and $this->sendArgumentsToAllMethods()) {
$params = array_merge($params, $argv);
}
// Check calling parameters against signatures
$matched = false;
$sigCalled = $request->getTypes();
$sigLength = count($sigCalled);
$paramsLen = count($params);
if ($sigLength < $paramsLen) {
for ($i = $sigLength; $i < $paramsLen; ++$i) {
$xmlRpcValue = AbstractValue::getXmlRpcValue($params[$i]);
$sigCalled[] = $xmlRpcValue->getType();
}
}
$signatures = $info->getPrototypes();
foreach ($signatures as $signature) {
$sigParams = $signature->getParameters();
if ($sigCalled === $sigParams) {
$matched = true;
break;
}
}
if (!$matched) {
throw new Server\Exception\RuntimeException('Calling parameters do not match signature', 623);
}
$return = $this->_dispatch($info, $params);
$responseClass = $this->getResponseClass();
return new $responseClass($return);
}
public function testPassingOptionsToConstructorShouldSetObjectState()
{
$method = array('name' => 'foo.bar', 'callback' => array('type' => 'function', 'function' => 'bar'), 'prototypes' => array(array('returnType' => 'string', 'parameters' => array('string'))), 'methodHelp' => 'Foo Bar!', 'invokeArguments' => array('foo'));
$options = array($method);
$definition = new Server\Definition($options);
$test = $definition->toArray();
$this->assertEquals(1, count($test));
$test = array_shift($test);
$this->assertEquals($method['name'], $test['name']);
$this->assertEquals($method['methodHelp'], $test['methodHelp']);
$this->assertEquals($method['invokeArguments'], $test['invokeArguments']);
$this->assertEquals($method['prototypes'][0]['returnType'], $test['prototypes'][0]['returnType']);
}