# Minimal required flags
./alosdb --username admin --password secret

# Custom data directory and database name
./alosdb --username admin --password secret \
    --data-path /var/lib/alosdb \
    --db-name myapp \
    --port 0.0.0.0:6900

# Enable compaction with aggressive settings
./alosdb --username admin --password secret \
    --compaction \
    --compact-interval 120 \
    --compact-stale-ratio 0.2 \
    --compact-parallel 2

# Node 1 — Primary
./alosdb --username admin --password secret \
    --port 0.0.0.0:6900 \
    --cluster \
    --cluster-port 6901

# Node 2 — Replica
./alosdb --username admin --password secret \
    --port 0.0.0.0:6900 \
    --cluster \
    --cluster-port 6901 \
    --cluster-bandwidth-mb 100

# Enable web panel on port 8080
./alosdb --username admin --password secret \
    --webpanel-port 8080 \
    --webpanel-pass mypanelpassword \
    --webpanel-key mysecretencryptionkey123

db, err := alosdbclient.Connect("localhost:6900",
    alosdbclient.WithCredentials("admin", "secret"),
    alosdbclient.WithDatabase("myapp"),
    alosdbclient.WithTimeout(5 * time.Second),
    alosdbclient.WithBatchSize(50),
    alosdbclient.WithFlushInterval(2 * time.Millisecond),
)

cfg := alosdbclient.DefaultClientConfig("localhost:6900")
cfg.Username = "admin"
cfg.Password = "secret"
cfg.PoolSize = 20
cfg.RequestTimeout = 10 * time.Second

db, err := alosdbclient.ConnectWithConfig(cfg)

# Production server
./alosdb \
    --username $ALOSDB_USER \
    --password $ALOSDB_PASS \
    --port 0.0.0.0:6900 \
    --data-path /var/lib/alosdb \
    --db-name production \
    --sync-mode sync \
    --shards 256 \
    --cache-mb 1024 \
    --compression 1 \
    --compaction \
    --compact-interval 180 \
    --compact-stale-ratio 0.25 \
    --compact-parallel 2 \
    --webpanel-port 8080 \
    --webpanel-pass $PANEL_PASS \
    --webpanel-key $PANEL_KEY

# Start server (all defaults)
./alosdb --username dev --password dev

# Connect from Go
# go get github.com/guno1928/alosdbclient

db, _ := alosdbclient.Connect("localhost:6900",
    alosdbclient.WithCredentials("dev", "dev"),
)
defer db.Close()

// Ready to use
coll := db.Collection("test")
coll.InsertOne(alosdbclient.Document{"hello": "world"})

config := alos.DefaultConfig("mydb")

fmt.Printf("shards=%d cache=%dMB sync=%v\n",
    config.NumShards,
    config.HotCacheMemoryMB,
    config.SyncMode,
)

config := alos.DefaultConfig("analytics")
config.DataPath = "/srv/alos/analytics"
config.HotCacheMemoryMB = 2048
config.NumShards = 256
config.PreFetchNeighbors = 16
config.MaxWriteDocsPerSec = 50000
config.Debug = false

db, err := alos.Open(config)

// Throughput-oriented default
fast := alos.DefaultConfig("events")
fast.SyncMode = alos.SyncAsync

// Stricter durability
strict := alos.DefaultConfig("ledger")
strict.SyncMode = alos.SyncSync

config := alos.DefaultConfig("write-heavy")
config.WorkerThresholds = []alos.WorkerThreshold{
    {QueueSize: 0, Workers: 16},
    {QueueSize: 250, Workers: 64},
    {QueueSize: 2000, Workers: 256},
    {QueueSize: 8000, Workers: 768},
}

config := alos.DefaultConfig("archive")
config.Compaction = alos.DefaultCompactionConfig()
config.Compaction.Interval = 600
config.Compaction.MaxParallel = 2
config.Compaction.StaleRatio = 0.40

panel := alos.DefaultWebPanelConfig()
panel.MasterPassword = os.Getenv("ALOS_PANEL_PASSWORD")
panel.EncryptionKey = os.Getenv("ALOS_PANEL_KEY")
panel.BindAddress = "127.0.0.1"
panel.Port = 8888

config := alos.DefaultConfig("ops")
config.WebPanel = panel

config := alos.DefaultConfig("remote")
config.Username = os.Getenv("ALOS_SERVER_USER")
config.Password = os.Getenv("ALOS_SERVER_PASS")

server, err := alos.StartServerAsync(":9210", config)
if err != nil {
    log.Fatal(err)
}
defer server.Stop()

config := alos.DefaultConfig("clustered")
config.Cluster = &alos.ClusterSettings{
    Enabled:         true,
    DataPort:        9310,
    SyncBandwidthMB: 128,
}

package main

import (
    "log"
    "os"

    "alosdb/pkg/alos"
)

func main() {
    config := alos.DefaultConfig("production")
    config.DataPath = "/srv/alos/production"
    config.NumShards = 256
    config.HotCacheMemoryMB = 4096
    config.PreFetchNeighbors = 16
    config.SyncMode = alos.SyncAsync
    config.CompressionLevel = 1
    config.Username = os.Getenv("ALOS_SERVER_USER")
    config.Password = os.Getenv("ALOS_SERVER_PASS")

    config.Compaction = alos.DefaultCompactionConfig()
    config.Compaction.Interval = 600
    config.Compaction.MaxParallel = 2

    panel := alos.DefaultWebPanelConfig()
    panel.Port = 8888
    panel.MasterPassword = os.Getenv("ALOS_PANEL_PASSWORD")
    panel.EncryptionKey = os.Getenv("ALOS_PANEL_KEY")
    config.WebPanel = panel

    config.Cluster = &alos.ClusterSettings{
        Enabled:         true,
        DataPort:        9310,
        SyncBandwidthMB: 128,
    }

    server, err := alos.StartServerAsync(":9210", config)
    if err != nil {
        log.Fatal(err)
    }
    defer server.Stop()

    select {}
}