LavinMQ

https://lavinmq.com/documentation/
Admin
LavinMQ is a high-performance message broker implementing the AMQP protocol, capable of handling...
Tokens:94,971
Snippets:341
Trust Score:7.2
Update:1 year ago
Show doc for...
Tokens:
Raw
### Connect to LavinMQ with PHP

Source: https://lavinmq.com/documentation/getting-started

This example shows how to connect to LavinMQ using the 'php-amqplib' library in PHP. It covers establishing a connection and creating a channel.

```php
<?php
require_once __DIR__ . '/vendor/autoload.php';
use PhpAmqpLib\Connection\AMQPStreamConnection;

$connection = new AMQPStreamConnection('localhost', 5672, 'guest', 'guest');
$channel = $connection->channel();

echo "Successfully connected to LavinMQ";

$channel->close();
$connection->close();
?>
```

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

### Install LavinMQ with Docker Compose

Source: https://lavinmq.com/documentation/getting-started

This snippet demonstrates how to set up a clustered LavinMQ environment using Docker Compose. It's a convenient way to get a multi-node setup for testing and development.

```yaml
version: "3.7"
services:
  lavinmq:
    image: lavinmq/lavinmq:latest
    ports:
      - "5672:5672"
      - "15672:15672"
    environment:
      - CLUSTER_NODES=lavinmq
      - CLUSTER_TOKEN=mysecrettoken
    networks:
      - lavinmq-net

networks:
  lavinmq-net:
    driver: bridge
```

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

### Connect to LavinMQ with Golang

Source: https://lavinmq.com/documentation/getting-started

This example shows how to connect to LavinMQ using the 'streadway/amqp' library in Golang. It covers establishing a connection and creating a channel.

```go
package main

import (
	"log"
	"github.com/streadway/amqp"
)

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	if err != nil {
		log.Fatalf("Failed to connect to RabbitMQ: %v", err)
	}
	defer conn.Close()

	ch, err := conn.Channel()
	if err != nil {
		log.Fatalf("Failed to open a channel: %v", err)
	}
	defer ch.Close()

	log.Println("Successfully connected to LavinMQ")
}
```

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

### Connect to LavinMQ with Java

Source: https://lavinmq.com/documentation/getting-started

This example shows how to connect to LavinMQ using the 'amqp-client' library in Java. It covers establishing a connection and creating a channel.

```java
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class LavinMQConnect {

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            System.out.println("Successfully connected to LavinMQ");
        }
    }
}
```

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

### Run LavinMQ with Data Directory

Source: https://lavinmq.com/documentation/installation-guide

Starts the LavinMQ server, requiring a path to a data directory as an argument.

```bash
lavinmq -D /var/lib/lavinmq
```

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

### Install and Start Celery Flower

Source: https://lavinmq.com/documentation/lavinmq-and-celery-task-management

Details the steps to install Celery Flower for monitoring and managing Celery tasks, and how to start the Flower service.

```Shell
pip install flower

celery -A your_module_name flower
```

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

### Build LavinMQ from Source

Source: https://lavinmq.com/documentation/installation-guide

Builds LavinMQ from source code. This process involves cloning the GitHub repository, navigating into the directory, and then using 'make' to build and install the application.

```bash
git clone git@github.com:cloudamqp/lavinmq.git
cd lavinmq
make
sudo make install
```

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

### LavinMQ Consumer Setup (Python)

Source: https://lavinmq.com/documentation/introduction-python

This snippet provides the initial setup for a LavinMQ consumer in Python. It includes necessary imports, loading environment variables, and establishing a connection to the LavinMQ instance, similar to the producer setup.

```Python
import pika, os, sys
from dotenv import load_dotenv

load_dotenv()


```

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

### Connect to LavinMQ with NodeJS

Source: https://lavinmq.com/documentation/getting-started

This snippet demonstrates how to establish a connection to LavinMQ using the 'amqplib' library in NodeJS. It covers basic connection and channel creation.

```javascript
const amqp = require('amqplib/callback_api');

amqp.connect('amqp://localhost', function(error0, connection) {
  if (error0) {
    throw error0;
  }
  connection.createChannel(function(error1, channel) {
    if (error1) {
      throw error1;
    }
    const queue = 'hello';

    channel.assertQueue(queue, { durable: false });

    channel.sendToQueue(queue, Buffer.from('Hello my world!'));
    console.log(" [x] Sent 'Hello my world!'");
  });
});
```

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

### Connect to LavinMQ with Ruby

Source: https://lavinmq.com/documentation/getting-started

This snippet demonstrates how to connect to LavinMQ using the 'bunny' gem in Ruby. It covers establishing a connection and creating a channel.

```ruby
require 'bunny'

conn = Bunny.new(:host => 'localhost')
conn.start

ch = conn.create_channel

puts "Successfully connected to LavinMQ"
```

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

### Connect to LavinMQ with .NET

Source: https://lavinmq.com/documentation/getting-started

This snippet demonstrates how to connect to LavinMQ using the 'RabbitMQ.Client' library in .NET. It covers establishing a connection and creating a channel.

```csharp
using RabbitMQ.Client;

var factory = new ConnectionFactory() { HostName = "localhost" };
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
    Console.WriteLine("Successfully connected to LavinMQ");
}
```

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

### Connect to LavinMQ with Python (Celery)

Source: https://lavinmq.com/documentation/getting-started

This example shows how to configure Celery, a distributed task queue, to use LavinMQ as its message broker. It assumes you have a LavinMQ instance running and accessible.

```python
from celery import Celery

app = Celery('tasks', broker='amqp://guest:guest@localhost:5672//')

@app.task
def add(x, y):
    return x + y
```

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

### Install LavinMQ on Fedora

Source: https://lavinmq.com/documentation/installation-guide

Installs LavinMQ on Fedora systems. This involves creating a .repo file with the LavinMQ repository configuration and then installing the lavinmq package using dnf.

```bash
sudo tee /etc/yum.repos.d/lavinmq.repo << 'EOF'
[lavinmq]
name=LavinMQ
baseurl=https://packagecloud.io/cloudamqp/lavinmq/fedora/$releasever/$basearch
gpgkey=https://packagecloud.io/cloudamqp/lavinmq/gpgkey
repo_gpgcheck=1
gpgcheck=0
EOF

sudo dnf install lavinmq
```

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

### Install LavinMQ Repository

Source: https://lavinmq.com/documentation/clustering

Adds the LavinMQ repository GPG key and source list to the system for installation via apt-get.

```bash
curl -fsSL https://packagecloud.io/cloudamqp/lavinmq/gpgkey | gpg --dearmor | sudo tee /usr/share/keyrings/lavinmq.gpg > /dev/null
. /etc/os-release
echo "deb [signed-by=/usr/share/keyrings/lavinmq.gpg] https://packagecloud.io/cloudamqp/lavinmq/$ID $VERSION_CODENAME main" | sudo tee /etc/apt/sources.list.d/lavinmq.list
```

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

### Golang LavinMQ Message Producer

Source: https://lavinmq.com/documentation/go-sample-code

This Go code snippet demonstrates how to publish a message to a LavinMQ queue. It establishes a connection to the LavinMQ server, opens a channel, declares a 'hello' queue, and then publishes a 'Hello World' message to it. Ensure you have the amqp091-go library installed and replace 'lavinmq server URL' with your actual server address.

```Go
package main

import (
  "context"
  "log"
  "time"

  amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
  if err != nil {
    log.Panicf("%s: %s", msg, err)
  }
}

func main() {
  connection, err := amqp.Dial("lavinmq server URL")
  failOnError(err, "Failed to connect to LavinMQ")
  defer connection.Close()

  channel, err := connection.Channel()
  failOnError(err, "Failed to open a channel")
  log.Print("[✅] Connection over channel established")
  defer channel.Close()

  queue, err := channel.QueueDeclare(
    "hello", // name
    false,   // durable
    false,   // delete when unused
    false,   // exclusive
    false,   // no-wait
    nil,     // arguments
  )
  failOnError(err, "Failed to declare a queue")


  ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
  defer cancel()

  body := "Hello World"
  err = channel.PublishWithContext(ctx,
    "",     // exchange
    queue.Name, // routing key
    false,  // mandatory
    false,  // immediate
    amqp.Publishing{
      ContentType: "text/plain",
      Body:        []byte(body),
    })
  failOnError(err, "Failed to publish a message")
  log.Printf("[📥] Message sent to queue:  %s\n", body)

}
```

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

### Docker Compose for LavinMQ

Source: https://lavinmq.com/documentation/installation-guide

A minimal Docker Compose configuration to run LavinMQ. It specifies the latest image and exposes the necessary ports for AMQP and the management interface.

```yaml
services:
  lavinmq:
    image: "cloudamqp/lavinmq:latest"
    ports: 
      - 15672:15672 # HTTP 
      - 5672:5672 # AMQP
```

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

### Install LavinMQ Package

Source: https://lavinmq.com/documentation/clustering

Updates the package list and installs the LavinMQ package using apt-get.

```bash
sudo apt-get update
sudo apt-get install lavinmq
```

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

### LavinMQ Example Configuration

Source: https://lavinmq.com/documentation/configuration-files

An example of a LavinMQ configuration file showing settings for the main, management, and AMQP interfaces.

```ini
[main]
data_dir = /var/lib/lavinmq
guest_only_loopback = true
log_level = info

[mgmt]
bind = 0.0.0.0
port = 15672
tls_port = 15671
unix_path = /tmp/lavinmq-http.sock

[amqp]
bind = 0.0.0.0
port = 5672
tcp_proxy_protocol = false
tls_port = 5671
unix_path = /tmp/lavinmq.sock
unix_proxy_protocol = true

```

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

### Install LavinMQ on Debian/Ubuntu

Source: https://lavinmq.com/documentation/installation-guide

Installs LavinMQ on Debian/Ubuntu systems using apt package manager. It involves adding the LavinMQ GPG key and repository, updating package lists, and installing the lavinmq package.

```bash
curl -fsSL https://packagecloud.io/cloudamqp/lavinmq/gpgkey | gpg --dearmor | sudo tee /usr/share/keyrings/lavinmq.gpg > /dev/null
. /etc/os-release
echo "deb [signed-by=/usr/share/keyrings/lavinmq.gpg] https://packagecloud.io/cloudamqp/lavinmq/$ID$VERSION_CODENAME main" | sudo tee /etc/apt/sources.list.d/lavinmq.list
sudo apt-get update
sudo apt-get install lavinmq
```

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

### Node.js Producer and Consumer Example

Source: https://lavinmq.com/documentation/introduction-node

This snippet demonstrates the creation of a basic producer and consumer application in Node.js using the amqp-client.js library. The producer publishes messages to LavinMQ, and the consumer receives and processes them. This example is fundamental for understanding message flow in LavinMQ.

```javascript
// Producer Code (Conceptual - actual code would be provided in a full tutorial)
// const amqp = require('amqp-client');
// async function publishMessage() {
//   const connection = await amqp.connect('amqp://localhost');
//   const channel = await connection.channel();
//   await channel.publish('my_queue', 'Hello LavinMQ!');
//   await connection.close();
// }

// Consumer Code (Conceptual - actual code would be provided in a full tutorial)
// const amqp = require('amqp-client');
// async function consumeMessage() {
//   const connection = await amqp.connect('amqp://localhost');
//   const channel = await connection.channel();
//   await channel.consume('my_queue', (msg) => {
//     console.log('Received message:', msg.content.toString());
//   });
// }

```

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

### Java Publish and Subscribe Example

Source: https://lavinmq.com/documentation/java-sample-code

A complete Java example demonstrating how to connect to LavinMQ, declare a queue, publish a message, and consume messages from the queue. It includes setting up the connection factory, handling environment variables for the host URL, and basic message processing.

```java
public static void main(String[] args) throws Exception {
  String uri = System.getenv("HOST_URL");
  if (uri == null) uri = "amqp://guest:guest@localhost";

  ConnectionFactory factory = new ConnectionFactory();
  factory.setUri(uri);

  //Recommended settings
  factory.setRequestedHeartbeat(30);
  factory.setConnectionTimeout(30000);

  Connection connection = factory.newConnection();
  Channel channel = connection.createChannel();

  String queue = "hello";     //queue name
  boolean durable = false;    //durable - LavinMQ will never lose the queue if a crash occurs
  boolean exclusive = false;  //exclusive - if queue only will be used by one connection
  boolean autoDelete = false; //autodelete - queue is deleted when last consumer unsubscribes

  channel.queueDeclare(queue, durable, exclusive, autoDelete, null);
  String message = "Hello CloudAMQP!";

  String exchangeName = "";
  String routingKey = "hello";
  channel.basicPublish(exchangeName, routingKey, null, message.getBytes());
  System.out.println(" [x] Sent '" + message + "'");

  QueueingConsumer consumer = new QueueingConsumer(channel);
  channel.basicConsume(queue, true, consumer);

  while (true) {
    QueueingConsumer.Delivery delivery = consumer.nextDelivery();
    message = new String(delivery.getBody());
    System.out.println(" [x] Received '" + message + "'");
  }
}
```

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

### Start LavinMQ Node

Source: https://lavinmq.com/documentation/clustering

Starts a LavinMQ node, optionally with a configuration file. The node will attempt to become a leader or join an existing cluster.

```shell
lavinmq --config-file=/path-to-config-file
```

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

### Install etcd on Debian/Ubuntu

Source: https://lavinmq.com/documentation/clustering

This snippet shows how to install the etcd binary on Debian-based systems using CloudAMQP's package repository. It includes steps for adding the GPG key, repository, updating package lists, and installing etcd.

```bash
curl -fsSL https://packagecloud.io/cloudamqp/etcd/gpgkey | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/cloudamqp_etcd.gpg
. /etc/os-release
echo "deb https://packagecloud.io/cloudamqp/etcd/any any main" | sudo tee /etc/apt/sources.list.d/cloudamqp_etcd.list
apt-get update
apt-get install etcd

```

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

### Install Celery using pip

Source: https://lavinmq.com/documentation/lavinmq-and-celery-task-management

This command installs the Celery library, a popular distributed task queue, using Python's package installer.

```bash
pip install celery
```

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

### Consume messages from LavinMQ using Go

Source: https://lavinmq.com/documentation/go-sample-code

This Go program connects to a LavinMQ server, declares a 'hello' queue, and starts consuming messages. It logs received messages and handles connection errors. Ensure you replace 'Lavinmq server URL' with your actual server address.

```Go
package main

import (
  "log"
  amqp "github.com/rabbitmq/amqp091-go"
)

func failOnError(err error, msg string) {
  if err != nil {
    log.Panicf("%s: %s", msg, err)
  }
}

func main() {
  connection, err := amqp.Dial("Lavinmq server URL")
  failOnError(err, "Failed to connect to LavinMQ")
  defer connection.Close()

  channel, err := connection.Channel()
  failOnError(err, "Failed to open a channel")
  log.Print("[✅] Connection over channel established")
  defer channel.Close()

  q, err := channel.QueueDeclare(
    "hello", // name
    false,   // durable
    false,   // delete when unused
    false,   // exclusive
    false,   // no-wait
    nil,     // arguments
  )
  failOnError(err, "Failed to declare a queue")

  msgs, err := channel.Consume(
    q.Name, // queue
    "",     // consumer
    true,   // auto-ack
    false,  // exclusive
    false,  // no-local
    false,  // no-wait
    nil,    // args
  )
  failOnError(err, "Failed to register a consumer")

  var forever chan struct{}

  go func() {
    for d := range msgs {
      log.Printf("[✅] Message Received: %s", d.Body)
    }
  }()

  log.Printf("[❎] Waiting for messages. To exit press CTRL+C")
  <-forever

}
```

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

### LavinMQ Topic Exchange Setup

Source: https://lavinmq.com/documentation/topic-exchange

This section outlines the theoretical setup for a topic exchange in LavinMQ to manage a granular notification system. It involves creating queues and binding them to a topic exchange with specific routing keys.

```AMQP
Queues:
  - marketing_messages
  - support_new_members
  - all_messages
  - all_notifications

Exchange:
  - Name: slack_notifications
    Type: topic

Bindings:
  - Queue: marketing_messages
    Exchange: slack_notifications
    Routing Key: notifications.marketing.messages
  - Queue: support_new_members
    Exchange: slack_notifications
    Routing Key: notifications.support.new_member_joined
  - Queue: all_messages
    Exchange: slack_notifications
    Routing Key: notifications.*.messages
  - Queue: all_notifications
    Exchange: slack_notifications
    Routing Key: notifications.#
```

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

### Python Direct Exchange Producer/Consumer Setup

Source: https://lavinmq.com/documentation/direct-exchange-python

This snippet outlines the setup for a Python producer and consumer application using LavinMQ's direct exchange. It assumes a similar development environment as a previous fanout exchange tutorial, focusing on the conceptual implementation of routing messages based on binding and routing keys.

```Python
import pika

# Connection parameters (replace with your LavinMQ details)
connection_params = pika.ConnectionParameters('localhost')
connection = pika.BlockingConnection(connection_params)
channel = connection.channel()

# Declare a direct exchange
channel.exchange_declare(exchange='slack_notifications', exchange_type='direct')

# Declare queues (example for HR)
channel.queue_declare(queue='hr_queue')
channel.queue_bind(exchange='slack_notifications', queue='hr_queue', routing_key='hr')

# Publish a message (example for HR)
message = "New HR notification!"
channel.basic_publish(exchange='slack_notifications', routing_key='hr', body=message)
print(f" [x] Sent '{message}' with routing key 'hr'")

connection.close()
```

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

### Start etcd Node

Source: https://lavinmq.com/documentation/clustering

Starts an etcd node, optionally with a specified configuration file. LavinMQ nodes query etcd for cluster status.

```shell
etcd --config-file=/path-to-config-file
```

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

### Start LavinMQ Service

Source: https://lavinmq.com/documentation/lavinmqperf

This snippet shows how to start the LavinMQ service using Crystal. It specifies the Crystal compiler and the main source file for LavinMQ, along with a flag to set the AMQP directory.

```crystal
crystal run src/lavinmq.cr -- -D /tmp/amqp
```

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

### Publish an MQTT Message

Source: https://lavinmq.com/documentation/mqtt-in-lavinmq

This example demonstrates how to publish a message to a specific MQTT topic. It requires that a session is already subscribed to the topic before publishing. The message content is 'Hello World'.

```Ruby
require "mqtt-client"
require "mqtt-protocol"

client = MQTT::Client.new("localhost", 1883, user: "guest", password: "guest", client_id: "hello", clean_session: false)

client.publish("my/topic", "Hello World")

```

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

### LavinMQ Consumer Setup (Ruby)

Source: https://lavinmq.com/documentation/introduction-ruby

This Ruby code sets up a LavinMQ consumer. It establishes a connection to the LavinMQ instance, creates a channel, and declares the 'hello_world' queue. It then prepares to consume messages by setting up a counter and printing a waiting message. The `at_exit` block ensures the connection is closed properly upon script termination.

```Ruby
require "amqp-client"
require "dotenv/load"

# Grab lavinmq url from .env file
lavinmq_url = ENV['CLOUDAMQP_URL']

# Opens and establishes a connection
connection = AMQP::Client.new(lavinmq_url).connect

# Open a channel
channel = connection.channel
puts "[✅] Connection over channel established"
puts "[❎] Waiting for messages. To exit press CTRL+C "

# Create a queue
queue = channel.queue_declare("hello_world")

counter = 0

```

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

### Install LavinMQ on macOS

Source: https://lavinmq.com/documentation/installation-guide

Installs LavinMQ on macOS using the Homebrew package manager. It requires updating Homebrew and then installing the lavinmq formula from the cloudamqp/cloudamqp tap.

```bash
brew update
brew install cloudamqp/cloudamqp/lavinmq
```

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

### Combine Offset Tracking with Specific Offset

Source: https://lavinmq.com/documentation/server-side-offset-tracking-and-stream-filtering

This example shows how to combine LavinMQ's automatic offset tracking with a specific starting offset. The consumer will begin from the provided offset and resume from where it left off on subsequent reconnections.

```AMQP
consumer_tag = "my_consumer_tag"
arguments = {
    "x-stream-offset": "12345",
    "x-stream-automatic-offset-tracking": true
}
```

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

### Ruby Hello World Producer and Consumer with AMQP::Client

Source: https://lavinmq.com/documentation/introduction-ruby

This snippet demonstrates the creation of a basic Ruby producer and consumer application for LavinMQ. The producer publishes messages, and the consumer consumes them using the AMQP::Client library. It covers setting up the Ruby development environment, creating the producer, and creating the consumer.

```Ruby
# Ruby hello world
# This part is also available in: Python Node.js

You might be familiar with what LavinMQ is already. But to reiterate, we are going to go over it again, but this time around, in an approachable manner.

## What is LavinMQ

LavinMQ is a message broker also called a message queue - But what is a message broker?

From a non-technical standpoint, a broker is literally a middle man that facilitates a transaction between two parties, usually a buyer and a seller. Message brokers do pretty much the same thing in the world of software.

LavinMQ and other brokers like it, facilitate the transfer of binary blobs of data, known as **messages** , between a _sending_ application and a _receiving_ application interested in the message. But how?

  * The sending application, known as a **producer** , creates and sends messages to LavinMQ. This process is referred to as **publishing**.
  * As a message broker, LavinMQ receives and securely stores messages from producers until they are retrieved by receiving applications. LavinMQ utilizes its built-in **queue** that maintains the order of arrival and persists messages until they are picked up.
    * To better get a sense of how a qeueue works in LavinMQ and in fact in most message brokers, you can think of it as a cylinder with open ends. New messages are added to the queue from one end of the cylinder and only removed from the opposite end - First In First Out(FIFO).
  * A receiving application formally called the **consumer** receives messages from LavinMQ and processes them at its own pace. This process is referred to as **consuming**.


The image below visualizes the flow of messages from the **Producer - > LavinMQ -> Consumer**.
Some noteworthy information on producers, consumers and messages: - Producers and consumers can be processes running on the same computer, modules of an application, or services running on different computers with varying technology stacks. - Messages are the data added by the sender application to the queue. They can include task requests for the receiving system, like sending an email or resizing an image, as well as plain text or information about completed tasks.

Now that we get the basics of LavinMQ, let’s see how we can set up a basic producer that publishes messages to LavinMQ and a corresponding consumer that consumes the messages.

## Publishing and consuming messages with amqp-client, Ruby client

Ruby developers have a number of options for AMQP client libraries. In this tutorial, AMQP::Client is used, an asynchronous client for publishing and consuming of messages.

We will build the simplest thing you can make with LavinMQ - two rudimentary Ruby applications. The first Ruby application, _the producer_ will publish messages to LavinMQ and the second application, _the consumer_ will receive these messages from LavinMQ.

There are three steps we will take to build our rudimentary producer and consumer: 1. **Setting up the Ruby development environment** - we will only have this step in this section. For subsequent Ruby tutorials, we will reference this guide and have you replicate steps where necessary. 1. **Creating the producer** 1. **Creating the consumer**
```

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

### Consume LavinMQ Stream from Specific Offset

Source: https://lavinmq.com/documentation/replay-with-offsets

This JavaScript snippet shows how to subscribe to a LavinMQ stream and consume messages starting from a specific numerical offset. The example uses offset 5000, and the consumer code also demonstrates consuming from offset 950.

```javascript
await q.subscribe({ noAck: false, args: { "x-stream-offset": 5000 }}, async (msg) => {
    try {
        console.log(`[📤] Message received (${++counter})`, msg.bodyToString())
    } catch (error) {
        console.error(error)
    }
})
```

```javascript
await q.subscribe({ noAck: false, args: { "x-stream-offset": 950 } }, async (msg) => {
    try {
      console.log(`[📤] Message received (${++counter})`, msg.bodyToString())
    } catch (error) {
      console.error(error)
    }
  })
```

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

### Check LavinMQ Version

Source: https://lavinmq.com/documentation/installation-guide

Checks the installed LavinMQ version using the command-line interface.

```bash
lavinmq -v
```

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

### LavinMQ CLI Tools

Source: https://lavinmq.com/documentation/introduction-node

This section covers the command-line interface tools provided by LavinMQ, specifically 'lavinmqperf' for performance testing and 'lavinmqctl' for management and control operations.

```bash
lavinmqperf
lavinmqctl
```

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

### Upgrade LavinMQ on Debian/Ubuntu

Source: https://lavinmq.com/documentation/installation-guide

Upgrades LavinMQ on Debian/Ubuntu systems by updating the package list and installing the latest version of the lavinmq package.

```bash
sudo apt update
sudo apt install lavinmq
```

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

### Testing Consumer and Producer

Source: https://lavinmq.com/documentation/introduction-ruby

Instructions for testing the LavinMQ consumer and producer applications. It involves running the consumer in one terminal and the producer in another, then observing the output to ensure messages are exchanged correctly.

```bash
-> ruby hello_world_consumer.rb
[✅] Connection over channel established
[❎] Waiting for messages. To exit press CTRL+C 
[📤] Message received [1]: Hello World - 1
[📤] Message received [2]: Hello World - 2
```

```bash
-> ruby hello_world_producer.rb
[✅] Connection over channel established
[📥] Message sent to queue - msg:  Hello World - 1
[📥] Message sent to queue - msg:  Hello World - 2
[📥] Message sent to queue - msg:  Hello World - 3
[❎] Connection closed
```

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

### Restart LavinMQ Service

Source: https://lavinmq.com/documentation/installation-guide

This command restarts the LavinMQ service. It is commonly used on Debian/Ubuntu systems where LavinMQ is installed as a service. Ensure you have the necessary sudo privileges to execute this command.

```bash
sudo service lavinmq restart
```

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

### Upgrade LavinMQ with Docker Compose

Source: https://lavinmq.com/documentation/installation-guide

Upgrades LavinMQ when running with Docker Compose. This involves pulling the latest image and restarting the containers.

```bash
docker-compose pull
docker-compose up -d
```

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

### Require Gems and Load Environment Variables in Ruby

Source: https://lavinmq.com/documentation/introduction-ruby

This snippet demonstrates how to import necessary libraries (amqp-client and dotenv) and load the LavinMQ connection URL from a .env file. It's the initial setup for a Ruby application interacting with LavinMQ.

```ruby
require "amqp-client"
require "dotenv/load"

# Grab lavinmq url from .env file
lavinmq_url = ENV['CLOUDAMQP_URL']
```

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

### Establish LavinMQ Connection in Ruby

Source: https://lavinmq.com/documentation/introduction-ruby

This code snippet shows how to establish a connection to the LavinMQ server using the loaded connection URL. It utilizes the AMQP::Client from the amqp-client gem to create and connect.

```ruby
# Opens and establishes a connection
connection = AMQP::Client.new(lavinmq_url).connect
```

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

### Python Hello World Producer and Consumer

Source: https://lavinmq.com/documentation/introduction-python

This snippet demonstrates the creation of a basic producer and consumer application using Python and the Pika library to interact with LavinMQ. It covers setting up the Python environment and writing the code for both publishing and consuming messages.

```Python
# Producer code would go here
# Example: publishing a message to LavinMQ
# import pika
# connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
# channel = connection.channel()
# channel.queue_declare(queue='hello')
# channel.basic_publish(exchange='', routing_key='hello', body='Hello World!')
# print(" [x] Sent 'Hello World!'")
# connection.close()
```

```Python
# Consumer code would go here
# Example: consuming a message from LavinMQ
# import pika
# connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
# channel = connection.channel()
# channel.queue_declare(queue='hello')
# def callback(ch, method, properties, body):
#     print(f" [x] Received {body}")
# channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=True)
# print(' [*] Waiting for messages. To exit press CTRL+C')
# channel.start_consuming()
```

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

### Upgrade LavinMQ on OS X / brew

Source: https://lavinmq.com/documentation/installation-guide

Upgrades LavinMQ on macOS using Homebrew. It first updates Homebrew and then upgrades the lavinmq formula.

```bash
brew update
brew upgrade cloudamqp/cloudamqp/lavinmq
```

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

### LavinMQ Producer Example (Node.js)

Source: https://lavinmq.com/documentation/introduction-node

This Node.js script acts as a producer for LavinMQ. It establishes a connection, creates a queue, and publishes messages to it. It uses the '@cloudamqp/amqp-client' library and dotenv for configuration. The producer sends messages with a 'hello_world' routing key and also demonstrates sending a message with a different routing key.

```javascript
//Dependencies
import { AMQPClient } from '@cloudamqp/amqp-client'
import {} from 'dotenv/config'

const cloudAMQPURL = process.env.CLOUDAMQP_URL

async function startProducer() {
  try {
    //Setup a connection to the LavinMQ server
    const connection = new AMQPClient(cloudAMQPURL)
    await connection.connect()
    const channel = await connection.channel()

    console.log("[✅] Connection over channel established")

    await channel.queue('hello_world', {durable: false})

    //Publish a message to the exchange
    async function sendToQueue(routingKey, body) {
      await channel.basicPublish("", routingKey, body)
      console.log("[📥] Message sent to queue", body)
    }

    //Send some messages to the queue
    sendToQueue("hello_world", "Hello World");
    sendToQueue("hello_world", "Hello World");
    sendToQueue("wrong_routing_key", "Hello World");

    setTimeout(() => {
      //Close the connection
      connection.close()
      console.log("[❎] Connection closed")
      process.exit(0)
    }, 500);
  } catch (error) {
    console.error(error)
    //Retry after 3 second
    setTimeout(() => {
      startProducer()
    }, 3000)
  }
}

startProducer()

```

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

### Run LavinMQ with Docker

Source: https://lavinmq.com/documentation/installation-guide

Runs the latest version of LavinMQ using Docker. It maps the AMQP (5672) and management (15672) ports and mounts a volume for persistent data.

```bash
docker run --rm -it -p 5672:5672 -p 15672:15672 -v /tmp/amqp:/var/lib/lavinmq cloudamqp/lavinmq
```

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

### Consume LavinMQ Stream from Beginning

Source: https://lavinmq.com/documentation/replay-with-offsets

This JavaScript snippet demonstrates how to subscribe to a LavinMQ stream and consume messages starting from the very beginning. It uses the 'first' offset value in the subscription arguments.

```javascript
await q.subscribe({ noAck: false, args: { "x-stream-offset": "first" }}, async (msg) => {
    try {
        console.log(`[📤] Message received (${++counter})`, msg.bodyToString())
    } catch (error) {
        console.error(error)
    }
})
```

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

### Testing LavinMQ Application (Bash)

Source: https://lavinmq.com/documentation/introduction-node

Instructions on how to test the LavinMQ producer and consumer applications. It involves running the consumer script in one terminal and the producer script in another. The expected output for both terminals is provided to verify successful message exchange.

```bash
In the first terminal, run your consumer application with `node hello_world_consumer.js`
In the second terminal run your producer application with: `node hello_world_producer.js`
```

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

### Python Pika Consumer Tagging and Cancellation

Source: https://lavinmq.com/documentation/consumer-cancellation

Shows how to assign a custom consumer tag when starting consumption with Pika's basic_consume method and how to subsequently cancel a consumer using its tag.

```Python
class MyAsyncConsumer:

      def __init__(self):
          self._channel = None

     def handle_message(self, _unused_channel, basic_deliver, properties, body):
         print("Handling Message")

      def start_consuming(self):
          self._channel.basic_consume("my_queue", self.handle_message), consumer_tag="my_custom_tag")


def handle_cancel(msg):
    print("Canceled")

channel.basic_cancel("my_consumer_tag")
```

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

### Python LavinMQ Consumer

Source: https://lavinmq.com/documentation/introduction-python

This Python code sets up a consumer for LavinMQ. It connects to the message broker using environment variables or a default URL, declares a 'hello_world' queue, and defines a callback function to process received messages. The consumer then starts listening for messages.

```Python
import pika
import os
import sys

url = os.environ.get('CLOUDAMQP_URL', 'amqp://guest:guest@localhost:5672/%2f')

# Create a connection
params = pika.URLParameters(url)
connection = pika.BlockingConnection(params)
print("[✅] Connection over channel established")

channel = connection.channel() # start a channel
channel.queue_declare(queue="hello_world") # Declare a queue

def callback(ch, method, properties, body):
    print(f"[✅] Received #{ body }")

channel.basic_consume(
    "hello_world",
    callback,
    auto_ack=True,
)

try:
  print("\n[❎] Waiting for messages. To exit press CTRL+C \n")
  channel.start_consuming()
except Exception as e:
  print(f"Error: #{e}")
  try:
    sys.exit(0)
  except SystemExit:
    os._exit(0)
```

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

### Set Max Queue Bytes Policy with HTTP API

Source: https://lavinmq.com/documentation/queue-length-limit

This example uses `curl` to set a policy named 'WatchDogLimit' for all queues starting with 'watchdog'. It limits the queue size to 1 MB and configures the overflow behavior to 'drop-head', meaning older messages are removed when the limit is reached. The policy also includes priority and specifies it applies only to queues.

```bash
curl -XPUT -u USERNAME:PWD --header "Content-Type: application/json"
--data ‘{"pattern":"^watchdog", "definition":{"max-length-bytes":1000, "overflow":"drop-head"}, "apply-to":"queues","priority":1}’ http://{AvMQ_HOSTNAME:15672}/api/policies/{VHOST}/WatchDogLimit
```

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

### Ruby LavinMQ Consumer

Source: https://lavinmq.com/documentation/introduction-ruby

This Ruby code snippet shows how to establish a connection to LavinMQ, consume messages from the 'hello_world' queue, and process each message. It includes logic to increment a counter and print received messages. The script also ensures the connection is closed upon exit and keeps the consumer running.

```ruby
channel.basic_consume("hello_world") do |msg|
  counter += 1
  # Add logic to handle the message here...
  puts "[📤] Message received [#{counter}]: #{msg.body}"
end

# Close the connection when the script exits
at_exit do 
  client.stop
  puts "[❎] Connection closed"
end

# Keep the consumer running
sleep
```

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

### Python: Publish Message to LavinMQ Queue

Source: https://lavinmq.com/documentation/introduction-python

Defines a function to publish messages to a specified queue with a given routing key. It then demonstrates publishing three 'Hello World' messages and closing the connection.

```python
def send_to_queue(channel, routing_key, body):
  channel.basic_publish(
      exchange='',
      routing_key=routing_key,
      body=body
  )
  print(f"[📥] Message sent to queue - msg:  #{body}")
```
Tokens:
Raw