├── .gitignore
├── LICENSE.txt
├── README.md
├── composer.json
└── src
    ├── Access
        └── Endpoint.php
    ├── Connection
        ├── Lookupd.php
        ├── Nsqd.php
        ├── Pool.php
        └── Transport
        │   ├── HTTP.php
        │   └── TCP.php
    ├── Contract
        ├── Message.php
        └── Network
        │   └── Stream.php
    ├── Exception
        ├── GenericErrorException.php
        ├── InvalidLookupdException.php
        ├── InvalidMessageException.php
        ├── LookupTopicException.php
        ├── NetworkSocketException.php
        ├── NetworkTimeoutException.php
        ├── PoolMissingSocketException.php
        ├── UnknownFrameException.php
        └── UnknownProtocolException.php
    ├── Logger
        ├── EchoLogger.php
        └── Logger.php
    ├── Message
        ├── Bag.php
        └── Message.php
    ├── Protocol
        ├── Binary.php
        ├── Command.php
        ├── CommandHTTP.php
        └── Specification.php
    ├── Queue.php
    ├── SDK.php
    └── Utils
        └── GracefulShutdown.php


/.gitignore:
--------------------------------------------------------------------------------
1 | vendor
2 | composer.lock


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) [2017] [moyo]
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # NSQClient
 2 | 
 3 | Yet another PHP client for [NSQ](http://nsq.io)
 4 | 
 5 | ### Installation (via composer)
 6 | 
 7 | ```
 8 | composer require moolex/nsqclient dev-master
 9 | ```
10 | 
11 | ### Usage
12 | 
13 | #### Publish
14 | 
15 | ```php
16 | $topic = 'my_topic';
17 | $endpoint = new \NSQClient\Access\Endpoint('http://127.0.0.1:4161');
18 | $message = new \NSQClient\Message\Message('hello world');
19 | $result = \NSQClient\Queue::publish($endpoint, $topic, $message);
20 | ```
21 | 
22 | #### Publish (deferred)
23 | 
24 | ```php
25 | $topic = 'my_topic';
26 | $endpoint = new \NSQClient\Access\Endpoint('http://127.0.0.1:4161');
27 | $message = (new \NSQClient\Message\Message('hello world'))->deferred(5);
28 | $result = \NSQClient\Queue::publish($endpoint, $topic, $message);
29 | ```
30 | 
31 | #### Publish (batch)
32 | 
33 | ```php
34 | $topic = 'my_topic';
35 | $endpoint = new \NSQClient\Access\Endpoint('http://127.0.0.1:4161');
36 | $message = \NSQClient\Message\Bag::generate(['msg data 1', 'msg data 2']);
37 | $result = \NSQClient\Queue::publish($endpoint, $topic, $message);
38 | ```
39 | 
40 | #### Subscribe
41 | 
42 | ```php
43 | $topic = 'my_topic';
44 | $channel = 'my_channel';
45 | $endpoint = new \NSQClient\Access\Endpoint('http://127.0.0.1:4161');
46 | \NSQClient\Queue::subscribe($endpoint, $topic, $channel, function (\NSQClient\Contract\Message $message) {
47 |     echo 'GOT ', $message->id(), "\n";
48 |     // make done
49 |     $message->done();
50 |     // make retry immediately
51 |     // $message->retry();
52 |     // make retry delayed in 10 seconds
53 |     // $message->delay(10);
54 | });
55 | ```
56 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "moolex/nsqclient",
 3 |   "keywords": ["nsq"],
 4 |   "license": "MIT",
 5 |   "require": {
 6 |     "php": ">=5.6",
 7 |     "ext-json" : "*",
 8 |     "ext-curl" : "*",
 9 |     "ext-bcmath" : "*",
10 |     "psr/log": "~1.0",
11 |     "react/event-loop": "~0.4"
12 |   },
13 |   "suggest": {
14 |     "ext-pcntl": "graceful shutdown"
15 |   },
16 |   "autoload":{
17 |     "psr-4": {
18 |       "NSQClient\\": "src"
19 |     }
20 |   }
21 | }


--------------------------------------------------------------------------------
/src/Access/Endpoint.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Access endpoint info
 4 |  * User: moyo
 5 |  * Date: 31/03/2017
 6 |  * Time: 4:24 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Access;
10 | 
11 | use NSQClient\Exception\InvalidLookupdException;
12 | 
13 | class Endpoint
14 | {
15 |     /**
16 |      * @var string
17 |      */
18 |     private $lookupd = 'http://nsqlookupd.local.moyo.im:4161';
19 | 
20 |     /**
21 |      * @var string
22 |      */
23 |     private $uniqueID = 'hash';
24 | 
25 |     /**
26 |      * Endpoint constructor.
27 |      * @param $lookupd
28 |      * @throws InvalidLookupdException
29 |      */
30 |     public function __construct($lookupd)
31 |     {
32 |         $this->lookupd = $lookupd;
33 |         $this->uniqueID = spl_object_hash($this);
34 | 
35 |         // checks
36 |         $parsed = parse_url($this->lookupd);
37 |         if (!isset($parsed['host'])) {
38 |             throw new InvalidLookupdException;
39 |         }
40 |     }
41 | 
42 |     /**
43 |      * @return string
44 |      */
45 |     public function getUniqueID()
46 |     {
47 |         return $this->uniqueID;
48 |     }
49 | 
50 |     /**
51 |      * @return string
52 |      */
53 |     public function getLookupd()
54 |     {
55 |         return $this->lookupd;
56 |     }
57 | 
58 |     /**
59 |      * @return string
60 |      */
61 |     public function getConnType()
62 |     {
63 |         return PHP_SAPI == 'cli' ? 'tcp' : 'http';
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/Connection/Lookupd.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Conn for Lookupd
 4 |  * User: moyo
 5 |  * Date: 31/03/2017
 6 |  * Time: 4:53 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Connection;
10 | 
11 | use NSQClient\Access\Endpoint;
12 | use NSQClient\Connection\Transport\HTTP;
13 | use NSQClient\Exception\LookupTopicException;
14 | use NSQClient\Logger\Logger;
15 | 
16 | class Lookupd
17 | {
18 |     /**
19 |      * @var string
20 |      */
21 |     private static $queryFormat = '/lookup?topic=%s';
22 | 
23 |     /**
24 |      * @var array
25 |      */
26 |     private static $caches = [];
27 | 
28 |     /**
29 |      * @param Endpoint $endpoint
30 |      * @param $topic
31 |      * @return array
32 |      * @throws LookupTopicException
33 |      */
34 |     public static function getNodes(Endpoint $endpoint, $topic)
35 |     {
36 |         if (isset(self::$caches[$endpoint->getUniqueID()][$topic])) {
37 |             return self::$caches[$endpoint->getUniqueID()][$topic];
38 |         }
39 | 
40 |         $url = $endpoint->getLookupd() . sprintf(self::$queryFormat, $topic);
41 | 
42 |         list($error, $result) = HTTP::get($url);
43 | 
44 |         if ($error) {
45 |             list($netErrNo, $netErrMsg) = $error;
46 |             Logger::ins()->error('Lookupd request failed', ['no' => $netErrNo, 'msg' => $netErrMsg]);
47 |             throw new LookupTopicException($netErrMsg, $netErrNo);
48 |         } else {
49 |             Logger::ins()->debug('Lookupd results got', ['raw' => $result]);
50 |             return self::$caches[$endpoint->getUniqueID()][$topic] = self::parseResult($result, $topic);
51 |         }
52 |     }
53 | 
54 |     /**
55 |      * @param $rawJson
56 |      * @param $scopeTopic
57 |      * @return array
58 |      */
59 |     private static function parseResult($rawJson, $scopeTopic)
60 |     {
61 |         $result = json_decode($rawJson, true);
62 | 
63 |         $nodes = [];
64 | 
65 |         if (isset($result['producers'])) {
66 |             foreach ($result['producers'] as $producer) {
67 |                 $nodes[] = [
68 |                     'topic' => $scopeTopic,
69 |                     'host' => $producer['broadcast_address'],
70 |                     'ports' => [
71 |                         'tcp' => $producer['tcp_port'],
72 |                         'http' => $producer['http_port']
73 |                     ]
74 |                 ];
75 |             }
76 |         }
77 | 
78 |         return $nodes;
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/src/Connection/Nsqd.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Connection node for nsqd
  4 |  * User: moyo
  5 |  * Date: 31/03/2017
  6 |  * Time: 4:37 PM
  7 |  */
  8 | 
  9 | namespace NSQClient\Connection;
 10 | 
 11 | use NSQClient\Access\Endpoint;
 12 | use NSQClient\Connection\Transport\HTTP;
 13 | use NSQClient\Connection\Transport\TCP;
 14 | use NSQClient\Contract\Network\Stream;
 15 | use NSQClient\Exception\GenericErrorException;
 16 | use NSQClient\Exception\InvalidMessageException;
 17 | use NSQClient\Exception\NetworkSocketException;
 18 | use NSQClient\Exception\UnknownProtocolException;
 19 | use NSQClient\Logger\Logger;
 20 | use NSQClient\Message\Bag as MessageBag;
 21 | use NSQClient\Message\Message;
 22 | use NSQClient\Protocol\Command;
 23 | use NSQClient\Protocol\CommandHTTP;
 24 | use NSQClient\Protocol\Specification;
 25 | use NSQClient\SDK;
 26 | 
 27 | class Nsqd
 28 | {
 29 |     /**
 30 |      * @var Endpoint
 31 |      */
 32 |     private $endpoint = null;
 33 | 
 34 |     /**
 35 |      * @var string
 36 |      */
 37 |     private $host = '127.0.0.1';
 38 | 
 39 |     /**
 40 |      * @var int
 41 |      */
 42 |     private $portTCP = 4150;
 43 | 
 44 |     /**
 45 |      * @var TCP
 46 |      */
 47 |     private $connTCP = null;
 48 | 
 49 |     /**
 50 |      * @var int
 51 |      */
 52 |     private $portHTTP = 4151;
 53 | 
 54 |     /**
 55 |      * @var string
 56 |      */
 57 |     private $topic = 'topic';
 58 | 
 59 |     /**
 60 |      * PUB: Idle seconds before recycling
 61 |      * SUB: Run seconds before exiting
 62 |      * @var int
 63 |      */
 64 |     private $lifecycle = 0;
 65 | 
 66 |     /**
 67 |      * @var callable
 68 |      */
 69 |     private $subProcessor = null;
 70 | 
 71 |     /**
 72 |      * Nsqd constructor.
 73 |      * @param Endpoint $endpoint
 74 |      */
 75 |     public function __construct(Endpoint $endpoint)
 76 |     {
 77 |         $this->endpoint = $endpoint;
 78 | 
 79 |         if ($this->endpoint->getConnType() == 'tcp') {
 80 |             $this->connTCP = new TCP;
 81 |             $this->connTCP->setHandshake([$this, 'handshake']);
 82 |         }
 83 |     }
 84 | 
 85 |     /**
 86 |      * @param $route
 87 |      * @return self
 88 |      */
 89 |     public function setRoute($route)
 90 |     {
 91 |         $this->host = $route['host'];
 92 |         $this->portTCP = $route['ports']['tcp'];
 93 |         $this->portHTTP = $route['ports']['http'];
 94 | 
 95 |         if ($this->connTCP) {
 96 |             $this->connTCP->setTarget($this->host, $this->portTCP);
 97 |         }
 98 | 
 99 |         return $this;
100 |     }
101 | 
102 |     /**
103 |      * @param $topic
104 |      * @return self
105 |      */
106 |     public function setTopic($topic)
107 |     {
108 |         $this->topic = $topic;
109 | 
110 |         return $this;
111 |     }
112 | 
113 |     /**
114 |      * @param $seconds
115 |      * @return self
116 |      */
117 |     public function setLifecycle($seconds)
118 |     {
119 |         $this->lifecycle = $seconds;
120 | 
121 |         return $this;
122 |     }
123 | 
124 |     /**
125 |      * @return self
126 |      */
127 |     public function setProducer()
128 |     {
129 |         if ($this->connTCP) {
130 |             $this->connTCP->setRecycling($this->lifecycle);
131 |         }
132 | 
133 |         return $this;
134 |     }
135 | 
136 |     /**
137 |      * @param callable $processor
138 |      * @return self
139 |      */
140 |     public function setConsumer(callable $processor)
141 |     {
142 |         $this->subProcessor = $processor;
143 | 
144 |         if ($this->lifecycle) {
145 |             $nsqd = $this;
146 |             Pool::getEvLoop()->addTimer($this->lifecycle, function () use ($nsqd) {
147 |                 $nsqd->closing();
148 |             });
149 |         }
150 | 
151 |         return $this;
152 |     }
153 | 
154 |     /**
155 |      * @return int
156 |      */
157 |     public function getSockID()
158 |     {
159 |         return (int)$this->connTCP->socket();
160 |     }
161 | 
162 |     /**
163 |      * @return Stream
164 |      */
165 |     public function getSockIns()
166 |     {
167 |         return $this->connTCP;
168 |     }
169 | 
170 |     /**
171 |      * @return bool
172 |      */
173 |     public function isConsumer()
174 |     {
175 |         return ! is_null($this->subProcessor);
176 |     }
177 | 
178 |     /**
179 |      * @param Stream $stream
180 |      */
181 |     public function handshake(Stream $stream)
182 |     {
183 |         $stream->write(Command::magic());
184 |     }
185 | 
186 |     /**
187 |      * @param $message
188 |      * @return bool
189 |      */
190 |     public function publish($message)
191 |     {
192 |         return
193 |             $this->endpoint->getConnType() == 'tcp'
194 |                 ? $this->publishViaTCP($message)
195 |                 : $this->publishViaHTTP($message)
196 |         ;
197 |     }
198 | 
199 |     /**
200 |      * @param $channel
201 |      */
202 |     public function subscribe($channel)
203 |     {
204 |         $this->connTCP->setBlocking(false);
205 | 
206 |         $evLoop = Pool::getEvLoop();
207 | 
208 |         $evLoop->addReadStream($this->connTCP->socket(), function ($socket) {
209 |             $this->dispatching(Specification::readFrame(Pool::search($socket)));
210 |         });
211 | 
212 |         $this->connTCP->write(Command::identify(getmypid(), gethostname(), sprintf('%s/%s', SDK::NAME, SDK::VERSION)));
213 |         $this->connTCP->write(Command::subscribe($this->topic, $channel));
214 |         $this->connTCP->write(Command::ready(1));
215 | 
216 |         Pool::setEvAttached();
217 | 
218 |         Logger::ins()->debug('Consumer is ready', $this->loggingMeta());
219 |     }
220 | 
221 |     /**
222 |      * @param $messageID
223 |      */
224 |     public function finish($messageID)
225 |     {
226 |         Logger::ins()->debug('Make message is finished', $this->loggingMeta(['id' => $messageID]));
227 |         $this->connTCP->write(Command::finish($messageID));
228 |     }
229 | 
230 |     /**
231 |      * @param $messageID
232 |      * @param $millisecond
233 |      */
234 |     public function requeue($messageID, $millisecond)
235 |     {
236 |         Logger::ins()->debug(
237 |             'Make message is requeued',
238 |             $this->loggingMeta(['id' => $messageID, 'delay' => $millisecond])
239 |         );
240 |         $this->connTCP->write(Command::requeue($messageID, $millisecond));
241 |     }
242 | 
243 |     /**
244 |      * subscribe closing
245 |      */
246 |     public function closing()
247 |     {
248 |         Logger::ins()->info('Consumer is closing', $this->loggingMeta());
249 |         $this->connTCP->write(Command::close());
250 |     }
251 | 
252 |     /**
253 |      * process exiting
254 |      */
255 |     private function exiting()
256 |     {
257 |         Logger::ins()->info('Consumer is exiting', $this->loggingMeta());
258 |         $this->connTCP->close();
259 |         Pool::setEvDetached();
260 |     }
261 | 
262 |     /**
263 |      * @param $message
264 |      * @return bool
265 |      */
266 |     private function publishViaHTTP($message)
267 |     {
268 |         if ($message instanceof Message) {
269 |             list($uri, $data) = CommandHTTP::message($this->topic, $message->data());
270 |         } elseif ($message instanceof MessageBag) {
271 |             list($uri, $data) = CommandHTTP::messages($this->topic, $message->export());
272 |         } else {
273 |             Logger::ins()->error('Un-expected pub message', $this->loggingMeta(['input' => json_encode($message)]));
274 |             throw new InvalidMessageException('Unknowns message object');
275 |         }
276 | 
277 |         list($error, $result) = HTTP::post(sprintf('http://%s:%d/%s', $this->host, $this->portHTTP, $uri), $data);
278 | 
279 |         if ($error) {
280 |             list($netErrNo, $netErrMsg) = $error;
281 |             Logger::ins()->error(
282 |                 'HTTP Publish is failed',
283 |                 $this->loggingMeta(['no' => $netErrNo, 'msg' => $netErrMsg])
284 |             );
285 |             throw new NetworkSocketException($netErrMsg, $netErrNo);
286 |         } else {
287 |             return $result === 'OK' ? true : false;
288 |         }
289 |     }
290 | 
291 |     /**
292 |      * @param $message
293 |      * @return bool
294 |      */
295 |     private function publishViaTCP($message)
296 |     {
297 |         if ($message instanceof Message) {
298 |             $buffer = Command::message($this->topic, $message->data(), $message->deferred());
299 |         } elseif ($message instanceof MessageBag) {
300 |             $buffer = Command::messages($this->topic, $message->export());
301 |         } else {
302 |             Logger::ins()->error('Un-expected pub message', $this->loggingMeta(['input' => json_encode($message)]));
303 |             throw new InvalidMessageException('Unknowns message object');
304 |         }
305 | 
306 |         $this->connTCP->write($buffer);
307 | 
308 |         do {
309 |             $result = $this->dispatching(Specification::readFrame($this->connTCP));
310 |         } while (is_null($result));
311 | 
312 |         return $result;
313 |     }
314 | 
315 |     /**
316 |      * @param $frame
317 |      * @return bool|null
318 |      */
319 |     private function dispatching($frame)
320 |     {
321 |         switch (true) {
322 |             case Specification::frameIsOK($frame):
323 |                 return true;
324 |                 break;
325 |             case Specification::frameIsMessage($frame):
326 |                 Logger::ins()->debug(
327 |                     'FRAME got is message',
328 |                     $this->loggingMeta(['id' => $frame['id'], 'data' => $frame['payload']])
329 |                 );
330 |                 $this->processingMessage(
331 |                     new Message(
332 |                         $frame['payload'],
333 |                         $frame['id'],
334 |                         $frame['attempts'],
335 |                         $frame['timestamp'],
336 |                         $this
337 |                     )
338 |                 );
339 |                 return null;
340 |                 break;
341 |             case Specification::frameIsHeartbeat($frame):
342 |                 Logger::ins()->debug('FRAME got is heartbeat', $this->loggingMeta());
343 |                 $this->connTCP->write(Command::nop());
344 |                 return null;
345 |                 break;
346 |             case Specification::frameIsError($frame):
347 |                 Logger::ins()->error('FRAME got is error', $this->loggingMeta(['error' => $frame['error']]));
348 |                 throw new GenericErrorException($frame['error']);
349 |                 break;
350 |             case Specification::frameIsBroken($frame):
351 |                 Logger::ins()->warning('FRAME got is broken', $this->loggingMeta(['error' => $frame['error']]));
352 |                 throw new GenericErrorException($frame['error']);
353 |                 break;
354 |             case Specification::frameIsCloseWait($frame):
355 |                 Logger::ins()->debug('FRAME got is close-wait', $this->loggingMeta());
356 |                 $this->exiting();
357 |                 return null;
358 |                 break;
359 |             default:
360 |                 Logger::ins()->warning('FRAME got is unknowns', $this->loggingMeta());
361 |                 throw new UnknownProtocolException('Unknowns protocol data ('.json_encode($frame).')');
362 |         }
363 |     }
364 | 
365 |     /**
366 |      * @param Message $message
367 |      */
368 |     private function processingMessage(Message $message)
369 |     {
370 |         try {
371 |             call_user_func_array($this->subProcessor, [$message]);
372 |         } catch (\Exception $exception) {
373 |             // TODO add observer for usr callback
374 |             Logger::ins()->critical('Consuming processor has exception', $this->loggingMeta([
375 |                 'cls' => get_class($exception),
376 |                 'msg' => $exception->getMessage()
377 |             ]));
378 |         }
379 |     }
380 | 
381 |     /**
382 |      * @param $extra
383 |      * @return array
384 |      */
385 |     private function loggingMeta($extra = [])
386 |     {
387 |         return array_merge([
388 |             'topic' => $this->topic,
389 |             'host' => $this->host,
390 |             'port-tcp' => $this->portTCP
391 |         ], $extra);
392 |     }
393 | }
394 | 


--------------------------------------------------------------------------------
/src/Connection/Pool.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Connection pool
  4 |  * User: moyo
  5 |  * Date: 31/03/2017
  6 |  * Time: 4:37 PM
  7 |  */
  8 | 
  9 | namespace NSQClient\Connection;
 10 | 
 11 | use NSQClient\Contract\Network\Stream;
 12 | use NSQClient\Exception\PoolMissingSocketException;
 13 | use NSQClient\Logger\Logger;
 14 | use NSQClient\Utils\GracefulShutdown;
 15 | use React\EventLoop\Factory;
 16 | use React\EventLoop\LoopInterface;
 17 | 
 18 | class Pool
 19 | {
 20 |     /**
 21 |      * @var Nsqd[]
 22 |      */
 23 |     private static $instances = [];
 24 | 
 25 |     /**
 26 |      * @var Stream[]
 27 |      */
 28 |     private static $sockMaps = [];
 29 | 
 30 |     /**
 31 |      * @var LoopInterface
 32 |      */
 33 |     private static $evLoops = null;
 34 | 
 35 |     /**
 36 |      * @var int
 37 |      */
 38 |     private static $evAttached = 0;
 39 | 
 40 |     /**
 41 |      * @return Nsqd[]
 42 |      */
 43 |     public static function instances()
 44 |     {
 45 |         return self::$instances;
 46 |     }
 47 | 
 48 |     /**
 49 |      * @param array $factors
 50 |      * @param callable $creator
 51 |      * @return Nsqd
 52 |      */
 53 |     public static function register($factors, callable $creator)
 54 |     {
 55 |         $insKey = self::getInsKey($factors);
 56 | 
 57 |         if (isset(self::$instances[$insKey])) {
 58 |             return self::$instances[$insKey];
 59 |         }
 60 | 
 61 |         return self::$instances[$insKey] = call_user_func($creator);
 62 |     }
 63 | 
 64 |     /**
 65 |      * @param resource $socket
 66 |      * @return Stream
 67 |      * @throws PoolMissingSocketException
 68 |      */
 69 |     public static function search($socket)
 70 |     {
 71 |         $expectSockID = (int)$socket;
 72 | 
 73 |         if (isset(self::$sockMaps[$expectSockID])) {
 74 |             return self::$sockMaps[$expectSockID];
 75 |         }
 76 | 
 77 |         foreach (self::$instances as $nsqd) {
 78 |             if ($nsqd->getSockID() == $expectSockID) {
 79 |                 self::$sockMaps[$nsqd->getSockID()] = $nsqd->getSockIns();
 80 |                 return $nsqd->getSockIns();
 81 |             }
 82 |         }
 83 | 
 84 |         throw new PoolMissingSocketException;
 85 |     }
 86 | 
 87 |     /**
 88 |      * @return LoopInterface
 89 |      */
 90 |     public static function getEvLoop()
 91 |     {
 92 |         if (is_null(self::$evLoops)) {
 93 |             self::$evLoops = Factory::create();
 94 |             GracefulShutdown::init(self::$evLoops);
 95 |         }
 96 |         return self::$evLoops;
 97 |     }
 98 | 
 99 |     /**
100 |      * New attach by consumer connects
101 |      */
102 |     public static function setEvAttached()
103 |     {
104 |         self::$evAttached ++;
105 |     }
106 | 
107 |     /**
108 |      * New detach by consumer closing
109 |      */
110 |     public static function setEvDetached()
111 |     {
112 |         self::$evAttached --;
113 |         if (self::$evAttached <= 0) {
114 |             Logger::ins()->info('ALL event detached .. perform shutdown');
115 |             self::$evLoops && self::$evLoops->stop();
116 |         }
117 |     }
118 | 
119 |     /**
120 |      * @param $factors
121 |      * @return string
122 |      */
123 |     private static function getInsKey($factors)
124 |     {
125 |         return implode('$', $factors);
126 |     }
127 | }
128 | 


--------------------------------------------------------------------------------
/src/Connection/Transport/HTTP.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * HTTP Client for NSQ
 4 |  * User: moyo
 5 |  * Date: 31/03/2017
 6 |  * Time: 4:56 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Connection\Transport;
10 | 
11 | use NSQClient\SDK;
12 | 
13 | class HTTP
14 | {
15 |     /**
16 |      * @var string
17 |      */
18 |     private static $agent = SDK::NAME.'-'.SDK::VERSION;
19 | 
20 |     /**
21 |      * @var array
22 |      */
23 |     private static $headers = ['Accept: application/vnd.nsq; version=1.0'];
24 | 
25 |     /**
26 |      * @var string
27 |      */
28 |     private static $encoding = '';
29 | 
30 |     /**
31 |      * @param $url
32 |      * @param array $extOptions
33 |      * @return array
34 |      */
35 |     public static function get($url, $extOptions = [])
36 |     {
37 |         return self::request($url, [], $extOptions);
38 |     }
39 | 
40 |     /**
41 |      * @param $url
42 |      * @param $data
43 |      * @param array $extOptions
44 |      * @return array
45 |      */
46 |     public static function post($url, $data, $extOptions = [])
47 |     {
48 |         return self::request($url, [CURLOPT_POST => true, CURLOPT_POSTFIELDS => $data], $extOptions);
49 |     }
50 | 
51 |     /**
52 |      * @param $url
53 |      * @param $selfOptions
54 |      * @param $usrOptions
55 |      * @return array
56 |      */
57 |     private static function request($url, $selfOptions, $usrOptions)
58 |     {
59 |         $ch = curl_init();
60 | 
61 |         $initOptions = [
62 |             CURLOPT_URL            => $url,
63 |             CURLOPT_RETURNTRANSFER => true,
64 |             CURLOPT_HEADER         => false,
65 |             CURLOPT_FOLLOWLOCATION => false,
66 |             CURLOPT_ENCODING       => self::$encoding,
67 |             CURLOPT_USERAGENT      => self::$agent,
68 |             CURLOPT_HTTPHEADER     => self::$headers,
69 |             CURLOPT_FAILONERROR    => true
70 |         ];
71 | 
72 |         $selfOptions && $initOptions = self::mergeOptions($initOptions, $selfOptions);
73 |         $usrOptions && $initOptions = self::mergeOptions($initOptions, $usrOptions);
74 | 
75 |         curl_setopt_array($ch, $initOptions);
76 | 
77 |         $result = curl_exec($ch);
78 | 
79 |         $error = curl_errno($ch) ? [curl_errno($ch), curl_error($ch)] : null;
80 | 
81 |         curl_close($ch);
82 | 
83 |         return [$error, $result];
84 |     }
85 | 
86 |     /**
87 |      * @param $base
88 |      * @param $custom
89 |      * @return mixed
90 |      */
91 |     private static function mergeOptions($base, $custom)
92 |     {
93 |         foreach ($custom as $key => $val) {
94 |             $base[$key] = $val;
95 |         }
96 |         return $base;
97 |     }
98 | }
99 | 


--------------------------------------------------------------------------------
/src/Connection/Transport/TCP.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * TCP Client for NSQ
  4 |  * User: moyo
  5 |  * Date: 31/03/2017
  6 |  * Time: 6:03 PM
  7 |  */
  8 | 
  9 | namespace NSQClient\Connection\Transport;
 10 | 
 11 | use NSQClient\Contract\Network\Stream;
 12 | use NSQClient\Exception\NetworkSocketException;
 13 | use NSQClient\Exception\NetworkTimeoutException;
 14 | 
 15 | class TCP implements Stream
 16 | {
 17 |     /**
 18 |      * @var string
 19 |      */
 20 |     private $host = '127.0.0.1';
 21 | 
 22 |     /**
 23 |      * @var int
 24 |      */
 25 |     private $port = 4150;
 26 | 
 27 |     /**
 28 |      * @var bool
 29 |      */
 30 |     private $blocking = true;
 31 | 
 32 |     /**
 33 |      * @var resource
 34 |      */
 35 |     private $socket = null;
 36 | 
 37 |     /**
 38 |      * @var callable
 39 |      */
 40 |     private $handshake = null;
 41 | 
 42 |     /**
 43 |      * @var int
 44 |      */
 45 |     private $readTimeoutSec = 5;
 46 | 
 47 |     /**
 48 |      * @var int
 49 |      */
 50 |     private $readTimeoutUsec = 0;
 51 | 
 52 |     /**
 53 |      * @var int
 54 |      */
 55 |     private $writeTimeoutSec = 5;
 56 | 
 57 |     /**
 58 |      * @var int
 59 |      */
 60 |     private $writeTimeoutUsec = 0;
 61 | 
 62 |     /**
 63 |      * @var int
 64 |      */
 65 |     private $connRecyclingSec = 0;
 66 | 
 67 |     /**
 68 |      * @var int
 69 |      */
 70 |     private $connEstablishedTime = 0;
 71 | 
 72 |     /**
 73 |      * @param $host
 74 |      * @param $port
 75 |      */
 76 |     public function setTarget($host, $port)
 77 |     {
 78 |         $this->host = $host;
 79 |         $this->port = $port;
 80 |     }
 81 | 
 82 |     /**
 83 |      * @param $switch
 84 |      */
 85 |     public function setBlocking($switch)
 86 |     {
 87 |         $this->blocking = $switch ? true : false;
 88 |     }
 89 | 
 90 |     /**
 91 |      * @param string $ch
 92 |      * @param float $time
 93 |      */
 94 |     public function setTimeout($ch = 'rw', $time = 5.0)
 95 |     {
 96 |         if ($ch === 'r' || $ch === 'rw') {
 97 |             $this->readTimeoutSec = floor($time);
 98 |             $this->readTimeoutUsec = ($time - $this->readTimeoutSec) * 1000000;
 99 |         }
100 | 
101 |         if ($ch === 'w' || $ch === 'rw') {
102 |             $this->writeTimeoutSec = floor($time);
103 |             $this->writeTimeoutUsec = ($time - $this->writeTimeoutSec) * 1000000;
104 |         }
105 |     }
106 | 
107 |     /**
108 |      * @param $seconds
109 |      */
110 |     public function setRecycling($seconds)
111 |     {
112 |         $this->connRecyclingSec = $seconds;
113 |     }
114 | 
115 |     /**
116 |      * @param callable $processor
117 |      */
118 |     public function setHandshake(callable $processor)
119 |     {
120 |         $this->handshake = $processor;
121 |     }
122 | 
123 |     /**
124 |      * @return resource
125 |      */
126 |     public function socket()
127 |     {
128 |         if ($this->socket) {
129 |             if ($this->connRecyclingSec
130 |                 && $this->connEstablishedTime
131 |                 && (time() - $this->connEstablishedTime > $this->connRecyclingSec)
132 |             ) {
133 |                 $this->close();
134 |             } else {
135 |                 return $this->socket;
136 |             }
137 |         }
138 | 
139 |         $netErrNo = $netErrMsg = null;
140 | 
141 |         $this->socket = fsockopen($this->host, $this->port, $netErrNo, $netErrMsg);
142 | 
143 |         if ($this->socket === false) {
144 |             throw new NetworkSocketException(
145 |                 "Connecting failed [{$this->host}:{$this->port}] - {$netErrMsg}",
146 |                 $netErrNo
147 |             );
148 |         } else {
149 |             $this->connEstablishedTime = time();
150 |         }
151 | 
152 |         stream_set_blocking($this->socket, $this->blocking ? 1 : 0);
153 | 
154 |         if (is_callable($this->handshake)) {
155 |             call_user_func($this->handshake, $this);
156 |         }
157 | 
158 |         return $this->socket;
159 |     }
160 | 
161 |     /**
162 |      * @param $buf
163 |      */
164 |     public function write($buf)
165 |     {
166 |         $null = null;
167 |         $socket = $this->socket();
168 |         $writeCh = [$socket];
169 | 
170 |         while (strlen($buf) > 0) {
171 |             $writable = stream_select($null, $writeCh, $null, $this->writeTimeoutSec, $this->writeTimeoutUsec);
172 |             if ($writable > 0) {
173 |                 $wroteLen = stream_socket_sendto($socket, $buf);
174 |                 if ($wroteLen === -1 || $wroteLen === false) {
175 |                     throw new NetworkSocketException("Writing failed [{$this->host}:{$this->port}](1)");
176 |                 }
177 |                 $buf = substr($buf, $wroteLen);
178 |             } elseif ($writable === 0) {
179 |                 throw new NetworkTimeoutException("Writing timeout [{$this->host}:{$this->port}]");
180 |             } else {
181 |                 throw new NetworkSocketException("Writing failed [{$this->host}:{$this->port}](2)");
182 |             }
183 |         }
184 |     }
185 | 
186 |     /**
187 |      * @param $len
188 |      * @return string
189 |      */
190 |     public function read($len)
191 |     {
192 |         $null = null;
193 |         $socket = $this->socket();
194 |         $readCh = [$socket];
195 | 
196 |         $remainingLen = $len;
197 |         $buffer = '';
198 | 
199 |         while (strlen($buffer) < $len) {
200 |             $readable = stream_select($readCh, $null, $null, $this->readTimeoutSec, $this->readTimeoutUsec);
201 |             if ($readable > 0) {
202 |                 $recv = stream_socket_recvfrom($socket, $remainingLen);
203 |                 if ($recv === false) {
204 |                     throw new NetworkSocketException("Reading failed [{$this->host}:{$this->port}](1)");
205 |                 } elseif ($recv === '') {
206 |                     throw new NetworkSocketException("Reading failed [{$this->host}:{$this->port}](2)");
207 |                 } else {
208 |                     $buffer .= $recv;
209 |                     $remainingLen -= strlen($recv);
210 |                 }
211 |             } elseif ($readable === 0) {
212 |                 throw new NetworkTimeoutException("Reading timeout [{$this->host}:{$this->port}]");
213 |             } else {
214 |                 throw new NetworkSocketException("Reading failed [{$this->host}:{$this->port}](3)");
215 |             }
216 |         }
217 | 
218 |         return $buffer;
219 |     }
220 | 
221 |     /**
222 |      * @return bool
223 |      */
224 |     public function close()
225 |     {
226 |         $closed = fclose($this->socket);
227 |         $this->socket = null;
228 |         return $closed;
229 |     }
230 | }
231 | 


--------------------------------------------------------------------------------
/src/Contract/Message.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Message interface
 4 |  * User: moyo
 5 |  * Date: 01/04/2017
 6 |  * Time: 4:39 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Contract;
10 | 
11 | interface Message
12 | {
13 |     /**
14 |      * Get message ID
15 |      * @return int
16 |      */
17 |     public function id();
18 | 
19 |     /**
20 |      * Get message payload (raw)
21 |      * @return string
22 |      */
23 |     public function payload();
24 | 
25 |     /**
26 |      * Get message data (serialized/un-serialized)
27 |      * @return mixed
28 |      */
29 |     public function data();
30 | 
31 |     /**
32 |      * Get attempts
33 |      * @return int
34 |      */
35 |     public function attempts();
36 | 
37 |     /**
38 |      * Get timestamp
39 |      * @return int
40 |      */
41 |     public function timestamp();
42 | 
43 |     /**
44 |      * Make msg is done
45 |      */
46 |     public function done();
47 | 
48 |     /**
49 |      * Make retry with msg
50 |      */
51 |     public function retry();
52 | 
53 |     /**
54 |      * Make delay with msg
55 |      * @param $seconds
56 |      */
57 |     public function delay($seconds);
58 | 
59 |     /**
60 |      * Set msg deferred or get msg's deferred milliseconds
61 |      * @param $seconds
62 |      * @return int|static
63 |      */
64 |     public function deferred($seconds = null);
65 | }
66 | 


--------------------------------------------------------------------------------
/src/Contract/Network/Stream.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Network stream
 4 |  * User: moyo
 5 |  * Date: 01/04/2017
 6 |  * Time: 3:12 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Contract\Network;
10 | 
11 | interface Stream
12 | {
13 |     /**
14 |      * @param $buf
15 |      */
16 |     public function write($buf);
17 | 
18 |     /**
19 |      * @param $len
20 |      * @return string
21 |      */
22 |     public function read($len);
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Exception/GenericErrorException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Generic error for nsq commands
 4 |  * User: moyo
 5 |  * Date: 01/04/2017
 6 |  * Time: 4:17 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Exception;
10 | 
11 | class GenericErrorException extends \RuntimeException
12 | {
13 | 
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidLookupdException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Invalid lookupd url
 4 |  * User: moyo
 5 |  * Date: 05/04/2017
 6 |  * Time: 10:48 AM
 7 |  */
 8 | 
 9 | namespace NSQClient\Exception;
10 | 
11 | class InvalidLookupdException extends \RuntimeException
12 | {
13 | 
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Exception/InvalidMessageException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Invalid message
 4 |  * User: moyo
 5 |  * Date: 01/04/2017
 6 |  * Time: 5:14 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Exception;
10 | 
11 | class InvalidMessageException extends \RuntimeException
12 | {
13 | 
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Exception/LookupTopicException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Lookup topic failed
 4 |  * User: moyo
 5 |  * Date: 31/03/2017
 6 |  * Time: 6:30 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Exception;
10 | 
11 | class LookupTopicException extends \RuntimeException
12 | {
13 | 
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Exception/NetworkSocketException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Generic network exception
 4 |  * User: moyo
 5 |  * Date: 01/04/2017
 6 |  * Time: 2:19 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Exception;
10 | 
11 | class NetworkSocketException extends \RuntimeException
12 | {
13 | 
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Exception/NetworkTimeoutException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Network timeout
 4 |  * User: moyo
 5 |  * Date: 01/04/2017
 6 |  * Time: 2:39 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Exception;
10 | 
11 | class NetworkTimeoutException extends NetworkSocketException
12 | {
13 | 
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Exception/PoolMissingSocketException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Pool missing socket (search failed)
 4 |  * User: moyo
 5 |  * Date: 01/04/2017
 6 |  * Time: 3:55 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Exception;
10 | 
11 | class PoolMissingSocketException extends \RuntimeException
12 | {
13 | 
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Exception/UnknownFrameException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * [Specification] Unknown frame
 4 |  * User: moyo
 5 |  * Date: 31/03/2017
 6 |  * Time: 4:49 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Exception;
10 | 
11 | class UnknownFrameException extends \RuntimeException
12 | {
13 | 
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Exception/UnknownProtocolException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * [Specification] Unknown protocol
 4 |  * User: moyo
 5 |  * Date: 01/04/2017
 6 |  * Time: 4:12 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Exception;
10 | 
11 | class UnknownProtocolException extends \RuntimeException
12 | {
13 | 
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Logger/EchoLogger.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Logger via echo
  4 |  * User: moyo
  5 |  * Date: 10/04/2017
  6 |  * Time: 12:07 PM
  7 |  */
  8 | 
  9 | namespace NSQClient\Logger;
 10 | 
 11 | use Psr\Log\AbstractLogger;
 12 | use Psr\Log\LogLevel;
 13 | 
 14 | class EchoLogger extends AbstractLogger
 15 | {
 16 |     /**
 17 |      * @var array
 18 |      */
 19 |     private $levels = [
 20 |         LogLevel::EMERGENCY,
 21 |         LogLevel::ALERT,
 22 |         LogLevel::CRITICAL,
 23 |         LogLevel::ERROR,
 24 |         LogLevel::WARNING,
 25 |         LogLevel::NOTICE,
 26 |         LogLevel::INFO,
 27 |         LogLevel::DEBUG,
 28 |     ];
 29 | 
 30 |     /**
 31 |      * @var array
 32 |      */
 33 |     private $colors = [
 34 |         LogLevel::EMERGENCY => '0;31m', // red
 35 |         LogLevel::ALERT => '0;31m', // red
 36 |         LogLevel::CRITICAL => '0;31m', // red
 37 |         LogLevel::ERROR => '0;31m', // red
 38 |         LogLevel::WARNING => '1;33m', // yellow
 39 |         LogLevel::NOTICE => '0;35m', // purple
 40 |         LogLevel::INFO => '0;36m', // cyan
 41 |         LogLevel::DEBUG => '0;32m', // green
 42 |     ];
 43 | 
 44 |     /**
 45 |      * @var string
 46 |      */
 47 |     private $colorCtxKey = '0;37m'; // light gray
 48 | 
 49 |     /**
 50 |      * @var string
 51 |      */
 52 |     private $colorMsg = '1;37m'; // white
 53 | 
 54 |     /**
 55 |      * @var string
 56 |      */
 57 |     private $colorNO = "\033[0m";
 58 | 
 59 |     /**
 60 |      * @var string
 61 |      */
 62 |     private $colorBGN = "\033[";
 63 | 
 64 |     /**
 65 |      * @var array
 66 |      */
 67 |     private $allows = [];
 68 | 
 69 |     /**
 70 |      * EchoLogger constructor.
 71 |      * @param string $minimalLevel
 72 |      */
 73 |     public function __construct($minimalLevel = LogLevel::NOTICE)
 74 |     {
 75 |         $this->allows = array_slice($this->levels, 0, array_search($minimalLevel, $this->levels, true) + 1);
 76 |     }
 77 | 
 78 |     /**
 79 |      * @param mixed $level
 80 |      * @param string $message
 81 |      * @param array $context
 82 |      */
 83 |     public function log($level, $message, array $context = array())
 84 |     {
 85 |         if (in_array($level, $this->allows)) {
 86 |             printf(
 87 |                 '[%s]%s[%s] : %s ~ %s %s',
 88 |                 $this->printableLevel($level),
 89 |                 " ",
 90 |                 date('Y-m-d H:i:s'),
 91 |                 $this->printableMessage($message),
 92 |                 $this->printableContext($context),
 93 |                 "\n"
 94 |             );
 95 |         }
 96 |     }
 97 | 
 98 |     /**
 99 |      * @param $level
100 |      * @return string
101 |      */
102 |     private function printableLevel($level)
103 |     {
104 |         return $this->colorBGN . $this->colors[$level] . strtoupper($level) . $this->colorNO;
105 |     }
106 | 
107 |     /**
108 |      * @param $message
109 |      * @return string
110 |      */
111 |     private function printableMessage($message)
112 |     {
113 |         return $this->colorBGN . $this->colorMsg . $message . $this->colorNO;
114 |     }
115 | 
116 |     /**
117 |      * @param $context
118 |      * @return string
119 |      */
120 |     private function printableContext($context)
121 |     {
122 |         $print = '[';
123 | 
124 |         array_walk($context, function ($item, $key) use (&$print) {
125 |             $ctx = $this->colorBGN . $this->colorCtxKey . $key . $this->colorNO . '=';
126 |             if (is_array($item)) {
127 |                 $ctx .= json_encode($item, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
128 |             } else {
129 |                 $ctx .= $item;
130 |             }
131 |             $print .= $ctx . ',';
132 |         });
133 | 
134 |         return $print . ']';
135 |     }
136 | }
137 | 


--------------------------------------------------------------------------------
/src/Logger/Logger.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Logger gate
 4 |  * User: moyo
 5 |  * Date: 10/04/2017
 6 |  * Time: 12:11 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Logger;
10 | 
11 | use NSQClient\SDK;
12 | use Psr\Log\AbstractLogger;
13 | use Psr\Log\NullLogger;
14 | 
15 | class Logger extends AbstractLogger
16 | {
17 |     /**
18 |      * @var self
19 |      */
20 |     private static $instance = null;
21 | 
22 |     /**
23 |      * @var NullLogger
24 |      */
25 |     private $nullLogger = null;
26 | 
27 |     /**
28 |      * @return self
29 |      */
30 |     public static function ins()
31 |     {
32 |         if (is_null(self::$instance)) {
33 |             self::$instance = new self;
34 |         }
35 |         return self::$instance;
36 |     }
37 | 
38 |     /**
39 |      * Logger constructor.
40 |      */
41 |     public function __construct()
42 |     {
43 |         $this->nullLogger = new NullLogger;
44 |     }
45 | 
46 |     /**
47 |      * @param mixed $level
48 |      * @param string $message
49 |      * @param array $context
50 |      */
51 |     public function log($level, $message, array $context = array())
52 |     {
53 |         if (SDK::$presentLogger) {
54 |             SDK::$presentLogger->log($level, $message, $context);
55 |         } else {
56 |             $this->nullLogger->log($level, $message, $context);
57 |         }
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/Message/Bag.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Message bag
 4 |  * User: moyo
 5 |  * Date: 01/04/2017
 6 |  * Time: 5:07 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Message;
10 | 
11 | class Bag
12 | {
13 |     /**
14 |      * @var Message[]
15 |      */
16 |     private $messages = [];
17 | 
18 |     /**
19 |      * @param $list
20 |      * @return self
21 |      */
22 |     public static function generate($list)
23 |     {
24 |         $bag = new self();
25 |         foreach ($list as $item) {
26 |             $bag->append(new Message($item));
27 |         }
28 |         return $bag;
29 |     }
30 | 
31 |     /**
32 |      * @param $msg
33 |      */
34 |     public function append($msg)
35 |     {
36 |         $this->messages[] = $msg;
37 |     }
38 | 
39 |     /**
40 |      * @return array
41 |      */
42 |     public function export()
43 |     {
44 |         $bag = [];
45 |         foreach ($this->messages as $msg) {
46 |             $bag[] = $msg->data();
47 |         }
48 |         return $bag;
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Message/Message.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * NSQ Message
  4 |  * User: moyo
  5 |  * Date: 01/04/2017
  6 |  * Time: 4:44 PM
  7 |  */
  8 | 
  9 | namespace NSQClient\Message;
 10 | 
 11 | use NSQClient\Connection\Nsqd;
 12 | use NSQClient\Contract\Message as MessageInterface;
 13 | 
 14 | class Message implements MessageInterface
 15 | {
 16 |     /**
 17 |      * @var string
 18 |      */
 19 |     private $id = null;
 20 | 
 21 |     /**
 22 |      * @var string
 23 |      */
 24 |     private $payload = null;
 25 | 
 26 |     /**
 27 |      * @var mixed
 28 |      */
 29 |     private $data = null;
 30 | 
 31 |     /**
 32 |      * @var int
 33 |      */
 34 |     private $attempts = null;
 35 | 
 36 |     /**
 37 |      * @var int
 38 |      */
 39 |     private $timestamp = null;
 40 | 
 41 |     /**
 42 |      * @var int
 43 |      */
 44 |     private $deferred = null;
 45 | 
 46 |     /**
 47 |      * @var Nsqd
 48 |      */
 49 |     private $nsqd = null;
 50 | 
 51 |     /**
 52 |      * Message constructor.
 53 |      * @param $payload
 54 |      * @param null $id
 55 |      * @param null $attempts
 56 |      * @param null $timestamp
 57 |      * @param Nsqd $nsqd
 58 |      */
 59 |     public function __construct($payload, $id = null, $attempts = null, $timestamp = null, Nsqd $nsqd = null)
 60 |     {
 61 |         $this->id = $id;
 62 |         $this->payload = $payload;
 63 |         $this->attempts = $attempts;
 64 |         $this->timestamp = $timestamp;
 65 |         $this->data = $id ? json_decode($payload, true) : json_encode($payload);
 66 |         $this->nsqd = $nsqd;
 67 |     }
 68 | 
 69 |     /**
 70 |      * @return string
 71 |      */
 72 |     public function id()
 73 |     {
 74 |         return $this->id;
 75 |     }
 76 | 
 77 |     /**
 78 |      * @return string
 79 |      */
 80 |     public function payload()
 81 |     {
 82 |         return $this->payload;
 83 |     }
 84 | 
 85 |     /**
 86 |      * @return mixed
 87 |      */
 88 |     public function data()
 89 |     {
 90 |         return $this->data;
 91 |     }
 92 | 
 93 |     /**
 94 |      * @return int
 95 |      */
 96 |     public function attempts()
 97 |     {
 98 |         return $this->attempts;
 99 |     }
100 | 
101 |     /**
102 |      * @return int
103 |      */
104 |     public function timestamp()
105 |     {
106 |         return $this->timestamp;
107 |     }
108 | 
109 |     /**
110 |      * just done
111 |      */
112 |     public function done()
113 |     {
114 |         $this->nsqd->finish($this->id);
115 |     }
116 | 
117 |     /**
118 |      * just retry
119 |      */
120 |     public function retry()
121 |     {
122 |         $this->delay(0);
123 |     }
124 | 
125 |     /**
126 |      * just delay
127 |      * @param $seconds
128 |      */
129 |     public function delay($seconds)
130 |     {
131 |         $this->nsqd->requeue($this->id, $seconds * 1000);
132 |     }
133 | 
134 |     /**
135 |      * @param $seconds
136 |      * @return null|int|static
137 |      */
138 |     public function deferred($seconds = null)
139 |     {
140 |         if (is_null($seconds)) {
141 |             return $this->deferred;
142 |         } else {
143 |             $this->deferred = $seconds * 1000;
144 |             return $this;
145 |         }
146 |     }
147 | }
148 | 


--------------------------------------------------------------------------------
/src/Protocol/Binary.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Binary code/decode
  4 |  * User: moyo
  5 |  * Date: 31/03/2017
  6 |  * Time: 4:43 PM
  7 |  */
  8 | 
  9 | namespace NSQClient\Protocol;
 10 | 
 11 | use NSQClient\Contract\Network\Stream;
 12 | use NSQClient\SDK;
 13 | 
 14 | class Binary
 15 | {
 16 |     /**
 17 |      * Read and unpack short (2 bytes) from buffer
 18 |      * @param Stream $buffer
 19 |      * @return int
 20 |      */
 21 |     public static function readShort(Stream $buffer)
 22 |     {
 23 |         $unpack = @unpack('n', $buffer->read(2));
 24 |         if (is_array($unpack)) {
 25 |             list(, $res) = $unpack;
 26 |             return $res;
 27 |         } else {
 28 |             return null;
 29 |         }
 30 |     }
 31 | 
 32 |     /**
 33 |      * Read and unpack integer (4 bytes) from buffer
 34 |      * @param Stream $buffer
 35 |      * @return int
 36 |      */
 37 |     public static function readInt(Stream $buffer)
 38 |     {
 39 |         $unpack = @unpack('N', $buffer->read(4));
 40 |         if (is_array($unpack)) {
 41 |             list(, $res) = $unpack;
 42 |             if (PHP_INT_SIZE !== 4) {
 43 |                 $res = sprintf('%u', $res);
 44 |             }
 45 |             return (int)$res;
 46 |         } else {
 47 |             return null;
 48 |         }
 49 |     }
 50 | 
 51 |     /**
 52 |      * Read and unpack long (8 bytes) from buffer
 53 |      * @param Stream $buffer
 54 |      * @return string
 55 |      */
 56 |     public static function readLong(Stream $buffer)
 57 |     {
 58 |         $hi = @unpack('N', $buffer->read(4));
 59 |         $lo = @unpack('N', $buffer->read(4));
 60 |         if (is_array($hi) && is_array($lo)) {
 61 |             $hi = sprintf('%u', $hi[1]);
 62 |             $lo = sprintf('%u', $lo[1]);
 63 |             return bcadd(bcmul($hi, '4294967296'), $lo);
 64 |         } else {
 65 |             return null;
 66 |         }
 67 |     }
 68 | 
 69 |     /**
 70 |      * Read and unpack string
 71 |      * @param Stream $buffer
 72 |      * @param int $size
 73 |      * @return string
 74 |      */
 75 |     public static function readString(Stream $buffer, $size)
 76 |     {
 77 |         if (!SDK::$enabledStringPack) {
 78 |             return $buffer->read($size);
 79 |         }
 80 | 
 81 |         $temp = @unpack('c'.$size.'chars', $buffer->read($size));
 82 |         if (is_array($temp)) {
 83 |             $out = '';
 84 |             foreach ($temp as $v) {
 85 |                 if ($v > 0) {
 86 |                     $out .= chr($v);
 87 |                 }
 88 |             }
 89 |             return $out;
 90 |         } else {
 91 |             return null;
 92 |         }
 93 |     }
 94 | 
 95 |     /**
 96 |      * Pack string
 97 |      * @param $data
 98 |      * @return string
 99 |      */
100 |     public static function packString($data)
101 |     {
102 |         if (!SDK::$enabledStringPack) {
103 |             return $data;
104 |         }
105 | 
106 |         $out = '';
107 |         $len = strlen($data);
108 |         for ($i = 0; $i < $len; $i++) {
109 |             $out .= pack('c', ord(substr($data, $i, 1)));
110 |         }
111 |         return $out;
112 |     }
113 | }
114 | 


--------------------------------------------------------------------------------
/src/Protocol/Command.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * NSQ Commands
  4 |  * User: moyo
  5 |  * Date: 31/03/2017
  6 |  * Time: 4:40 PM
  7 |  */
  8 | 
  9 | namespace NSQClient\Protocol;
 10 | 
 11 | class Command
 12 | {
 13 |     /**
 14 |      * Magic header
 15 |      */
 16 |     const MAGIC_V2 = '  V2';
 17 | 
 18 |     /**
 19 |      * Magic hello
 20 |      * @return string
 21 |      */
 22 |     public static function magic()
 23 |     {
 24 |         return self::MAGIC_V2;
 25 |     }
 26 | 
 27 |     /**
 28 |      * Identify self [IDENTIFY]
 29 |      * @param $client_id
 30 |      * @param $hostname
 31 |      * @param $user_agent
 32 |      * @return string
 33 |      */
 34 |     public static function identify($client_id, $hostname, $user_agent)
 35 |     {
 36 |         $cmd = self::command('IDENTIFY');
 37 |         $data = json_encode([
 38 |             'client_id' => (string)$client_id,
 39 |             'hostname' => (string)$hostname,
 40 |             'user_agent' => (string)$user_agent
 41 |         ]);
 42 |         $size = pack('N', strlen($data));
 43 |         return $cmd . $size . $data;
 44 |     }
 45 | 
 46 |     /**
 47 |      * Subscribe [SUB]
 48 |      * @param string $topic
 49 |      * @param string $channel
 50 |      * @return string
 51 |      */
 52 |     public static function subscribe($topic, $channel)
 53 |     {
 54 |         return self::command('SUB', $topic, $channel);
 55 |     }
 56 | 
 57 |     /**
 58 |      * Publish [PUB]
 59 |      * @param string $topic
 60 |      * @param string $message
 61 |      * @param int $deferred
 62 |      * @return string
 63 |      */
 64 |     public static function message($topic, $message, $deferred = null)
 65 |     {
 66 |         $cmd = is_null($deferred)
 67 |             ? self::command('PUB', $topic)
 68 |             : self::command('DPUB', $topic, $deferred);
 69 |         $data = Binary::packString($message);
 70 |         $size = pack('N', strlen($data));
 71 |         return $cmd . $size . $data;
 72 |     }
 73 | 
 74 |     /**
 75 |      * Publish -multi [MPUB]
 76 |      * @param $topic
 77 |      * @param $messages
 78 |      * @return string
 79 |      */
 80 |     public static function messages($topic, $messages)
 81 |     {
 82 |         $cmd = self::command('MPUB', $topic);
 83 |         $msgNum = pack('N', count($messages));
 84 |         $buffer = '';
 85 |         foreach ($messages as $message) {
 86 |             $data = Binary::packString($message);
 87 |             $size = pack('N', strlen($data));
 88 |             $buffer .= $size . $data;
 89 |         }
 90 |         $bodySize = pack('N', strlen($msgNum . $buffer));
 91 |         return $cmd . $bodySize . $msgNum . $buffer;
 92 |     }
 93 | 
 94 |     /**
 95 |      * Ready [RDY]
 96 |      * @param integer $count
 97 |      * @return string
 98 |      */
 99 |     public static function ready($count)
100 |     {
101 |         return self::command('RDY', $count);
102 |     }
103 | 
104 |     /**
105 |      * Finish [FIN]
106 |      * @param string $id
107 |      * @return string
108 |      */
109 |     public static function finish($id)
110 |     {
111 |         return self::command('FIN', $id);
112 |     }
113 | 
114 |     /**
115 |      * Requeue [REQ]
116 |      * @param string $id
117 |      * @param integer $millisecond
118 |      * @return string
119 |      */
120 |     public static function requeue($id, $millisecond)
121 |     {
122 |         return self::command('REQ', $id, $millisecond);
123 |     }
124 | 
125 |     /**
126 |      * No-op [NOP]
127 |      * @return string
128 |      */
129 |     public static function nop()
130 |     {
131 |         return self::command('NOP');
132 |     }
133 | 
134 |     /**
135 |      * Cleanly close [CLS]
136 |      * @return string
137 |      */
138 |     public static function close()
139 |     {
140 |         return self::command('CLS');
141 |     }
142 | 
143 |     /**
144 |      * Gen command
145 |      * @return string
146 |      */
147 |     private static function command()
148 |     {
149 |         $args = func_get_args();
150 |         $cmd = array_shift($args);
151 |         return sprintf('%s %s%s', $cmd, implode(' ', $args), "\n");
152 |     }
153 | }
154 | 


--------------------------------------------------------------------------------
/src/Protocol/CommandHTTP.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * NSQ Commands / HTTP
 4 |  * User: moyo
 5 |  * Date: 01/04/2017
 6 |  * Time: 5:18 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Protocol;
10 | 
11 | class CommandHTTP
12 | {
13 |     /**
14 |      * Publish [PUB]
15 |      * @param string $topic
16 |      * @param string $message
17 |      * @return array
18 |      */
19 |     public static function message($topic, $message)
20 |     {
21 |         return [
22 |             sprintf('pub?topic=%s', $topic),
23 |             Binary::packString($message)
24 |         ];
25 |     }
26 | 
27 |     /**
28 |      * Publish -multi [MPUB]
29 |      * @param $topic
30 |      * @param $messages
31 |      * @return array
32 |      */
33 |     public static function messages($topic, $messages)
34 |     {
35 |         $buffer = '';
36 |         foreach ($messages as $message) {
37 |             $data = Binary::packString($message);
38 |             $size = pack('N', strlen($data));
39 |             $buffer .= $size . $data;
40 |         }
41 | 
42 |         return [
43 |             sprintf('mpub?topic=%s&binary=true', $topic),
44 |             pack('N', count($messages)) . $buffer
45 |         ];
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Protocol/Specification.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Specification defines
  4 |  * User: moyo
  5 |  * Date: 31/03/2017
  6 |  * Time: 4:47 PM
  7 |  */
  8 | 
  9 | namespace NSQClient\Protocol;
 10 | 
 11 | use NSQClient\Contract\Network\Stream;
 12 | use NSQClient\Exception\UnknownFrameException;
 13 | 
 14 | class Specification
 15 | {
 16 |     /**
 17 |      * Frame types
 18 |      */
 19 |     const FRAME_TYPE_BROKEN = -1;
 20 |     const FRAME_TYPE_RESPONSE = 0;
 21 |     const FRAME_TYPE_ERROR = 1;
 22 |     const FRAME_TYPE_MESSAGE = 2;
 23 | 
 24 |     /**
 25 |      * Heartbeat response content
 26 |      */
 27 |     const HEARTBEAT = '_heartbeat_';
 28 | 
 29 |     /**
 30 |      * OK response content
 31 |      */
 32 |     const OK = 'OK';
 33 | 
 34 |     /**
 35 |      * CLOSE_WAIT response content
 36 |      */
 37 |     const CLOSE_WAIT = 'CLOSE_WAIT';
 38 | 
 39 |     /**
 40 |      * Read frame
 41 |      * @param Stream $buffer
 42 |      * @return array
 43 |      */
 44 |     public static function readFrame(Stream $buffer)
 45 |     {
 46 |         $size = Binary::readInt($buffer);
 47 |         $frameType = Binary::readInt($buffer);
 48 | 
 49 |         $frame = ['type' => $frameType, 'size'  => $size];
 50 | 
 51 |         // switch
 52 |         switch ($frameType) {
 53 |             case self::FRAME_TYPE_RESPONSE:
 54 |                 $frame['response'] = Binary::readString($buffer, $size - 4);
 55 |                 break;
 56 |             case self::FRAME_TYPE_ERROR:
 57 |                 $frame['error'] = Binary::readString($buffer, $size - 4);
 58 |                 break;
 59 |             case self::FRAME_TYPE_MESSAGE:
 60 |                 $frame['timestamp'] = Binary::readLong($buffer);
 61 |                 $frame['attempts'] = Binary::readShort($buffer);
 62 |                 $frame['id'] = Binary::readString($buffer, 16);
 63 |                 $frame['payload'] = Binary::readString($buffer, $size - 30);
 64 |                 break;
 65 |             default:
 66 |                 throw new UnknownFrameException(Binary::readString($buffer, $size - 4));
 67 |                 break;
 68 |         }
 69 | 
 70 |         // check frame data
 71 |         foreach ($frame as $k => $val) {
 72 |             if (is_null($val)) {
 73 |                 $frame['type'] = self::FRAME_TYPE_BROKEN;
 74 |                 $frame['error'] = 'broken frame (maybe network error)';
 75 |                 break;
 76 |             }
 77 |         }
 78 | 
 79 |         return $frame;
 80 |     }
 81 | 
 82 |     /**
 83 |      * Test if frame is a message
 84 |      * @param array $frame
 85 |      * @return bool
 86 |      */
 87 |     public static function frameIsMessage(array $frame)
 88 |     {
 89 |         return isset($frame['type'], $frame['payload']) && $frame['type'] === self::FRAME_TYPE_MESSAGE;
 90 |     }
 91 | 
 92 |     /**
 93 |      * Test if frame is HEARTBEAT
 94 |      * @param array $frame
 95 |      * @return bool
 96 |      */
 97 |     public static function frameIsHeartbeat(array $frame)
 98 |     {
 99 |         return self::frameIsResponse($frame, self::HEARTBEAT);
100 |     }
101 | 
102 |     /**
103 |      * Test if frame is OK
104 |      * @param array $frame
105 |      * @return bool
106 |      */
107 |     public static function frameIsOK(array $frame)
108 |     {
109 |         return self::frameIsResponse($frame, self::OK);
110 |     }
111 | 
112 |     /**
113 |      * Test if frame is CLOSE_WAIT
114 |      * @param array $frame
115 |      * @return bool
116 |      */
117 |     public static function frameIsCloseWait(array $frame)
118 |     {
119 |         return self::frameIsResponse($frame, self::CLOSE_WAIT);
120 |     }
121 | 
122 |     /**
123 |      * Test if frame is ERROR
124 |      * @param array $frame
125 |      * @return bool
126 |      */
127 |     public static function frameIsError(array $frame)
128 |     {
129 |         return isset($frame['type']) && $frame['type'] === self::FRAME_TYPE_ERROR && isset($frame['error']);
130 |     }
131 | 
132 |     /**
133 |      * Test if frame is BROKEN
134 |      * @param array $frame
135 |      * @return bool
136 |      */
137 |     public static function frameIsBroken(array $frame)
138 |     {
139 |         return isset($frame['type']) && $frame['type'] === self::FRAME_TYPE_BROKEN;
140 |     }
141 | 
142 |     /**
143 |      * Test if frame is a response frame (optionally with content $response)
144 |      * @param array $frame
145 |      * @param string
146 |      * @return bool
147 |      */
148 |     private static function frameIsResponse(array $frame, $response = null)
149 |     {
150 |         return
151 |             isset($frame['type'], $frame['response'])
152 |             &&
153 |             $frame['type'] === self::FRAME_TYPE_RESPONSE
154 |             &&
155 |             ($response === null || $frame['response'] === $response);
156 |     }
157 | }
158 | 


--------------------------------------------------------------------------------
/src/Queue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Queue API
 4 |  * User: moyo
 5 |  * Date: 31/03/2017
 6 |  * Time: 3:59 PM
 7 |  */
 8 | 
 9 | namespace NSQClient;
10 | 
11 | use NSQClient\Access\Endpoint;
12 | use NSQClient\Connection\Lookupd;
13 | use NSQClient\Connection\Nsqd;
14 | use NSQClient\Connection\Pool;
15 | use NSQClient\Logger\Logger;
16 | 
17 | class Queue
18 | {
19 |     /**
20 |      * @param Endpoint $endpoint
21 |      * @param $topic
22 |      * @param $message
23 |      * @return bool
24 |      */
25 |     public static function publish(Endpoint $endpoint, $topic, $message)
26 |     {
27 |         $routes = Lookupd::getNodes($endpoint, $topic);
28 | 
29 |         $route = $routes[rand(0, count($routes) - 1)];
30 | 
31 |         $keys = [$route['host'], $route['ports']['tcp']];
32 | 
33 |         return
34 |         Pool::register($keys, function () use ($endpoint, $route) {
35 |             Logger::ins()->info('Creating new nsqd for producer', [
36 |                 'lookupd' => $endpoint->getLookupd(),
37 |                 'route' => $route
38 |             ]);
39 |             return (new Nsqd($endpoint))
40 |                 ->setRoute($route)
41 |                 ->setLifecycle(SDK::$pubRecyclingSec)
42 |                 ->setProducer();
43 |         })
44 |             ->setTopic($topic)
45 |             ->publish($message)
46 |         ;
47 |     }
48 | 
49 |     /**
50 |      * @param Endpoint $endpoint
51 |      * @param string $topic
52 |      * @param string $channel
53 |      * @param callable $processor
54 |      * @param int $lifecycle
55 |      */
56 |     public static function subscribe(Endpoint $endpoint, $topic, $channel, callable $processor, $lifecycle = 0)
57 |     {
58 |         $routes = Lookupd::getNodes($endpoint, $topic);
59 | 
60 |         foreach ($routes as $route) {
61 |             $keys = [$route['topic'], $route['host'], $route['ports']['tcp']];
62 | 
63 |             Pool::register($keys, function () use ($endpoint, $route, $topic, $processor, $lifecycle) {
64 | 
65 |                 Logger::ins()->info('Creating new nsqd for consumer', [
66 |                     'lookupd' => $endpoint->getLookupd(),
67 |                     'route' => $route,
68 |                     'topic' => $topic,
69 |                     'lifecycle' => $lifecycle
70 |                 ]);
71 |                 return (new Nsqd($endpoint))
72 |                     ->setRoute($route)
73 |                     ->setTopic($topic)
74 |                     ->setLifecycle($lifecycle)
75 |                     ->setConsumer($processor);
76 |             })
77 |                 ->subscribe($channel)
78 |             ;
79 |         }
80 | 
81 |         Pool::getEvLoop()->run();
82 |     }
83 | }
84 | 


--------------------------------------------------------------------------------
/src/SDK.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * SDK meta info
 4 |  * User: moyo
 5 |  * Date: 01/04/2017
 6 |  * Time: 3:21 PM
 7 |  */
 8 | 
 9 | namespace NSQClient;
10 | 
11 | use Psr\Log\LoggerInterface;
12 | 
13 | class SDK
14 | {
15 |     /**
16 |      * sdk version
17 |      */
18 |     const VERSION = '1.0';
19 | 
20 |     /**
21 |      * amazing name
22 |      */
23 |     const NAME = 'nsqclient';
24 | 
25 |     /**
26 |      * @var int
27 |      */
28 |     public static $pubRecyclingSec = 45;
29 | 
30 |     /**
31 |      * @var LoggerInterface
32 |      */
33 |     public static $presentLogger = null;
34 | 
35 |     /**
36 |      * @var bool
37 |      */
38 |     public static $enabledStringPack = true;
39 | 
40 |     /**
41 |      * @param LoggerInterface $logger
42 |      */
43 |     public static function setLogger(LoggerInterface $logger)
44 |     {
45 |         self::$presentLogger = $logger;
46 |     }
47 | 
48 |     /**
49 |      * @param $enable
50 |      */
51 |     public static function setStringPack($enable)
52 |     {
53 |         self::$enabledStringPack = $enable;
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Utils/GracefulShutdown.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Graceful shutdown tools
 4 |  * User: moyo
 5 |  * Date: 06/05/2017
 6 |  * Time: 11:44 PM
 7 |  */
 8 | 
 9 | namespace NSQClient\Utils;
10 | 
11 | use NSQClient\Connection\Pool;
12 | use NSQClient\Logger\Logger;
13 | use React\EventLoop\LoopInterface;
14 | 
15 | class GracefulShutdown
16 | {
17 |     /**
18 |      * 500 ms
19 |      * @var float
20 |      */
21 |     private static $signalDispatchInv = 0.5;
22 | 
23 |     /**
24 |      * @var array
25 |      */
26 |     private static $acceptSignals = [
27 |         SIGHUP => 'SIGHUP',
28 |         SIGINT => 'SIGINT',
29 |         SIGTERM => 'SIGTERM'
30 |     ];
31 | 
32 |     /**
33 |      * @param LoopInterface $evLoop
34 |      */
35 |     public static function init(LoopInterface $evLoop)
36 |     {
37 |         if (extension_loaded('pcntl')) {
38 |             foreach (self::$acceptSignals as $signal => $name) {
39 |                 pcntl_signal($signal, [__CLASS__, 'signalHandler']);
40 |             }
41 | 
42 |             $evLoop->addPeriodicTimer(self::$signalDispatchInv, function () {
43 |                 pcntl_signal_dispatch();
44 |             });
45 |         }
46 |     }
47 | 
48 |     /**
49 |      * @param $signal
50 |      */
51 |     public static function signalHandler($signal)
52 |     {
53 |         Logger::ins()->info('Signal ['.self::$acceptSignals[$signal].'] received .. prepare shutdown');
54 | 
55 |         $instances = Pool::instances();
56 |         foreach ($instances as $nsqdIns) {
57 |             $nsqdIns->isConsumer() && $nsqdIns->closing();
58 |         }
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------