RESTBagOStuff.php

Go to the documentation of this file.

<?php
 
use Psr\Log\LoggerInterface;
 
class RESTBagOStuff extends MediumSpecificBagOStuff {
    private const DEFAULT_CONN_TIMEOUT = 1.2;
 
    private const DEFAULT_REQ_TIMEOUT = 3.0;
 
    private $client;
 
    private $url;
 
    private $httpParams;
 
    private $serializationType;
 
    private $hmacKey;
 
    private $extendedErrorBodyFields;
 
    public function __construct( $params ) {
        $params['segmentationSize'] ??= INF;
        if ( empty( $params['url'] ) ) {
            throw new InvalidArgumentException( 'URL parameter is required' );
        }
 
        if ( empty( $params['client'] ) ) {
            // Pass through some params to the HTTP client.
            $clientParams = [
                'connTimeout' => $params['connTimeout'] ?? self::DEFAULT_CONN_TIMEOUT,
                'reqTimeout' => $params['reqTimeout'] ?? self::DEFAULT_REQ_TIMEOUT,
            ];
            foreach ( [ 'caBundlePath', 'proxy' ] as $key ) {
                if ( isset( $params[$key] ) ) {
                    $clientParams[$key] = $params[$key];
                }
            }
            $this->client = new MultiHttpClient( $clientParams );
        } else {
            $this->client = $params['client'];
        }
 
        $this->httpParams['writeMethod'] = $params['httpParams']['writeMethod'] ?? 'PUT';
        $this->httpParams['readHeaders'] = $params['httpParams']['readHeaders'] ?? [];
        $this->httpParams['writeHeaders'] = $params['httpParams']['writeHeaders'] ?? [];
        $this->httpParams['deleteHeaders'] = $params['httpParams']['deleteHeaders'] ?? [];
        $this->extendedErrorBodyFields = $params['extendedErrorBodyFields'] ?? [];
        $this->serializationType = $params['serialization_type'] ?? 'PHP';
        $this->hmacKey = $params['hmac_key'] ?? '';
 
        // The parent constructor calls setLogger() which sets the logger in $this->client
        parent::__construct( $params );
 
        // Make sure URL ends with /
        $this->url = rtrim( $params['url'], '/' ) . '/';
 
        $this->attrMap[self::ATTR_DURABILITY] = self::QOS_DURABILITY_DISK;
    }
 
    public function setLogger( LoggerInterface $logger ) {
        parent::setLogger( $logger );
        $this->client->setLogger( $logger );
    }
 
    protected function doGet( $key, $flags = 0, &$casToken = null ) {
        $getToken = ( $casToken === self::PASS_BY_REF );
        $casToken = null;
 
        $req = [
            'method' => 'GET',
            'url' => $this->url . rawurlencode( $key ),
            'headers' => $this->httpParams['readHeaders'],
        ];
 
        $value = false;
        $valueSize = false;
        [ $rcode, , $rhdrs, $rbody, $rerr ] = $this->client->run( $req );
        if ( $rcode === 200 && is_string( $rbody ) ) {
            $value = $this->decodeBody( $rbody );
            $valueSize = strlen( $rbody );
            // @FIXME: use some kind of hash or UUID header as CAS token
            if ( $getToken && $value !== false ) {
                $casToken = $rbody;
            }
        } elseif ( $rcode === 0 || ( $rcode >= 400 && $rcode != 404 ) ) {
            $this->handleError( 'Failed to fetch {cacheKey}', $rcode, $rerr, $rhdrs, $rbody,
                [ 'cacheKey' => $key ] );
        }
 
        $this->updateOpStats( self::METRIC_OP_GET, [ $key => [ 0, $valueSize ] ] );
 
        return $value;
    }
 
    protected function doSet( $key, $value, $exptime = 0, $flags = 0 ) {
        $req = [
            'method' => $this->httpParams['writeMethod'],
            'url' => $this->url . rawurlencode( $key ),
            'body' => $this->encodeBody( $value ),
            'headers' => $this->httpParams['writeHeaders'],
        ];
 
        [ $rcode, , $rhdrs, $rbody, $rerr ] = $this->client->run( $req );
        $res = ( $rcode === 200 || $rcode === 201 || $rcode === 204 );
        if ( !$res ) {
            $this->handleError( 'Failed to store {cacheKey}', $rcode, $rerr, $rhdrs, $rbody,
                [ 'cacheKey' => $key ] );
        }
 
        $this->updateOpStats( self::METRIC_OP_SET, [ $key => [ strlen( $rbody ), 0 ] ] );
 
        return $res;
    }
 
    protected function doAdd( $key, $value, $exptime = 0, $flags = 0 ) {
        // NOTE: This is non-atomic
        if ( $this->get( $key ) === false ) {
            return $this->set( $key, $value, $exptime, $flags );
        }
 
        // key already set
        return false;
    }
 
    protected function doDelete( $key, $flags = 0 ) {
        $req = [
            'method' => 'DELETE',
            'url' => $this->url . rawurlencode( $key ),
            'headers' => $this->httpParams['deleteHeaders'],
        ];
 
        [ $rcode, , $rhdrs, $rbody, $rerr ] = $this->client->run( $req );
        $res = in_array( $rcode, [ 200, 204, 205, 404, 410 ] );
        if ( !$res ) {
            $this->handleError( 'Failed to delete {cacheKey}', $rcode, $rerr, $rhdrs, $rbody,
                [ 'cacheKey' => $key ] );
        }
 
        $this->updateOpStats( self::METRIC_OP_DELETE, [ $key ] );
 
        return $res;
    }
 
    protected function doIncrWithInit( $key, $exptime, $step, $init, $flags ) {
        // NOTE: This is non-atomic
        $curValue = $this->doGet( $key );
        if ( $curValue === false ) {
            $newValue = $this->doSet( $key, $init, $exptime ) ? $init : false;
        } elseif ( $this->isInteger( $curValue ) ) {
            $sum = max( $curValue + $step, 0 );
            $newValue = $this->doSet( $key, $sum, $exptime ) ? $sum : false;
        } else {
            $newValue = false;
        }
 
        return $newValue;
    }
 
    protected function makeKeyInternal( $keyspace, $components ) {
        return $this->genericKeyFromComponents( $keyspace, ...$components );
    }
 
    protected function convertGenericKey( $key ) {
        // short-circuit; already uses "generic" keys
        return $key;
    }
 
    private function decodeBody( $body ) {
        $pieces = explode( '.', $body, 3 );
        if ( count( $pieces ) !== 3 || $pieces[0] !== $this->serializationType ) {
            return false;
        }
        [ , $hmac, $serialized ] = $pieces;
        if ( $this->hmacKey !== '' ) {
            $checkHmac = hash_hmac( 'sha256', $serialized, $this->hmacKey, true );
            if ( !hash_equals( $checkHmac, base64_decode( $hmac ) ) ) {
                return false;
            }
        }
 
        switch ( $this->serializationType ) {
            case 'JSON':
                $value = json_decode( $serialized, true );
                return ( json_last_error() === JSON_ERROR_NONE ) ? $value : false;
 
            case 'PHP':
                return unserialize( $serialized );
 
            default:
                throw new \DomainException(
                    "Unknown serialization type: $this->serializationType"
                );
        }
    }
 
    private function encodeBody( $body ) {
        switch ( $this->serializationType ) {
            case 'JSON':
                $value = json_encode( $body );
                if ( $value === false ) {
                    throw new InvalidArgumentException( __METHOD__ . ": body could not be encoded." );
                }
                break;
 
            case 'PHP':
                $value = serialize( $body );
                break;
 
            default:
                throw new \DomainException(
                    "Unknown serialization type: $this->serializationType"
                );
        }
 
        if ( $this->hmacKey !== '' ) {
            $hmac = base64_encode(
                hash_hmac( 'sha256', $value, $this->hmacKey, true )
            );
        } else {
            $hmac = '';
        }
        return $this->serializationType . '.' . $hmac . '.' . $value;
    }
 
    protected function handleError( $msg, $rcode, $rerr, $rhdrs, $rbody, $context = [] ) {
        $message = "$msg : ({code}) {error}";
        $context = [
            'code' => $rcode,
            'error' => $rerr
        ] + $context;
 
        if ( $this->extendedErrorBodyFields !== [] ) {
            $body = $this->decodeBody( $rbody );
            if ( $body ) {
                $extraFields = '';
                foreach ( $this->extendedErrorBodyFields as $field ) {
                    if ( isset( $body[$field] ) ) {
                        $extraFields .= " : ({$field}) {$body[$field]}";
                    }
                }
                if ( $extraFields !== '' ) {
                    $message .= " {extra_fields}";
                    $context['extra_fields'] = $extraFields;
                }
            }
        }
 
        $this->logger->error( $message, $context );
        $this->setLastError( $rcode === 0 ? self::ERR_UNREACHABLE : self::ERR_UNEXPECTED );
    }
}