Centrifugo::history() - Code Metrics - Opekunov/laravel-centrifugo-broadcaster - Measure and Improve Code Quality continuously with Scrutinizer

Centrifugo::history() A
last analyzed 2022-03-25 17:02 UTC

↳ Parent: Centrifugo

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	1
dl	0
loc	3
rs	10

<?php

declare(strict_types=1);

namespace Opekunov\Centrifugo;

use Carbon\Carbon;
use GuzzleHttp\Client as HttpClient;
use GuzzleHttp\Exception\ClientException;
use Opekunov\Centrifugo\Contracts\CentrifugoInterface;

class Centrifugo implements CentrifugoInterface
{
    const API_PATH = '/api';

    /**
     * @var \GuzzleHttp\Client
     */
    protected $httpClient;

    /**
     * @var array
     */
    protected $config;

    /**
     * Create a new Centrifugo instance.
     *
     * @param array              $config
     * @param \GuzzleHttp\Client $httpClient
     */
    public function __construct(array $config = null, HttpClient $httpClient = null)
    {
        $this->httpClient = $httpClient ?? new HttpClient();
        if (!$config) {
            $this->config = app()->make('config')->get('broadcasting.connections.centrifugo');
        } else {
            $this->config = $this->initConfiguration($config ?? []) ??
                app()->make('config')->get('broadcasting.connections.centrifugo');
        }
    }

    /**
     * Init centrifugo configuration.
     *
     * @param array $config
     *
     * @return array
     */
    protected function initConfiguration(array $config)
    {
        $defaults = [
            'url'            => 'http://localhost:8000',
            'secret'         => null,
            'apikey'         => null,
            'ssl_key'        => null,
            'verify'         => true,
            'show_node_info' => false,
            'timeout'        => 10,
        ];

        foreach ($config as $key => $value) {
            if (array_key_exists($key, $defaults)) {
                $defaults[$key] = $value;
            }
        }

        return $defaults;
    }

    /**
     * Send message into channel.
     *
     * @param string $channel
     * @param array  $data
     *
     * @return mixed
     */
    public function publish(string $channel, array $data)
    {
        return $this->send('publish', [
            'channel' => $channel,
            'data'    => $data,
        ]);
    }

    /**
     * Send message into multiple channel.
     *
     * @param array $channels
     * @param array $data
     *
     * @return mixed
     */
    public function broadcast(array $channels, array $data)
    {
        $params = ['channels' => $channels, 'data' => $data];

        return $this->send('broadcast', $params);
    }

    /**
     * Get channel presence information (all clients currently subscribed on this channel).
     *
     * @param string $channel
     *
     * @return mixed
     */
    public function presence(string $channel)
    {
        return $this->send('presence', ['channel' => $channel]);
    }

    /**
     * Get channel presence information in short form.
     *
     * @param string $channel
     *
     * @return mixed
     */
    public function presenceStats(string $channel)
    {
        return $this->send('presence_stats', ['channel' => $channel]);
    }

    /**
     * Get channel history information (list of last messages sent into channel).
     *
     * @param string $channel
     *
     * @return mixed
     */
    public function history(string $channel)
    {
        return $this->send('history', ['channel' => $channel]);
    }

    /**
     * Remove channel history information.
     *
     * @param string $channel
     *
     * @return mixed
     */
    public function historyRemove(string $channel)
    {
        return $this->send('history_remove', [
            'channel' => $channel,
        ]);
    }

    /**
     * Unsubscribe user from channel.
     *
     * @param string $channel
     * @param string $user
     *
     * @return mixed
     */
    public function unsubscribe(string $channel, string $user)
    {
        return $this->send('unsubscribe', [
            'channel' => $channel,
            'user'    => $user,
        ]);
    }

    /**
     * Disconnect user by its ID.
     *
     * @param string $user_id
     *
     * @return mixed
     */
    public function disconnect(string $user_id)
    {
        return $this->send('disconnect', ['user' => (string) $user_id]);
    }

    /**
     * Get channels information (list of currently active channels).
     *
     * @return mixed
     */
    public function channels()
    {
        return $this->send('channels');
    }

    /**
     * Get stats information about running server nodes.
     *
     * @return mixed
     */
    public function info()
    {
        return $this->send('info');
    }

    /**
     * Generate connection token.
     *
     * @param string     $userId
     * @param int|Carbon $exp
     * @param array      $info
     *
     * @return string
     */
    public function generateConnectionToken(string $userId = '', $exp = 0, array $info = []): string
    {
        if (gettype($exp) !== 'integer') {
            $exp = $exp->unix();
        }
        $header = ['typ' => 'JWT', 'alg' => 'HS256'];
        $payload = ['sub' => $userId];
        if (!empty($info)) {
            $payload['info'] = $info;
        }
        if ($exp) {
            $payload['exp'] = $exp;
        }
        $segments = [];
        $segments[] = $this->urlsafeB64Encode(json_encode($header));
        $segments[] = $this->urlsafeB64Encode(json_encode($payload));
        $signing_input = implode('.', $segments);
        $signature = $this->sign($signing_input, $this->getSecret());
        $segments[] = $this->urlsafeB64Encode($signature);

        return implode('.', $segments);
    }

    /**
     * Generate private channel token.
     *
     * @param string     $client
     * @param string     $channel
     * @param int|Carbon $exp
     * @param array      $info
     *
     * @return string
     */
    public function generatePrivateChannelToken(string $client, string $channel, $exp = 0, array $info = []): string
    {
        if (gettype($exp) !== 'integer') {
            $exp = $exp->unix();
        }
        $header = ['typ' => 'JWT', 'alg' => 'HS256'];
        $payload = ['channel' => $channel, 'client' => $client];
        if (!empty($info)) {
            $payload['info'] = $info;
        }
        if ($exp) {
            $payload['exp'] = $exp;
        }
        $segments = [];
        $segments[] = $this->urlsafeB64Encode(json_encode($header));
        $segments[] = $this->urlsafeB64Encode(json_encode($payload));
        $signing_input = implode('.', $segments);
        $signature = $this->sign($signing_input, $this->getSecret());
        $segments[] = $this->urlsafeB64Encode($signature);

        return implode('.', $segments);
    }

    /**
     * Get secret key.
     *
     * @return string
     */
    protected function getSecret()
    {
        return $this->config['secret'];
    }

    /**
     * Send message to centrifugo server.
     *
     * @param string $method
     * @param array  $params
     *
     * @return mixed
     */
    protected function send($method, array $params = [])
    {
        $json = json_encode(['method' => $method, 'params' => $params]);

        $headers = [
            'Content-type'  => 'application/json',
            'Authorization' => 'apikey '.$this->config['apikey'],
        ];

        try {
            $url = parse_url($this->prepareUrl());

            $config = collect([
                'headers'     => $headers,
                'body'        => $json,
                'http_errors' => true,
                'timeout'     => $this->config['timeout'],
            ]);

            if ($url['scheme'] == 'https') {
                $config->put('verify', collect($this->config)->get('verify', false));

                if (collect($this->config)->get('ssl_key')) {
                    $config->put('ssl_key', collect($this->config)->get('ssl_key'));
                }
            }

            $response = $this->httpClient->post($this->prepareUrl(), $config->toArray());

            $result = json_decode((string) $response->getBody(), true);
        } catch (ClientException $e) {
            $result = [
                'method' => $method,
                'error'  => $e->getMessage(),
                'body'   => $params,
            ];
        }

        return $result;
    }

    /**
     * Prepare URL to send the http request.
     *
     * @return string
     */
    protected function prepareUrl()
    {
        $address = rtrim($this->config['url'], '/');

        if (substr_compare($address, static::API_PATH, -strlen(static::API_PATH)) !== 0) {
            $address .= static::API_PATH;
        }
        //$address .= '/';

        return $address;
    }

    /**
     * Safely encode string in base64.
     *
     * @param string $input
     *
     * @return string
     */
    private function urlsafeB64Encode($input)
    {
        return str_replace('=', '', strtr(base64_encode($input), '+/', '-_'));
    }

    /**
     * Sign message with secret key.
     *
     * @param string $msg
     * @param string $key
     *
     * @return string
     */
    private function sign($msg, $key)
    {
        return hash_hmac('sha256', $msg, $key, true);
    }

    /**
     * Can show Node info when return auth token.
     *
     * @return bool
     */
    public function showNodeInfo(): bool
    {
        return (bool) $this->config['show_node_info'];
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Opekunov\Centrifugo;
6
7			use Carbon\Carbon;
8			use GuzzleHttp\Client as HttpClient;
9			use GuzzleHttp\Exception\ClientException;
10			use Opekunov\Centrifugo\Contracts\CentrifugoInterface;
11
12			class Centrifugo implements CentrifugoInterface
13			{
14			const API_PATH = '/api';
15
16			/**
17			* @var \GuzzleHttp\Client
18			*/
19			protected $httpClient;
20
21			/**
22			* @var array
23			*/
24			protected $config;
25
26			/**
27			* Create a new Centrifugo instance.
28			*
29			* @param array $config
30			* @param \GuzzleHttp\Client $httpClient
31			*/
32			public function __construct(array $config = null, HttpClient $httpClient = null)
33			{
34			$this->httpClient = $httpClient ?? new HttpClient();
35			if (!$config) {
36			$this->config = app()->make('config')->get('broadcasting.connections.centrifugo');
37			} else {
38			$this->config = $this->initConfiguration($config ?? []) ??
39			app()->make('config')->get('broadcasting.connections.centrifugo');
40			}
41			}
42
43			/**
44			* Init centrifugo configuration.
45			*
46			* @param array $config
47			*
48			* @return array
49			*/
50			protected function initConfiguration(array $config)
51			{
52			$defaults = [
53			'url' => 'http://localhost:8000',
54			'secret' => null,
55			'apikey' => null,
56			'ssl_key' => null,
57			'verify' => true,
58			'show_node_info' => false,
59			'timeout' => 10,
60			];
61
62			foreach ($config as $key => $value) {
63			if (array_key_exists($key, $defaults)) {
64			$defaults[$key] = $value;
65			}
66			}
67
68			return $defaults;
69			}
70
71			/**
72			* Send message into channel.
73			*
74			* @param string $channel
75			* @param array $data
76			*
77			* @return mixed
78			*/
79			public function publish(string $channel, array $data)
80			{
81			return $this->send('publish', [
82			'channel' => $channel,
83			'data' => $data,
84			]);
85			}
86
87			/**
88			* Send message into multiple channel.
89			*
90			* @param array $channels
91			* @param array $data
92			*
93			* @return mixed
94			*/
95			public function broadcast(array $channels, array $data)
96			{
97			$params = ['channels' => $channels, 'data' => $data];
98
99			return $this->send('broadcast', $params);
100			}
101
102			/**
103			* Get channel presence information (all clients currently subscribed on this channel).
104			*
105			* @param string $channel
106			*
107			* @return mixed
108			*/
109			public function presence(string $channel)
110			{
111			return $this->send('presence', ['channel' => $channel]);
112			}
113
114			/**
115			* Get channel presence information in short form.
116			*
117			* @param string $channel
118			*
119			* @return mixed
120			*/
121			public function presenceStats(string $channel)
122			{
123			return $this->send('presence_stats', ['channel' => $channel]);
124			}
125
126			/**
127			* Get channel history information (list of last messages sent into channel).
128			*
129			* @param string $channel
130			*
131			* @return mixed
132			*/
133			public function history(string $channel)
134			{
135			return $this->send('history', ['channel' => $channel]);
136			}
137
138			/**
139			* Remove channel history information.
140			*
141			* @param string $channel
142			*
143			* @return mixed
144			*/
145			public function historyRemove(string $channel)
146			{
147			return $this->send('history_remove', [
148			'channel' => $channel,
149			]);
150			}
151
152			/**
153			* Unsubscribe user from channel.
154			*
155			* @param string $channel
156			* @param string $user
157			*
158			* @return mixed
159			*/
160			public function unsubscribe(string $channel, string $user)
161			{
162			return $this->send('unsubscribe', [
163			'channel' => $channel,
164			'user' => $user,
165			]);
166			}
167
168			/**
169			* Disconnect user by its ID.
170			*
171			* @param string $user_id
172			*
173			* @return mixed
174			*/
175			public function disconnect(string $user_id)
176			{
177			return $this->send('disconnect', ['user' => (string) $user_id]);
178			}
179
180			/**
181			* Get channels information (list of currently active channels).
182			*
183			* @return mixed
184			*/
185			public function channels()
186			{
187			return $this->send('channels');
188			}
189
190			/**
191			* Get stats information about running server nodes.
192			*
193			* @return mixed
194			*/
195			public function info()
196			{
197			return $this->send('info');
198			}
199
200			/**
201			* Generate connection token.
202			*
203			* @param string $userId
204			* @param int\|Carbon $exp
205			* @param array $info
206			*
207			* @return string
208			*/
209			public function generateConnectionToken(string $userId = '', $exp = 0, array $info = []): string
210			{
211			if (gettype($exp) !== 'integer') {
212			$exp = $exp->unix();
213			}
214			$header = ['typ' => 'JWT', 'alg' => 'HS256'];
215			$payload = ['sub' => $userId];
216			if (!empty($info)) {
217			$payload['info'] = $info;
218			}
219			if ($exp) {
220			$payload['exp'] = $exp;
221			}
222			$segments = [];
223			$segments[] = $this->urlsafeB64Encode(json_encode($header));
224			$segments[] = $this->urlsafeB64Encode(json_encode($payload));
225			$signing_input = implode('.', $segments);
226			$signature = $this->sign($signing_input, $this->getSecret());
227			$segments[] = $this->urlsafeB64Encode($signature);
228
229			return implode('.', $segments);
230			}
231
232			/**
233			* Generate private channel token.
234			*
235			* @param string $client
236			* @param string $channel
237			* @param int\|Carbon $exp
238			* @param array $info
239			*
240			* @return string
241			*/
242			public function generatePrivateChannelToken(string $client, string $channel, $exp = 0, array $info = []): string
243			{
244			if (gettype($exp) !== 'integer') {
245			$exp = $exp->unix();
246			}
247			$header = ['typ' => 'JWT', 'alg' => 'HS256'];
248			$payload = ['channel' => $channel, 'client' => $client];
249			if (!empty($info)) {
250			$payload['info'] = $info;
251			}
252			if ($exp) {
253			$payload['exp'] = $exp;
254			}
255			$segments = [];
256			$segments[] = $this->urlsafeB64Encode(json_encode($header));
257			$segments[] = $this->urlsafeB64Encode(json_encode($payload));
258			$signing_input = implode('.', $segments);
259			$signature = $this->sign($signing_input, $this->getSecret());
260			$segments[] = $this->urlsafeB64Encode($signature);
261
262			return implode('.', $segments);
263			}
264
265			/**
266			* Get secret key.
267			*
268			* @return string
269			*/
270			protected function getSecret()
271			{
272			return $this->config['secret'];
273			}
274
275			/**
276			* Send message to centrifugo server.
277			*
278			* @param string $method
279			* @param array $params
280			*
281			* @return mixed
282			*/
283			protected function send($method, array $params = [])
284			{
285			$json = json_encode(['method' => $method, 'params' => $params]);
286
287			$headers = [
288			'Content-type' => 'application/json',
289			'Authorization' => 'apikey '.$this->config['apikey'],
290			];
291
292			try {
293			$url = parse_url($this->prepareUrl());
294
295			$config = collect([
296			'headers' => $headers,
297			'body' => $json,
298			'http_errors' => true,
299			'timeout' => $this->config['timeout'],
300			]);
301
302			if ($url['scheme'] == 'https') {
303			$config->put('verify', collect($this->config)->get('verify', false));
304
305			if (collect($this->config)->get('ssl_key')) {
306			$config->put('ssl_key', collect($this->config)->get('ssl_key'));
307			}
308			}
309
310			$response = $this->httpClient->post($this->prepareUrl(), $config->toArray());
311
312			$result = json_decode((string) $response->getBody(), true);
313			} catch (ClientException $e) {
314			$result = [
315			'method' => $method,
316			'error' => $e->getMessage(),
317			'body' => $params,
318			];
319			}
320
321			return $result;
322			}
323
324			/**
325			* Prepare URL to send the http request.
326			*
327			* @return string
328			*/
329			protected function prepareUrl()
330			{
331			$address = rtrim($this->config['url'], '/');
332
333			if (substr_compare($address, static::API_PATH, -strlen(static::API_PATH)) !== 0) {
334			$address .= static::API_PATH;
335			}
336			//$address .= '/';
337
338			return $address;
339			}
340
341			/**
342			* Safely encode string in base64.
343			*
344			* @param string $input
345			*
346			* @return string
347			*/
348			private function urlsafeB64Encode($input)
349			{
350			return str_replace('=', '', strtr(base64_encode($input), '+/', '-_'));
351			}
352
353			/**
354			* Sign message with secret key.
355			*
356			* @param string $msg
357			* @param string $key
358			*
359			* @return string
360			*/
361			private function sign($msg, $key)
362			{
363			return hash_hmac('sha256', $msg, $key, true);
364			}
365
366			/**
367			* Can show Node info when return auth token.
368			*
369			* @return bool
370			*/
371			public function showNodeInfo(): bool
372			{
373			return (bool) $this->config['show_node_info'];
374			}
375			}
376

Opekunov / laravel-centrifugo-broadcaster

Centrifugo::history() A last analyzed 2022-03-25 17:02 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Centrifugo::history() A
last analyzed 2022-03-25 17:02 UTC