wiki on ege's wiki

Mutating a slice in struct

Sat, 01 Aug 2026 11:40:00 +0300

package main

import "fmt"

type Bar struct {
	Bar string
}

type Bars []Bar

type Foo struct {
	Bars Bars
}

func main() {
	f := Foo{Bars: []Bar{{Bar: "ege"}}}
	fmt.Printf("Foo: %+v\n", f)
	for _, e := range f.Bars {
		e.Bar = "gule"
	}
	fmt.Printf("Foo: %+v\n", f)

	f = Foo{Bars: []Bar{{Bar: "ege"}}}
	fmt.Printf("Foo: %+v\n", f)
	for i, _ := range f.Bars {
		x := &f.Bars[i]
		x.Bar = "gule"
	}
	fmt.Printf("Foo: %+v\n", f)
}

Foo: {Bars:[{Bar:ege}]}
Foo: {Bars:[{Bar:ege}]}
Foo: {Bars:[{Bar:ege}]}
Foo: {Bars:[{Bar:gule}]}

http.Server

Sat, 01 Aug 2026 11:37:46 +0300

Graceful shutdown

server := &http.Server{Addr: ":8080", Handler: handler}
    
go func() {
    if err := server.ListenAndServe(); err != nil {
        // handle err
    }
}()

// Setting up signal capturing
stop := make(chan os.Signal, 1)
signal.Notify(stop, os.Interrupt)

// Waiting for SIGINT (kill -2)
<-stop

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := server.Shutdown(ctx); err != nil {
    // handle err
}
    
// Wait for ListenAndServe goroutine to close.

Binary Search

Sat, 01 Aug 2026 11:31:37 +0300

package main

import (
	"fmt"
)

// binarySearch performs binary search on a sorted slice.
// It returns the index of target if present, or -1 if not found.
func binarySearch(slice []int, target int) int {
    low := 0
    high := len(slice) - 1

    for low <= high {
        mid := low + (high-low)/2

        if slice[mid] == target {
            return mid
        }

        if slice[mid] < target {
            low = mid + 1
        } else {
            high = mid - 1
        }
    }

    return -1 // target not found
}

func main() {
    slice := []int{2, 3, 4, 10, 40}
    target := 10
    result := binarySearch(slice, target)
    if result != -1 {
        fmt.Printf("Element found at index %d\n", result)
    } else {
        fmt.Println("Element not found in the slice")
    }
}

time.Ticker

Sat, 01 Aug 2026 11:30:37 +0300

Simple

ticker := time.NewTicker(5 * time.Second)
for range ticker.C {
	log.Println("Hey!")
}

With timeout

ticker := time.NewTicker(5 * time.Second)
defer ticker.Stop()

timeout := time.NewTimer(300 * time.Second)
defer timeout.Stop()

for {
	select {
	case <-timeout.C:
		return errors.New("timeout")
	case <-ticker.C:
		// do
	}
}

bytes.Buffer

Sat, 01 Aug 2026 11:25:32 +0300

Direct Initialization vs Pre-allocated Buffer

First Approach:

w := bytes.Buffer{}
w.WriteString(itemType)
w.WriteRune(':')
w.WriteString(clientId)

Second Approach:

l := len(itemType) + len(clientId) + len(id) + 2
buf := make([]byte, 0, l)
w := bytes.NewBuffer(buf)

Key Differences

Memory Allocation:

The first approach uses bytes.Buffer's internal 64-byte array for small strings
The second approach pre-allocates a specific buffer size based on the final string length

Performance Characteristics:

First approach: 2 allocations (one for buffer structure, one for String() conversion)
Second approach: 3 allocations (initial slice, buffer structure, and String() conversion)

Use Cases:

MySQL Group Replication

Sat, 01 Aug 2026 11:11:11 +0300

Group replication (GR) can operate in two modes: 1. Single primary 2. Multiple primaries

If a group member becomes unavailable clients need to failover to another member. GR doesn't provide a built-in method for this. We'll probably use [[MySQL Router]] for it.

GR uses [[Paxos]] in the background.

The communication protocol uses something called atomic broadcast. Every update is sent through an atomic broadcast and either all members of the group receive the transaction or none do. All members receive the same set of transactions in the same order.

MySQL Binlog

Sat, 01 Aug 2026 11:09:38 +0300

Most numeric fields use fixed-length encoding with little-endian byte order.
- When you see 7a000000 in a hex dump, you read it as 0x0000007a = 122 in decimal.
The first event starts at position 4.
Every event in the binary log (version 4+) shares a common 19-byte header structure.
- Timestamp, 4 bytes, Unix epoch seconds when the event was created
- Event Type, 1 byte, Identifies how to interpret the payload
- Server ID, 4 bytes, The server that originated this event (prevents circular replication)
- Event Size, 4 bytes, Total size of this event in bytes (header + payload)
- Next Position, 4 bytes, File offset where the next event begins
- Flags, 2 bytes, Event-specific flags (bit field)

Socket Types

Fri, 31 Jul 2026 19:59:08 +0300

SOCK_STREAM:
- Provides a reliable, connection-oriented, bidirectional byte stream.
- Uses TCP (Transmission Control Protocol) for transport.
- Ensures data is received in the same order it was sent.
- Guarantees delivery of data (or notifies of failure).
- Handles flow control and error correction.
- Suitable for applications requiring reliable data transfer, like file transfer or web browsing.
SOCK_DGRAM:
- Provides a connectionless, unreliable datagram service.
- Uses UDP (User Datagram Protocol) for transport.
- Messages have defined boundaries (sent and received as discrete units).
- No guarantee of delivery, ordering, or protection against duplication.
- Faster than SOCK_STREAM due to less overhead.
- Suitable for applications where speed is more important than reliability, like real-time gaming or streaming.
SOCK_SEQPACKET:

Hostnames With Multiple Headless Services

Fri, 31 Jul 2026 19:56:59 +0300

$ k get pod cluster1-mysql-0 -o yaml | grep subdomain
  subdomain: cluster1-mysql

Kubernetes has a check to match subdomain to service name:

func ShouldSetHostname(pod *v1.Pod, svc *v1.Service) bool {  
    return len(pod.Spec.Hostname) > 0 && pod.Spec.Subdomain == svc.Name && svc.Namespace == pod.Namespace  
}

That's why resolving cluster1-mysql-0.cluster1-mysql.default.svc.cluster.local works but cluster1-mysql-0.cluster1-mysql-unready.default.svc.cluster.local not.

Unsafe Sysctls

Fri, 31 Jul 2026 19:55:28 +0300

Kubernetes maintains a list of safe sysctls to modify.

As of 1.36 the list is:

kernel.shm_rmid_forced;
net.ipv4.ip_local_port_range;
net.ipv4.tcp_syncookies;
net.ipv4.ping_group_range (since Kubernetes 1.18);
net.ipv4.ip_unprivileged_port_start (since Kubernetes 1.22);
net.ipv4.ip_local_reserved_ports (since Kubernetes 1.27, needs kernel 3.16+);
net.ipv4.tcp_keepalive_time (since Kubernetes 1.29, needs kernel 4.5+);
net.ipv4.tcp_fin_timeout (since Kubernetes 1.29, needs kernel 4.6+);
net.ipv4.tcp_keepalive_intvl (since Kubernetes 1.29, needs kernel 4.5+);
net.ipv4.tcp_keepalive_probes (since Kubernetes 1.29, needs kernel 4.5+).
net.ipv4.tcp_rmem (since Kubernetes 1.32, needs kernel 4.15+).
net.ipv4.tcp_wmem (since Kubernetes 1.32, needs kernel 4.15+).

Up-to-date list can be found in docs.

vm.overcommit_memory

Fri, 31 Jul 2026 19:53:28 +0300

vm.overcommit_memory needs to be set on kubernetes node since it's a kernel parameter.

however, kubelet won't allow you to set it to 2. see https://github.com/kubernetes/kubernetes/blob/093c91d2264ad9c4b965ad6dd27b3089681b0d73/pkg/kubelet/cm/container_manager_linux.go?plain=1#L485

kubelet, depending on your configuration, either errors if this is set to 2 or sets it to 1.

so it's not possible for us to set it to 0 or 2.

https://github.com/kubernetes/kubernetes/issues/135294 https://github.com/kubernetes/kubernetes/issues/14935 https://github.com/kubernetes/kubernetes/issues/90973

MySQL set DEFAULT

Fri, 31 Jul 2026 19:51:32 +0300

To set a global system variable value to the compiled-in MySQL default value or a session system variable to the current corresponding global value, set the variable to the value DEFAULT:

SET @@SESSION.max_join_size = DEFAULT;

Bash required variable

Fri, 31 Jul 2026 19:49:38 +0300

Instead of doing this:

local pod=$1
if [[ -z ${pod} ]]; then
  echo "pod is required, aborting!"
  return
fi

You can just do this:

local pod="${1:?pod is required, aborting!}"

Isolating a PXC Node on K8s

Fri, 31 Jul 2026 19:36:29 +0300

isolating a PXC pod so it's removed from the cluster while running

NetworkPolicy is CNI-dependent, so might not work with K3s/minikube; Customer was using Cillium, so we:

labeled the pod (this was for some reason required, can't recall, but it would refuse to take the pod name as a pod selector)
touch /var/lib/mysql/sst_in_progress to keep liveness check happy
make un-ready: mv /var/lib/mysql/readiness-check.sh /var/lib/mysql/readiness-check.sh.$(date +%s).backup; ln -s /bin/false /var/lib/mysql/readiness-check.sh
apply policy:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: pxc-0-deny-egress
spec:
  podSelector:
    matchLabels:
      joni4: joni4
  policyTypes:
    - Ingress
    - Egress
  ingress:
    - ports:
        - protocol: TCP
          port: 3306
      from:
        - namespaceSelector:
            matchLabels:
              project: myproject
        - podSelector:
            matchLabels:
              role: frontend
  egress:
    - ports:
        - protocol: TCP
          port: 22
      to:
        - namespaceSelector:
            matchLabels:
              project: myproject
        - podSelector:
            matchLabels:
              role: frontend