PHP 8.0.0 Migration Guide

The PHP SDK improves compatibility and performance in v8.0.0. The legacy transport layer is replaced with an implementation that follows PHP Standards Recommendation (PSR). By default, the SDK uses the Guzzle HTTP client.

What has changed

See the major differences between versions:

Feature	PHP SDK v7.x.x	PHP SDK v8.x.x
Method to set transport layer	PubNub::setTransport()	PubNub::setClient()

Transport was removed

PubNub::setTransport() is removed. Use PubNub::setClient() instead.

Required changes

If you didn't override the default transport, this update is seamless.

If you did, your client must implement PSR-18. Optionally, expose an extended send method that accepts request options for a single call.

1use Psr\Http\Client\ClientInterface;
2

3class CustomClient implements ClientInterface
4{
5    /**
6     * Sends a PSR-7 request and returns a PSR-7 response.
7     *
8     * @param RequestInterface $request
9     *
10     * @return ResponseInterface
11     *
12     * @throws \Psr\Http\Client\ClientExceptionInterface If an error happens while processing the request.
13     */
14    public function sendRequest(RequestInterface $request): ResponseInterface { }
15

16    /**
17     * Send an HTTP request.
18     *
19     * @param array $options Request options to apply to the given
20     *                       request and to the transfer. See \GuzzleHttp\RequestOptions.
21     *
22     * @throws \Psr\Http\Client\ClientExceptionInterface If an error happens while processing the request.
23     */
24    public function send(RequestInterface $request, array $options = []): ResponseInterface { }
25}

show all 25 lines

Use default HTTP client

If you don't need a custom transport, use the default GuzzleHttp client.

The default setup works out of the box. It suits most use cases and provides a reliable, efficient HTTP client.

1use PubNub\PubNub;
2use PubNub\PNConfiguration;
3

4$config = new PNConfiguration();
5$config->setPublishKey('demo');
6$config->setSubscribeKey('demo');
7$config->setUserId('demo');
8$pubnub = new PubNub();
9$pubnub->publish()->channel('test')->message('Hello')->sync();

Use custom HTTP client

To use a custom HTTP client, implement PSR‑18 ClientInterface. The example below uses built‑in cURL.

1class CustomClient implements ClientInterface
2{
3    public function sendRequest(RequestInterface $request): ResponseInterface
4    {
5        $ch = curl_init();
6

7        curl_setopt($ch, CURLOPT_URL, (string) $request->getUri());
8        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $request->getMethod());
9        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
10

11        $headers = [];
12        foreach ($request->getHeaders() as $name => $values) {
13            foreach ($values as $value) {
14                $headers[] = $name . ': ' . $value;
15            }
16        }
17        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
18

19        if ($request->getBody()->getSize() > 0) {
20            curl_setopt($ch, CURLOPT_POSTFIELDS, (string) $request->getBody());
21        }
22

23        $responseBody = curl_exec($ch);
24        $responseCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
25

26        if ($responseBody === false) {
27            throw new \RuntimeException('Curl error: ' . curl_error($ch));
28        }
29

30        curl_close($ch);
31

32        return new Response($responseCode, [], $responseBody);
33    }
34}

show all 34 lines

This class uses cURL to send the request. It returns a Response (an implementation of ResponseInterface) and uses a Stream that implements StreamInterface.

To use this custom client with the SDK, instantiate it and call PubNub::setClient.

1use PubNub\PubNub;
2use PubNub\PNConfiguration;
3use CustomClient;
4

5$config = new PNConfiguration();
6$config->setPublishKey("demo");
7$config->setSubscribeKey("demo");
8$config->setUserId("test");
9

10$client = new CustomClient();
11

12$pubnub = new PubNub($config);
13$pubnub->setClient($client);
14$pubnub->publish()->channel('test')->message('Hello')->sync();

Response

Basic Response implementation:

1use Psr\Http\Message\ResponseInterface;
2

3class Response implements ResponseInterface
4{
5    private int $statusCode;
6    private array $headers;
7    private StreamInterface $body;
8

9    public function __construct(int $statusCode, array $headers, string $body)
10    {
11        $this->statusCode = $statusCode;
12        $this->headers = $headers;
13        $this->body = new Stream($body);
14    }
15

16    public function getStatusCode(): int
17    {
18        return $this->statusCode;
19    }
20

21    public function getReasonPhrase(): string
22    {
23        return '';
24    }
25

26    public function getProtocolVersion(): string
27    {
28        return '';
29    }
30

31    public function getHeaders(): array
32    {
33        return $this->headers;
34    }
35

36    public function getBody(): StreamInterface
37    {
38        return $this->body;
39    }
40

41    public function withStatus($code, $reasonPhrase = ''): self
42    {
43        $this->statusCode = $code;
44        return $this;
45    }
46

47    public function withHeader($name, $value): self
48    {
49        $this->headers[$name] = $value;
50        return $this;
51    }
52

53    public function withAddedHeader($name, $value): self
54    {
55        $this->headers[$name][] = $value;
56        return $this;
57    }
58

59    public function withoutHeader($name): self
60    {
61        unset($this->headers[$name]);
62        return $this;
63    }
64

65    public function withProtocolVersion($version): self
66    {
67        return $this;
68    }
69

70    public function hasHeader($name): bool
71    {
72        return isset($this->headers[$name]);
73    }
74

75    public function getHeader($name): array
76    {
77        return $this->headers[$name] ?? [];
78    }
79

80    public function getHeaderLine($name): string
81    {
82        return implode(', ', $this->headers[$name] ?? []);
83    }
84

85    public function withBody(StreamInterface $body): self
86    {
87        $this->body = $body;
88        return $this;
89    }
90}

show all 90 lines

Stream

Basic Stream implementation:

1use Psr\Http\Message\StreamInterface;
2

3class Stream implements StreamInterface
4{
5    private $stream;
6    private $size;
7

8    public function __construct(string $content = '')
9    {
10        $this->stream = fopen('php://temp', 'r+');
11        fwrite($this->stream, $content);
12        rewind($this->stream);
13        $this->size = strlen($content);
14    }
15

16    public function __toString(): string
17    {
18        return stream_get_contents($this->stream, -1, 0);
19    }
20

21    public function close(): void
22    {
23        fclose($this->stream);
24    }
25

26    public function detach()
27    {
28        $result = $this->stream;
29        $this->stream = null;
30        return $result;
31    }
32

33    public function getSize(): ?int
34    {
35        return $this->size;
36    }
37

38    public function tell(): int
39    {
40        return ftell($this->stream);
41    }
42

43    public function eof(): bool
44    {
45        return feof($this->stream);
46    }
47

48    public function isSeekable(): bool
49    {
50        return true;
51    }
52

53    public function seek($offset, $whence = SEEK_SET): void
54    {
55        fseek($this->stream, $offset, $whence);
56    }
57

58    public function rewind(): void
59    {
60        rewind($this->stream);
61    }
62

63    public function isWritable(): bool
64    {
65        return true;
66    }
67

68    public function write($string): int
69    {
70        $result = fwrite($this->stream, $string);
71        $this->size += strlen($string);
72        return $result;
73    }
74

75    public function isReadable(): bool
76    {
77        return true;
78    }
79

80    public function read($length): string
81    {
82        return fread($this->stream, $length);
83    }
84

85    public function getContents(): string
86    {
87        return stream_get_contents($this->stream);
88    }
89

90    public function getMetadata($key = null)
91    {
92        $meta = stream_get_meta_data($this->stream);
93        if ($key === null) {
94            return $meta;
95        }
96        return $meta[$key] ?? null;
97    }
98}

show all 98 lines