Chapter 3. Using the command line interface

Procedure

1. Switch to the user account you created during installation.

   $ su - amq-broker

2. Use the artemis run command to start the broker instance.

   $ /var/opt/amq-broker/mybroker/bin/artemis run
   
             __  __  ____    ____            _
       /\   |  \/  |/ __ \  |  _ \          | |
      /  \  | \  / | |  | | | |_) |_ __ ___ | | _____ _ __
     / /\ \ | |\/| | |  | | |  _ <| '__/ _ \| |/ / _ \ '__|
    / ____ \| |  | | |__| | | |_) | | | (_) |   <  __/ |
   /_/    \_\_|  |_|\___\_\ |____/|_|  \___/|_|\_\___|_|
   
   Red Hat JBoss AMQ 7.2.1.GA
   
   10:53:43,959 INFO  [org.apache.activemq.artemis.integration.bootstrap] AMQ101000: Starting ActiveMQ Artemis Server
   10:53:44,076 INFO  [org.apache.activemq.artemis.core.server] AMQ221000: live Message Broker is starting with configuration Broker Configuration (clustered=false,journalDirectory=./data/journal,bindingsDirectory=./data/bindings,largeMessagesDirectory=./data/large-messages,pagingDirectory=./data/paging)
   10:53:44,099 INFO  [org.apache.activemq.artemis.core.server] AMQ221012: Using AIO Journal
   ...

   The broker starts and displays log output with the following information:

   • The location of the transaction logs and cluster configuration.
   • The type of journal being used for message persistence (AIO in this case).

   • The URI(s) that can accept client connections.

     By default, port 61616 can accept connections from any of the supported protocols (CORE, MQTT, AMQP, STOMP, HORNETQ, and OPENWIRE). There are separate, individual ports for each protocol as well.

   • The web console is available at http://localhost:8161.
   • The Jolokia service (JMX over REST) is available at http://localhost:8161/jolokia.

Procedure

1. Create a new amq-broker.service file in the /etc/systemd/system/ directory.

2. Copy the following text into the file.

   Modify the path and user fields according to the information provided during the broker instance creation. In the example below, the user amq-broker starts the broker service installed under the /var/opt/amq-broker/mybroker/ directory.

   [Unit]
   Description=AMQ Broker
   After=syslog.target network.target
   
   [Service]
   ExecStart=/var/opt/amq-broker/mybroker/bin/artemis run
   Restart=on-failure
   User=amq-broker
   Group=amq-broker
   
   # A workaround for Java signal handling
   SuccessExitStatus=143
   
   [Install]
   WantedBy=multi-user.target

3. Open a terminal.

4. Enable the broker service using the following command:

   sudo systemctl enable amq-broker

5. Run the broker service using the following command:

   sudo systemctl start amq-broker

Procedure

1. Open a command prompt to enter the commands

2. Install the broker as a service with the following command:

   <broker-instance-dir>\bin\artemis-service.exe install

3. Start the service by using the following command:

   <broker-instance-dir>\bin\artemis-service.exe start

4. (Optional) Uninstall the service:

   <broker-instance-dir>\bin\artemis-service.exe uninstall

Procedure

1. Open the configuration file <broker-instance-dir>\etc\broker.xml.

2. Add the graceful-shutdown-enabled configuration element and set the value to true.

   <configuration>
        <core>
             ...
             <graceful-shutdown-enabled>
                 true
             </graceful-shutdown-enabled>
             ...
        </core>
   </configuration>

3. Add the graceful-shutdown-timeout configuration element and set a value for the timeout in milliseconds. In the following example, client connections are forcefully closed 30 seconds (30000 milliseconds) after the stop command is issued.

   <configuration>
        <core>
             ...
             <graceful-shutdown-enabled>
                 true
             </graceful-shutdown-enabled>
             <graceful-shutdown-timeout>
                 30000
             </graceful-shutdown-timeout>
             ...
        </core>
   </configuration>

Procedure

1. Implement the appropriate interface and override its intercept() method.

   1. If you are using the AMQP protocol, implement the org.apache.activemq.artemis.protocol.amqp.broker.AmqpInterceptor interface.

      package com.example;
      
      import org.apache.activemq.artemis.protocol.amqp.broker.AMQPMessage;
      import org.apache.activemq.artemis.protocol.amqp.broker.AmqpInterceptor;
      import org.apache.activemq.artemis.spi.core.protocol.RemotingConnection;
      
      public class MyInterceptor implements AmqpInterceptor
      {
        private final int ACCEPTABLE_SIZE = 1024;
      
        @Override
        public boolean intercept(final AMQPMessage message, RemotingConnection connection)
        {
          int size = message.getEncodeSize();
          if (size <= ACCEPTABLE_SIZE) {
            System.out.println("This AMQPMessage has an acceptable size.");
            return true;
          }
          return false;
        }
      }

   2. If you are using the Core protocol, your interceptor must implement the org.apache.artemis.activemq.api.core.Interceptor interface.

      package com.example;
      
      import org.apache.artemis.activemq.api.core.Interceptor;
      import org.apache.activemq.artemis.core.protocol.core.Packet;
      import org.apache.activemq.artemis.spi.core.protocol.RemotingConnection;
      
      public class MyInterceptor implements Interceptor
      {
        private final int ACCEPTABLE_SIZE = 1024;
      
        @Override
        boolean intercept(Packet packet, RemotingConnection connection)
        throws ActiveMQException
        {
          int size = packet.getPacketSize();
          if (size <= ACCEPTABLE_SIZE) {
            System.out.println("This Packet has an acceptable size.");
            return true;
          }
          return false;
        }
      }

   3. If you are using the MQTT protocol, implement the org.apache.activemq.artemis.core.protocol.mqtt.MQTTInterceptor interface.

      package com.example;
      
      import org.apache.activemq.artemis.core.protocol.mqtt.MQTTInterceptor;
      import io.netty.handler.codec.mqtt.MqttMessage;
      import org.apache.activemq.artemis.spi.core.protocol.RemotingConnection;
      
      public class MyInterceptor implements Interceptor
      {
        private final int ACCEPTABLE_SIZE = 1024;
      
        @Override
        boolean intercept(MqttMessage mqttMessage, RemotingConnection connection)
        throws ActiveMQException
        {
          byte[] msg = (mqttMessage.toString()).getBytes();
          int size = msg.length;
          if (size <= ACCEPTABLE_SIZE) {
            System.out.println("This MqttMessage has an acceptable size.");
            return true;
          }
          return false;
        }
      }

   4. If you are using the Stomp protocol, implement the org.apache.activemq.artemis.core.protocol.stomp.StompFrameInterceptor interface.

      package com.example;
      
      import org.apache.activemq.artemis.core.protocol.stomp.StompFrameInterceptor;
      import org.apache.activemq.artemis.core.protocol.stomp.StompFrame;
      import org.apache.activemq.artemis.spi.core.protocol.RemotingConnection;
      
      public class MyInterceptor implements Interceptor
      {
        private final int ACCEPTABLE_SIZE = 1024;
      
        @Override
        boolean intercept(StompFrame stompFrame, RemotingConnection connection)
        throws ActiveMQException
        {
          int size = stompFrame.getEncodedSize();
          if (size <= ACCEPTABLE_SIZE) {
            System.out.println("This StompFrame has an acceptable size.");
            return true;
          }
          return false;
        }
      }

Procedure

1. Open <broker-instance-dir>/etc/broker.xml

2. Configure the broker to use an interceptor by adding configuration to _<broker-instance-dir>/etc/broker.xml

   1. If the interceptor is intended for incoming messages, add its class-name to the list of remoting-incoming-interceptors.

      <configuration>
        <core>
          ...
          <remoting-incoming-interceptors>
             <class-name>org.example.MyIncomingInterceptor</class-name>
          </remoting-incoming-interceptors>
          ...
        </core>
      </configuration>

   2. If the interceptor is intended for outgoing messages, add its class-name to the list of remoting-outgoing-interceptors.

      <configuration>
        <core>
          ...
          <remoting-outgoing-interceptors>
             <class-name>org.example.MyOutgoingInterceptor</class-name>
          </remoting-outgoing-interceptors>
        </core>
      </configuration>