due Game Server Framework

The framework uses a unified packet format: size + header + route + seq + message.

Data Packet Structure

• size (4 bytes): Fixed length indicating packet size.
• header (1 byte):
  • h (1 bit): Heartbeat flag. %x0 for data packets, %x1 for heartbeat packets.
  • extcode (7 bits): Extended operation code.
• route (1, 2, or 4 bytes): Message routing. Defaults to 2 bytes (configurable via packet.routeBytes). Heartbeat packets do not have a route.
• seq (0, 1, 2, or 4 bytes): Message sequence number. Defaults to 2 bytes (configurable via packet.seqBytes). Used for request/response confirmation. Heartbeat packets do not have a seq.
• message data (n bytes): The actual payload.

Heartbeat Packet Structure

• size (4 bytes)
• header (1 byte)
• extcode (7 bits)
• heartbeat time (8 bytes): Server time in nanoseconds (ns). This is automatically handled by the network layer.

To implement file-based configuration in your application, follow these steps:

1. Initialize the Global Configurator: In your init() function, use config.SetConfigurator with a new configurator that includes file.NewSource().
2. Store/Update Configuration: Use config.Store(ctx, name, filepath, data) to write or update configuration values. The data parameter is a map[string]any.
3. Retrieve Configuration: Use config.Get(key, defaultValue) to fetch values. The returned value can be cast to specific types (e.g., .String()).

Important: When performing rapid updates and reads, allow a small delay (e.g., time.Sleep) to ensure file system synchronization/hot-updates are processed.

package main

import (
    "context"
    "github.com/dobyte/due/v2/config"
    "github.com/dobyte/due/v2/config/file"
    "github.com/dobyte/due/v2/log"
    "time"
)

func init() {
    // Set the global configurator with the file source
    config.SetConfigurator(config.NewConfigurator(config.WithSources(file.NewSource())))
}

func main() {
    var (
        ctx      = context.Background()
        name     = file.Name
        filepath = "config.toml"
    )

    // Update/Store configuration
    if err := config.Store(ctx, name, filepath, map[string]any{
        "timezone": "Local",
    }); err != nil {
        log.Errorf("store config failed: %v", err)
        return
    }

    time.Sleep(5 * time.Millisecond)

    // Read configuration
    timezone := config.Get("config.timezone", "UTC").String()
    log.Infof("timezone: %s", timezone)

    // Update configuration again
    if err := config.Store(ctx, name, filepath, map[string]any{
        "timezone": "UTC",
    }); err != nil {
        log.Errorf("store config failed: %v", err)
        return
    }

    time.Sleep(5 * time.Millisecond)

    // Read updated configuration
    timezone = config.Get("config.timezone", "UTC").String()
    log.Infof("timezone: %s", timezone)
}

To use Consul as a configuration source, initialize the global configurator in your init() function using config.WithSources(consul.NewSource()).

Once initialized, you can use config.Store to save configurations to Consul and config.Get to retrieve them. The Consul source supports hot-reloading, multiple formats (JSON, YAML, TOML, XML), and cluster-wide hot updates.

package main

import (
    "context"
    "github.com/dobyte/due/config/consul/v2"
    "github.com/dobyte/due/v2/config"
    "github.com/dobyte/due/v2/log"
    "time"
)

func init() {
    // Set the global configurator with Consul as a source
    config.SetConfigurator(config.NewConfigurator(config.WithSources(consul.NewSource())))
}

func main() {
    var (
        ctx  = context.Background()
        file = "config.toml"
        name = consul.Name
    )

    // Store/Update configuration in Consul
    if err := config.Store(ctx, name, file, map[string]any{
        "timezone": "Local",
    }); err != nil {
        log.Errorf("store config failed: %v", err)
        return
    }

    time.Sleep(5 * time.Millisecond)

    // Read configuration
    timezone := config.Get("config.timezone", "UTC").String()
    log.Infof("timezone: %s", timezone)
}