public void testRedelivery() throws Exception {
AMQPContext ctx = new AMQPContext(AMQPContext.CLIENT);
Connection conn = new Connection(ctx, host, port, false);
conn.connect();
Session s = conn.createSession(INBOUND_WINDOW, OUTBOUND_WINDOW);
Producer p = s.createProducer(QUEUE, QoS.AT_MOST_ONCE);
p.send(msg());
p.close();
Consumer c = s.createConsumer(QUEUE, CONSUMER_LINK_CREDIT, QoS.AT_LEAST_ONCE, false, null);
AMQPMessage m1 = c.receive();
assertTrue(m1.getHeader().getFirstAcquirer().getValue());
assertFalse(m1.isSettled());
s.close();
s = conn.createSession(INBOUND_WINDOW, OUTBOUND_WINDOW);
c = s.createConsumer(QUEUE, CONSUMER_LINK_CREDIT, QoS.AT_LEAST_ONCE, false, null);
AMQPMessage m2 = c.receive();
m2.accept();
assertTrue(compareMessageData(m1, m2));
assertFalse(m2.getHeader().getFirstAcquirer().getValue());
assertNull(get(c));
conn.close();
}
/*
* Initiate the snapshot by sending a Marker message to one of the Players (Player0)
* Any Player could have been used to initiate the snapshot.
*/
private void sendInitSnapshot() {
try {
// Gather necessary JMS resources
Context ctx = new InitialContext();
ConnectionFactory cf = (ConnectionFactory) ctx.lookup("jms/myConnectionFactory");
Queue q = (Queue) ctx.lookup("jms/PITplayer0");
Connection con = cf.createConnection();
Session session = con.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer writer = session.createProducer(q);
/*
* As part of the snapshot algorithm, players need to record
* what other Players they receive markers from.
* "-1" indicates to the PITplayer0 that this marker is coming from
* the monitor, not another Player.
*/
Marker m = new Marker(-1);
ObjectMessage msg = session.createObjectMessage(m);
System.out.println("Initiating Snapshot");
writer.send(msg);
con.close();
} catch (JMSException e) {
System.out.println("JMS Exception thrown" + e);
} catch (Throwable e) {
System.out.println("Throwable thrown" + e);
}
}
private void route(String consumerSource, String producerTarget, String routingKey, boolean succeed) throws Exception {
AMQPContext ctx = new AMQPContext(AMQPContext.CLIENT);
Connection conn = new Connection(ctx, host, port, false);
conn.connect();
Session s = conn.createSession(INBOUND_WINDOW, OUTBOUND_WINDOW);
Consumer c = s.createConsumer(consumerSource, CONSUMER_LINK_CREDIT, QoS.AT_LEAST_ONCE, false, null);
Producer p = s.createProducer(producerTarget, QoS.AT_LEAST_ONCE);
AMQPMessage msg = msg();
AmqpValue sentinel = new AmqpValue(new AMQPDouble(Math.random()));
msg.setAmqpValue(sentinel);
Properties props = new Properties();
props.setSubject(new AMQPString(routingKey));
msg.setProperties(props);
p.send(msg);
if (succeed) {
AMQPMessage m = c.receive();
assertNotNull(m);
assertEquals(sentinel.getValue().getValueString(), m.getAmqpValue().getValue().getValueString());
m.accept();
} else {
assertNull(get(c));
}
c.close();
p.close();
conn.close();
}
/**
* Initializes the qpid connection with a jndiName of cow, and a host and port taken from the
* cow-server.properties file.
*/
public void init() {
String connectionFactorylocation =
"amqp://*****:*****@clientid/test?brokerlist='tcp://" + host + ":" + port + "'";
String destinationType = "topic";
String jndiName = "cow";
String destinationName = "myTopic";
try {
properties = new Properties();
properties.setProperty(
Context.INITIAL_CONTEXT_FACTORY,
"org.apache.qpid.jndi.PropertiesFileInitialContextFactory");
properties.setProperty("connectionfactory.amqpConnectionFactory", connectionFactorylocation);
properties.setProperty(destinationType + "." + jndiName, destinationName);
context = new InitialContext(properties);
ConnectionFactory connectionFactory =
(ConnectionFactory) context.lookup("amqpConnectionFactory");
Connection connection = connectionFactory.createConnection();
connection.start();
session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
Destination destination = (Destination) context.lookup(jndiName);
messageProducer = session.createProducer(destination);
initialized = true;
} catch (Exception e) {
log.debug(e.getMessage());
initialized = false;
}
}
public UserMessageService(String brokerURL, String queueName) throws JMSException {
this.queueName = queueName;
ConnectionFactory factory = new ActiveMQConnectionFactory(brokerURL);
this.con = factory.createConnection();
session = con.createSession(false, Session.AUTO_ACKNOWLEDGE);
this.producer = session.createProducer(null);
}
private void sendTextMessage(String msg) throws Exception {
try (Connection connection = cf.createConnection();
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer publisher = session.createProducer(queue); ) {
connection.start();
TextMessage message = session.createTextMessage(msg);
publisher.send(message);
}
}
public void sendReply(Message request, int sum) {
try {
MessageProducer MP = session.createProducer(null);
Destination reply = request.getJMSReplyTo();
TextMessage TM = session.createTextMessage();
TM.setText("" + sum);
MP.send(reply, TM);
} catch (JMSException JMSE) {
System.out.println("JMS Exception: " + JMSE);
}
}
@Override
public void info(long lectureWrapperId) {
InfoLectureWrapperDTO infoLectureWrapperDTO = new InfoLectureWrapperDTO(lectureWrapperId);
try {
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
ObjectMessage objectMessage = session.createObjectMessage(infoLectureWrapperDTO);
session.createProducer(serverQueue).send(objectMessage);
} catch (JMSException e) {
e.printStackTrace();
}
}
/** Connects to a named queue. */
public JMSQueue(ConnectionFactory connectionFactory, Destination queue) throws Exception {
_connection = connectionFactory.createConnection();
_session = _connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
if (queue == null) _destination = _session.createTemporaryQueue();
else _destination = queue;
_consumer = _session.createConsumer(_destination);
_producer = _session.createProducer(_destination);
_connection.start();
}
@Override
public void init() {
try {
createAndStartConnection("", "", brokerUrl);
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
destination = session.createQueue(destinationName);
producer = session.createProducer(destination);
consumer = session.createConsumer(destination);
LOG.info("Initialized Queue on ActiveMQ: {}", destinationName);
} catch (Exception e) {
LOG.error("Error starting ActiveMQ connection for delayed queue", e);
throw new RuntimeException("Error starting ActiveMQ connection for delayed queue", e);
}
}
public static void main(String[] args) throws JMSException {
String uri = "failover://tcp://103.224.81.184:61616";
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(uri);
Connection connection = connectionFactory.createConnection();
Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
Topic topic = session.createTopic("topic1");
MessageProducer producer = session.createProducer(topic);
TextMessage textMessage = session.createTextMessage("HelloWorld4");
producer.send(textMessage);
connection.start();
producer.close();
session.close();
connection.close();
}
// Sends a message using the exchange name over qpid
private void sendMessage(String message, String exchangeName) {
TextMessage textMessage;
properties.setProperty("topic" + "." + "cow", exchangeName);
try {
context = new InitialContext(properties);
Destination destination = (Destination) context.lookup("cow");
messageProducer = session.createProducer(destination);
textMessage = session.createTextMessage(message);
messageProducer.send(textMessage);
} catch (Exception e) {
log.debug(e.getMessage());
initialized = false;
}
}
public void testRoundTrip() throws Exception {
AMQPContext ctx = new AMQPContext(AMQPContext.CLIENT);
Connection conn = new Connection(ctx, host, port, false);
conn.connect();
Session s = conn.createSession(INBOUND_WINDOW, OUTBOUND_WINDOW);
Producer p = s.createProducer(QUEUE, QoS.AT_LEAST_ONCE);
p.send(msg());
p.close(); // Settlement happens here
Consumer c = s.createConsumer(QUEUE, CONSUMER_LINK_CREDIT, QoS.AT_LEAST_ONCE, false, null);
AMQPMessage m = c.receive();
m.accept();
assertEquals(1, m.getData().size());
assertEquals(data(), m.getData().get(0));
conn.close();
}
private void sendJmsMessage() {
String message = "Salutation generated for MDB";
try {
Connection connection = queueConnectionFactory.createConnection();
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer messageProducer = (MessageProducer) session.createProducer(queue);
TextMessage textMessage = session.createTextMessage();
textMessage.setText(message);
messageProducer.send(textMessage);
Logger.getLogger("SalutationLog")
.log(Level.WARNING, "Message sent successfully", "Message sent successfully2");
} catch (JMSException e) {
e.printStackTrace();
}
}
public void testReject() throws Exception {
AMQPContext ctx = new AMQPContext(AMQPContext.CLIENT);
Connection conn = new Connection(ctx, host, port, false);
conn.connect();
Session s = conn.createSession(INBOUND_WINDOW, OUTBOUND_WINDOW);
Producer p = s.createProducer(QUEUE, QoS.AT_LEAST_ONCE);
p.send(msg());
p.close();
Consumer c = s.createConsumer(QUEUE, CONSUMER_LINK_CREDIT, QoS.AT_LEAST_ONCE, false, null);
AMQPMessage m = c.receive();
m.reject();
assertNull(get(c));
conn.close();
}
public void invoke(T message) throws EndpointException {
MessageProducer messageProducer = null;
Message jmsMessage = null;
try {
messageProducer = session.createProducer(destination);
if (message instanceof FlowEvent) {
jmsMessage = this.convertToMessage(((FlowEvent) message).getPayload());
// carry the event identifier if available
this.managedEventIdentifierService.setEventIdentifier(
((FlowEvent<String, ?>) message).getIdentifier(), jmsMessage);
} else {
jmsMessage = this.convertToMessage(message);
}
// pass original message to getMessageProperties to allow overridding classes to implement
// custom processing
// and set whatever comes back as properties on the message
setMessageProperties(jmsMessage, getMessageProperties(message));
// allow programmatic overrride of properties
if (customMessagePropertyProvider != null) {
setMessageProperties(jmsMessage, customMessagePropertyProvider.getProperties(message));
}
// publish message
messageProducer.send(jmsMessage);
if (logger.isDebugEnabled()) {
logger.debug("Published [" + message.toString() + "]");
}
} catch (JMSException e) {
throw new EndpointException(e);
} finally {
if (messageProducer != null) {
try {
messageProducer.close();
messageProducer = null;
} catch (JMSException e) {
logger.error("Failed to close session", e);
}
}
}
}
/**
* Get the `MessageProducer` or create one from the JMS session.
*
* @param destinationName destinationName
* @return JMS `MessageProducer`.
*/
private MessageProducer getProducer(final String destinationName) {
if (!producers.containsKey(destinationName)) {
Session session = getSession();
Destination destination = getDestination(destinationName);
MessageProducer producer;
try {
producer = session.createProducer(destination);
} catch (JMSException e) {
throw new IllegalStateException(
"Unable to create producer for destination " + destinationName, e);
}
producers.put(destinationName, producer);
}
return producers.get(destinationName);
}
private void routeInvalidTarget(String producerTarget) throws Exception {
AMQPContext ctx = new AMQPContext(AMQPContext.CLIENT);
Connection conn = new Connection(ctx, host, port, false);
conn.connect();
Session s = conn.createSession(INBOUND_WINDOW, OUTBOUND_WINDOW);
try {
Producer p = s.createProducer(producerTarget, QoS.AT_LEAST_ONCE);
p.close();
fail("Target '" + producerTarget + "' should fail");
}
catch (Exception e) {
// no-op
}
finally {
conn.close();
}
}
private void decorationTest(DecorationProtocol d, Map<AMQPString, AMQPType> map) throws Exception {
AMQPContext ctx = new AMQPContext(AMQPContext.CLIENT);
Connection conn = new Connection(ctx, host, port, false);
conn.connect();
Session s = conn.createSession(INBOUND_WINDOW, OUTBOUND_WINDOW);
Producer p = s.createProducer(QUEUE, QoS.AT_LEAST_ONCE);
AMQPMessage msg = msg();
d.decorateMessage(msg, map);
p.send(msg);
p.close();
Consumer c = s.createConsumer(QUEUE, CONSUMER_LINK_CREDIT, QoS.AT_LEAST_ONCE, false, null);
AMQPMessage recvMsg = c.receive();
recvMsg.accept();
compareMaps(map, d.getDecoration(recvMsg));
conn.close();
}
public void handleRequest(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
PrintWriter out = res.getWriter();
ConnectionFactory cf;
Destination dest;
try {
Context initCtx = new InitialContext();
Context envCtx = (Context) initCtx.lookup("java:comp/env");
cf = (ConnectionFactory) envCtx.lookup("jms/connectionFactory");
dest = (Destination) envCtx.lookup(QUEUE_NAME);
} catch (NamingException e) {
throw new RuntimeException(e);
}
Connection connection = null;
try {
connection = cf.createConnection();
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer producer = session.createProducer(dest);
TextMessage message = session.createTextMessage();
for (int i = 0; i < NUM_MSGS; i++) {
message.setText("This is message " + (i + 1));
log.info("Sending message: " + message.getText());
producer.send(message);
}
producer.send(session.createTextMessage());
} catch (JMSException e) {
throw new RuntimeException(e);
} finally {
if (connection != null) {
try {
connection.close();
} catch (JMSException e) {
}
}
}
out.write("<p>Wrote " + NUM_MSGS + " to queue " + QUEUE_NAME + " followed by a blank.</p>");
out.close();
}
public void _sendOne(String topic, String msg) {
Session session = null;
try {
session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
Destination destination = session.createQueue(topic);
MessageProducer producer = session.createProducer(destination);
producer.setDeliveryMode(DeliveryMode.PERSISTENT);
TextMessage message = session.createTextMessage(JSON.toJSONString(msg));
producer.send(message);
session.commit();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (null != session) session.close();
} catch (Throwable ignore) {
}
}
}
public static void main(String[] args) throws JMSException {
String user = env("ACTIVEMQ_USER", "");
String password = env("ACTIVEMQ_PASSWORD", "");
String host = env("ACTIVEMQ_HOST", "localhost");
int port = Integer.parseInt(env("ACTIVEMQ_PORT", "61616"));
String destination = arg(args, 0, "foo.bar");
int messages = 10;
int size = 256;
String DATA = "abcdefghijklmnopqrstuvwxyz";
String body = "";
for (int i = 0; i < size; i++) {
body += DATA.charAt(i % DATA.length());
}
ActiveMQConnectionFactory factory =
new ActiveMQConnectionFactory(
"tcp://" + host + ":" + port + "?jms.useAsyncSend=false&jms.alwaysSyncSend=true");
Connection connection = factory.createConnection(user, password);
logger.info("Connection created");
connection.start();
logger.info("Connection started");
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
Destination dest = new ActiveMQQueue(destination);
MessageProducer producer = session.createProducer(dest);
producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
for (int i = 1; i <= messages; i++) {
TextMessage msg = session.createTextMessage(body);
msg.setIntProperty("id", i);
producer.send(msg);
logger.info("Message send" + i);
}
producer.send(session.createTextMessage("THE.END"));
connection.close();
logger.info("Connection closed");
}
public void sendOne(String topic, String msg) {
long s = System.currentTimeMillis();
Session session = null;
try {
session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
Destination destination = session.createQueue(topic);
MessageProducer producer = session.createProducer(destination);
producer.setDeliveryMode(DeliveryMode.PERSISTENT);
TextMessage message = session.createTextMessage(msg);
producer.send(message);
session.commit();
logger.info("cost: {}ms {}/{}", System.currentTimeMillis() - s, topic, msg);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (null != session) session.close();
} catch (Throwable ignore) {
}
}
}
public void run() throws JMSException {
ConnectionFactory factory = new ActiveMQConnectionFactory(brokerURL);
Connection connection = factory.createConnection();
connection.start();
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
Destination destination = session.createQueue(queueName);
MessageProducer producer = session.createProducer(destination);
Message message = null;
for (int i = 0; i < 10; i++) {
System.out.println("Creating Message " + i);
message = session.createTextMessage("Hello World! " + i);
producer.send(message);
}
if (connection != null) {
connection.close();
}
}
/**
* Sends a command into a queue for processing
*
* @param queueName name of queue
* @param command command to process
* @param deliveryMode delivery mode: {@link javax.jms.DeliveryMode}.
* @param priority priority of the message. Correct values are from 0 to 9, with higher number
* denoting a higher priority.
* @param timeToLive the message's lifetime (in milliseconds, where 0 is to never expire)
*/
public void send(
String queueName, Command command, int deliveryMode, int priority, int timeToLive) {
try {
checkRange(deliveryMode, 1, 2, "delivery mode");
checkRange(priority, 0, 9, "priority");
if (timeToLive < 0) throw new HornetNestException("time to live cannot be negative");
Queue queue = (Queue) jmsServer.lookup("/queue/" + queueName);
if (queue == null) throw new HornetNestException("Failed to find queue: " + queueName);
Session session = producerConnection.createSession();
TextMessage msg = session.createTextMessage(command.toString());
msg.setStringProperty("command_class", command.getClass().getName());
MessageProducer p = session.createProducer(queue);
p.send(msg, deliveryMode, priority, timeToLive);
} catch (HornetNestException e) {
throw e;
} catch (Exception e) {
throw new HornetNestException("Failed to send message", e);
}
}
public void fragmentation(long FrameSize, int PayloadSize)
throws UnsupportedProtocolVersionException, AMQPException, AuthenticationException, IOException {
AMQPContext ctx = new AMQPContext(AMQPContext.CLIENT);
Connection conn = new Connection(ctx, host, port, false);
conn.setMaxFrameSize(FrameSize);
conn.connect();
Session s = conn.createSession(INBOUND_WINDOW, OUTBOUND_WINDOW);
Producer p = s.createProducer(QUEUE, QoS.AT_LEAST_ONCE);
AMQPMessage msg = new AMQPMessage();
msg.addData(new Data(new byte [PayloadSize]));
p.send(msg);
p.close();
Consumer c = s.createConsumer(QUEUE, CONSUMER_LINK_CREDIT, QoS.AT_LEAST_ONCE, false, null);
AMQPMessage m = c.receive();
m.accept();
c.close();
assertEquals(PayloadSize, m.getData().get(0).getValue().length);
conn.close();
}
public void send(ExampleCommand command, String queueName, String filter)
throws JMSException, IOException {
try (Session session = connection.createSession()) {
Message message;
if (binaryMode) {
message = session.createBytesMessage();
((BytesMessage) message).writeBytes(command.toBytes());
} else {
message = session.createTextMessage(command.toXml());
}
if (filter != null && !blank(filter)) {
String[] parts = filter.split("\\s*=\\s*");
message.setStringProperty(parts[0], parts[1]);
}
try (MessageProducer p = session.createProducer(ActiveMQJMSClient.createQueue(queueName))) {
p.send(message, DeliveryMode.PERSISTENT, 4, 0);
}
}
}
public static void publish(String dest, Serializable object, String contentType, String tag)
throws Exception {
Connection conn = connectionFactory.createConnection();
try {
Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
Destination destination = createDestination(dest);
MessageProducer producer = session.createProducer(destination);
ObjectMessage message = session.createObjectMessage();
if (contentType != null) {
message.setStringProperty(HttpHeaderProperty.CONTENT_TYPE, contentType);
}
if (tag != null) {
message.setStringProperty("MyTag", tag);
}
message.setObject(object);
producer.send(message);
} finally {
conn.close();
}
}
public static void main(String[] args) throws JMSException {
String user = env("ACTIVEMQ_USER", "admin");
String password = env("ACTIVEMQ_PASSWORD", "password");
String host = env("ACTIVEMQ_HOST", "localhost");
int port = Integer.parseInt(env("ACTIVEMQ_PORT", "61616"));
String destination = arg(args, 0, "event");
int messages = 10000;
int size = 256;
String DATA = "abcdefghijklmnopqrstuvwxyz";
String body = "";
for (int i = 0; i < size; i++) {
body += DATA.charAt(i % DATA.length());
}
ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("tcp://" + host + ":" + port);
Connection connection = factory.createConnection(user, password);
connection.start();
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
Destination dest = new ActiveMQTopic(destination);
MessageProducer producer = session.createProducer(dest);
producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
for (int i = 1; i <= messages; i++) {
TextMessage msg = session.createTextMessage(body);
msg.setIntProperty("id", i);
producer.send(msg);
if ((i % 1000) == 0) {
System.out.println(String.format("Sent %d messages", i));
}
}
producer.send(session.createTextMessage("SHUTDOWN"));
connection.close();
}
// envoyer un messsage à l'ESB
public void ecrireMessage(String messageXML) throws JMSException, NamingException {
// BasicConfigurator.configure();
// Obtention de connexion JMS e partir du serveur
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url);
Connection connection = connectionFactory.createConnection();
connection.start();
try {
// Creation de session (Messages JMS sont envoyes et recus en utilisant une session)
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// Destination de la file
Destination destination = session.createQueue(subject);
// MessageProducer est utilise pour l'envoi de messages
MessageProducer producer = session.createProducer(destination);
// le message transferer
TextMessage message = session.createTextMessage(messageXML);
// Transfert de message vers la file ( L'ESB)
producer.send(message);
// System.out.println("message envoye : " + message.getText() + "");
} finally {
connection.close();
}
}
