STOMP

package main

import (
	"fmt"
	"log"
	"os"

	"github.com/go-stomp/stomp/v3"
)

func stompURL() string {
	if v := os.Getenv("KUBEMQ_STOMP_URL"); v != "" {
		return v
	}
	return "tcp://localhost:61613"
}

func main() {
	// The scheme in KUBEMQ_STOMP_URL selects the transport; strip it for net.Dial.
	addr := stompURL()[len("tcp://"):]
	const destination = "/queue/orders/new" // Queues pattern, channel "orders.new"

	// CONNECT: accept-version 1.2, default heart-beat, no-auth.
	conn, err := stomp.Dial("tcp", addr,
		stomp.ConnOpt.AcceptVersion(stomp.V12),
		stomp.ConnOpt.Login("my-app", ""))
	if err != nil {
		log.Fatalf("connect: %v", err)
	}
	defer conn.Disconnect() //nolint:errcheck

	// SEND one message; the receipt blocks until KubeMQ accepts the frame.
	if err := conn.Send(destination, "text/plain",
		[]byte("hello from STOMP"), stomp.SendOpt.Receipt); err != nil {
		log.Fatalf("send: %v", err)
	}
	fmt.Printf("sent 1 message to %s (channel orders.new)\n", destination)
}

import os

import stomp


def stomp_endpoint() -> tuple[str, int]:
    url = os.environ.get("KUBEMQ_STOMP_URL", "tcp://localhost:61613")
    host_port = url.split("://", 1)[1]
    host, port = host_port.split(":", 1)
    return host, int(port)


def main() -> None:
    destination = "/queue/orders/new"  # Queues pattern, channel "orders.new"
    host, port = stomp_endpoint()

    # CONNECT: accept-version 1.2, default heart-beat, no-auth.
    conn = stomp.Connection([(host, port)], heartbeats=(10000, 10000))
    conn.connect(login="my-app", passcode="", wait=True)
    try:
        conn.send(destination=destination, body="hello from STOMP",
                  content_type="text/plain")
        print(f"sent 1 message to {destination} (channel orders.new)")
    finally:
        conn.disconnect()


if __name__ == "__main__":
    main()

import java.net.URI;

import org.springframework.messaging.simp.stomp.StompHeaders;
import org.springframework.messaging.simp.stomp.StompSession;
import org.springframework.messaging.simp.stomp.StompSessionHandlerAdapter;
import org.springframework.messaging.tcp.reactor.ReactorNettyTcpClient;
import org.springframework.web.socket.messaging.WebSocketStompClient;
import org.springframework.messaging.simp.stomp.ReactorNettyTcpStompClient;

public final class Main {
    public static void main(String[] args) throws Exception {
        String url = System.getenv().getOrDefault("KUBEMQ_STOMP_URL", "tcp://localhost:61613");
        URI uri = URI.create(url);
        String destination = "/queue/orders/new"; // Queues pattern, channel "orders.new"

        // CONNECT over raw TCP; Spring negotiates STOMP 1.2 by default.
        ReactorNettyTcpStompClient client =
                new ReactorNettyTcpStompClient(uri.getHost(), uri.getPort());
        StompSession session =
                client.connect(new StompSessionHandlerAdapter() {}).get();

        StompHeaders headers = new StompHeaders();
        headers.setDestination(destination);
        headers.add("content-type", "text/plain");
        session.send(headers, "hello from STOMP".getBytes());
        System.out.printf("sent 1 message to %s (channel orders.new)%n", destination);

        session.disconnect();
        client.shutdown();
    }
}

import { connect, type Client } from "stompit";

function endpoint(): { host: string; port: number } {
  const url = new URL(process.env["KUBEMQ_STOMP_URL"] ?? "tcp://localhost:61613");
  return { host: url.hostname, port: Number(url.port) || 61613 };
}

async function main(): Promise<void> {
  const destination = "/queue/orders/new"; // Queues pattern, channel "orders.new"
  const { host, port } = endpoint();

  // CONNECT over raw TCP — stompit, NOT @stomp/stompjs (which is WebSocket-only).
  const client: Client = await new Promise((resolve, reject) => {
    connect({ host, port, connectHeaders: { "accept-version": "1.2",
      "heart-beat": "10000,10000", login: "my-app" } },
      (err, c) => (err ? reject(err) : resolve(c)));
  });

  const frame = client.send({ destination, "content-type": "text/plain" });
  frame.write("hello from STOMP");
  frame.end();
  console.log(`sent 1 message to ${destination} (channel orders.new)`);

  client.disconnect();
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

using System.Text;
using Stomp.Net;

static string BrokerUri()
{
    var url = Environment.GetEnvironmentVariable("KUBEMQ_STOMP_URL") ?? "tcp://localhost:61613";
    var u = new Uri(url);
    // Stomp.Net dispatches on the outer scheme: tcp:// or ssl://.
    var transport = u.Scheme == "tls" ? "ssl" : "tcp";
    return $"{transport}://{u.Host}:{(u.Port > 0 ? u.Port : 61613)}";
}

const string destination = "/queue/orders/new"; // Queues pattern, channel "orders.new"

// CONNECT: Stomp.Net performs the STOMP 1.2 handshake; no-auth default.
var factory = new ConnectionFactory(BrokerUri(), new StompConnectionSettings());
using var connection = factory.CreateConnection();
connection.Start();
using var session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
using var producer = session.CreateProducer(session.GetQueue(destination));

var message = session.CreateBytesMessage(Encoding.UTF8.GetBytes("hello from STOMP"));
message.StompType = "text/plain";
producer.Send(message);
Console.WriteLine($"sent 1 message to {destination} (channel orders.new)");

require "stomp"
require "uri"

uri = URI.parse(ENV.fetch("KUBEMQ_STOMP_URL", "tcp://localhost:61613"))
destination = "/queue/orders/new" # Queues pattern, channel "orders.new"

# CONNECT: accept-version 1.2, default heart-beat, no-auth.
client = Stomp::Client.new(
  hosts: [{ host: uri.host, port: uri.port }],
  connect_headers: { "accept-version" => "1.2", "heart-beat" => "10000,10000",
                     "login" => "my-app", "passcode" => "" },
)

client.publish(destination, "hello from STOMP", { "content-type" => "text/plain" })
puts "sent 1 message to #{destination} (channel orders.new)"
client.close

use async_stomp::client::Connector;
use async_stomp::ToServer;
use futures::SinkExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = std::env::var("KUBEMQ_STOMP_URL").unwrap_or_else(|_| "tcp://localhost:61613".into());
    let host_port = url.split("://").nth(1).unwrap_or("localhost:61613");
    let destination = "/queue/orders/new"; // Queues pattern, channel "orders.new"

    // CONNECT over raw TCP; async-stomp negotiates STOMP 1.2.
    let mut conn = Connector::builder()
        .server(host_port)
        .login("my-app".to_string())
        .passcode(String::new())
        .connect()
        .await?;

    conn.send(ToServer::Send {
        destination: destination.to_string(),
        transaction: None,
        headers: Some(vec![("content-type".to_string(), "text/plain".to_string())]),
        body: Some(b"hello from STOMP".to_vec()),
    })
    .await?;
    println!("sent 1 message to {destination} (channel orders.new)");

    conn.send(ToServer::Disconnect { receipt: None }).await?;
    Ok(())
}