# babuza-transport

> Use for configuring network transport (TCP, HTTP, gRPC) and TLS. Triggers on:
raft transport, babuza network, grpc transport, tcp transport, http transport,  babuza tls

- Author: Chen Chunchieh
- Repository: fanaujie/babuza-skills
- Version: 20260126153848
- Stars: 0
- Forks: 0
- Last Updated: 2026-02-06
- Source: https://github.com/fanaujie/babuza-skills
- Web: https://mule.run/skillshub/@@fanaujie/babuza-skills~babuza-transport:20260126153848

---

---
name: babuza-transport
description: |
  Use for configuring network transport (TCP, HTTP, gRPC) and TLS. Triggers on:
  raft transport, babuza network, grpc transport, tcp transport, http transport,  babuza tls
---

# 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`.

```go
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.

```go
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

```go
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:

```go
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

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