]> git.mxchange.org Git - quix0rs-gnu-social.git/blob - extlib/Stomp.php
Notice getRendered() can now be called on uninserted notices
[quix0rs-gnu-social.git] / extlib / Stomp.php
1 <?php
2 /**
3  *
4  * Copyright 2005-2006 The Apache Software Foundation
5  *
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18
19 /* vim: set expandtab tabstop=3 shiftwidth=3: */
20
21 require_once 'Stomp/Frame.php';
22
23 /**
24  * A Stomp Connection
25  *
26  *
27  * @package Stomp
28  * @author Hiram Chirino <hiram@hiramchirino.com>
29  * @author Dejan Bosanac <dejan@nighttale.net> 
30  * @author Michael Caplan <mcaplan@labnet.net>
31  * @version $Revision: 43 $
32  */
33 class Stomp
34 {
35     /**
36      * Perform request synchronously
37      *
38      * @var boolean
39      */
40     public $sync = false;
41
42     /**
43      * Default prefetch size
44      *
45      * @var int
46      */
47         public $prefetchSize = 1;
48     
49         /**
50      * Client id used for durable subscriptions
51      *
52      * @var string
53      */
54         public $clientId = null;
55     
56     protected $_brokerUri = null;
57     protected $_socket = null;
58     protected $_hosts = array();
59     protected $_params = array();
60     protected $_subscriptions = array();
61     protected $_defaultPort = 61613;
62     protected $_currentHost = - 1;
63     protected $_attempts = 10;
64     protected $_username = '';
65     protected $_password = '';
66     protected $_sessionId;
67     protected $_read_timeout_seconds = 60;
68     protected $_read_timeout_milliseconds = 0;
69     protected $_connect_timeout_seconds = 60;
70     
71     /**
72      * Constructor
73      *
74      * @param string $brokerUri Broker URL
75      * @throws StompException
76      */
77     public function __construct ($brokerUri)
78     {
79         $this->_brokerUri = $brokerUri;
80         $this->_init();
81     }
82     /**
83      * Initialize connection
84      *
85      * @throws StompException
86      */
87     protected function _init ()
88     {
89         $pattern = "|^(([a-zA-Z]+)://)+\(*([a-zA-Z0-9\.:/i,-]+)\)*\??([a-zA-Z0-9=]*)$|i";
90         if (preg_match($pattern, $this->_brokerUri, $regs)) {
91             $scheme = $regs[2];
92             $hosts = $regs[3];
93             $params = $regs[4];
94             if ($scheme != "failover") {
95                 $this->_processUrl($this->_brokerUri);
96             } else {
97                 $urls = explode(",", $hosts);
98                 foreach ($urls as $url) {
99                     $this->_processUrl($url);
100                 }
101             }
102             if ($params != null) {
103                 parse_str($params, $this->_params);
104             }
105         } else {
106             require_once 'Stomp/Exception.php';
107             throw new StompException("Bad Broker URL {$this->_brokerUri}");
108         }
109     }
110     /**
111      * Process broker URL
112      *
113      * @param string $url Broker URL
114      * @throws StompException
115      * @return boolean
116      */
117     protected function _processUrl ($url)
118     {
119         $parsed = parse_url($url);
120         if ($parsed) {
121             array_push($this->_hosts, array($parsed['host'] , $parsed['port'] , $parsed['scheme']));
122         } else {
123             require_once 'Stomp/Exception.php';
124             throw new StompException("Bad Broker URL $url");
125         }
126     }
127     /**
128      * Make socket connection to the server
129      *
130      * @throws StompException
131      */
132     protected function _makeConnection ()
133     {
134         if (count($this->_hosts) == 0) {
135             require_once 'Stomp/Exception.php';
136             throw new StompException("No broker defined");
137         }
138         
139         // force disconnect, if previous established connection exists
140         $this->disconnect();
141         
142         $i = $this->_currentHost;
143         $att = 0;
144         $connected = false;
145         $connect_errno = null;
146         $connect_errstr = null;
147         
148         while (! $connected && $att ++ < $this->_attempts) {
149             if (isset($this->_params['randomize']) && $this->_params['randomize'] == 'true') {
150                 $i = rand(0, count($this->_hosts) - 1);
151             } else {
152                 $i = ($i + 1) % count($this->_hosts);
153             }
154             $broker = $this->_hosts[$i];
155             $host = $broker[0];
156             $port = $broker[1];
157             $scheme = $broker[2];
158             if ($port == null) {
159                 $port = $this->_defaultPort;
160             }
161             if ($this->_socket != null) {
162                 fclose($this->_socket);
163                 $this->_socket = null;
164             }
165             $this->_socket = @fsockopen($scheme . '://' . $host, $port, $connect_errno, $connect_errstr, $this->_connect_timeout_seconds);
166             if (!is_resource($this->_socket) && $att >= $this->_attempts && !array_key_exists($i + 1, $this->_hosts)) {
167                 require_once 'Stomp/Exception.php';
168                 throw new StompException("Could not connect to $host:$port ($att/{$this->_attempts})");
169             } else if (is_resource($this->_socket)) {
170                 $connected = true;
171                 $this->_currentHost = $i;
172                 break;
173             }
174         }
175         if (! $connected) {
176             require_once 'Stomp/Exception.php';
177             throw new StompException("Could not connect to a broker");
178         }
179     }
180     /**
181      * Connect to server
182      *
183      * @param string $username
184      * @param string $password
185      * @return boolean
186      * @throws StompException
187      */
188     public function connect ($username = '', $password = '')
189     {
190         $this->_makeConnection();
191         if ($username != '') {
192             $this->_username = $username;
193         }
194         if ($password != '') {
195             $this->_password = $password;
196         }
197                 $headers = array('login' => $this->_username , 'passcode' => $this->_password);
198                 if ($this->clientId != null) {
199                         $headers["client-id"] = $this->clientId;
200                 }
201                 $frame = new StompFrame("CONNECT", $headers);
202         $this->_writeFrame($frame);
203         $frame = $this->readFrame();
204         if ($frame instanceof StompFrame && $frame->command == 'CONNECTED') {
205             $this->_sessionId = $frame->headers["session"];
206             return true;
207         } else {
208             require_once 'Stomp/Exception.php';
209             if ($frame instanceof StompFrame) {
210                 throw new StompException("Unexpected command: {$frame->command}", 0, $frame->body);
211             } else {
212                 throw new StompException("Connection not acknowledged");
213             }
214         }
215     }
216     
217     /**
218      * Check if client session has ben established
219      *
220      * @return boolean
221      */
222     public function isConnected ()
223     {
224         return !empty($this->_sessionId) && is_resource($this->_socket);
225     }
226     /**
227      * Current stomp session ID
228      *
229      * @return string
230      */
231     public function getSessionId()
232     {
233         return $this->_sessionId;
234     }
235     /**
236      * Send a message to a destination in the messaging system 
237      *
238      * @param string $destination Destination queue
239      * @param string|StompFrame $msg Message
240      * @param array $properties
241      * @param boolean $sync Perform request synchronously
242      * @return boolean
243      */
244     public function send ($destination, $msg, $properties = array(), $sync = null)
245     {
246         if ($msg instanceof StompFrame) {
247             $msg->headers['destination'] = $destination;
248             if (is_array($properties)) $msg->headers = array_merge($msg->headers, $properties);
249             $frame = $msg;
250         } else {
251             $headers = $properties;
252             $headers['destination'] = $destination;
253             $frame = new StompFrame('SEND', $headers, $msg);
254         }
255         $this->_prepareReceipt($frame, $sync);
256         $this->_writeFrame($frame);
257         return $this->_waitForReceipt($frame, $sync);
258     }
259     /**
260      * Prepair frame receipt
261      *
262      * @param StompFrame $frame
263      * @param boolean $sync
264      */
265     protected function _prepareReceipt (StompFrame $frame, $sync)
266     {
267         $receive = $this->sync;
268         if ($sync !== null) {
269             $receive = $sync;
270         }
271         if ($receive == true) {
272             $frame->headers['receipt'] = md5(microtime());
273         }
274     }
275     /**
276      * Wait for receipt
277      *
278      * @param StompFrame $frame
279      * @param boolean $sync
280      * @return boolean
281      * @throws StompException
282      */
283     protected function _waitForReceipt (StompFrame $frame, $sync)
284     {
285
286         $receive = $this->sync;
287         if ($sync !== null) {
288             $receive = $sync;
289         }
290         if ($receive == true) {
291             $id = (isset($frame->headers['receipt'])) ? $frame->headers['receipt'] : null;
292             if ($id == null) {
293                 return true;
294             }
295             $frame = $this->readFrame();
296             if ($frame instanceof StompFrame && $frame->command == 'RECEIPT') {
297                 if ($frame->headers['receipt-id'] == $id) {
298                     return true;
299                 } else {
300                     require_once 'Stomp/Exception.php';
301                     throw new StompException("Unexpected receipt id {$frame->headers['receipt-id']}", 0, $frame->body);
302                 }
303             } else {
304                 require_once 'Stomp/Exception.php';
305                 if ($frame instanceof StompFrame) {
306                     throw new StompException("Unexpected command {$frame->command}", 0, $frame->body);
307                 } else {
308                     throw new StompException("Receipt not received");
309                 }
310             }
311         }
312         return true;
313     }
314     /**
315      * Register to listen to a given destination
316      *
317      * @param string $destination Destination queue
318      * @param array $properties
319      * @param boolean $sync Perform request synchronously
320      * @return boolean
321      * @throws StompException
322      */
323     public function subscribe ($destination, $properties = null, $sync = null)
324     {
325         $headers = array('ack' => 'client');
326                 $headers['activemq.prefetchSize'] = $this->prefetchSize;
327                 if ($this->clientId != null) {
328                         $headers["activemq.subcriptionName"] = $this->clientId;
329                 }
330         if (isset($properties)) {
331             foreach ($properties as $name => $value) {
332                 $headers[$name] = $value;
333             }
334         }
335         $headers['destination'] = $destination;
336         $frame = new StompFrame('SUBSCRIBE', $headers);
337         $this->_prepareReceipt($frame, $sync);
338         $this->_writeFrame($frame);
339         if ($this->_waitForReceipt($frame, $sync) == true) {
340             $this->_subscriptions[$destination] = $properties;
341             return true;
342         } else {
343             return false;
344         }
345     }
346     /**
347      * Remove an existing subscription
348      *
349      * @param string $destination
350      * @param array $properties
351      * @param boolean $sync Perform request synchronously
352      * @return boolean
353      * @throws StompException
354      */
355     public function unsubscribe ($destination, $properties = null, $sync = null)
356     {
357         $headers = array();
358         if (isset($properties)) {
359             foreach ($properties as $name => $value) {
360                 $headers[$name] = $value;
361             }
362         }
363         $headers['destination'] = $destination;
364         $frame = new StompFrame('UNSUBSCRIBE', $headers);
365         $this->_prepareReceipt($frame, $sync);
366         $this->_writeFrame($frame);
367         if ($this->_waitForReceipt($frame, $sync) == true) {
368             unset($this->_subscriptions[$destination]);
369             return true;
370         } else {
371             return false;
372         }
373     }
374     /**
375      * Start a transaction
376      *
377      * @param string $transactionId
378      * @param boolean $sync Perform request synchronously
379      * @return boolean
380      * @throws StompException
381      */
382     public function begin ($transactionId = null, $sync = null)
383     {
384         $headers = array();
385         if (isset($transactionId)) {
386             $headers['transaction'] = $transactionId;
387         }
388         $frame = new StompFrame('BEGIN', $headers);
389         $this->_prepareReceipt($frame, $sync);
390         $this->_writeFrame($frame);
391         return $this->_waitForReceipt($frame, $sync);
392     }
393     /**
394      * Commit a transaction in progress
395      *
396      * @param string $transactionId
397      * @param boolean $sync Perform request synchronously
398      * @return boolean
399      * @throws StompException
400      */
401     public function commit ($transactionId = null, $sync = null)
402     {
403         $headers = array();
404         if (isset($transactionId)) {
405             $headers['transaction'] = $transactionId;
406         }
407         $frame = new StompFrame('COMMIT', $headers);
408         $this->_prepareReceipt($frame, $sync);
409         $this->_writeFrame($frame);
410         return $this->_waitForReceipt($frame, $sync);
411     }
412     /**
413      * Roll back a transaction in progress
414      *
415      * @param string $transactionId
416      * @param boolean $sync Perform request synchronously
417      */
418     public function abort ($transactionId = null, $sync = null)
419     {
420         $headers = array();
421         if (isset($transactionId)) {
422             $headers['transaction'] = $transactionId;
423         }
424         $frame = new StompFrame('ABORT', $headers);
425         $this->_prepareReceipt($frame, $sync);
426         $this->_writeFrame($frame);
427         return $this->_waitForReceipt($frame, $sync);
428     }
429     /**
430      * Acknowledge consumption of a message from a subscription
431          * Note: This operation is always asynchronous
432      *
433      * @param string|StompFrame $messageMessage ID
434      * @param string $transactionId
435      * @return boolean
436      * @throws StompException
437      */
438     public function ack ($message, $transactionId = null)
439     {
440         if ($message instanceof StompFrame) {
441             $headers = $message->headers;
442             if (isset($transactionId)) {
443                 $headers['transaction'] = $transactionId;
444             }                   
445             $frame = new StompFrame('ACK', $headers);
446             $this->_writeFrame($frame);
447             return true;
448         } else {
449             $headers = array();
450             if (isset($transactionId)) {
451                 $headers['transaction'] = $transactionId;
452             }
453             $headers['message-id'] = $message;
454             $frame = new StompFrame('ACK', $headers);
455             $this->_writeFrame($frame);
456             return true;
457         }
458     }
459     /**
460      * Graceful disconnect from the server
461      *
462      */
463     public function disconnect ()
464     {
465                 $headers = array();
466
467                 if ($this->clientId != null) {
468                         $headers["client-id"] = $this->clientId;
469                 }
470
471         if (is_resource($this->_socket)) {
472             $this->_writeFrame(new StompFrame('DISCONNECT', $headers));
473             fclose($this->_socket);
474         }
475         $this->_socket = null;
476         $this->_sessionId = null;
477         $this->_currentHost = -1;
478         $this->_subscriptions = array();
479         $this->_username = '';
480         $this->_password = '';
481     }
482     /**
483      * Write frame to server
484      *
485      * @param StompFrame $stompFrame
486      */
487     protected function _writeFrame (StompFrame $stompFrame)
488     {
489         if (!is_resource($this->_socket)) {
490             require_once 'Stomp/Exception.php';
491             throw new StompException('Socket connection hasn\'t been established');
492         }
493
494         $data = $stompFrame->__toString();
495         $r = fwrite($this->_socket, $data, strlen($data));
496         if ($r === false || $r == 0) {
497             $this->_reconnect();
498             $this->_writeFrame($stompFrame);
499         }
500     }
501     
502     /**
503      * Set timeout to wait for content to read
504      *
505      * @param int $seconds_to_wait  Seconds to wait for a frame
506      * @param int $milliseconds Milliseconds to wait for a frame
507      */
508     public function setReadTimeout($seconds, $milliseconds = 0) 
509     {
510         $this->_read_timeout_seconds = $seconds;
511         $this->_read_timeout_milliseconds = $milliseconds;
512     }
513     
514     /**
515      * Read response frame from server
516      *
517      * @return StompFrame False when no frame to read
518      */
519     public function readFrame ()
520     {
521         if (!$this->hasFrameToRead()) {
522             return false;
523         }
524         
525         $rb = 1024;
526         $data = '';
527         $end = false;
528         
529         do {
530             $read = fread($this->_socket, $rb);
531             if ($read === false) {
532                 $this->_reconnect();
533                 return $this->readFrame();
534             }
535             $data .= $read;
536             if (strpos($data, "\x00") !== false) {
537                 $end = true;
538                 $data = rtrim($data, "\n");
539             }
540             $len = strlen($data);
541         } while ($len < 2 || $end == false);
542         
543         list ($header, $body) = explode("\n\n", $data, 2);
544         $header = explode("\n", $header);
545         $headers = array();
546         $command = null;
547         foreach ($header as $v) {
548             if (isset($command)) {
549                 list ($name, $value) = explode(':', $v, 2);
550                 $headers[$name] = $value;
551             } else {
552                 $command = $v;
553             }
554         }
555         $frame = new StompFrame($command, $headers, trim($body));
556         if (isset($frame->headers['transformation']) && $frame->headers['transformation'] == 'jms-map-json') {
557             require_once 'Stomp/Message/Map.php';
558             return new StompMessageMap($frame);
559         } else {
560             return $frame;
561         }
562         return $frame;
563     }
564     
565     /**
566      * Check if there is a frame to read
567      *
568      * @return boolean
569      */
570     public function hasFrameToRead()
571     {
572         $read = array($this->_socket);
573         $write = null;
574         $except = null;
575         
576         $has_frame_to_read = @stream_select($read, $write, $except, $this->_read_timeout_seconds, $this->_read_timeout_milliseconds);
577         
578         if ($has_frame_to_read !== false)
579             $has_frame_to_read = count($read);
580
581
582         if ($has_frame_to_read === false) {
583             throw new StompException('Check failed to determine if the socket is readable');
584         } else if ($has_frame_to_read > 0) {
585             return true;
586         } else {
587             return false; 
588         }
589     }
590     
591     /**
592      * Reconnects and renews subscriptions (if there were any)
593      * Call this method when you detect connection problems     
594      */
595     protected function _reconnect ()
596     {
597         $subscriptions = $this->_subscriptions;
598         
599         $this->connect($this->_username, $this->_password);
600         foreach ($subscriptions as $dest => $properties) {
601             $this->subscribe($dest, $properties);
602         }
603     }
604     /**
605      * Graceful object desruction
606      *
607      */
608     public function __destruct()
609     {
610         $this->disconnect();
611     }
612 }
613 ?>