Kilo

https://github.com/squat/kilo
Admin
Kilo is a networking project likely related to Kubernetes, offering features such as multi-cluster...
Tokens:59,754
Snippets:871
Trust Score:9.8
License:Apache-2.0
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install Flect

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/gobuffalo/flect/README.md

Install the flect package using go get.

```console
go get github.com/gobuffalo/flect
```

--------------------------------

### Install go-isatty Package

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/mattn/go-isatty/README.md

Install the go-isatty package using the go get command. This command fetches and installs the package and its dependencies.

```bash
go get github.com/mattn/go-isatty
```

--------------------------------

### Install wgctrl Package

Source: https://github.com/squat/kilo/blob/main/vendor/golang.zx2c4.com/wireguard/wgctrl/README.md

Install the wgctrl package using go get.

```text
go get golang.zx2c4.com/wireguard/wgctrl
```

--------------------------------

### Install Go Color Package

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/fatih/color/README.md

Install the color package using go get.

```bash
go get github.com/fatih/color
```

--------------------------------

### Install Cobra Library

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/spf13/cobra/README.md

Use 'go get' to install the latest version of the Cobra library.

```go
go get -u github.com/spf13/cobra@latest
```

--------------------------------

### Install json-iterator/go

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/json-iterator/go/README.md

Install the json-iterator/go library using the go get command.

```go
go get github.com/json-iterator/go
```

--------------------------------

### Install and Import YAML Package

Source: https://github.com/squat/kilo/blob/main/vendor/sigs.k8s.io/yaml/README.md

Install the package using go get and import it in your Go programs.

```bash
$ go get sigs.k8s.io/yaml
```

```go
import "sigs.k8s.io/yaml"
```

--------------------------------

### Install go-colorable Package

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/mattn/go-colorable/README.md

Standard Go installation command for the go-colorable package.

```bash
$ go get github.com/mattn/go-colorable
```

--------------------------------

### Install uuid Package

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/google/uuid/README.md

Installs the uuid package using the go get command.

```sh
go get github.com/google/uuid
```

--------------------------------

### Start Local Development Server

Source: https://github.com/squat/kilo/blob/main/website/README.md

Starts a local development server for live preview. Changes are reflected without restarting.

```bash
yarn start
```

--------------------------------

### Install TOML Parser

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/BurntSushi/toml/README.md

Install the TOML parser library for Go using the go get command. Requires Go 1.13 or newer.

```bash
$ go get github.com/BurntSushi/toml
```

--------------------------------

### Start Website Server

Source: https://github.com/squat/kilo/blob/main/docs/building_website.md

Start the local development server for the website. This command should automatically open the site in your browser.

```shell
yarn --cwd website start
```

--------------------------------

### Go Example: Create and Interact with a New Network Namespace

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/vishvananda/netns/README.md

This example demonstrates how to create a new network namespace, perform operations within it (like listing interfaces), and then switch back to the original namespace. It's crucial to lock the OS thread and defer unlocking to ensure namespace stability.

```go
package main

import (
    "fmt"
    "net"
    "runtime"

    "github.com/vishvananda/netns"
)

func main() {
    // Lock the OS Thread so we don't accidentally switch namespaces
    runtime.LockOSThread()
    defer runtime.UnlockOSThread()

    // Save the current network namespace
    origns, _ := netns.Get()
    defer origns.Close()

    // Create a new network namespace
    newns, _ := netns.New()
    defer newns.Close()

    // Do something with the network namespace
    ifaces, _ := net.Interfaces()
    fmt.Printf("Interfaces: %v\n", ifaces)

    // Switch back to the original namespace
    netns.Set(origns)
}

```

--------------------------------

### Install kgctl using Go Toolchain

Source: https://github.com/squat/kilo/blob/main/docs/kgctl.md

Installs the latest version of the kgctl binary using the Go toolchain. Ensure the Go toolchain is installed.

```shell
go install github.com/squat/kilo/cmd/kgctl@latest
```

--------------------------------

### Retrieve Network Device Statistics and Peer Index

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/safchain/ethtool/README.md

This example demonstrates how to initialize the ethtool handler, retrieve transmit statistics (tx_bytes) for 'eth0', and get the peer interface index for 'veth0'. Ensure the network interfaces exist and the program has necessary permissions.

```go
package main

import (
	"fmt"

	"github.com/safchain/ethtool"
)

func main() {
	ethHandle, err := ethtool.NewEthtool()
	if err != nil {
		panic(err.Error())
	}
	defer ethHandle.Close()

	// Retrieve tx from eth0
	stats, err := ethHandle.Stats("eth0")
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("TX: %d\n", stats["tx_bytes"])

	// Retrieve peer index of a veth interface
	stats, err = ethHandle.Stats("veth0")
	if err != nil {
		panic(err.Error())
	}
	fmt.Printf("Peer Index: %d\n", stats["peer_ifindex"])
}
```

--------------------------------

### Install Dependencies

Source: https://github.com/squat/kilo/blob/main/website/README.md

Installs project dependencies using Yarn. This is the first step before running any other commands.

```bash
yarn
```

--------------------------------

### Install kgctl using Mise

Source: https://github.com/squat/kilo/blob/main/docs/kgctl.md

Installs kgctl using the mise version manager. Updates will be installed automatically with 'mise up'.

```bash
mise use -g github:squat/kilo@latest
```

--------------------------------

### Install kgctl using Arkade CLI

Source: https://github.com/squat/kilo/blob/main/docs/kgctl.md

Installs the kgctl binary on any OS and architecture using the arkade CLI.

```shell
arkade get kgctl
```

--------------------------------

### Coexisting with glog

Source: https://github.com/squat/kilo/blob/main/vendor/k8s.io/klog/v2/README.md

Example demonstrating how to use klog and glog simultaneously. It shows flag synchronization and redirecting output to stderr.

```go
package main

import (
	"flag"
	"github.com/golang/glog"
	"k8s.io/klog/v2"
)

func main() {
	// Initialize flags for both klog and glog from the command line.
	klog.InitFlags(nil)
	glog.InitFlags()

	// Set alsologtostderr to true to combine output to stderr.
	flag.Set("alsologtostderr", "true")

	klog.Info("This is a klog message.")
	glog.Info("This is a glog message.")

	klog.Flush()
	glog.Flush()
}
```

--------------------------------

### Install YAML Package for Go

Source: https://github.com/squat/kilo/blob/main/vendor/go.yaml.in/yaml/v3/README.md

Run this command to install the yaml v3 package for your Go projects.

```bash
go get go.yaml.in/yaml/v3
```

--------------------------------

### Install Latest JSON-Patch v5

Source: https://github.com/squat/kilo/blob/main/vendor/gopkg.in/evanphx/json-patch.v4/README.md

Use this command to get the latest version of the json-patch library for Go.

```bash
go get -u github.com/evanphx/json-patch/v5
```

--------------------------------

### Create Root Logger with Implementation

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/go-logr/logr/README.md

Example of creating the root logger in an application's main function, choosing a specific logging implementation (e.g., 'logimpl') and passing initial parameters.

```Go
func main() {
    // ... other setup code ...

    // Create the "root" logger.  We have chosen the "logimpl" implementation,
    // which takes some initial parameters and returns a logr.Logger.
    logger := logimpl.New(param1, param2)

    // ... other setup code ...
}
```

--------------------------------

### Example using TagSet and TagOptions

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/fxamacker/cbor/v2/README.md

Illustrates creating a TagSet, adding custom tag options and types, and then using this TagSet to create decoding and encoding modes for handling specific CBOR tags.

```go
// Use signedCWT struct defined in "Decoding CWT" example.

// Create TagSet (safe for concurrency).
tags := cbor.NewTagSet()
// Register tag COSE_Sign1 18 with signedCWT type.
tags.Add(    
	cbor.TagOptions{EncTag: cbor.EncTagRequired, DecTag: cbor.DecTagRequired}, 
	reflect.TypeOf(signedCWT{}), 
	18)

// Create DecMode with immutable tags.
dm, _ := cbor.DecOptions{}.DecModeWithTags(tags)

// Unmarshal to signedCWT with tag support.
var v signedCWT
if err := dm.Unmarshal(data, &v); err != nil {
	return err
}

// Create EncMode with immutable tags.
em, _ := cbor.EncOptions{}.EncModeWithTags(tags)

// Marshal signedCWT with tag number.
if data, err := em.Marshal(v); err != nil {
	return err
}
```

--------------------------------

### Install embedmd with Go

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/campoy/embedmd/README.md

Install the embedmd tool using the Go package manager. This command downloads, compiles, and installs the embedmd binary.

```bash
go get github.com/campoy/embedmd
```

--------------------------------

### Install Kilo on bootkube

Source: https://github.com/squat/kilo/blob/main/README.md

Apply the necessary CRDs and Kilo DaemonSet for bootkube installations.

```shell
kubectl apply -f https://raw.githubusercontent.com/squat/kilo/main/manifests/crds.yaml
kubectl apply -f https://raw.githubusercontent.com/squat/kilo/main/manifests/kilo-bootkube.yaml
```

--------------------------------

### Install Cobra CLI Generator

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/spf13/cobra/README.md

Install the cobra-cli command line program to generate Cobra application scaffolding.

```go
go install github.com/spf13/cobra-cli@latest
```

--------------------------------

### Install Kilo on kubeadm

Source: https://github.com/squat/kilo/blob/main/README.md

Apply the necessary CRDs and Kilo DaemonSet for kubeadm installations.

```shell
kubectl apply -f https://raw.githubusercontent.com/squat/kilo/main/manifests/crds.yaml
kubectl apply -f https://raw.githubusercontent.com/squat/kilo/main/manifests/kilo-kubeadm.yaml
```

--------------------------------

### Install kgctl using AUR Helper

Source: https://github.com/squat/kilo/blob/main/docs/kgctl.md

Installs the kgctl binary package from the Arch User Repository using an AUR helper like paru or yay.

```shell
paru -S kgctl-bin
```

--------------------------------

### Install Specific kgctl Version using Go Toolchain

Source: https://github.com/squat/kilo/blob/main/docs/kgctl.md

Installs a specific version of the kgctl binary using the Go toolchain. Specify the desired Git tag or hash.

```shell
go install github.com/squat/kilo/cmd/kgctl@0.2.0
```

--------------------------------

### Install Kilo on k3s

Source: https://github.com/squat/kilo/blob/main/README.md

Apply the necessary CRDs and Kilo DaemonSet for k3s installations.

```shell
kubectl apply -f https://raw.githubusercontent.com/squat/kilo/main/manifests/crds.yaml
kubectl apply -f https://raw.githubusercontent.com/squat/kilo/main/manifests/kilo-k3s.yaml
```

--------------------------------

### Basic WebService Definition and Route

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/emicklei/go-restful/v3/README.md

Defines a WebService with a path, consumes/produces media types, and a GET route for retrieving a user. The route includes documentation and path parameter definition.

```Go
ws := new(restful.WebService)
ws.
	Path("/users").
	Consumes(restful.MIME_XML, restful.MIME_JSON).
	Produces(restful.MIME_JSON, restful.MIME_XML)

ws.Route(ws.GET("/{user-id}").To(u.findUser).
	Doc("get a user").
	Param(ws.PathParameter("user-id", "identifier of the user").DataType("string")).
	Writes(User{}))		
...

func (u UserResource) findUser(request *restful.Request, response *restful.Response) {
	id := request.PathParameter("user-id")
	...
}
```

--------------------------------

### Install Kilo on Typhoon

Source: https://github.com/squat/kilo/blob/main/README.md

Apply the necessary CRDs and Kilo DaemonSet for Typhoon installations.

```shell
kubectl apply -f https://raw.githubusercontent.com/squat/kilo/main/manifests/crds.yaml
kubectl apply -f https://raw.githubusercontent.com/squat/kilo/main/manifests/kilo-typhoon.yaml
```

--------------------------------

### Command Line Flag Syntax Examples

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/spf13/pflag/README.md

Illustrates different ways to specify flags on the command line, including long form, shorthand, and value assignment.

```bash
--flag    // boolean flags, or flags with no option default values
--flag x  // only on flags without a default value
--flag=x
```

```bash
// boolean or flags where the 'no option default value' is set
-f
-f=true
-abc
but
-b true is INVALID

// non-boolean and flags without a 'no option default value'
-n 1234
-n=1234
-n1234

// mixed
-abcs "hello"
-absd="hello"
-abcs1234
```

--------------------------------

### Go YAML Marshal and Unmarshal Example

Source: https://github.com/squat/kilo/blob/main/vendor/go.yaml.in/yaml/v2/README.md

Demonstrates how to unmarshal YAML data into a Go struct and a map, and then marshal them back into YAML. Ensure struct fields are public for correct unmarshalling.

```Go
package main

import (
        "fmt"
        "log"

        "go.yaml.in/yaml/v2"
)

var data = `
a: Easy!
b:
  c: 2
  d: [3, 4]
`

// Note: struct fields must be public in order for unmarshal to
// correctly populate the data.
type T struct {
        A string
        B struct {
                RenamedC int   `yaml:"c"`
                D        []int `yaml:",flow"`
        }
}

func main() {
        t := T{}
    
        err := yaml.Unmarshal([]byte(data), &t)
        if err != nil {
                log.Fatalf("error: %v", err)
        }
        fmt.Printf("--- t:\n%v\n\n", t)
    
        d, err := yaml.Marshal(&t)
        if err != nil {
                log.Fatalf("error: %v", err)
        }
        fmt.Printf("--- t dump:\n%s\n\n", string(d))
    
        m := make(map[interface{}]interface{})
    
        err = yaml.Unmarshal([]byte(data), &m)
        if err != nil {
                log.Fatalf("error: %v", err)
        }
        fmt.Printf("--- m:\n%v\n\n", m)
    
        d, err = yaml.Marshal(&m)
        if err != nil {
                log.Fatalf("error: %v", err)
        }
        fmt.Printf("--- m dump:\n%s\n\n", string(d))
}

```

--------------------------------

### Install TOML Validator CLI

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/BurntSushi/toml/README.md

Install the TOML validator command-line tool. This tool can be used to validate TOML files.

```bash
$ go get github.com/BurntSushi/toml/cmd/tomlv
$ tomlv some-toml-file.toml
```

--------------------------------

### Redirecting Stdlib Logger to Go Kit JSON Logger

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/go-kit/kit/log/README.md

This example demonstrates how to redirect the standard library's logger output to a Go kit JSON logger. It uses `kitlog.NewStdlibAdapter` to bridge the two.

```go
import (
	os
	stdlog "log"
	kitlog "github.com/go-kit/kit/log"
)

func main() {
	logger := kitlog.NewJSONLogger(kitlog.NewSyncWriter(os.Stdout))
	stdlog.SetOutput(kitlog.NewStdlibAdapter(logger))
	stdlog.Print("I sure like pie")
}

// Output:
// {"msg":"I sure like pie","ts":"2016/01/01 12:34:56"}
```

--------------------------------

### Convert klog Infof to logr Info

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/go-logr/logr/README.md

Example of converting a klog.Infof call with format specifiers to a logr.Info call with key-value pairs. Use this for general informational logging where details need to be structured.

```go
logger.V(4).Info("got a retry-after response when requesting url", "attempt", retries, "after seconds", seconds, "url", url)
```

--------------------------------

### Install kube-router for Network Policy Support

Source: https://github.com/squat/kilo/blob/main/docs/network-policies.md

Installs kube-router to enable Kubernetes Network Policy functionality alongside Kilo. This is a prerequisite for applying network policies.

```shell
kubectl apply -f https://raw.githubusercontent.com/squat/kilo/main/manifests/kube-router.yaml
```

--------------------------------

### Install JSON-Patch v4

Source: https://github.com/squat/kilo/blob/main/vendor/gopkg.in/evanphx/json-patch.v4/README.md

Use this command if you specifically need version 4 of the json-patch library.

```bash
go get -u gopkg.in/evanphx/json-patch.v4
```

--------------------------------

### Install Kilo as Add-on on Typhoon with Flannel

Source: https://github.com/squat/kilo/blob/main/README.md

Apply CRDs and Kilo DaemonSet for running Kilo in add-on mode on Typhoon with Flannel.

```shell
kubectl apply -f https://raw.githubusercontent.com/squat/kilo/main/manifests/crds.yaml
kubectl apply -f https://raw.githubusercontent.com/squat/kilo/main/manifests/kilo-typhoon-flannel.yaml
```

--------------------------------

### Trace Introspection and Unconditional Logging

Source: https://github.com/squat/kilo/blob/main/vendor/k8s.io/utils/trace/README.md

Shows how to get the total elapsed time of a trace and how to log the trace unconditionally.

```go
opTrace.TotalTime() // Duration since the Trace was created
opTrace.Log() // unconditionally log the trace
```

--------------------------------

### CLI for Applying JSON Patches

Source: https://github.com/squat/kilo/blob/main/vendor/gopkg.in/evanphx/json-patch.v4/README.md

Demonstrates using the json-patch CLI tool to apply multiple patches to a JSON document provided via stdin. Requires installation of the CLI.

```json
[
    {"op": "replace", "path": "/name", "value": "Jane"},
    {"op": "remove", "path": "/height"}
]
```

```json
[
    {"op": "add", "path": "/address", "value": "123 Main St"},
    {"op": "replace", "path": "/age", "value": "21"}
]
```

```json
{
    "name": "John",
    "age": 24,
    "height": 3.21
}
```

```bash
go install github.com/evanphx/json-patch/cmd/json-patch
cat document.json | json-patch -p patch.1.json -p patch.2.json
```

--------------------------------

### Configure a Peer to Connect to a Node

Source: https://github.com/squat/kilo/blob/main/docs/kgctl.md

Use the `--as-peer` and `--output yaml` flags with `kgctl showconf` to get the configuration needed for another WireGuard interface to connect to the specified node. This is useful for inter-cluster peer registration.

```shell
NODE=master # the name of a node
kgctl --kubeconfig $KUBECONFIG1 showconf node $NODE --as-peer --output yaml | kubectl --kubeconfig $KUBECONFIG2 apply -f -
```

--------------------------------

### WireGuard Peer Configuration Output

Source: https://github.com/squat/kilo/blob/main/docs/vpn.md

Example output of the WireGuard configuration generated by `kgctl showconf peer`. This configuration is used for local WireGuard interfaces.

```ini
[Peer]
PublicKey = 2/xU029dz/WtvMZAbnSzmhicl8U1/Y3NYmunRr8EJ0Q=
AllowedIPs = 10.4.0.2/32, 10.2.3.0/24, 10.1.0.3/32
Endpoint = 108.61.142.123:51820
```

--------------------------------

### Annotate Nodes for Logical Grouping (GCP Example)

Source: https://github.com/squat/kilo/blob/main/docs/topology.md

Annotates nodes containing 'GCP' in their name with the 'kilo.squat.ai/location="gcp"' annotation. This is used to group these nodes into a logical location for Kilo's topology.

```shell
for node in $(kubectl get nodes | grep -i gcp | awk '{print $1}'); do kubectl annotate node $node kilo.squat.ai/location="gcp"; done
```

--------------------------------

### Apply Kilo PodMonitor

Source: https://github.com/squat/kilo/blob/main/docs/monitoring.md

Apply the PodMonitor configuration to monitor the Kilo DaemonSet. This requires the kube-prometheus monitoring stack to be installed.

```shell
kubectl apply -f https://raw.githubusercontent.com/squat/kilo/main/manifests/podmonitor.yaml
```

--------------------------------

### Add or Update Dependency

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/prometheus/procfs/CONTRIBUTING.md

Use 'go get' to add or update external package dependencies. This command manages versions and ensures dependencies are vendored.

```bash
# Pick the latest tagged release.
go get example.com/some/module/pkg

# Pick a specific version.
go get example.com/some/module/pkg@vX.Y.Z
```

--------------------------------

### Check if Started by Explorer

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/inconshreveable/mousetrap/README.md

This function returns true if the process was invoked by double-clicking the executable in Windows Explorer. It is useful for providing user-friendly messages to those unfamiliar with command-line tools.

```Go
func StartedByExplorer() (bool)
```

--------------------------------

### Log formatted string value with logr

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/go-logr/logr/README.md

Example of using fmt.Sprintf within a key's value in logr when a format string is absolutely necessary. This should be used sparingly.

```go
logger.Info("unable to reflect over type", "type", fmt.Sprintf("%T"))
```

--------------------------------

### Typical Application Logging with Logfmt

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/go-kit/kit/log/README.md

Demonstrates basic structured logging using the logfmt format. It initializes a logger that writes to standard error.

```go
w := log.NewSyncWriter(os.Stderr)
logger := log.NewLogfmtLogger(w)
logger.Log("question", "what is the meaning of life?", "answer", 42)

// Output:
// question="what is the meaning of life?" answer=42
```

--------------------------------

### Convert klog Infof to logr Error

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/go-logr/logr/README.md

Example of converting a klog.Infof call with format specifiers to a logr.Error call with key-value pairs. Use this when an error occurs and you need to log associated details.

```go
logger.Error(err, "client returned an error", "code", responseCode)
```

--------------------------------

### Configure Local DNS for Cluster Domain

Source: https://github.com/squat/kilo/blob/main/docs/kgctl.md

Configures the local host's DNS server to use the cluster DNS provider via the `kilo0` interface for resolving `.cluster.local` domains. This example uses `systemd-resolved`.

```shell
systemd-resolve --interface kilo0 --set-dns $(kubectl get service -n kube-system kube-dns -o=jsonpath='{.spec.clusterIP}') --set-domain cluster.local
dig kubernetes.default.svc.cluster.local +short
```

--------------------------------

### Initialize Block Device Filesystem

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/prometheus/procfs/README.md

Initializes both proc and sys filesystems to gather block device statistics.

```go
fs, err := blockdevice.NewFS("/proc", "/sys")
stats, err := fs.ProcDiskstats()
```

--------------------------------

### Build All Container Images

Source: https://github.com/squat/kilo/blob/main/docs/building_kilo.md

Build the 'kg' container image for multiple architectures (arm, arm64, amd64) using Make.

```shell
make all-container
```

--------------------------------

### Build Manifest and Push Images

Source: https://github.com/squat/kilo/blob/main/docs/building_kilo.md

Build a container manifest and push the container images to the configured registry.

```shell
make manifest
```

--------------------------------

### Initialize Procfs Filesystem

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/prometheus/procfs/README.md

Initializes the proc filesystem mount point to gather CPU statistics.

```go
fs, err := procfs.NewFS("/proc")
stats, err := fs.Stat()
```

--------------------------------

### Add a New Bridge and Add Interface to it

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/vishvananda/netlink/README.md

Demonstrates creating a new bridge interface and assigning an existing interface (eth1) to it. Requires root privileges.

```go
package main

import (
    "fmt"
    "github.com/vishvananda/netlink"
)

func main() {
    la := netlink.NewLinkAttrs()
    la.Name = "foo"
    mybridge := &netlink.Bridge{LinkAttrs: la}
    err := netlink.LinkAdd(mybridge)
    if err != nil  {
        fmt.Printf("could not add %s: %v\n", la.Name, err)
    }
    eth1, _ := netlink.LinkByName("eth1")
    netlink.LinkSetMaster(eth1, mybridge)
}

```

--------------------------------

### Contextual Loggers with Go Kit

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/go-kit/kit/log/README.md

Shows how to create contextual loggers by wrapping an existing logger with additional key/value pairs. This is useful for adding common context like instance IDs or component names.

```go
func main() {
	var logger log.Logger
	logger = log.NewLogfmtLogger(log.NewSyncWriter(os.Stderr))
	logger = log.With(logger, "instance_id", 123)

	logger.Log("msg", "starting")
	NewWorker(log.With(logger, "component", "worker")).Run()
	NewSlacker(log.With(logger, "component", "slacker")).Run()
}

// Output:
// instance_id=123 msg=starting
// instance_id=123 component=worker msg=running
// instance_id=123 component=slacker msg=running
```

--------------------------------

### Even Slice Length Validator Example

Source: https://github.com/squat/kilo/blob/main/vendor/k8s.io/apimachinery/pkg/api/validate/README.md

Example of a generic validator function that checks if a slice has an even number of items. It can be used with slices of any type.

```go
// Even validates that a slice has an even number of items.
func Even[T any](ctx context.Context, op operation.Operation, fldPath *field.Path, value, _ []T) field.ErrorList
```

--------------------------------

### Nest Traces

Source: https://github.com/squat/kilo/blob/main/vendor/k8s.io/utils/trace/README.md

Demonstrates creating a root trace and then nesting a sub-trace within it, each with its own logging threshold.

```go
func doSomething() {
    rootTrace := trace.New("rootOperation")
    defer rootTrace.LogIfLong(100 * time.Millisecond)
    
    func() {
        nestedTrace := rootTrace.Nest("nested", Field{Key: "nestedFieldKey1", Value: "nestedFieldValue1"})
        defer nestedTrace.LogIfLong(50 * time.Millisecond)
        // do nested operation
    }()
}
```

--------------------------------

### xxhash Benchmarking Commands

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/cespare/xxhash/v2/README.md

Commands to run benchmarks for xxhash, comparing pure Go and assembly implementations. Use benchstat to analyze the results.

```bash
benchstat <(go test -tags purego -benchtime 500ms -count 15 -bench 'Sum64$')
benchstat <(go test -benchtime 500ms -count 15 -bench 'Sum64$')
```

--------------------------------

### NonEmpty Validator Example

Source: https://github.com/squat/kilo/blob/main/vendor/k8s.io/apimachinery/pkg/api/validate/README.md

Example of a validator function that checks if a string value is not empty. It takes context, operation, field path, and the string value as input.

```go
// NonEmpty validates that a string is not empty.
func NonEmpty(ctx context.Context, op operation.Operation, fldPath *field.Path, value, _ *string) field.ErrorList
```

--------------------------------

### Run Go Benchmarks

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/go-openapi/swag/BENCHMARK.md

Command to execute benchmarks for the go-openapi/swag project. Use -bench XXX to specify benchmark functions and -run XXX to skip tests.

```bash
go test -bench XXX -run XXX -benchtime 30s
```

--------------------------------

### KeysMaxLen Validator Example

Source: https://github.com/squat/kilo/blob/main/vendor/k8s.io/apimachinery/pkg/api/validate/README.md

Example of a generic validator function that enforces a maximum length for all string keys in a map. It takes the map, maximum length, and other standard validator arguments.

```go
// KeysMaxLen validates that all of the string keys in a map are under the
// specified length.
func KeysMaxLen[T any](ctx context.Context, op operation.Operation, fldPath *field.Path, value, _ map[string]T, maxLen int) field.ErrorList
```

--------------------------------

### Embed content between two regular expressions

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/campoy/embedmd/README.md

Embeds content starting from the first line matching the start regular expression and ending at the first line matching the end regular expression. This allows for embedding specific code blocks or sections.

```Markdown
[embedmd]:# (pathOrURL language /start regexp/ /end regexp/)
```

--------------------------------

### Split Trace into Steps

Source: https://github.com/squat/kilo/blob/main/vendor/k8s.io/utils/trace/README.md

Creates a trace and logs it if its duration exceeds a limit. It also demonstrates how to define and log individual steps within the trace.

```go
func doSomething() {
    opTrace := trace.New("operation")
    defer opTrace.LogIfLong(100 * time.Millisecond)
    // do step 1
    opTrace.Step("step1", Field{Key: "stepFieldKey1", Value: "stepFieldValue1"})
    // do step 2
    opTrace.Step("step2")
}
```

--------------------------------

### Log to a Single File with klog

Source: https://github.com/squat/kilo/blob/main/vendor/k8s.io/klog/v2/README.md

Demonstrates how to configure klog to log to a single file using the 'log_file' flag, instead of a directory.

```go
package main

import (
	"flag"
	"k8s.io/klog/v2"
)

func main() {
	// Define and parse flags, including klog's
	logFile := flag.String("log_file", "", "Path to the log file.")
	flag.Parse()

	// Set the log file path for klog
	klog.SetLogFile(*logFile)

	// Now you can use klog for logging
	klog.Info("Logging to a single file")

	// Flush logs before exiting
	klog.Flush()
}
```

--------------------------------

### Example using Embedded JSON Tag for CBOR (tag 262)

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/fxamacker/cbor/v2/README.md

Demonstrates encoding and decoding a tagged CBOR data item with tag number 262, where the tag content is a JSON object embedded as a CBOR byte string. This example defines custom MarshalCBOR and UnmarshalCBOR methods for a Go struct to handle this specific tag.

```go
// https://github.com/fxamacker/cbor/issues/657

package cbor_test

// NOTE: RFC 8949 does not mention tag number 262. IANA assigned
// CBOR tag number 262 as "Embedded JSON Object" specified by the
// document Embedded JSON Tag for CBOR:
//
//	"Tag 262 can be applied to a byte string (major type 2) to indicate
//	that the byte string is a JSON Object. The length of the byte string
//	indicates the content."
//
// For more info, see Embedded JSON Tag for CBOR at:
// https://github.com/toravir/CBOR-Tag-Specs/blob/master/embeddedJSON.md

import (
	"bytes"
	"encoding/json"
	"fmt"

	"github.com/fxamacker/cbor/v2"
)

// cborTagNumForEmbeddedJSON is the CBOR tag number 262.
const cborTagNumForEmbeddedJSON = 262

// EmbeddedJSON represents a Go value to be encoded as a tagged CBOR data item
// with tag number 262 and the tag content is a JSON object "embedded" as a
// CBOR byte string (major type 2).
type EmbeddedJSON struct {
	any
}

func NewEmbeddedJSON(val any) EmbeddedJSON {
	return EmbeddedJSON{val}
}

// MarshalCBOR encodes EmbeddedJSON to a tagged CBOR data item with the
// tag number 262 and the tag content is a JSON object that is
// "embedded" as a CBOR byte string.
func (v EmbeddedJSON) MarshalCBOR() ([]byte, error) {
	// Encode v to JSON object.
	data, err := json.Marshal(v)
	if err != nil {
		return nil, err
	}

	// Create cbor.Tag representing a tagged CBOR data item.
	tag := cbor.Tag{
		Number:  cborTagNumForEmbeddedJSON,
		Content: data,
	}

	// Marshal to a tagged CBOR data item.
	return cbor.Marshal(tag)
}

// UnmarshalCBOR decodes a tagged CBOR data item to EmbeddedJSON.
// The byte slice provided to this function must contain a single
// tagged CBOR data item with the tag number 262 and tag content
// must be a JSON object "embedded" as a CBOR byte string.
func (v *EmbeddedJSON) UnmarshalCBOR(b []byte) error {
	// Unmarshal tagged CBOR data item.
	var tag cbor.Tag
	if err := cbor.Unmarshal(b, &tag); err != nil {
		return err
	}

	// Check tag number.
	if tag.Number != cborTagNumForEmbeddedJSON {
		return fmt.Errorf("got tag number %d, expect tag number %d", tag.Number, cborTagNumForEmbeddedJSON)
	}

	// Check tag content.
	jsonData, isByteString := tag.Content.([]byte)
	if !isByteString {
		return fmt.Errorf("got tag content type %T, expect tag content []byte", tag.Content)
	}

	// Unmarshal JSON object.
	return json.Unmarshal(jsonData, v)
}

// MarshalJSON encodes EmbeddedJSON to a JSON object.
func (v EmbeddedJSON) MarshalJSON() ([]byte, error) {
	return json.Marshal(v.any)
}

// UnmarshalJSON decodes a JSON object.
func (v *EmbeddedJSON) UnmarshalJSON(b []byte) error {
	dec := json.NewDecoder(bytes.NewReader(b))
	dec.UseNumber()
	return dec.Decode(&v.any)
}

func Example_embeddedJSONTagForCBOR() {
	value := NewEmbeddedJSON(map[string]any{
		"name": "gopher",
		"id":   json.Number("42"),
	})

	data, err := cbor.Marshal(value)
	if err != nil {
		panic(err)
	}

	fmt.Printf("cbor: %x\n", data)

	var v EmbeddedJSON
	err = cbor.Unmarshal(data, &v)
	if err != nil {
		panic(err)
	}

```

--------------------------------

### Build Website HTML

Source: https://github.com/squat/kilo/blob/main/docs/building_website.md

After generating markdown, use this command to build the website's HTML files.

```shell
make website/build/index.html
```

--------------------------------

### Create and Log Trace

Source: https://github.com/squat/kilo/blob/main/vendor/k8s.io/utils/trace/README.md

Creates a new trace with initial fields and logs it if its duration exceeds a specified limit.

```go
func doSomething() {
    opTrace := trace.New("operation", Field{Key: "fieldKey1", Value: "fieldValue1"})
    defer opTrace.LogIfLong(100 * time.Millisecond)
    // do something
}
```

--------------------------------

### Configure QEMU for Multi-Architecture Builds

Source: https://github.com/squat/kilo/blob/main/docs/building_kilo.md

Configure QEMU as the interpreter for binaries built for non-native architectures when building Docker containers.

```shell
docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
```

--------------------------------

### Structured vs. Unstructured Logging

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/go-kit/kit/log/README.md

Illustrates the difference between unstructured and structured logging formats. Structured logging uses key/value pairs for contextual information.

```go
// Unstructured
log.Printf("HTTP server listening on %s", addr)

// Structured
logger.Log("transport", "HTTP", "addr", addr, "msg", "listening")
```

--------------------------------

### Get Flag Value from FlagSet

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/spf13/pflag/README.md

Retrieve the integer value of a flag from a FlagSet using GetInt(). This requires the flag to exist and be of the correct type.

```go
i, err := flagset.GetInt("flagname")
```

--------------------------------

### Execute Unit Tests

Source: https://github.com/squat/kilo/blob/main/docs/building_kilo.md

Run all unit tests for the Kilo project using the Make command.

```shell
make unit
```

--------------------------------

### Custom Unmarshaling with TextUnmarshaler

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/BurntSushi/toml/README.md

Decode TOML strings into custom Go types by implementing the encoding.TextUnmarshaler interface. This example parses duration strings into time.Duration.

```toml
[[song]]
name = "Thunder Road"
duration = "4m49s"

[[song]]
name = "Stairway to Heaven"
duration = "8m03s"
```

```go
type song struct {
	Name     string
	Duration duration
}
type songs struct {
	Song []song
}
var favorites songs
if _, err := toml.Decode(blob, &favorites); err != nil {
	log.Fatal(err)
}

for _, s := range favorites.Song {
	fmt.Printf("%s (%s)\n", s.Name, s.Duration)
}
```

```go
type duration struct {
	time.Duration
}

func (d *duration) UnmarshalText(text []byte) error {
	var err error
	d.Duration, err = time.ParseDuration(string(text))
	return err
}
```

--------------------------------

### Embed from a specific line to the end

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/campoy/embedmd/README.md

Embeds content starting from a line matching the provided regular expression until the end of the file. The '$' symbol denotes the end of the file.

```Markdown
[embedmd]:# (pathOrURL language /start regexp/ $)
```

--------------------------------

### Customize Nil Pointer Chance

Source: https://github.com/squat/kilo/blob/main/vendor/sigs.k8s.io/randfill/README.md

Illustrates customizing the probability of generating nil pointers for fields within a struct. Approximately half the pointers will be set in this example.

```go
f := randfill.New().NilChance(.5)
var fancyStruct struct {
  A, B, C, D *string
}
f.Fill(&fancyStruct) // About half the pointers should be set.
```

--------------------------------

### Redirect klog Output with SetOutput

Source: https://github.com/squat/kilo/blob/main/vendor/k8s.io/klog/v2/README.md

Shows how to redirect all klog output to a custom io.Writer, such as syslog or a different file.

```go
package main

import (
	"io"
	"k8s.io/klog/v2"
	"os"
)

func main() {
	// Example: Redirect klog output to stdout
	var writer io.Writer = os.Stdout
	klog.SetOutput(writer)

	klog.Info("This message will be written to the custom output.")

	klog.Flush()
}
```

--------------------------------

### Compile Binaries for Different OS

Source: https://github.com/squat/kilo/blob/main/docs/building_kilo.md

Build Kilo binaries for a specific operating system (Windows, Darwin, Linux) by setting the OS environment variable before running Make.

```shell
OS=<windows|darwin|linux> make
```

--------------------------------

### Embed a whole Go file

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/campoy/embedmd/README.md

Embeds the entire content of the specified Go file into the Markdown document. This is useful for including complete source code examples.

```go
// Copyright 2016 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println("Hello, there, it is", time.Now())
}
```

--------------------------------

### Custom Randomization Logic with Funcs

Source: https://github.com/squat/kilo/blob/main/vendor/sigs.k8s.io/randfill/README.md

Demonstrates advanced customization by providing a custom function to randfill. This allows for complex initialization logic based on random choices.

```go
type MyEnum string
const (
        A MyEnum = "A"
        B MyEnum = "B"
)
type MyInfo struct {
        Type MyEnum
        AInfo *string
        BInfo *string
}

f := randfill.New().NilChance(0).Funcs(
        func(e *MyInfo, c randfill.Continue) {
                switch c.Intn(2) {
                case 0:
                        e.Type = A
                        c.Fill(&e.AInfo)
                case 1:
                        e.Type = B
                        c.Fill(&e.BInfo)
                }
        },
)

var myObject MyInfo
f.Fill(&myObject) // Type will correspond to whether A or B info is set.
```

--------------------------------

### Compile Kilo Binaries

Source: https://github.com/squat/kilo/blob/main/docs/building_kilo.md

Compile the 'kg' and 'kgctl' binaries using Make. Binaries are placed in 'bin/<os>/<architecture>/'.

```shell
make
```

--------------------------------

### xxhash Direct Hashing Functions

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/cespare/xxhash/v2/README.md

Use Sum64 for byte slices and Sum64String for strings to get the XXH64 hash directly. These functions are convenient for one-off hashing operations.

```go
func Sum64(b []byte) uint64
func Sum64String(s string) uint64
```

--------------------------------

### Build Static Website

Source: https://github.com/squat/kilo/blob/main/website/README.md

Generates the static content for the website into the 'build' directory.

```bash
yarn build
```

--------------------------------

### Deprecate a Flag Shorthand

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/spf13/pflag/README.md

Marks a flag's shorthand as deprecated, hiding it from help text and issuing a warning when the shorthand is used, guiding users to the full flag name.

```go
// deprecate a flag shorthand by specifying its flag name and a usage message
flags.MarkShorthandDeprecated("noshorthandflag", "please use --noshorthandflag only")
```

--------------------------------

### Conditional Verbose Logging (Level 2)

Source: https://github.com/squat/kilo/blob/main/vendor/k8s.io/klog/v2/README.md

Use glog.V(level) to conditionally log messages based on verbosity level. This example logs only if verbosity level 2 or higher is enabled.

```Go
if glog.V(2) {
	glog.Info("Starting transaction...")
}
```

--------------------------------

### Clone Kilo Repository

Source: https://github.com/squat/kilo/blob/main/docs/building_kilo.md

Clone the Kilo repository and navigate into the project directory. This is the initial step for building and testing.

```shell
git clone https://github.com/squat/kilo.git
cd kilo
```

--------------------------------

### Tag and Push Manifest with Latest

Source: https://github.com/squat/kilo/blob/main/docs/building_kilo.md

Tag the container manifest with 'latest' and push it. This is typically done after building and pushing other manifests.

```shell
make manifest-latest
```

--------------------------------

### Set Unsafe.Pointer Value in Go

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/modern-go/reflect2/README.md

Illustrates setting a value via `unsafe.Pointer` using `reflect2.TypeOf` and its `UnsafeSet` method. Similar to interface{} operations, use the pointer `*type` for getting and setting.

```go
valType := reflect2.TypeOf(1)
i := 1
j := 10
valType.UnsafeSet(unsafe.Pointer(&i), unsafe.Pointer(&j))
// i will be 10
```

--------------------------------

### Compile Binaries for Different Architecture

Source: https://github.com/squat/kilo/blob/main/docs/building_kilo.md

Build Kilo binaries for a specific architecture (ARM, ARM64, AMD64) by setting the ARCH environment variable before running Make.

```shell
ARCH=<arm|arm64|amd64> make
```

--------------------------------

### Get Type by Name in Go

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/modern-go/reflect2/README.md

Use `reflect2.TypeByName` to retrieve a type by its package and name, similar to Java's `Class.forName`. Note that types eliminated by the compiler may not be retrievable at runtime.

```go
// given package is github.com/your/awesome-package
type MyStruct struct {
	// ...
}

// will return the type
reflect2.TypeByName("awesome-package.MyStruct")
// however, if the type has not been used
// it will be eliminated by compiler, so we can not get it in runtime
```

--------------------------------

### Generate Website Markdown

Source: https://github.com/squat/kilo/blob/main/docs/building_website.md

Run this command to generate the markdown files for the website from the source documentation.

```shell
make website/docs/README.md
```

--------------------------------

### Embed Markdown content with specific lines

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/campoy/embedmd/README.md

Embeds a section of a Markdown file, starting from a line matching '/./' and ending at a line matching 'embedmd.*time.*'. This allows for selective inclusion of content.

```Markdown
# A hello world in Go

Go is very simple, here you can see a whole "hello, world" program.

[embedmd]:# (hello.go)

We can try to embed a file from a directory.

[embedmd]:# (test/hello.go /func main/ $)

You always start with a `package` statement like:

[embedmd]:# (hello.go /package.* /)

Followed by an `import` statement:

[embedmd]:# (hello.go /import/ /\)/)

You can also see how to get the current time:

[embedmd]:# (hello.go /time\.[^)]*\)/)
```

--------------------------------

### Initialize klog Flags

Source: https://github.com/squat/kilo/blob/main/vendor/k8s.io/klog/v2/README.md

Explicitly initialize global flags for klog. This is required as klog no longer uses the init() method for flag registration.

```go
import "k8s.io/klog/v2"

func main() {
	// ... other setup ...
	klog.InitFlags(nil)
	// ... rest of your application ...
}
```

--------------------------------

### Set Interface{} Value with Type Checking in Go

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/modern-go/reflect2/README.md

Demonstrates setting a value within an interface{} using `reflect2.TypeOf` and its `Set` method. Always use the pointer `*type` when getting or setting values.

```go
valType := reflect2.TypeOf(1)
i := 1
j := 10
valType.Set(&i, &j)
// i will be 10
```

--------------------------------

### Creating Custom CBOR Encoding Modes

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/fxamacker/cbor/v2/README.md

Create custom immutable encoding modes by starting with preset options and modifying settings as needed. These modes are safe for concurrent use and should be created at application startup.

```go
// Create encoding mode.
opts := cbor.CoreDetEncOptions()   // use preset options as a starting point
opts.Time = cbor.TimeUnix          // change any settings if needed
em, err := opts.EncMode()          // create an immutable encoding mode

// Reuse the encoding mode. It is safe for concurrent use.

// API matches encoding/json.
b, err := em.Marshal(v)            // encode v to []byte b
encoder := em.NewEncoder(w)        // create encoder with io.Writer w
err := encoder.Encode(v)           // encode v to io.Writer w
```

--------------------------------

### Create and Apply JSON Patch

Source: https://github.com/squat/kilo/blob/main/vendor/gopkg.in/evanphx/json-patch.v4/README.md

Demonstrates how to decode a JSON patch from bytes and apply it to an original JSON document. Requires importing the jsonpatch library.

```go
package main

import (
	"fmt"

	jsonpatch "github.com/evanphx/json-patch"
)

func main() {
	original := []byte(`{"name": "John", "age": 24, "height": 3.21}`)
	patchJSON := []byte(`[
		{"op": "replace", "path": "/name", "value": "Jane"},
		{"op": "remove", "path": "/height"}
	]`)

	patch, err := jsonpatch.DecodePatch(patchJSON)
	if err != nil {
		panic(err)
	}

	modified, err := patch.Apply(original)
	if err != nil {
		panic(err)
	}

	fmt.Printf("Original document: %s\n", original)
	fmt.Printf("Modified document: %s\n", modified)
}
```

--------------------------------

### Add an IP Address to the Loopback Interface

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/vishvananda/netlink/README.md

Shows how to parse an IP address string and add it to a specified network interface (loopback in this case). Requires root privileges.

```go
package main

import (
    "github.com/vishvananda/netlink"
)

func main() {
    lo, _ := netlink.LinkByName("lo")
    addr, _ := netlink.ParseAddr("169.254.169.254/32")
    netlink.AddrAdd(lo, addr)
}

```

--------------------------------

### Gob Out of Memory Error Example

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/fxamacker/cbor/v2/README.md

Demonstrates a 'fatal error: runtime: out of memory' scenario when decoding adversarial input with Go's encoding/gob. This highlights a security concern with gob when handling untrusted data.

```Go
package main
import (
	"bytes"
	"encoding/gob"
	"encoding/hex"
	"fmt"
)

// Example data is from https://github.com/golang/go/issues/24446
// (shortened to 181 bytes).
const data = "4dffb503010102303001ff30000109010130010800010130010800010130"
	+ "01ffb80001014a01ffb60001014b01ff860001013001ff860001013001ff"
	+ "860001013001ff860001013001ffb80000001eff850401010e3030303030"
	+ "303030303030303030303030303030303030303030303030303030303030"
	+ "303030303030303030303030303030303030303030303030303030303030"
	+ "30"

type X struct {
	J *X
	K map[string]int
}

func main() {
	raw, _ := hex.DecodeString(data)
	decoder := gob.NewDecoder(bytes.NewReader(raw))

	var x X
	decoder.Decode(&x) // fatal error: runtime: out of memory
	fmt.Println("Decoding finished.")
}

```

--------------------------------

### Run All Go Tests

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/spf13/cobra/CONTRIBUTING.md

Execute all tests within the Go modules of the project.

```shell
go test ./...
```

--------------------------------

### Display WireGuard Configuration for a Node

Source: https://github.com/squat/kilo/blob/main/docs/kgctl.md

Use the `showconf node` command to retrieve the WireGuard configuration required by a specific node to join the mesh. The output is in INI format.

```shell
NODE=master # the name of a node
kgctl showconf node $NODE
```

--------------------------------

### Deploy to GitHub Pages

Source: https://github.com/squat/kilo/blob/main/website/README.md

Builds the website and deploys it to the 'gh-pages' branch, suitable for GitHub Pages hosting.

```bash
GIT_USER=<Your GitHub username> USE_SSH=true yarn deploy
```

--------------------------------

### xxhash Digest Type for Incremental Hashing

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/cespare/xxhash/v2/README.md

The Digest type implements the hash.Hash64 interface, allowing for incremental hashing. Use New to create a Digest, then Write data and finally call Sum64 to get the result.

```go
func New() *Digest
func (*Digest) Write([]byte) (int, error)
func (*Digest) WriteString(string) (int, error)
func (*Digest) Sum64() uint64
```

--------------------------------

### Basic Info Log

Source: https://github.com/squat/kilo/blob/main/vendor/k8s.io/klog/v2/README.md

Use glog.Info for standard informational messages. This is a basic logging function.

```Go
glog.Info("Prepare to repel boarders")
```

--------------------------------

### Run All Kilo Tests

Source: https://github.com/squat/kilo/blob/main/docs/building_kilo.md

Execute all available tests (unit, lint, e2e) for the Kilo project with a single command.

```shell
make test
```

--------------------------------

### Configure WireGuard Interface with Kilo Peer

Source: https://github.com/squat/kilo/blob/main/README.md

Export Kilo peer configuration and apply it to a local WireGuard interface using `wg setconf` and `kgctl`.

```shell
kgctl showconf peer squat > peer.ini
sudo wg setconf wg0 peer.ini
```

--------------------------------

### Parsing Skipped Go Test Flags with pflag

Source: https://github.com/squat/kilo/blob/main/vendor/github.com/spf13/pflag/README.md

This example demonstrates how to use `ParseSkippedFlags` to correctly parse Go test flags that are otherwise ignored by `pflag.Parse()`. It ensures that both pflag-defined flags and Go's built-in test flags are handled.

```go
import (
	goflag "flag"
	flag "github.com/spf13/pflag"
)

var ip *int = flag.Int("flagname", 1234, "help message for flagname")

func main() {
	flag.CommandLine.AddGoFlagSet(goflag.CommandLine)
    flag.ParseSkippedFlags(os.Args[1:], goflag.CommandLine)
	flag.Parse()
}
```

--------------------------------

### Rebuild and Reload Website

Source: https://github.com/squat/kilo/blob/main/docs/building_website.md

If changes are made to markdown files, run this command to rebuild the website and reload the local node server automatically.

```shell
make website/docs/README.md -B
```
Tokens:
Raw