Babuza Transport Skill

Package: github.com/fanaujie/babuza/pkg/transport

Pluggable network transport layer for Raft message and snapshot communication.

You are an expert at configuring babuza networking. Help users by:

•Writing code: Configure TCP/HTTP/gRPC transports and TLS.
•Answering questions: Explain chunked snapshot transfer and transport protocols.

Documentation

Refer to the local files for detailed API:

•./references/transport-api.md - Transport interfaces, options, and TLS config.

Key Patterns

1. Configuring Transport via Builder

The easiest way to set up transport is using the BabuzaComponentBuilder.

import (
    "github.com/fanaujie/babuza/pkg/builder"
)

func buildComponent() *builder.BabuzaComponent {
    return builder.NewBabuzaComponentBuilder(&builder.BabuzaComponentConfig{
        ClusterId:      1,
        StorageRootDir: "/tmp/babuza",

        // Select Transport Type
        TransportType: builder.HttpTransport,  // or TcpTransport, GrpcTransport

        // Other required fields
        WalType:      builder.BabuzaWal,
        SessionType:  builder.NoOpSession,
        SnapshotType: builder.DurableSnapshot,
    }).Build()
}

2. Transport with TLS

Enable TLS for secure cluster communication.

import (
    "github.com/fanaujie/babuza/ibabuza"
    "github.com/fanaujie/babuza/pkg/builder"
)

func buildSecureTransport() *builder.BabuzaComponent {
    return builder.NewBabuzaComponentBuilder(&builder.BabuzaComponentConfig{
        ClusterId:      1,
        StorageRootDir: "/tmp/babuza",
        TransportType:  builder.TcpTransport,
        WalType:        builder.BabuzaWal,
        SessionType:    builder.NoOpSession,
        SnapshotType:   builder.DurableSnapshot,

        // TLS Configuration (embedded in BabuzaComponentConfig)
        // Note: TLSConfig fields are directly in the config struct
    }).Build()
}

3. Full Example with Raft

import (
    "github.com/fanaujie/babuza/pkg/builder"
    "github.com/fanaujie/babuza/raft"
)

func startNode(stateMachine ibabuza.BaseStateMachine) (*raft.Raft, error) {
    // Build components with HTTP transport
    component := builder.NewBabuzaComponentBuilder(&builder.BabuzaComponentConfig{
        ClusterId:      1,
        StorageRootDir: "/tmp/node1",
        TransportType:  builder.HttpTransport,
        WalType:        builder.BabuzaWal,
        SessionType:    builder.NoOpSession,
        SnapshotType:   builder.DurableSnapshot,
    }).Build()

    cfg := raft.DefaultBabuzaConfig(1, 1, "127.0.0.1:9001")

    peers := raft.NewPeersConfiguration()
    peers.AddPeer(1, "127.0.0.1:9001", false)

    bootstrap, err := raft.NewBootstrapRaftCluster(
        cfg, *peers, stateMachine,
        component.Cluster, component.RaftNode, component.SessionManager,
        component.SnapshotManager, component.WalManager, component.Transport,
        component.Logger, component.MetricsController,
    )
    if err != nil {
        return nil, err
    }

    return raft.NewRaft(cfg, bootstrap, nil)
}

Transport Types

Type	Builder Constant	Description
TCP	`builder.TcpTransport`	Raw TCP with length-prefixed messages. Low overhead.
TCP Memory	`builder.TcpMemoryTransport`	In-memory TCP for testing. No network I/O.
HTTP	`builder.HttpTransport`	HTTP/1.1 REST-like transport. Good for firewall traversal.
gRPC	`builder.GrpcTransport`	gRPC streaming transport. Good for interop.

When to Use Each Transport

Scenario	Recommended
Internal cluster, low latency	TCP
Cross-datacenter, firewalls	HTTP
Polyglot environment	gRPC
Testing/Development	TCP Memory

BabuzaComponent Fields

After calling Build(), the component contains:

type BabuzaComponent struct {
    Cluster           ibabuza.Cluster
    RaftNode          ibabuza.RaftNode
    SessionManager    ibabuza.SessionManager
    SnapshotManager   ibabuza.SnapshotManager
    WalManager        ibabuza.WalManager
    Transport         ibabuza.Transport  // The configured transport
    Logger            ibabuza.Logger
    MetricsController ibabuza.MetricsCollector
}

When Answering Questions

•Snapshots: Explain that Babuza uses chunked snapshot transfer, allowing large snapshots to be sent without high memory usage.
•TLS: For production, enable TLS. Mutual TLS (mTLS) requires both client and server certificates.
•Performance: TCP is generally preferred for internal cluster communication due to lower overhead than HTTP. HTTP is useful when traversing firewalls or load balancers.
•Port: Each node needs to expose its Raft transport port for peer communication.