/** @param args [0] RabbitmqHost */
public static void main(String[] args) {
System.out.println(Constants.HEADER);
String RabbitmqHost = "localhost";
if (args.length > 0) RabbitmqHost = args[0];
ConnectionFactory factory = new ConnectionFactory();
factory.setHost(RabbitmqHost);
try {
Connection connection = factory.newConnection();
System.out.println("Connected: " + RabbitmqHost);
Channel channel = connection.createChannel();
channel.exchangeDeclare(Constants.exchange, "direct", false);
Stats stats = new Stats();
JSONWriter rabbitmqJson = new JSONWriter();
int msgCount = 0;
for (; ; ) {
stats.Update();
String statMsg = rabbitmqJson.write(stats);
System.out.println(stats.toString());
channel.basicPublish(Constants.exchange, Constants.routingKey, null, statMsg.getBytes());
++msgCount;
if (System.in.available() > 0) break;
Thread.sleep(1000);
}
channel.close();
System.out.println("Done: " + msgCount + " messages sent");
connection.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] argv) throws java.io.IOException, TimeoutException {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
/*
* The durability options let the tasks survive even if RabbitMQ is
* restarted
*/
boolean durable = true;
channel.queueDeclare(TASK_QUEUE_NAME, durable, false, false, null);
String message = getMessage(argv);
/*
* publish 設成 persistent 的用處是為了防止RabbitMQ server gg 時忘記message 的內容
*/
channel.basicPublish(
"", TASK_QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
System.out.println(" [x] Sent '" + message + "'");
channel.close();
connection.close();
}
public static void main(String[] argv) throws java.io.IOException {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "direct");
System.out.println(
"Type message to send to logs.\n"
+ "Format ${severity}:${message}\n"
+ " or ${message} (uses default severity 'error')\n"
+ "Type an empty message to exit this process.");
try {
while (true) {
Message message = getMessage();
if (message == null) {
break;
}
channel.basicPublish(EXCHANGE_NAME, message.severity, null, message.msg.getBytes());
System.out.println(" [x] Sent '" + message + "'");
}
} finally {
channel.close();
connection.close();
}
}
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
try {
channel.exchangeDeclare(EXCHANGE_NAME, "direct");
String queueName = channel.queueDeclare().getQueue();
String severity = "warning";
channel.queueBind(queueName, EXCHANGE_NAME, severity);
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
Consumer consumer =
new DefaultConsumer(channel) {
@Override
public void handleDelivery(
String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body)
throws IOException {
String message = new String(body, "UTF-8");
System.out.println(
" [x] Received '" + envelope.getRoutingKey() + "':'" + message + "'");
}
};
channel.basicConsume(queueName, true, consumer);
while (true) {}
} finally {
channel.close();
connection.close();
}
}
public boolean notice() {
try {
String searchServices = VrsMqConfig.VRS_MQ_SEARCH_SERVICE;
for (String service : searchServices.split(",")) {
String exchange = "";
String routingKey = VrsMqConfig.VRS_MQ_ROUTINGKEY + "_search_" + service;
cfconn.setUri(VrsMqConfig.VRS_MQ_HOSTNAME);
cfconn.setPort(VrsMqConfig.VRS_MQ_PORT);
cfconn.setUsername(VrsMqConfig.VRS_MQ_USERNAME);
cfconn.setPassword(VrsMqConfig.VRS_MQ_PASSWORD);
Connection conn = cfconn.newConnection();
Channel ch = conn.createChannel();
if (exchange.equals("")) {
ch.queueDeclare(routingKey, false, false, false, null);
}
String message = "sync";
logger.info("=========notice=========:" + message);
ch.basicPublish(exchange, routingKey, null, message.getBytes());
ch.close();
conn.close();
}
return true;
} catch (Exception e) {
System.err.println("Main thread caught exception: " + e);
e.printStackTrace();
return false;
}
}
public static void main(String[] argv) {
Connection connection = null;
Channel channel = null;
try {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
connection = factory.newConnection();
channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "topic");
String routingKey = getRouting(argv);
String message = getMessage(argv);
channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes());
System.out.println(" [x] Sent '" + routingKey + "':'" + message + "'");
} catch (Exception e) {
e.printStackTrace();
} finally {
if (connection != null) {
try {
connection.close();
} catch (Exception ignore) {
}
}
}
}
private void runIt() throws IOException {
Channel channel = _connection.createChannel();
String queueName = "test queue";
channel.queueDeclare(queueName, true, false, false, null);
String exchangeName = "test completion";
channel.exchangeDeclare(exchangeName, "fanout", false, false, null);
String completionQueue = channel.queueDeclare().getQueue();
channel.queueBind(completionQueue, exchangeName, "");
LatencyExperimentConsumer callback = new LatencyExperimentConsumer(channel, queueName);
callback._autoAck = this._autoAck;
channel.basicConsume(queueName, _autoAck, callback);
channel.basicConsume(completionQueue, true, "completion", callback);
callback.report(_writeStats);
System.out.println("Deleting test queue.");
channel.queueDelete(queueName);
System.out.println("Deleting completion queue.");
channel.queueDelete(completionQueue);
System.out.println("Closing the channel.");
channel.close();
System.out.println("Closing the connection.");
_connection.close();
System.out.println("Leaving ConsumerMain.run().");
}
/**
*
* <!-- begin-custom-doc -->
* <!-- end-custom-doc -->
*
* @generated This method is called when an activity is destroyed. It is called by the
* BusinessWorks Engine and the method must be implemented to release or cleanup any resources
* held by this activity.
*/
@Override
public void destroy() {
if (this.getActivityLogger().isDebugEnabled()) {
activityLogger.debug(
RuntimeMessageBundle.DEBUG_PLUGIN_ACTIVITY_METHOD_CALLED,
new Object[] {
"destroy()",
activityContext.getActivityName(),
activityContext.getProcessName(),
activityContext.getDeploymentUnitName(),
activityContext.getDeploymentUnitVersion()
});
}
// begin-custom-code
// add your own business code here
try {
channel.close();
connection.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (TimeoutException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// end-custom-code
super.destroy();
}
@Test
public void testBasicConnectivity() {
String sentMsg = "sent";
String recvdMsg = "received";
try {
channel.queueDeclare(basicTestQueue, false, false, false, null);
sentMsg = "testBasicConnectivity";
channel.basicPublish("", basicTestQueue, null, sentMsg.getBytes());
QueueingConsumer consumer = new QueueingConsumer(channel);
channel.basicConsume(basicTestQueue, true, consumer);
QueueingConsumer.Delivery delivery = consumer.nextDelivery(1500);
if (delivery != null) {
recvdMsg = new String(delivery.getBody());
}
} catch (Exception ex) {
fail("Connectivity error to MQ while running Test" + ex);
} finally {
try {
channel.close();
connection.close();
} catch (Exception ex) {
fail("Connectivity error to MQ while running Test" + ex);
}
}
assertEquals(sentMsg, recvdMsg);
}
public static void main(String[] argv) throws IOException {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("datdb.cphbusiness.dk");
factory.setUsername("student");
factory.setPassword("cph");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
String queueName = "Kender du hende der Arne";
channel.queueDeclare(queueName, false, false, false, null);
channel.queueBind(queueName, EXCHANGE_NAME, "");
String messageOut =
"{\"ssn\":1605789787,\"creditScore\":699,\"loanAmount\":10.0,\"loanDuration\":360}";
BasicProperties.Builder props = new BasicProperties().builder();
props.replyTo("");
BasicProperties bp = props.build();
channel.basicPublish(EXCHANGE_NAME, "", bp, messageOut.getBytes());
System.out.println(" [x] Sent by JSONtester: '" + messageOut + "'");
channel.close();
connection.close();
}
@Test
public void testDisconnectViaExceeded() {
// Make the test run a little faster
SystemProperties.setProperty("ss.echo_sender_interval", "1");
SystemProperties.setProperty("ss.echo_max_missed_echos", "2");
// Instatiate the resource
ResourceImpl resourceImpl = new ResourceImpl(restItem);
try {
channel.queueDeclare(intTestQueue, false, false, false, null);
} catch (Exception ex) {
fail("Connectivity error to MQ while running Test" + ex);
try {
channel.close();
connection.close();
} catch (Exception otherEx) {
// We couldn't close a connection that's already closed or
// hasn't been open...
}
}
// Here we build the queue ResourceImpl is going to connect to and we
// will later publish to
try {
resourceImpl.startStreaming(createListeners());
} catch (Exception ex) {
fail("Error while starting streaming service: " + ex);
}
// Have a rest to let the echo count expire
try {
Thread.sleep(30000);
} catch (Exception ex) {
fail("Interrupted sleep cycle" + ex);
}
// 1st test: did the echo count get increased by the batch echo sends?
assertTrue(disconnectedEventCalled);
try {
channel.queuePurge(resourceId);
channel.close();
connection.close();
} catch (Exception otherEx) {
// We couldn't close a connection that's already closed or hasn't
// been open...
}
}
@Test
public void testStreamingEvent() {
// Instantiate the resource
ResourceImpl resourceImpl = new ResourceImpl(restItem);
try {
channel.queueDeclare(intTestQueue, false, false, false, null);
} catch (Exception ex) {
fail("Connectivity error to MQ while running Test" + ex);
try {
channel.close();
connection.close();
} catch (Exception otherEx) {
// We couldn't close a connection that's already closed or
// hasn't been open...
}
}
// Here we build the queue ResourceImpl is going to connect to and we
// will later publish to
try {
resourceImpl.startStreaming(createListeners());
} catch (Exception ex) {
fail("Error while starting streaming service: " + ex);
}
// Have a rest to let all the services start up properly
try {
Thread.sleep(5000);
channel.basicPublish("", intTestQueue, null, mqMessage.getBytes());
} catch (Exception ex) {
fail("Cannot publish to MQ on test environment" + ex);
}
// A little rest to let the publication go through
try {
Thread.sleep(2000);
} catch (Exception ex) {
}
// 1st test: did we get a callback on ConnectedEvent (Connected to MQ) ?
assertTrue(connectedEventCalled);
// 2nd test: The stream received event was triggered
assertTrue(streamEventCalled);
// 3rd test: And the message received was the same as posted on the
// Queue
assertEquals(mqMessage, recvdFromMq);
resourceImpl.mqDisconnectEvent();
// Have a rest to let all the services shut down up properly
try {
Thread.sleep(2000);
channel.queuePurge(intTestQueue);
} catch (Exception ex) {
// Bit of housekeeping
}
}
public void closeConnection() {
if (connection != null) {
try {
connection.close();
} catch (Exception ignore) {
}
}
}
@Test
public void testConnectedDisconnectedEvents() {
// Instantiate the resource
ResourceImpl resourceImpl = new ResourceImpl(restItem);
try {
channel.queueDeclare(intTestQueue, false, false, false, null);
} catch (Exception ex) {
fail("Connectivity error to MQ while running Test" + ex);
try {
channel.close();
connection.close();
} catch (Exception otherEx) {
fail(
"Error while closing MQ channle, may have been closed alreadyConnectivity error to MQ while running Test"
+ ex);
}
}
// 1st test: We should, at this stage not received a ConnectedEvent yet
assertFalse(connectedEventCalled);
// Here we build the queue ResourceImpl is going to connect to and we
// will later publish to
try {
resourceImpl.startStreaming(createListeners());
} catch (Exception ex) {
fail("Error while starting streaming: " + ex);
}
// Have a rest to let all the services start up properly
try {
Thread.sleep(5000);
} catch (Exception ex) {
// Cleaning a queue gave us problems? yikes!
}
// 2nd test: did we get a callback on ConnectedEvent (Connected to MQ) ?
assertTrue(connectedEventCalled);
// 3rd test: We should, at this stage not received a DisconnectedEvent
// yet
assertFalse(disconnectedEventCalled);
resourceImpl.mqDisconnectEvent();
// Have a rest to let all the services shut down up properly
try {
Thread.sleep(2000);
channel.queuePurge(intTestQueue);
} catch (Exception ex) {
// Bit of housekeeping
}
// 4th test: did we get a callback on DisconnectedEvent (Disconnected
// from MQ) ?
assertTrue(disconnectedEventCalled);
}
public void stop() throws IOException {
if (channel != null && channel.isOpen()) {
channel.close();
}
if (connection != null && connection.isOpen()) {
connection.close();
}
}
public void close() {
try {
channel.close();
conn.close();
} catch (IOException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
}
}
@Override
public void shutdown() {
super.shutdown();
try {
mqChannel.close();
mqConnection.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public void disconnect() {
status = AMBStatus.DISCONNECTED;
try {
channel.close();
connection.close();
} catch (IOException e) {
e.printStackTrace();
}
channel = null;
}
@Override
protected void closeImpl() throws IOException {
// ! We are going to assume that closing an already closed
// connection is considered success.
if (connection != null && connection.isOpen()) {
try {
connection.close(factory.getConnectionTimeout());
} catch (AlreadyClosedException ignored) {
}
}
}
public void StopConsumer() {
try {
channel.basicCancel(consumerTag);
channel.close();
connection.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@PreDestroy
public void stop() {
try {
messageAcker.stop();
producerChannel.close();
consumerChannel.close();
clientConnection.close();
} catch (IOException | TimeoutException e) {
logger.error("Failed to close all RabbitMQ Client resources", e);
}
}
private void cleanup(int code, String message) {
try {
channel.close(code, message);
} catch (Exception e) {
logger.debug("failed to close channel on [{}]", e, message);
}
try {
connection.close(code, message);
} catch (Exception e) {
logger.debug("failed to close connection on [{}]", e, message);
}
}
public void testRoutingInvalidRoutes() throws Exception {
ConnectionFactory factory = new ConnectionFactory();
com.rabbitmq.client.Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare("transient", false, false, false, null);
connection.close();
for (String dest : Arrays.asList("/exchange/missing", "/queue/transient", "/fruit/orange")) {
routeInvalidSource(dest);
routeInvalidTarget(dest);
}
}
private void destory() {
try {
if (null != channel) {
channel.close();
}
if (null != connection) {
connection.close();
}
} catch (IOException e) {
log.error("Failed to close MQ connection: ", e);
}
}
public void shutdown() {
run.set(false);
synchronized (channel) {
try {
channel.close();
connection.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static void main(String args[]) throws IOException {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare("QUEUE_NAME", false, false, false, null);
String message = "Hello World!";
channel.basicPublish("", "QUEUE_NAME", null, message.getBytes());
System.out.println("[x] sent'" + message + "'");
channel.close();
connection.close();
}
public static void main(String[] args) throws IOException {
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("localhost");
Connection connection = connectionFactory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
String message = "Hello, World!";
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.printf("Sent: %s\n", message);
channel.close();
connection.close();
}
/**
* Remove RabbitReconnector if it's not null (to prevent reconnect). Close connection if it's not
* null. Swallow IOExceptions.
*
* @param conn
* @param reconnector
*/
public static void closeConnectionAndRemoveReconnector(
Connection conn, RabbitReconnector reconnector) {
if (conn == null) {
return;
}
if (reconnector != null) {
conn.removeShutdownListener(reconnector);
}
try {
conn.close();
} catch (IOException e) {
e.printStackTrace();
// throw new RuntimeException(e);
}
}
public static void main(String[] argv) {
Connection connection = null;
Channel channel = null;
try {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
connection = factory.newConnection();
channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "topic");
String queueName = channel.queueDeclare().getQueue();
if (argv.length < 1) {
System.err.println("Usage: ReceiveLogsTopic [binding_key]...");
System.exit(1);
}
for (String bindingKey : argv) {
channel.queueBind(queueName, EXCHANGE_NAME, bindingKey);
}
System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
QueueingConsumer consumer = new QueueingConsumer(channel);
channel.basicConsume(queueName, true, consumer);
while (true) {
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
String message = new String(delivery.getBody());
String routingKey = delivery.getEnvelope().getRoutingKey();
System.out.println(" [x] Received '" + routingKey + "':'" + message + "'");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (connection != null) {
try {
connection.close();
} catch (Exception ignore) {
}
}
}
}
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "direct");
String severity = getSeverity(argv);
String message = getMessage(argv);
channel.basicPublish(EXCHANGE_NAME, severity, null, message.getBytes());
System.out.println(" [x] Sent '" + severity + "':'" + message + "'");
channel.close();
connection.close();
}
