Using $libXmlOptions with Client::call()

[LordOfTheRats]

Feature Request

Q	A
New Feature	not really
RFC	no
BC Break	no

Summary

I need to use the $libXmlOptions parameter, that is available for doRequest(), but I also need to use the call() function.

Can the $libXmlOptions parameter be added to the call() function and be relayed to the doRequest() method?

[wychoong]

needed this as well. how do you workaround for now?

[LordOfTheRats]

Currently I override the call function to provide LIBXML_PARSEHUGE to doRequest()

src/App/XmlRpc/Client.php:

<?php
namespace App\XmlRpc;

use Laminas\Http\Client as HttpClient;
use Laminas\XmlRpc\AbstractValue;
use Laminas\XmlRpc\Client as BaseClient;
use Laminas\XmlRpc\Client\Exception\FaultException;
use Laminas\XmlRpc\Exception\ExceptionInterface;

class Client extends BaseClient
{
    public function __construct(string $server, ?HttpClient $httpClient = null)
    {
        parent::__construct($server, $httpClient);
    }

    public function call($method, $params = []): mixed
    {
        if (!$this->skipSystemLookup() && ('system.' !== substr($method, 0, 7))) {
            // Ensure empty array/struct params are cast correctly
            // If system.* methods are not available, bypass. (Laminas-2978)
            $success = true;
            try {
                $signatures = $this->getIntrospector()->getMethodSignature($method);
            } catch (ExceptionInterface $e) {
                $success = false;
            }
            if ($success) {
                $validTypes = [
                    AbstractValue::XMLRPC_TYPE_ARRAY,
                    AbstractValue::XMLRPC_TYPE_BASE64,
                    AbstractValue::XMLRPC_TYPE_BOOLEAN,
                    AbstractValue::XMLRPC_TYPE_DATETIME,
                    AbstractValue::XMLRPC_TYPE_DOUBLE,
                    AbstractValue::XMLRPC_TYPE_I4,
                    AbstractValue::XMLRPC_TYPE_INTEGER,
                    AbstractValue::XMLRPC_TYPE_NIL,
                    AbstractValue::XMLRPC_TYPE_STRING,
                    AbstractValue::XMLRPC_TYPE_STRUCT,
                ];

                if (!is_array($params)) {
                    $params = [$params];
                }
                foreach ($params as $key => $param) {
                    if ($param instanceof AbstractValue) {
                        continue;
                    }

                    if (count($signatures) > 1) {
                        $type = AbstractValue::getXmlRpcTypeByValue($param);
                        foreach ($signatures as $signature) {
                            if (!is_array($signature)) {
                                continue;
                            }
                            if (isset($signature['parameters'][$key])) {
                                if ($signature['parameters'][$key] === $type) {
                                    break;
                                }
                            }
                        }
                    } elseif (isset($signatures[0]['parameters'][$key])) {
                        $type = $signatures[0]['parameters'][$key];
                    } else {
                        $type = null;
                    }

                    if (empty($type) || !in_array($type, $validTypes)) {
                        $type = AbstractValue::AUTO_DETECT_TYPE;
                    }

                    $params[$key] = AbstractValue::getXmlRpcValue($param, $type);
                }
            }
        }

        $request = $this->createRequest($method, $params);

        $this->doRequest($request, null, LIBXML_PARSEHUGE);

        if ($this->lastResponse->isFault()) {
            $fault = $this->lastResponse->getFault();
            /**
             * Exception thrown when an XML-RPC fault is returned
             */
            throw new FaultException(
                $fault->getMessage(),
                $fault->getCode()
            );
        }

        return $this->lastResponse->getReturnValue();
    }
}

[gsteel]

Out of interest, are the options you need to pass consistent across all calls? i.e. would setting the options via the client constructor and removing them from doRequest() be sufficient?

[gsteel]

If that's the case, your custom class could be:

<?php
namespace App\XmlRpc;

use Laminas\Http\Client as HttpClient;
use Laminas\XmlRpc\Client as BaseClient;

class Client extends BaseClient
{
    public function __construct(private int $libXmlOptions, string $server, ?HttpClient $httpClient = null)
    {
        parent::__construct($server, $httpClient);
    }

    public function doRequest($request, $response = null, int $libXmlOptions = 0)
    {
        $libXmlOptions |= $this->libXmlOptions;
        return parent::doRequest($request, $response, $libXmlOptions);
    }
}

But it would be better to fix this here as work is being done on the next major and Client will likely become final.

[wychoong]

If that's the case, your custom class could be:

libXmlOptions; return parent::doRequest($request, $response, $libXmlOptions); } } But it would be better to fix this here as work is being done on the next major and Client will likely become final.

This is similar to what I ended up with.

[wychoong]

If that's the case, your custom class could be:

libXmlOptions; return parent::doRequest($request, $response, $libXmlOptions); } } But it would be better to fix this here as work is being done on the next major and Client will likely become final.

with the new 3.0, this workaround doesnt work anymore

[froschdesign]

with the new 3.0, this workaround doesnt work anymore

Correct, this note is also already included under the workaround.

I’m not very familiar with this component, but if I’m not mistaken, the underlying interface only contains one method, so maybe something like this:

use Laminas\Server\ClientInterface;
use Laminas\XmlRpc\Client;
use Laminas\XmlRpc\Request;
use Psr\Http\Client\ClientInterface as HttpClientInterface;
use Psr\Http\Message\RequestFactoryInterface;
use Psr\Http\Message\StreamFactoryInterface;

final class MyCustomClient implements ClientInterface
{
    private Client $client;

    public function __construct(
        private readonly string $serverAddress,
        private readonly HttpClientInterface $httpClient,
        private readonly RequestFactoryInterface $requestFactory,
        private readonly StreamFactoryInterface $streamFactory,
        private readonly int $libXmlOptions = 0
    ) {
        $this->client = new Client(
            $this->serverAddress,
            $this->httpClient,
            $this->requestFactory,
            $this->streamFactory
        );
    }

    public function call($method, $params = []): mixed
    {
        return $this->client->call($method, $params);
    }

    public function doRequest(Request $request, int $libXmlOptions = 0): void
    {
        $libXmlOptions |= $this->libXmlOptions;
        $this->client->doRequest($request, $libXmlOptions);
    }
}