├── .gitignore
├── ActiveMq
    ├── Base.php
    ├── Connection.php
    ├── Consumer.php
    ├── ConsumerInterface.php
    ├── Message.php
    └── Publisher.php
├── Command
    ├── ConsumerCommand.php
    └── ProducerCommand.php
├── DependencyInjection
    ├── Configuration.php
    └── OverblogActiveMqExtension.php
├── Exception
    └── ActiveMqException.php
├── LICENSE
├── OverblogActiveMqBundle.php
├── README.md
├── Resources
    └── config
    │   └── services.yml
└── composer.json


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Bootstrap
 2 | app/bootstrap*
 3 | 
 4 | # Symfony directories
 5 | vendor/*
 6 | */logs/*
 7 | */cache/*
 8 | web/uploads/*
 9 | web/bundles/*
10 | 
11 | # Configuration files
12 | app/config/parameters.ini
13 | 
14 | # composer
15 | composer.lock
16 | 


--------------------------------------------------------------------------------
/ActiveMq/Base.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Overblog\ActiveMqBundle\ActiveMq;
 3 | 
 4 | use Overblog\ActiveMqBundle\Exception\ActiveMqException;
 5 | use Symfony\Component\HttpFoundation\ParameterBag;
 6 | 
 7 | /**
 8 |  * Description of Base
 9 |  *
10 |  * @author Xavier HAUSHERR
11 |  */
12 | abstract class Base
13 | {
14 |     /**
15 |      * Options
16 |      * @var array $options
17 |      */
18 |     protected $options;
19 | 
20 |     /**
21 |      * Connection handler
22 |      * @var Connection $connection
23 |      */
24 |     protected $connection;
25 | 
26 |     /**
27 |      * Instanciate
28 |      * @param Connection $connection
29 |      * @param array $options
30 |      */
31 |     public function __construct(Connection $connection, array $options)
32 |     {
33 |         $this->connection = $connection;
34 |         $this->options = new ParameterBag($options);
35 |     }
36 | 
37 |     /**
38 |      * Return destination string
39 |      * @param string $routing_key
40 |      * @param boolean $concat_key
41 |      * @return string
42 |      * @throws ActiveMqException
43 |      */
44 |     public function getDestination($routing_key = null, $concat_key = false)
45 |     {
46 |         if(in_array($this->options->get('type'), array('queue', 'topic')))
47 |         {
48 |             $destination = sprintf('/%s/%s',
49 |                     $this->options->get('type'),
50 |                     $this->options->get('name')
51 |                 );
52 | 
53 |             if(true === $concat_key && !empty($routing_key))
54 |             {
55 |                 $destination = preg_replace('#\\' . $this->options->get('separator') . '>|\*$#', '', $destination);
56 | 
57 |                 $destination .= $this->options->get('separator') . $routing_key;
58 |             }
59 | 
60 |             return $destination;
61 |         }
62 |         else
63 |         {
64 |             throw new ActiveMqException('Wrong destination type');
65 |         }
66 |     }
67 | 
68 |     /**
69 |      * Purge given destination
70 |      * @param string $routing_key
71 |      * @param boolean $concat_key
72 |      */
73 |     public function purge($routing_key = null, $concat_key = false)
74 |     {
75 |         $this->connection->purge($this->getDestination($routing_key, $concat_key));
76 |     }
77 | }


--------------------------------------------------------------------------------
/ActiveMq/Connection.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Overblog\ActiveMqBundle\ActiveMq;
  3 | 
  4 | use CentralDesktop\Stomp\Connection as StompConnection;
  5 | use CentralDesktop\Stomp\ConnectionFactory\Simple;
  6 | use CentralDesktop\Stomp\ConnectionFactory\Failover;
  7 | 
  8 | /**
  9 |  * Handler for Stomp connections
 10 |  *
 11 |  * @author Xavier HAUSHERR
 12 |  */
 13 | class Connection
 14 | {
 15 |     /**
 16 |      * Stomp connection handler
 17 |      * @var StompConnection
 18 |      */
 19 |     protected $connection;
 20 | 
 21 |     /**
 22 |      * Options container
 23 |      * @var array
 24 |      */
 25 |     protected $options = array();
 26 | 
 27 |     /**
 28 |      * Instanciate connection service
 29 |      * @param array $options
 30 |      */
 31 |     public function __construct(array $options)
 32 |     {
 33 |         $this->options = $options;
 34 |     }
 35 | 
 36 |     /**
 37 |      * Return and instanciate connection if needed
 38 |      * @return StompConnection
 39 |      */
 40 |     public function getConnection()
 41 |     {
 42 |         if(is_null($this->connection))
 43 |         {
 44 |             $this->connection = new StompConnection(
 45 |                     $this->getConnectionFactory()
 46 |                 );
 47 | 
 48 |             $this->connection->connect(
 49 |                     $this->options['user'],
 50 |                     $this->options['password'],
 51 |                     $this->options['version']
 52 |                 );
 53 |         }
 54 | 
 55 |         return $this->connection;
 56 |     }
 57 | 
 58 |     protected function getConnectionFactory()
 59 |     {
 60 |         if(count($this->options['servers']) == 1)
 61 |         {
 62 |             // Single connection
 63 |             return new Simple($this->getBrokerUri(
 64 |                     current($this->options['servers'])
 65 |                 ));
 66 |         }
 67 |         else
 68 |         {
 69 |             // Failover connection
 70 |             $servers = array();
 71 | 
 72 |             foreach($this->options['servers'] as $server)
 73 |             {
 74 |                 $servers[] = $this->getBrokerUri($server);
 75 |             }
 76 | 
 77 |             return new Failover($servers, $this->options['randomize_failover']);
 78 |         }
 79 |     }
 80 | 
 81 |     /**
 82 |      * Create broker URI
 83 |      * http://activemq.apache.org/failover-transport-reference.html
 84 |      *
 85 |      * @param array $params
 86 |      * @return string
 87 |      */
 88 |     protected function getBrokerUri(array $params)
 89 |     {
 90 |         $options = array();
 91 | 
 92 |         // Base URI
 93 |         $uri = 'tcp://' . $params['uri'];
 94 | 
 95 |         if(true === $params['useAsyncSend'])
 96 |         {
 97 |             $options['useAsyncSend'] = 'true';
 98 |         }
 99 | 
100 |         if(!is_null($params['startupMaxReconnectAttempts']))
101 |         {
102 |             $options['startupMaxReconnectAttempts'] =
103 |                     $params['startupMaxReconnectAttempts'];
104 |         }
105 | 
106 |         if(!is_null($params['maxReconnectAttempts']))
107 |         {
108 |             $options['maxReconnectAttempts'] =
109 |                     $params['maxReconnectAttempts'];
110 |         }
111 | 
112 |         if(count($options) > 0)
113 |         {
114 |             $uri.= '?' . http_build_query($options);
115 |         }
116 | 
117 |         return $uri;
118 |     }
119 | 
120 |     /**
121 |      * Purge queue or topic
122 |      * @param string $queue
123 |      */
124 |     public function purge($queue)
125 |     {
126 |         $stomp = $this->getConnection();
127 |         $header = array('id' => sprintf('purge:%s', $queue));
128 | 
129 |         // No need to wait more than 1s if there is no messages in queue
130 |         $stomp->setReadTimeout(1, 0);
131 | 
132 |         $stomp->subscribe($queue, $header);
133 | 
134 |         while($stomp->hasFrameToRead())
135 |         {
136 |             $stomp->ack($stomp->readFrame());
137 |         }
138 | 
139 |         $stomp->unsubscribe($queue, $header);
140 | 
141 |         // Disconnect & delete connection
142 |         $this->close();
143 |     }
144 | 
145 |     /**
146 |      * Close the connection
147 |      */
148 |     public function close()
149 |     {
150 |         if(!is_null($this->connection))
151 |         {
152 |             $this->connection->disconnect();
153 |             $this->connection = null;
154 |         }
155 |     }
156 | 
157 |     public function __destruct()
158 |     {
159 |         $this->close();
160 |     }
161 | }
162 | 


--------------------------------------------------------------------------------
/ActiveMq/Consumer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Overblog\ActiveMqBundle\ActiveMq;
 3 | 
 4 | /**
 5 |  * Description of Consumer
 6 |  *
 7 |  * @author xavier
 8 |  */
 9 | class Consumer extends Base
10 | {
11 |     /**
12 |      * Handler who treat the message
13 |      * @var ConsumerInterface $handler
14 |      */
15 |     protected $handler;
16 | 
17 |     /**
18 |      * Routing key (concept from RabbitMQ)
19 |      * @var string
20 |      */
21 |     protected $routing_key;
22 | 
23 |     /**
24 |      * Init service
25 |      * @param Connection $connection
26 |      * @param ConsumerInterface $handler
27 |      * @param array $options
28 |      */
29 |     public function __construct(Connection $connection, ConsumerInterface $handler, array $options)
30 |     {
31 |         $this->handler = $handler;
32 | 
33 |         parent::__construct($connection, $options);
34 |     }
35 | 
36 |     /**
37 |      * Set routing key
38 |      * @param string $routing_key
39 |      */
40 |     public function setRoutingKey($routing_key)
41 |     {
42 |         $this->routing_key = $routing_key;
43 |     }
44 | 
45 |     /**
46 |      * Consume messages
47 |      * @param int $msgAmount
48 |      */
49 |     public function consume($msgAmount)
50 |     {
51 |         $stomp = $this->connection->getConnection();
52 |         $id = $this->getHeaders()['id'];
53 | 
54 |         $stomp->subscribe($this->getDestination($this->routing_key), $this->getHeaders());
55 | 
56 |         // Infinite loop
57 |         if($msgAmount <= 0) $msgAmount = -1;
58 | 
59 |         while($msgAmount != 0)
60 |         {
61 |             if($stomp->hasFrameToRead())
62 |             {
63 |                 // Inject frame into ActimeMQ message
64 |                 $frame = $stomp->readFrame();
65 |                 $msg = new Message($frame->body, $frame->headers);
66 | 
67 |                 if (false !== call_user_func(array($this->handler, 'execute'), $msg))
68 |                 {
69 |                     $stomp->ack($frame);
70 |                 }
71 | 
72 |                 $msgAmount --;
73 |             }
74 |         }
75 | 
76 |         $stomp->unsubscribe($this->getDestination(), array('id' => $id));
77 |     }
78 | 
79 |     /**
80 |      * Set headers
81 |      * @return array
82 |      */
83 |     protected function getHeaders()
84 |     {
85 |         $headers = array(
86 |             'id' => $this->getDestination($this->routing_key) . microtime(true)
87 |         );
88 | 
89 |         if($this->options->has('prefetchSize'))
90 |         {
91 |             $headers['activemq.prefetchSize'] = $this->options->get('prefetchSize');
92 |         }
93 | 
94 |         return $headers;
95 |     }
96 | }
97 | 
98 | 


--------------------------------------------------------------------------------
/ActiveMq/ConsumerInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Overblog\ActiveMqBundle\ActiveMq;
 3 | 
 4 | /**
 5 |  * Description of Consumer
 6 |  *
 7 |  * @author Xavier HAUSHERR
 8 |  */
 9 | interface ConsumerInterface
10 | {
11 |     /**
12 |      * Consume message
13 |      */
14 |     public function execute(Message $msg);
15 | }
16 | 
17 | 


--------------------------------------------------------------------------------
/ActiveMq/Message.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Overblog\ActiveMqBundle\ActiveMq;
  3 | 
  4 | use Symfony\Component\HttpFoundation\ParameterBag;
  5 | 
  6 | /**
  7 |  * Description of Active MQ Message
  8 |  *
  9 |  * @author Xavier HAUSHERR
 10 |  */
 11 | class Message
 12 | {
 13 |     /**
 14 |      * Message Type Text (default)
 15 |      */
 16 |     const TYPE_TEXT = 'text';
 17 | 
 18 |     /**
 19 |      * Message Type Bytes
 20 |      */
 21 |     const TYPE_BYTES = 'bytes';
 22 | 
 23 |     /**
 24 |      * Message body
 25 |      * @var string
 26 |      */
 27 |     public $body;
 28 | 
 29 |     /**
 30 |      * Expiration time of the message
 31 |      * time in milliseconds to expire the message - 0 means never expire
 32 |      * @var int
 33 |      */
 34 |     protected $expires = 0;
 35 | 
 36 |     /**
 37 |      * Whether or not the message is persistent
 38 |      * @var boolean
 39 |      */
 40 |     protected $persistent = true;
 41 | 
 42 |     /**
 43 |      * Priority on the message (0 < 9)
 44 |      * value from 0-9
 45 |      * @var int
 46 |      */
 47 |     protected $priority = 4;
 48 | 
 49 |     /**
 50 |      * Specifies the Message Groups
 51 |      * identity of the message group
 52 |      * @var string
 53 |      */
 54 |     protected $groupId;
 55 | 
 56 |     /**
 57 |      * Specifies the sequence number in the Message Groups
 58 |      * @var int
 59 |      */
 60 |     protected $groupSeq = 0;
 61 | 
 62 |     /**
 63 |      * The time in milliseconds that a message will wait
 64 |      * before being scheduled to be delivered by the broker
 65 |      * @var int
 66 |      */
 67 |     protected $scheduledDelay = 0;
 68 | 
 69 |     /**
 70 |      * The time in milliseconds to wait after the start time
 71 |      * to wait before scheduling the message again
 72 |      * @var int
 73 |      */
 74 |     protected $scheduledPeriod = 0;
 75 | 
 76 |     /**
 77 |      * The number of times to repeat scheduling a message for delivery
 78 |      * @var int
 79 |      */
 80 |     protected $scheduledRepeat = 0;
 81 | 
 82 |     /**
 83 |      * Use a Cron entry to set the schedule
 84 |      * @var string
 85 |      */
 86 |     protected $scheduledCron;
 87 | 
 88 |     /**
 89 |      * Additional headers
 90 |      * @var ParameterBag
 91 |      */
 92 |     public $headers;
 93 | 
 94 |     /**
 95 |      * Create a new message for sending to Active MQ
 96 |      * @param string $body
 97 |      * @param array $headers
 98 |      */
 99 |     public function __construct($body, $headers = array())
100 |     {
101 |         $this->body = $body;
102 |         $this->setHeaders($headers);
103 |     }
104 | 
105 |     /**
106 |      * Set object with correct headers
107 |      * @param array $headers
108 |      */
109 |     protected function setHeaders(array $headers)
110 |     {
111 |         foreach($headers as $key => $value)
112 |         {
113 |             if(isset($this->$key))
114 |             {
115 |                 $this->$key = $value;
116 |                 unset($headers[$key]);
117 |             }
118 | 
119 |             // Clés JMSX
120 |             elseif(isset($this->{'JMSX' . $key}))
121 |             {
122 |                 $this->{'JMSX' . $key} = $value;
123 |                 unset($headers[$key]);
124 |             }
125 |         }
126 | 
127 |         $this->headers = new ParameterBag($headers);
128 |     }
129 | 
130 |     /**
131 |      * Return header value
132 |      * @param string $key
133 |      * @return string
134 |      */
135 |     public function get($key)
136 |     {
137 |         return $this->headers->get($key);
138 |     }
139 | 
140 |     /**
141 |      * Return body
142 |      * @return string
143 |      */
144 |     public function getBody()
145 |     {
146 |         return (string)$this->body;
147 |     }
148 | 
149 |     /**
150 |      * Set body
151 |      * @param string $body
152 |      */
153 |     public function setBody($body)
154 |     {
155 |         $this->body = $body;
156 |     }
157 | 
158 |     /**
159 |      * Return expiration time
160 |      * @return int
161 |      */
162 |     public function getExpires()
163 |     {
164 |         return $this->expires;
165 |     }
166 | 
167 |     /**
168 |      * Set expiration time
169 |      * @param int $expires
170 |      */
171 |     public function setExpires($expires)
172 |     {
173 |         $this->expires = intval($expires);
174 |     }
175 | 
176 |     /**
177 |      * Return whether or not the message is persistent
178 |      * @return boolean
179 |      */
180 |     public function getPersistent()
181 |     {
182 |         return $this->persistent;
183 |     }
184 | 
185 |     /**
186 |      * Set whether or not the message is persistent
187 |      * @param boolean $persistent
188 |      */
189 |     public function setPersistent($persistent)
190 |     {
191 |         $this->persistent = (bool)$persistent;
192 |     }
193 | 
194 |     /**
195 |      * Return priority on the message
196 |      * @return int
197 |      */
198 |     public function getPriority()
199 |     {
200 |         return $this->priority;
201 |     }
202 | 
203 |     /**
204 |      * Set priority on the message
205 |      * @param int $priority
206 |      */
207 |     public function setPriority($priority)
208 |     {
209 |         $this->priority = intval($priority);
210 |     }
211 | 
212 |     /**
213 |      * Get the Message Groups
214 |      * @return string
215 |      */
216 |     public function getGroupId()
217 |     {
218 |         return $this->groupId;
219 |     }
220 | 
221 |     /**
222 |      * Specifies the Message Groups
223 |      * @param string $groupId
224 |      */
225 |     public function setGroupId($groupId)
226 |     {
227 |         $this->groupId = $groupId;
228 |     }
229 | 
230 |     /**
231 |      * Reset the group affectation by specify the sequence number to -1
232 |      * Next message will be reaffected
233 |      */
234 |     public function closeGroup()
235 |     {
236 |         $this->groupSeq = -1;
237 |     }
238 | 
239 |     /**
240 |      * Get the time in milliseconds that a message will wait
241 |      * before being scheduled to be delivered by the broker
242 |      * @return int
243 |      */
244 |     public function getScheduledDelay()
245 |     {
246 |         return $this->scheduledDelay;
247 |     }
248 | 
249 |     /**
250 |      * Set the time in milliseconds that a message will wait
251 |      * before being scheduled to be delivered by the broker
252 |      * @param int $scheduledDelay
253 |      */
254 |     public function setScheduledDelay($scheduledDelay)
255 |     {
256 |         $this->scheduledDelay = intval($scheduledDelay);
257 |     }
258 | 
259 |     /**
260 |      * Get the time in milliseconds to wait after the start time
261 |      * to wait before scheduling the message again
262 |      * @return int
263 |      */
264 |     public function getScheduledPeriod()
265 |     {
266 |         return $this->scheduledPeriod;
267 |     }
268 | 
269 |     /**
270 |      * Set the time in milliseconds to wait after the start time
271 |      * to wait before scheduling the message again
272 |      * @param int $scheduledPeriod
273 |      */
274 |     public function setScheduledPeriod($scheduledPeriod)
275 |     {
276 |         $this->scheduledPeriod = intval($scheduledPeriod);
277 |     }
278 | 
279 |     /**
280 |      * Get the number of times to repeat scheduling a message for delivery
281 |      * @return int
282 |      */
283 |     public function getScheduledRepeat()
284 |     {
285 |         return $this->scheduledRepeat;
286 |     }
287 | 
288 |     /**
289 |      * Set the number of times to repeat scheduling a message for delivery
290 |      * @param int $scheduledRepeat
291 |      */
292 |     public function setScheduledRepeat($scheduledRepeat)
293 |     {
294 |         $this->scheduledRepeat = intval($scheduledRepeat);
295 |     }
296 | 
297 |     /**
298 |      * Get Cron entry used to set the schedule
299 |      * @return string
300 |      */
301 |     public function getScheduledCron()
302 |     {
303 |         return $this->scheduledCron;
304 |     }
305 | 
306 |     /**
307 |      * Use a Cron entry to set the schedule
308 |      * @param string $scheduledCron
309 |      */
310 |     public function setScheduledCron($scheduledCron)
311 |     {
312 |         $this->scheduledCron = $scheduledCron;
313 |     }
314 | 
315 |     /**
316 |      * Return message Type
317 |      * @return string
318 |      */
319 |     public function getMessageType()
320 |     {
321 |         if($this->headers->has('amq-msg-type'))
322 |         {
323 |             return $this->headers->get('amq-msg-type');
324 |         }
325 |         else
326 |         {
327 |             return self::TYPE_TEXT;
328 |         }
329 |     }
330 | 
331 |     /**
332 |      * Set message type to text
333 |      */
334 |     public function setAsTextMessage()
335 |     {
336 |         $this->headers->set('amq-msg-type', self::TYPE_TEXT);
337 |     }
338 | 
339 |     /**
340 |      * Set message type to bytes
341 |      */
342 |     public function setAsBytesMessage()
343 |     {
344 |         $this->headers->set('amq-msg-type', self::TYPE_BYTES);
345 |     }
346 | 
347 |     /**
348 |      * Return message options in header format
349 |      * @return array
350 |      */
351 |     public function getMessageHeaders()
352 |     {
353 |         $header = array();
354 | 
355 |         // Send only header if default value is changed
356 |         if($this->expires != 0)
357 |         {
358 |             $header['expires'] =
359 |                 (double)round(microtime(true) * 1000) + $this->expires;
360 |         }
361 | 
362 |         // Stomp message is not persistent by default
363 |         if($this->persistent)
364 |         {
365 |             $header['persistent'] = 'true';
366 |         }
367 | 
368 |         if($this->priority != 4)
369 |         {
370 |             $header['priority'] = $this->priority;
371 |         }
372 | 
373 |         if(!is_null($this->groupId) && !empty($this->groupId))
374 |         {
375 |             $header['JMSXGroupID'] = $this->groupId;
376 |         }
377 | 
378 |         if($this->groupSeq != 0)
379 |         {
380 |             $header['JMSXGroupSeq'] = $this->groupSeq;
381 |         }
382 | 
383 |         if($this->scheduledDelay != 0)
384 |         {
385 |             $header['AMQ_SCHEDULED_DELAY'] = $this->scheduledDelay;
386 |         }
387 | 
388 |         if($this->scheduledPeriod != 0)
389 |         {
390 |             $header['AMQ_SCHEDULED_PERIOD'] = $this->scheduledPeriod;
391 |         }
392 | 
393 |         if($this->scheduledRepeat != 0)
394 |         {
395 |             $header['AMQ_SCHEDULED_REPEAT'] = $this->scheduledRepeat;
396 |         }
397 | 
398 |         if(!is_null($this->scheduledCron) && !empty($this->scheduledCron))
399 |         {
400 |             $header['AMQ_SCHEDULED_CRON'] = $this->scheduledCron;
401 |         }
402 | 
403 |         // Add additional headers
404 |         foreach($this->headers->all() as $key => $var)
405 |         {
406 |             if(!isset($this->$key))
407 |             {
408 |                 $header[$key] = $var;
409 |             }
410 |         }
411 | 
412 |         return $header;
413 |     }
414 | }
415 | 


--------------------------------------------------------------------------------
/ActiveMq/Publisher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Overblog\ActiveMqBundle\ActiveMq;
 3 | 
 4 | use Overblog\ActiveMqBundle\Exception\ActiveMqException;
 5 | 
 6 | /**
 7 |  * Description of Publisher
 8 |  *
 9 |  * @author Xavier HAUSHERR
10 |  */
11 | class Publisher extends Base
12 | {
13 |     /**
14 |      * Publish Message in ActiveMQ
15 |      * @param mixed $msg
16 |      * @param string $routing_key
17 |      * @param boolean $concat_key
18 |      * @return boolean
19 |      * @throws ActiveMqException
20 |      */
21 |     public function publish($msg, $routing_key = null, $concat_key = false)
22 |     {
23 |         // Create object if text is send
24 |         if(!is_object($msg))
25 |         {
26 |             $msg = new Message($msg);
27 |         }
28 | 
29 |         // Add routing key if needed
30 |         if(!empty($routing_key))
31 |         {
32 |             $msg->headers->set('routing_key', $routing_key);
33 |         }
34 | 
35 |         $stomp = $this->connection->getConnection();
36 | 
37 |         if(!$stomp->send($this->getDestination($routing_key, $concat_key),
38 |                 $msg->getBody(),
39 |                 $msg->getMessageHeaders()
40 |             ))
41 |         {
42 |             throw new ActiveMqException('Unable to send message');
43 |         }
44 | 
45 |         return true;
46 |     }
47 | }


--------------------------------------------------------------------------------
/Command/ConsumerCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Overblog\ActiveMqBundle\Command;
 3 | 
 4 | use Overblog\ActiveMqBundle\ActiveMq\Consumer;
 5 | use Symfony\Component\Console\Command\Command;
 6 | use Symfony\Component\Console\Input\InputInterface;
 7 | use Symfony\Component\Console\Input\InputArgument;
 8 | use Symfony\Component\Console\Input\InputOption;
 9 | use Symfony\Component\Console\Output\OutputInterface;
10 | 
11 | /**
12 |  * Description of ProducerCommand
13 |  *
14 |  * @author Xavier HAUSHERR
15 |  */
16 | class ConsumerCommand extends Command
17 | {
18 |     /**
19 |      * @var Consumer[]
20 |      */
21 |     private $consumers;
22 | 
23 |     public function addConsumer($name, Consumer $consumer)
24 |     {
25 |         $this->consumers[$name] = $consumer;
26 |     }
27 | 
28 |     protected function configure()
29 |     {
30 |         $this->setName('activemq:consumer')
31 |             ->setDescription('Consume a message from a given queue.');
32 | 
33 |         $this->addArgument('name', InputArgument::REQUIRED, 'Consumer name');
34 |         $this->addOption('messages', 'm', InputOption::VALUE_REQUIRED, 'Messages to consume', 0);
35 |         $this->addOption('route', 'r', InputOption::VALUE_OPTIONAL, 'Routing Key', '');
36 |     }
37 | 
38 |     protected function execute(InputInterface $input, OutputInterface $output)
39 |     {
40 |         $name = $input->getArgument('name');
41 |         if (!isset($this->consumers[$name])) {
42 |             throw new \InvalidArgumentException(sprintf('Consumer "%s" not found', $name));
43 |         }
44 |         $consumer = $this->consumers[$name];
45 | 
46 |         $consumer->setRoutingKey($input->getOption('route'));
47 |         $consumer->consume($input->getOption('messages'));
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/Command/ProducerCommand.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Overblog\ActiveMqBundle\Command;
  3 | 
  4 | use Overblog\ActiveMqBundle\ActiveMq\Message;
  5 | use Overblog\ActiveMqBundle\ActiveMq\Publisher;
  6 | use Symfony\Component\Console\Command\Command;
  7 | use Symfony\Component\Console\Helper\QuestionHelper;
  8 | use Symfony\Component\Console\Input\InputInterface;
  9 | use Symfony\Component\Console\Input\InputArgument;
 10 | use Symfony\Component\Console\Input\InputOption;
 11 | use Symfony\Component\Console\Output\OutputInterface;
 12 | use Symfony\Component\Console\Question\Question;
 13 | 
 14 | /**
 15 |  * Description of ProducerCommand
 16 |  *
 17 |  * @author Xavier HAUSHERR
 18 |  */
 19 | class ProducerCommand extends Command
 20 | {
 21 |     /**
 22 |      * @var Publisher[]
 23 |      */
 24 |     private $publishers;
 25 | 
 26 |     public function addPublisher($name, Publisher $consumer)
 27 |     {
 28 |         $this->publishers[$name] = $consumer;
 29 |     }
 30 | 
 31 | 
 32 |     protected function configure()
 33 |     {
 34 |         $this->setName('activemq:producer')
 35 |             ->setDescription('Send a message to a given queue.');
 36 | 
 37 |         $this->addArgument('name', InputArgument::REQUIRED, 'Producer name')
 38 |             ->addOption('message', 'm', InputOption::VALUE_REQUIRED, 'Message to send')
 39 |             ->addOption('serializer', 'z', InputOption::VALUE_REQUIRED, 'Serialize message (serialize, json)')
 40 |             ->addOption('route', 'r', InputOption::VALUE_OPTIONAL, 'Routing Key', '');
 41 |     }
 42 | 
 43 |     /**
 44 |      * Interaction with console
 45 |      * @param InputInterface $input
 46 |      * @param OutputInterface $output
 47 |      */
 48 |     protected function interact(InputInterface $input, OutputInterface $output)
 49 |     {
 50 |         $questionHelper = $this->getQuestionHelper();
 51 | 
 52 |         if(!$input->getOption('message'))
 53 |         {
 54 |             $input->setOption(
 55 |                 'message',
 56 |                 $questionHelper->ask(
 57 |                     $input,
 58 |                     $output,
 59 |                     new Question('<comment>Enter the message to send: </comment>')
 60 |                 ));
 61 |         }
 62 |     }
 63 | 
 64 |     /**
 65 |      * Send the message
 66 |      * @param InputInterface $input
 67 |      * @param OutputInterface $output
 68 |      * @return void
 69 |      */
 70 |     protected function execute(InputInterface $input, OutputInterface $output)
 71 |     {
 72 |         $time_start = microtime(true);
 73 | 
 74 |         $message = $input->getOption('message');
 75 | 
 76 |         if(empty($message))
 77 |         {
 78 |             $output->writeln('<error>Message cannot be empty</error>');
 79 |             return;
 80 |         }
 81 | 
 82 |         $name = $input->getArgument('name');
 83 |         if (!isset($this->publishers[$name])) {
 84 |             throw new \InvalidArgumentException(sprintf('Publisher "%s" not found', $name));
 85 |         }
 86 |         $publisher = $this->publishers[$name];
 87 | 
 88 |         // Serializer
 89 |         switch($input->getOption('serializer'))
 90 |         {
 91 |             case 'serialize':
 92 |                 $message = serialize($message);
 93 |                 break;
 94 | 
 95 |             case 'json':
 96 |                 $message = json_encode($message);
 97 |                 break;
 98 |         }
 99 | 
100 |         // Send message
101 |         try
102 |         {
103 |             $msg = new Message($message);
104 | 
105 |             $publisher->publish($msg, $input->getOption('route'));
106 |             $output->writeln(
107 |                 sprintf(
108 |                     '<info>Message has been sent in %s ms</info>',
109 |                     round(microtime(true) - $time_start, 3)
110 |                 )
111 |             );
112 |         }
113 |         catch(\Exception $e)
114 |         {
115 |             $output->writeln(
116 |                 sprintf(
117 |                     '<error>Error while sending message: %s</error>',
118 |                     $e->getMessage()
119 |                 )
120 |             );
121 |         }
122 |     }
123 | 
124 |     /**
125 |      * Replace standard question helper
126 |      * @return QuestionHelper
127 |      */
128 |     protected function getQuestionHelper()
129 |     {
130 |         $questionHelper = $this->getHelperSet()->get('question');
131 | 
132 |         //@todo Update the Deploy project wich have a strong dependance with this bundle
133 |         if (!$questionHelper /*|| get_class($questionHelper) !== 'Overblog\DeployBundle\Command\Helper\DialogHelper'*/) {
134 |             $this->getHelperSet()->set($questionHelper = new QuestionHelper());
135 |         }
136 | 
137 |         return $questionHelper;
138 |     }
139 | }
140 | 


--------------------------------------------------------------------------------
/DependencyInjection/Configuration.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Overblog\ActiveMqBundle\DependencyInjection;
  4 | 
  5 | use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
  6 | use Symfony\Component\Config\Definition\Builder\TreeBuilder;
  7 | use Symfony\Component\Config\Definition\ConfigurationInterface;
  8 | 
  9 | /**
 10 |  * This is the class that validates and merges configuration from your app/config files
 11 |  *
 12 |  * To learn more see {@link http://symfony.com/doc/current/cookbook/bundles/extension.html#cookbook-bundles-extension-config-class}
 13 |  */
 14 | class Configuration implements ConfigurationInterface
 15 | {
 16 |     const NAME = 'overblog_active_mq';
 17 | 
 18 |     /**
 19 |      * {@inheritDoc}
 20 |      */
 21 |     public function getConfigTreeBuilder()
 22 |     {
 23 |         $treeBuilder = new TreeBuilder(self::NAME);
 24 |         $rootNode = self::getRootNodeWithoutDeprecation($treeBuilder, self::NAME);
 25 | 
 26 |         $rootNode
 27 |             ->children()
 28 |                 ->arrayNode('connections')
 29 |                     ->useAttributeAsKey('key')
 30 |                     ->requiresAtLeastOneElement()
 31 |                     ->prototype('array')
 32 |                         ->children()
 33 |                             ->scalarNode('user')->defaultNull()->end()
 34 |                             ->scalarNode('password')->defaultNull()->end()
 35 |                             ->scalarNode('version')->defaultValue(1.1)->end()
 36 |                             ->scalarNode('randomize_failover')->defaultFalse()->end()
 37 |                             ->arrayNode('servers')
 38 |                                 ->requiresAtLeastOneElement()
 39 |                                 ->prototype('array')
 40 |                                     ->addDefaultsIfNotSet()
 41 |                                     ->children()
 42 |                                         ->scalarNode('uri')->defaultValue('localhost:61613')->end()
 43 |                                         ->scalarNode('useAsyncSend')->defaultTrue()->end()
 44 |                                         ->scalarNode('startupMaxReconnectAttempts')->defaultNull()->end()
 45 |                                         ->scalarNode('maxReconnectAttempts')->defaultNull()->end()
 46 |                                         ->scalarNode('separator')->defaultValue('.')->end()
 47 |                                     ->end()
 48 |                                 ->end()
 49 |                             ->end()
 50 |                         ->end()
 51 |                     ->end()
 52 |                 ->end()
 53 |                 ->arrayNode('publishers')
 54 |                     ->useAttributeAsKey('key')
 55 |                     ->prototype('array')
 56 |                         ->addDefaultsIfNotSet()
 57 |                         ->children()
 58 |                             ->scalarNode('connection')->defaultValue('default')->end()
 59 |                             ->arrayNode('options')
 60 |                                 ->children()
 61 |                                     ->scalarNode('type')->defaultValue('queue')->end()
 62 |                                     ->scalarNode('name')->isRequired()->end()
 63 |                                 ->end()
 64 |                             ->end()
 65 |                         ->end()
 66 |                     ->end()
 67 |                 ->end()
 68 |                 ->arrayNode('consumers')
 69 |                     ->useAttributeAsKey('key')
 70 |                     ->prototype('array')
 71 |                         ->addDefaultsIfNotSet()
 72 |                         ->children()
 73 |                             ->scalarNode('connection')->defaultValue('default')->end()
 74 |                             ->scalarNode('handler')->isRequired()->end()
 75 |                             ->arrayNode('options')
 76 |                                 ->children()
 77 |                                     ->scalarNode('type')->defaultValue('queue')->end()
 78 |                                     ->scalarNode('name')->isRequired()->end()
 79 |                                     ->scalarNode('prefetchSize')->defaultValue(1)->end()
 80 |                                 ->end()
 81 |                             ->end()
 82 |                         ->end()
 83 |                     ->end()
 84 |                 ->end()
 85 |             ->end()
 86 |             //Connection validation
 87 |             ->validate()
 88 |                 ->ifTrue( function($v) {
 89 |                     foreach($v['publishers'] as $key => $producer)
 90 |                     {
 91 |                         if(!isset($v['connections'][$producer['connection']])) return true;
 92 |                     }
 93 | 
 94 |                     return false;
 95 |                 })
 96 |                 ->thenInvalid('Unknown connection in publishers configuration.')
 97 |             ->end()
 98 |             //Connection validation
 99 |             ->validate()
100 |                 ->ifTrue( function($v) {
101 |                     foreach($v['consumers'] as $key => $producer)
102 |                     {
103 |                         if(!isset($v['connections'][$producer['connection']])) return true;
104 |                     }
105 | 
106 |                     return false;
107 |                 })
108 |                 ->thenInvalid('Unknown connection in consumers configuration.')
109 |             ->end()
110 |         ;
111 | 
112 |         return $treeBuilder;
113 |     }
114 | 
115 |     /**
116 |      * @param TreeBuilder $builder
117 |      * @param string|null $name
118 |      * @param string      $type
119 |      *
120 |      * @return ArrayNodeDefinition|\Symfony\Component\Config\Definition\Builder\NodeDefinition
121 |      */
122 |     private static function getRootNodeWithoutDeprecation(TreeBuilder $builder, $name, $type = 'array')
123 |     {
124 |         // BC layer for symfony/config 4.1 and older
125 |         return \method_exists($builder, 'getRootNode') ? $builder->getRootNode() : $builder->root($name, $type);
126 |     }
127 | }
128 | 


--------------------------------------------------------------------------------
/DependencyInjection/OverblogActiveMqExtension.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Overblog\ActiveMqBundle\DependencyInjection;
  4 | 
  5 | use Overblog\ActiveMqBundle\ActiveMq\Connection;
  6 | use Overblog\ActiveMqBundle\ActiveMq\Consumer;
  7 | use Overblog\ActiveMqBundle\ActiveMq\Publisher;
  8 | use Overblog\ActiveMqBundle\Command\ConsumerCommand;
  9 | use Overblog\ActiveMqBundle\Command\ProducerCommand;
 10 | use Symfony\Component\DependencyInjection\Alias;
 11 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 12 | use Symfony\Component\Config\FileLocator;
 13 | use Symfony\Component\HttpKernel\DependencyInjection\Extension;
 14 | use Symfony\Component\DependencyInjection\Loader;
 15 | use Symfony\Component\DependencyInjection\Definition;
 16 | use Symfony\Component\DependencyInjection\Reference;
 17 | 
 18 | /**
 19 |  * This is the class that loads and manages your bundle configuration
 20 |  *
 21 |  * To learn more see {@link http://symfony.com/doc/current/cookbook/bundles/extension.html}
 22 |  */
 23 | class OverblogActiveMqExtension extends Extension
 24 | {
 25 |     /**
 26 |      * {@inheritDoc}
 27 |      */
 28 |     public function load(array $configs, ContainerBuilder $container)
 29 |     {
 30 |         $configuration = new Configuration();
 31 |         $config = $this->processConfiguration($configuration, $configs);
 32 | 
 33 |         $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
 34 |         $loader->load('services.yml');
 35 | 
 36 |         // Register connections
 37 |         foreach($config['connections'] as $name => $connection) {
 38 |             $this->addConnection($name, $connection, $container);
 39 |         }
 40 | 
 41 |         // Register publishers
 42 |         foreach($config['publishers'] as $name => $producer) {
 43 |             $this->addPublisher($name, $producer, $container);
 44 |         }
 45 | 
 46 |         // Register consumers
 47 |         foreach($config['consumers'] as $name => $consumer) {
 48 |             $this->addConsumer($name, $consumer, $container);
 49 |         }
 50 |     }
 51 | 
 52 |     private function addConnection($name, array $connection, ContainerBuilder $container)
 53 |     {
 54 |         $definition = new Definition(Connection::class);
 55 |         $definition
 56 |             ->addArgument($connection)
 57 |             ->addTag('activemq.connection')
 58 |         ;
 59 | 
 60 |         $container->setDefinition(
 61 |             $this->buildConnectionServiceId($name),
 62 |             $definition
 63 |         );
 64 | 
 65 |         //@see https://github.com/overblog/ActiveMqBundle/issues/9
 66 |         $container->setAlias(
 67 |             $definition->getClass(),
 68 |             new Alias($this->buildConnectionServiceId($name), true)
 69 |         );
 70 |     }
 71 | 
 72 |     private function addPublisher($name, array $publisher, ContainerBuilder $container)
 73 |     {
 74 |         $definition = new Definition(Publisher::class);
 75 |         $definition
 76 |             ->addArgument(new Reference($this->buildConnectionServiceId($publisher['connection'])))
 77 |             ->addArgument($publisher['options'])
 78 |             ->addTag('activemq.publisher');
 79 |         $serviceID = sprintf('%s.publisher.%s', $this->getAlias(), $name);
 80 |         $container->setDefinition($serviceID, $definition);
 81 |         $container->getDefinition(ProducerCommand::class)
 82 |             ->addMethodCall('addPublisher', [$name, new Reference($serviceID)]);
 83 | 
 84 |         //@see https://github.com/overblog/ActiveMqBundle/issues/9
 85 |         $container->setAlias($definition->getClass(), new Alias($serviceID, true));
 86 |     }
 87 | 
 88 |     private function addConsumer($name, array $consumer, ContainerBuilder $container)
 89 |     {
 90 |         $definition = new Definition(Consumer::class);
 91 |         $definition
 92 |             ->addArgument(new Reference($this->buildConnectionServiceId($consumer['connection'])))
 93 |             ->addArgument(new Reference($consumer['handler']))
 94 |             ->addArgument($consumer['options'])
 95 |             ->addTag('activemq.consumer');
 96 |         $serviceID = sprintf('%s.consumer.%s', $this->getAlias(), $name);
 97 |         $container->setDefinition($serviceID, $definition);
 98 |         $container->getDefinition(ConsumerCommand::class)
 99 |             ->addMethodCall('addConsumer', [$name, new Reference($serviceID)]);
100 | 
101 |         //@see https://github.com/overblog/ActiveMqBundle/issues/9
102 |         $container->setAlias($definition->getClass(), new Alias($serviceID, true));
103 | 
104 |         return $definition;
105 |     }
106 | 
107 |     private function buildConnectionServiceId($name)
108 |     {
109 |         return sprintf('%s.connection.%s', $this->getAlias(), $name);
110 |     }
111 | }
112 | 


--------------------------------------------------------------------------------
/Exception/ActiveMqException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Overblog\ActiveMqBundle\Exception;
 3 | 
 4 | /**
 5 |  * Description of ActiveMqException
 6 |  *
 7 |  * @author Xavier HAUSHERR
 8 |  */
 9 | class ActiveMqException extends \Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2018 Webedia - Overblog
 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.
22 | 


--------------------------------------------------------------------------------
/OverblogActiveMqBundle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Overblog\ActiveMqBundle;
 4 | 
 5 | use Symfony\Component\HttpKernel\Bundle\Bundle;
 6 | 
 7 | class OverblogActiveMqBundle extends Bundle
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | OverblogActiveMqBundle
  2 | ======================
  3 | 
  4 | ActiveMQ Bundle for the Symfony.
  5 | 
  6 | Installation
  7 | --------------
  8 | 
  9 | ```
 10 | composer req overblog/activemq-bundle
 11 | ```
 12 | 
 13 | Usage
 14 | ----------
 15 | 
 16 | Define publishers and consumers:
 17 | 
 18 | ```yaml
 19 | overblog_active_mq:
 20 |     connections:
 21 |         default:
 22 |             user: '%env(MQ_USER)%'
 23 |             password: '%env(MQ_PASSWORD)%'
 24 |             servers: '%mq_servers%'
 25 | 
 26 |     publishers:
 27 |         foo:
 28 |             connection: default
 29 |             options:
 30 |                 type: queue
 31 |                 name: foo.notification
 32 |         bar:
 33 |             connection: default
 34 |             options:
 35 |                 type: queue
 36 |                 name: bar.notification
 37 |     consumers:
 38 |         foo:
 39 |             connection: default
 40 |             handler: App\Consumer\FooConsumer
 41 |             options:
 42 |                 type: queue
 43 |                 name: foo.notification # queue name
 44 |                 prefetchSize: 10
 45 |         bar:
 46 |             connection: default
 47 |             handler: App\Consumer\BarConsumer
 48 |             options:
 49 |                 type: queue
 50 |                 name: bar.notification
 51 |                 prefetchSize: 10
 52 | 
 53 | services:
 54 |     App\Consumer\BarConsumer: ~
 55 |     App\Consumer\FooConsumer: ~
 56 | ```
 57 | 
 58 | An example of how to publish a message:
 59 | you can access publisher using service id `overblog_active_mq.{PUBLISHER_NAME}` for example
 60 | `overblog_active_mq.foo` or `overblog_active_mq.bar` for above configuration. Services is not public so create a public alias or inject it.
 61 | ```php
 62 | <?php
 63 | 
 64 | namespace App\Controller;
 65 | 
 66 | use Overblog\ActiveMqBundle\ActiveMq\Publisher;
 67 | use Symfony\Component\HttpFoundation\Request;
 68 | use Symfony\Component\HttpFoundation\Response;
 69 | 
 70 | class BazController
 71 | {
 72 |     public function webhookCallbackAction(Request $request, Publisher $publisher)
 73 |     {
 74 |         $content = trim($request->getContent());
 75 |         $publisher->publish($content);
 76 | 
 77 |         return new Response('Successful notification', 200);
 78 |     }
 79 | }
 80 | ```
 81 | 
 82 | An example of a consumer:
 83 | ```php
 84 | <?php
 85 | 
 86 | namespace App\Consumer;
 87 | 
 88 | use Overblog\ActiveMqBundle\ActiveMq\ConsumerInterface;
 89 | use Overblog\ActiveMqBundle\ActiveMq\Message;
 90 | 
 91 | class FooConsumer extends Consumer
 92 | {
 93 |     /**
 94 |      * {@inheritdoc}
 95 |      */
 96 |     public function execute(Message $message)
 97 |     {
 98 |         // here you treat your message. Return false to noack the message.
 99 |     }
100 | }
101 | ```
102 | 


--------------------------------------------------------------------------------
/Resources/config/services.yml:
--------------------------------------------------------------------------------
1 | services:
2 |     Overblog\ActiveMqBundle\Command\ConsumerCommand:
3 |         tags:
4 |             - { name: console.command, command: activemq:consumer }
5 | 
6 |     Overblog\ActiveMqBundle\Command\ProducerCommand:
7 |         tags:
8 |             - { name: console.command, command: activemq:producer }
9 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "overblog/activemq-bundle",
 3 |     "description": "OverBlog ActiveMQ Bundle",
 4 |     "homepage": "https://github.com/overblog/ActiveMqBundle.git",
 5 |     "type": "symfony-bundle",
 6 |     "authors": [
 7 |         {
 8 |           "name": "OverBlog",
 9 |           "homepage": "http://www.over-blog.com"
10 |         }
11 |     ],
12 |     "require": {
13 |         "php": ">=5.6",
14 |         "centraldesktop/stomp": "2.0.*",
15 |         "symfony/console": "^3.4 || ^4.0",
16 |         "symfony/framework-bundle": "^3.4 || ^4.0"
17 |     },
18 | 
19 |     "autoload": {
20 |         "psr-4": {"Overblog\\ActiveMqBundle\\": ""}
21 |     }
22 | }
23 | 


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