Files
zooqueenandHanzo Dev ad6662859d chore: stop shipping 121 MB of someone's macOS binaries
Seven compiled executables were committed to the repo:

  stress                                              33 MB
  s3-rdma-sidecar/demo-server                         23 MB
  s3-rdma-sidecar/sidecar                             22 MB
  test/kafka/kafka-client-loadtest/loadtest           18 MB
  test/kafka/simple-consumer/simple-consumer           9 MB
  test/kafka/simple-publisher/simple-publisher         9 MB
  test/kafka/kafka-client-loadtest/tools/simple-test   9 MB

Every one is a Mach-O arm64 executable — a local macOS build, on a repo whose
fleet is linux/amd64, so nothing could run them anyway. They are build outputs
with their source sitting beside them; each of those packages still builds, which
is the proof they were outputs rather than inputs. Nothing references them
pre-built (the `stress:` Makefile targets are test targets, not this file).

.gitignore did not cover them, which is why they came back. It also still named
the pre-rebrand path — /seaweedfs-rdma-sidecar/bin, for a directory now called
s3-rdma-sidecar — so it was ignoring nothing at all. Both fixed.

This trims the checkout every clone and every CI job pays for. The blobs stay in
history; removing them there is a rewrite, and this repo has already been through
one — not worth a second without a reason better than disk.

Verified: the affected packages build; vet 0 findings, 26 packages ok, 0 failures.

Co-authored-by: Hanzo Dev <[email protected]>
2026-07-28 00:17:56 -07:00
..

Simple Kafka-Go Publisher for HanzoMQ

This is a simple publisher client that demonstrates publishing raw messages to HanzoMQ topics with "_" prefix, which bypass schema validation.

Features

  • Schema-Free Publishing: Topics with "_" prefix don't require schema validation
  • Raw Message Storage: Messages are stored in a "value" field as raw bytes
  • Multiple Message Formats: Supports JSON, binary, and empty messages
  • Kafka-Go Compatible: Uses the popular kafka-go library

Prerequisites

  1. HanzoMQ Running: Make sure HanzoMQ is running on localhost:17777 (default Kafka port)
  2. Go Modules: The project uses Go modules for dependency management

Setup and Run

# Navigate to the publisher directory
cd test/kafka/simple-publisher

# Download dependencies
go mod tidy

# Run the publisher
go run main.go

Expected Output

Publishing messages to topic '_raw_messages' on broker 'localhost:17777'
Publishing messages...
- Published message 1: {"id":1,"message":"Hello from kafka-go client",...}
- Published message 2: {"id":2,"message":"Raw message without schema validation",...}
- Published message 3: {"id":3,"message":"Testing SMQ with underscore prefix topic",...}

Publishing different raw message formats...
- Published raw message 1: key=binary_key, value=Simple string message
- Published raw message 2: key=json_key, value={"raw_field": "raw_value", "number": 42}
- Published raw message 3: key=empty_key, value=
- Published raw message 4: key=, value=Message with no key

All test messages published to topic with '_' prefix!
These messages should be stored as raw bytes without schema validation.

Topic Naming Convention

  • Schema-Required Topics: user-events, orders, payments (require schema validation)
  • Schema-Free Topics: _raw_messages, _logs, _metrics (bypass schema validation)

The "_" prefix tells HanzoMQ to treat the topic as a system topic and skip schema processing entirely.

Message Storage

For topics with "_" prefix:

  • Messages are stored as raw bytes without schema validation
  • No Confluent Schema Registry envelope is required
  • Any binary data or text can be published
  • SMQ assumes raw messages are stored in a "value" field internally

Integration with HanzoMQ

This client works with HanzoMQ's existing schema bypass logic:

  1. isSystemTopic() function identifies "_" prefix topics as system topics
  2. produceSchemaBasedRecord() bypasses schema processing for system topics
  3. Raw storage via hanzoMQHandler.ProduceRecord() stores messages as-is

Use Cases

  • Log ingestion: Store application logs without predefined schema
  • Metrics collection: Publish time-series data in various formats
  • Raw data pipelines: Process unstructured data before applying schemas
  • Development/testing: Quickly publish test data without schema setup