Mike Chirico

Bytes Buffer in Go

2022-10-24T23:38:50+00:00

Strings in Go are extremely inefficient. They are immutable and are stored as a slice of bytes. This means that every time you want to append a character to a string, you have to create a new string and copy the old one into it. This is extremely inefficient and can lead to a lot of memory usage.

It’s better to use bytes buffer instead of strings. Bytes buffer is a mutable slice of bytes. It is more efficient than strings because it doesn’t have to create a new string every time you want to append a character to it. It can just append the character to the end of the slice.

Here is an example of how to use bytes buffer:

    package main

    import (
        "bytes"
        "fmt"
    )

    func main() {
        var buffer bytes.Buffer
        buffer.WriteString("Hello")
        buffer.WriteString(" ")
        buffer.WriteString("World")
        fmt.Println(buffer.String())
        // Note: We don't clear buffer
        fmt.Println("We didn't clear buffer. Len: ",buffer.Len()) 
    }

playground

Above we didn’t clear the buffer. Below we create our own Read, and read in nBytes each pass through the loop, until io.EOF.

package main

import (
	"bytes"
	"fmt"
	"io"
)

func Read(r io.Reader, nBytes int) {
	for {
		b := make([]byte, nBytes)
		n, err := r.Read(b)
		if err != nil {
			fmt.Printf("Done: %d,b: %s\n", n, string(b))
			if err == io.EOF {
				return
			}
			fmt.Println("error: ", err)
		}
		fmt.Printf("%d,b: %s\n", n, string(b))
	}
}

func main() {
	var buf bytes.Buffer
	nBytes := 5
	buf.WriteString("This is a string here.")
	buf.WriteString(
        fmt.Sprintf(" We will read %d bytes at a time.", nBytes))
	Read(&buf, nBytes)
	fmt.Println(buf.String())
	fmt.Println(buf.Len())

	fmt.Println("buf: ", buf.String())
}

playground

AWS Sessions

2022-10-23T14:32:49+00:00

Simple way to generate and jump into a new AWS temp session. The session here expires after 15 minutes.

#!/bin/bash
set -e

sts=( $(
    aws sts get-session-token --duration-seconds 900  \
    --query 'Credentials.[AccessKeyId,SecretAccessKey,SessionToken]' \
    --output text
) )
export TMP_AWS_ACCESS_KEY_ID=${sts[0]}
export TMP_AWS_SECRET_ACCESS_KEY=${sts[1]}
export TMP_AWS_SESSION_TOKEN=${sts[2]}

Go Custom Errors

2022-10-23T13:53:06+00:00

package main

import (
	"errors"
	"fmt"
)

// FooError records an error and what caused it
type FooError struct {
	Op       string
	FooThing string
	Err      error
}

// ErrorCreator creates an error, which is an interface, so we can return *FooError as error

//	   type error interface {
//		       Error() string
//	    }
func ErrorCreator() error {
	return &FooError{
		Op:       "was eating miso soup",
		FooThing: "just happend",
		Err:      errors.New("bad fortune cookie"),
	}

}

func (e *FooError) Error() string { return e.Op + " " + e.FooThing + ": " + e.Err.Error() }

func (e *FooError) Unwrap() error { return e.Err }

func (e *FooError) Thing() string { return e.FooThing }

// The key here is to use "errors.As" to check if the error is of type FooError
func main() {
	if err := ErrorCreator(); err != nil {
		var fooError *FooError
		if errors.As(err, &fooError) {
			fmt.Println("Explain failure thing...:", fooError.Thing())
		} else {
			fmt.Println(err)
		}
	}

}

AWS ECT with Kubernetes KinD

2022-09-22T19:18:33+00:00



TOKEN=$(aws ecr get-login-password --region us-east-1)
SERVER=$(aws ecr describe-repositories|jq '.repositories[0].repositoryUri'|sed  's/\/.*//'|sed -r 's/\"//g')
NAMESPACE="dev"


kubectl create namespace $NAMESPACE
kubectl create secret docker-registry regcred \
--docker-server=${SERVER} \
--docker-username=AWS --docker-password=${TOKEN} -n ${NAMESPACE}

kubectl patch serviceaccount default -p "{\"imagePullSecrets\": [{\"name\": \"regcred\"}]}" -n ${NAMESPACE}

Try pulling image

Note, you’ll need to replace 1111.xxx.ecr.us-east-1.amazonaws.com/repodev:latest with your own image.

kubectl create deployment --image=1111.xxx.ecr.us-east-1.amazonaws.com/repodev:latest dev-dep

Go Relative Directory

2022-08-29T14:28:53+00:00

package fixtures

import (
	"path/filepath"
	"runtime"
)

// basepath is the root directory of this package.
var basepath string

func init() {
	_, currentFile, _, _ := runtime.Caller(0)
	basepath = filepath.Dir(currentFile)
}

// Path returns the absolute path the given relative file or directory path,
// relative to the "fixtures" directory.
// If rel is already absolute, it is returned unmodified.
func Path(rel string) string {
	if filepath.IsAbs(rel) {
		return rel
	}

	return filepath.Join(basepath, rel)
}

Go Embedding

2022-08-07T18:43:52+00:00

Example using embeddings… with interface playground

package main

import (
	"fmt"
)

type A struct{}

func (a *A) f0() string {
	return "f0()"
}

type B struct{}

func (b *B) f1() string {
	return "f1()"
}

type f0f1 interface {
	f0() string
	f1() string
}

type C struct {
	*A
	*B
}

func Pr(f f0f1) {
	fmt.Println(f.f0())
	fmt.Println(f.f1())

}

func main() {
	c := &C{A: &A{}, B: &B{}}
	Pr(c)

}

Go Programs – Reminders

2022-06-28T14:10:53+00:00

Some personal reminders on Go development.

1) Perfect is enemy of good.

Often times is makes sense to keep going with a code idea. Write tests, so you can back out. But, if you have writers block… sometimes it helps to just code. Other options:

Write next move with pen and paper - this helps with complex structures
Review previous works of code - always helps to read other’s code

2) Interface Names (should be verbs)

Use verbs for interface names. Ref io.go, where names are WriteString, Reader, ByteWriter, Closer... Interfaces define function calls, so should be actions.

type Reader interface {
	Read(p []byte) (n int, err error)
}
...
type Writer interface {
	Write(p []byte) (n int, err error)
}

type Closer interface {
	Close() error
}

3) Select – Hate this about Go

The two programs below produce different results, based on where the “{“ is placed in the select.

Always `false`

package main

func False() bool {
	return false
}

func main() {
	switch False() {
	case false: println("False")
	case true: println("True")
	}
}
// Returns false

The above program will always return false. It does what you expect it to do.

Always `true`

package main

func False() bool {
	return false
}

func main() {
	switch False() // <<== Note "{" is no longer on this line
	{
	case false: println("False")
	case true: println("True")
	}
}
// returns true

But, the above program returns true, because it’s really formatted to be the following…

package main

func False() bool {
	return false
}

func main() {
	switch False(); {
	case false:
		println("False")
	case true:
		println("True")
	}
}

4 - Files relative

Reading files from relative directories doesn’t have to be difficult. Package runtime allows you to read in files relative to what directory you code is running in…

import (
	"path/filepath"
	"runtime"
)

var basepath string

func init() {
	_, currentFile, _, _ := runtime.Caller(0)
	basepath = filepath.Dir(currentFile)
}

func Path(rel string) string {
	if filepath.IsAbs(rel) {
		return rel
	}

	return filepath.Join(basepath, rel)
}

ko with Go

2022-05-16T19:30:50+00:00

Clean Go Code

2021-10-30T13:24:15+00:00

Good article on Clean Go Code…

k8s view-last-applied

2020-10-29T18:13:31+00:00

Suppose you want to view the whatever.yaml you applied. Is there a way to generate this file?

Note: kubectl describe crd foos.samplecontroller.k8s.io would give a lot of extra information. There’s a better way view-last-applied

Here’s an example, for a CRD.


kubectl apply view-last-applied crd foos.samplecontroller.k8s.io -o yaml

apiVersion: apiextensions.k8s.io/v1beta1
kind: CustomResourceDefinition
metadata:
  annotations: {}
  labels:
    tag: foo
  name: foos.samplecontroller.k8s.io
spec:
  group: samplecontroller.k8s.io
  names:
    kind: Foo
    plural: foos
  scope: Namespaced
  version: v1alpha1

Deployment


k get deployment

NAME             READY   UP-TO-DATE   AVAILABLE   AGE
eventer-server   1/1     1            1           7m58s

# Example..

kubectl apply view-last-applied deployment/eventer-server -o yaml