261 lines
8.8 KiB
PHP
261 lines
8.8 KiB
PHP
<?php
|
|
|
|
namespace App\BusProNet\Transport;
|
|
|
|
use App\BusProNet\Exception\ApiClientException;
|
|
use App\BusProNet\Exception\ImmediateConnectionCloseException;
|
|
use App\BusProNet\Exception\ResponseParserException;
|
|
use App\BusProNet\MessageType;
|
|
use App\BusProNet\XmlParser\ApiResponseParser;
|
|
use App\Service\XmlDumpWriter;
|
|
use Psr\Log\LoggerInterface;
|
|
use Symfony\Component\OptionsResolver\OptionsResolver;
|
|
use Symfony\Component\Serializer\Encoder\XmlEncoder;
|
|
use Symfony\Component\Serializer\SerializerInterface;
|
|
|
|
/**
|
|
* The XML protocol around one BusPro command: authentication, serialization, dumps, the
|
|
* busy-retry and parsing. What a command contains is up to the caller.
|
|
*/
|
|
class XmlChannel
|
|
{
|
|
/** @var array<string, mixed> */
|
|
private array $config;
|
|
|
|
/** @param array<string, mixed> $options */
|
|
public function __construct(
|
|
private readonly SerializerInterface $serializer,
|
|
private readonly ApiResponseParser $responseParser,
|
|
private readonly XmlDumpWriter $dumpWriter,
|
|
private readonly LoggerInterface $logger,
|
|
private readonly RequestIdSequence $requestIds,
|
|
private readonly SocketTransport $transport,
|
|
array $options,
|
|
) {
|
|
$this->config = $this->resolveOptions($options);
|
|
}
|
|
|
|
/**
|
|
* Sends command $type with $fields and returns the parsed response.
|
|
*
|
|
* @param array<string, mixed> $fields
|
|
* @param array<string, mixed> $parserArgs
|
|
*
|
|
* @throws ApiClientException
|
|
*/
|
|
public function request(MessageType $type, array $fields = [], array $parserArgs = [], bool $debug = false): mixed
|
|
{
|
|
$data = $this->envelope($type, $fields);
|
|
|
|
return $this->executeWithRetry(function () use ($type, $data, $parserArgs, $debug) {
|
|
$requestId = $this->requestIds->next();
|
|
$dump = $debug || true === $this->config['debug'];
|
|
|
|
$xml = $this->exchange($requestId, $this->serializeXml($data), $type->value, 'Sending request to BPN API', $dump);
|
|
|
|
return $this->parseResponse($type, $xml, $parserArgs, $requestId);
|
|
}, $type->value);
|
|
}
|
|
|
|
/**
|
|
* Like request(), but returns the unparsed response.
|
|
*
|
|
* @param array<string, mixed> $fields
|
|
*
|
|
* @throws ApiClientException
|
|
*/
|
|
public function requestRaw(MessageType $type, array $fields = []): string
|
|
{
|
|
$data = $this->envelope($type, $fields);
|
|
|
|
return $this->executeWithRetry(function () use ($type, $data) {
|
|
$requestId = $this->requestIds->next();
|
|
$body = $this->serializeXml($data);
|
|
|
|
return $this->exchange($requestId, $body, $type->value, 'Sending raw request to BPN API', true === $this->config['debug']);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Sends a recorded request as is, except for the key, which is regenerated for the current
|
|
* date. Returns the unparsed response.
|
|
*
|
|
* @throws ApiClientException
|
|
*/
|
|
public function replay(string $xml, bool $debug = false): string
|
|
{
|
|
return $this->executeWithRetry(fn () => $this->doReplay($xml, $debug));
|
|
}
|
|
|
|
/**
|
|
* The authentication every request starts with, followed by the command's own fields.
|
|
*
|
|
* @param array<string, mixed> $fields
|
|
*
|
|
* @return array<string, mixed>
|
|
*/
|
|
private function envelope(MessageType $type, array $fields): array
|
|
{
|
|
return [
|
|
'user' => $this->config['bpn_username'],
|
|
'key' => $this->createKey($type->value),
|
|
'satz' => ['@typ' => $type->value],
|
|
...$fields,
|
|
];
|
|
}
|
|
|
|
private function createKey(string $type): string
|
|
{
|
|
$date = (new \DateTimeImmutable())->format('Ymd');
|
|
|
|
return md5($this->config['bpn_username'].$this->config['bpn_password'].$date.$type);
|
|
}
|
|
|
|
/**
|
|
* Executes an operation with automatic retry on immediate connection close.
|
|
*
|
|
* When the BPN server is busy, it may close connections immediately without responding.
|
|
* This method detects such conditions and automatically retries after a short delay.
|
|
*
|
|
* @throws ImmediateConnectionCloseException If all retry attempts fail
|
|
*/
|
|
private function executeWithRetry(callable $operation, ?string $type = null): mixed
|
|
{
|
|
$maxAttempts = $this->config['busy_retry_attempts'];
|
|
$retryDelay = $this->config['busy_retry_delay'];
|
|
$typeContext = null !== $type ? ['type' => $type] : [];
|
|
$lastException = null;
|
|
|
|
for ($attempt = 1; $attempt <= $maxAttempts; ++$attempt) {
|
|
try {
|
|
return $operation();
|
|
} catch (ImmediateConnectionCloseException $e) {
|
|
$lastException = $e;
|
|
|
|
if ($attempt < $maxAttempts) {
|
|
$this->logger->warning('BPN server busy, retrying request', [
|
|
'attempt' => $attempt,
|
|
'maxAttempts' => $maxAttempts,
|
|
'retryDelay' => $retryDelay,
|
|
...$typeContext,
|
|
]);
|
|
sleep($retryDelay);
|
|
}
|
|
}
|
|
}
|
|
|
|
$this->logger->error('BPN server busy after all retry attempts', ['attempts' => $maxAttempts, ...$typeContext]);
|
|
|
|
throw $lastException;
|
|
}
|
|
|
|
/**
|
|
* @throws ApiClientException
|
|
* @throws ImmediateConnectionCloseException
|
|
*/
|
|
private function doReplay(string $xml, bool $debug): string
|
|
{
|
|
$requestId = $this->requestIds->next();
|
|
|
|
$doc = new \DOMDocument();
|
|
if (false === @$doc->loadXML($xml)) {
|
|
throw new ApiClientException('Invalid XML provided');
|
|
}
|
|
|
|
$satzNode = $doc->getElementsByTagName('satz')->item(0);
|
|
if (null === $satzNode) {
|
|
throw new ApiClientException('Missing <satz> element in XML');
|
|
}
|
|
|
|
$type = $satzNode->getAttribute('typ');
|
|
if ('' === $type) {
|
|
throw new ApiClientException('Missing typ attribute on <satz> element');
|
|
}
|
|
|
|
$keyNode = $doc->getElementsByTagName('key')->item(0);
|
|
if (null === $keyNode) {
|
|
throw new ApiClientException('Missing <key> element in XML');
|
|
}
|
|
|
|
$keyNode->nodeValue = $this->createKey($type);
|
|
|
|
return $this->exchange($requestId, $doc->saveXML(), $type, 'Sending raw XML request to BPN API', $debug || true === $this->config['debug']);
|
|
}
|
|
|
|
/**
|
|
* @throws ApiClientException
|
|
* @throws ImmediateConnectionCloseException
|
|
*/
|
|
private function exchange(string $requestId, string $body, string $type, string $logMessage, bool $dump): string
|
|
{
|
|
if ($dump) {
|
|
$this->dumpWriter->write($requestId, XmlDumpWriter::REQUEST, $body);
|
|
}
|
|
|
|
$response = $this->transport->exchange($body, $logMessage, ['requestId' => $requestId, 'type' => $type]);
|
|
|
|
if ($dump) {
|
|
$this->dumpWriter->write($requestId, XmlDumpWriter::RESPONSE, $response);
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $parserArgs
|
|
*
|
|
* @throws ApiClientException
|
|
*/
|
|
private function parseResponse(MessageType $type, string $xml, array $parserArgs, string $requestId, bool $dumpOnFailure = true): mixed
|
|
{
|
|
try {
|
|
return $this->responseParser->parseXmlString($type, $xml, $parserArgs);
|
|
} catch (ResponseParserException $e) {
|
|
// Keep the evidence even outside debug mode: without the raw response a parse
|
|
// failure is not diagnosable after the fact. app:cleanup:xml-dumps prunes it.
|
|
if ($dumpOnFailure) {
|
|
$this->dumpWriter->write($requestId, XmlDumpWriter::RESPONSE, $xml);
|
|
}
|
|
|
|
$this->logger->error('Unable to parse response received from API', [
|
|
'request_id' => $requestId,
|
|
'type' => $type->value,
|
|
'response_length' => strlen($xml),
|
|
'error_message' => $e->getMessage(),
|
|
]);
|
|
|
|
throw new ApiClientException('Unable to parse response received from API: '.$e->getMessage(), 0, $e);
|
|
}
|
|
}
|
|
|
|
/** @param array<string, mixed> $data */
|
|
private function serializeXml(array $data): string
|
|
{
|
|
return $this->serializer->serialize($data, 'xml', [
|
|
XmlEncoder::ROOT_NODE_NAME => 'anfrage',
|
|
XmlEncoder::ENCODING => 'UTF-8',
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $options
|
|
*
|
|
* @return array<string, mixed>
|
|
*/
|
|
private function resolveOptions(array $options): array
|
|
{
|
|
$optionsResolver = new OptionsResolver();
|
|
$optionsResolver->setRequired([
|
|
'bpn_username',
|
|
'bpn_password',
|
|
]);
|
|
$optionsResolver->setDefaults([
|
|
'debug' => false,
|
|
'busy_retry_attempts' => 3,
|
|
'busy_retry_delay' => 1,
|
|
]);
|
|
|
|
return $optionsResolver->resolve($options);
|
|
}
|
|
}
|