reveal-md

----

# Go Tour

----

## Authors
<table>
  <tbody>
    <tr>
      <td style="vertical-align: middle;"><img src="img/cc_manfred.jpg" style="height:200px;"></td>
      <td style="vertical-align: middle;">
        <a href="https://codecentric.de">Manfred Dreese</a><br>
        <a href="https://dreese.de">dreese.de</a><br>
        <a href="https://dreese.de">dreese.de</a><br>
        <a href="https://github.com/i78">github/i78</a><br>
        <a href="https://twitter.com/dem9d">twitter/dem9d</a>
      </td>
    </tr>
    <tr>
      <td style="vertical-align: middle;"><img src="img/cc_grohmio.png" style="height:200px;"></td>
      <td style="vertical-align: middle;">
        <a href="https://grohm.io">Andreas Grohmann</a><br>
        <a href="https://grohm.io">grohm.io</a><br>
        <a href="https://github.com/grohmio">github/grohmio</a><br>
        <a href="https://twitter.com/grohmeo">twitter/grohmeo</a><br>
        <a href="https://stackoverflow.com/users/6654539/grohmio">stackoverflow/grohmio</a>
      </td>
    </tr>
  </tbody>
</table>

----

----

## Materials
* slides
  * [go-gurus.github.io/go_tour]( https://go-gurus.github.io/go_tour)
  * [go.grohm.io](https://go.grohm.io)
* source code
  * [github.com/go-gurus/go_tour_src](https://github.com/go-gurus/go_tour_src)
* presentation
  * [github.com/go-gurus/go_tour](https://github.com/go-gurus/go_tour)
* Slack
  * [go-gurus.slack.com](https://go-gurus.slack.com)
* github
  * [github.com/go-gurus](https://github.com/go-gurus)

----

## Workshop Abstract
Golang powers some of the most relevant IT projects of the last decade, such as Docker or Kubernetes. A lot of this success can be traced back to its simplicity, efficiency, tooling and developer experience.

In this workshop, we assume that the participants are already fluent with another programming language, such as Java, Python or C#. We will cover the go basics, walk along some real-world examples and build some REST/GraphQL and Data Analysis usecases.

---

----

## Introduction
Why should you look at the GO programming language?
Go is an open source programming language. 
But go takes a lot of getting used to and is reduced to the essentials.
You can build anything from small helper scripts for pipelines to microservices to highly complex monoliths with GO.
The advantages of Go are a strong standardization of the tools,
a high applicability of the binaries and a high performance of the build process.
We will discuss further advantages of Go in more detail.

----

### Why Go?
* small binaries
* fast build times
* multi platform builds
* binaries could be used in scratch image
* small set of keywords (25)
* parallelism
* completely downward compatible

----

----

### Install Golang Linux, Windows, MacOS
* download your package from [go.dev/dl/](https://go.dev/dl/)
* follow instructions from [go.dev/doc/install](https://go.dev/doc/install)
* recommended for MacOS [formulae.brew.sh/formula/go](https://formulae.brew.sh/formula/go)

```shell
brew install go
```

----

### Go Playground
![go-playground](img/INTRODUCTION/playground.png)
[go.dev/play](https://go.dev/play/)

----

### Useful Go Tools
* `go build` the go compiler
* `go fmt` format your go code
* `go get` load/installs dependencies
* `go run` compiles and executes go code directly
* `go test` compiles and executes go testcases
* `go mod [download|edit|graph|init|tidy|vendor|verify|why]` manages modules
* `go generate` generates code from source files
* `go version` determines the go version used

----

### Useful Go Tools
* `go vet` finds potential errors in the application
* `go bug` report error
* `go doc` standard tool to view documentation and source code
* `go env` set and read go environment variables
* `go fix` makes adjustments to new go versions
* `go tool` lists tools

----

### Set of Keywords

```
break, case, chan, const, continue
default, defer, else, fallthrough
for, func, go, goto, if, import
interface, map, package, range
return, select, struct, switch
type, var
```

----

### Base Types
* bool
* numeric types
  * int8, int16, int32, int64, int
  * uint8, uint16, uint32, uint64, uint
  * float32, float64
  * complex64, complex128
  * byte (alias for uint8)
  * rune (alias for int32)
* string

----

### Functions
```go
func add(x int, y int) int {
	return x + y
}
```

```go
func add(x, y int) int {
    return x + y
}
```

----

* multiple results

```go
func swap(x, y string) (string, string) {
	return y, x
}
```

* named return values

```go
func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return
}
```
----
* first class functions

```go
func process(sample int, fn func(int) int) int {
	return fn(sample)
}

func adder(term int) func(a int) int {
	return func(a int) int { return a + term }
}

func increment(term int) int {
	return adder(1)(term)
}

func main() {
	sample := 23
	fmt.Println(process(sample, increment),
		process(sample, adder(100)))

}
```

----

### Variables

```go
var hot, wet, far bool
var tool string
var x int
```

* with initializers

```go
var x, y int = 1, 2
var hot, wet, tool = true, false, "screwdriver"
```

* short declaration

```go
x := 3
hot, wet, tool := true, false, "screwdriver"
```

----

### Loops

```go
for i := 0; i < 10; i++ {
	sum += i
}
```

* optional init and post statements, while loop

```go
sum := 1
for sum < 1000; {
    sum += sum
}
```

* endless loop

```go
for {
}
```

----

### If statement

```go
if x < 0 {
	return "something"
}
```
```go
if a < b {
	return a
} else {
    return b
}
```

----

### Switch Statement

```go
os := runtime.GOOS
switch os {
case "darwin":
    fmt.Println("OS X.")
case "linux":
    fmt.Println("Linux.")
default:
    // freebsd, openbsd, plan9, windows...
    fmt.Printf("%s.\n", os)
}
```

----

### Defer

* defers the execution of a function until the surrounding function returns

```go
func main() {
    defer fmt.Println("world")
    fmt.Println("hello")
}
```

```go
...
func main() {
    file, _ := os.Open("README.md")
    defer file.Close()
    buffer := make([]byte, 1024)
    bytesRead, _ := file.Read(buffer)
    fmt.Printf("Content: %s\n", buffer[:bytesRead])
}
...
```

----

### Structs

```go
type Vertex struct {
    X int
    Y int
}

func main() {
    v := Vertex{1, 2}
    v.X = 4
    fmt.Println(v.X)
}
```

----

### Arrays

```go
var tools [2]string
a[0] = "screwdriver"
a[1] = "hammer"

primes := [6]int{2, 3, 5, 7, 11, 13}
```

----

### Slices

```go
primes := [6]int{2, 3, 5, 7, 11, 13}

var s []int = primes[1:4]
```

----

### Tour of go

* for more topics checkout the tour of go

![go-playground](img/INTRODUCTION/tour_of_go.png)
[go.dev/tour](https://go.dev/tour/)

----

### What we have learned
* Advantages of go
* How to install go
* overview of go tools
* overview of go keywords
* overview of base types
* `tour of go` is a good starting point

----

### Further readings
* Source Code for all slides
  * [github.com/go-gurus/go_tour_src](https://github.com/go-gurus/go_tour_src/tree/main/hello-world)
* Documentation
  * [golang.org/pkg](https://golang.org/pkg/)
* Go Packages
  * [pkg.go.dev](https://pkg.go.dev/)
* Tour of Go
  * [go.dev/tour](https://go.dev/tour/)

---

----

## Hello World
This task is supposed to demonstrate basic console I/O in Go.

The program should print the text `Hello World! This is Go.` to the standard output.

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/hello-world](https://github.com/go-gurus/go_tour_src/tree/main/hello-world)

----

----

### Solution
```golang
// main.go
package main

import "fmt"

func main() {
	fmt.Println("Hello World! This is Go.")
}
```

----

### Building and executing Go code
Run a go file directly
```
go run main.go

Hello World! This is Go.
```

Compile and run a go file:

```
go build main.go
./main
Hello World! This is Go.
```
----

### Compile for other platforms:

```
GOOS=linux GOARCH=arm go build main.go

$ file main
main: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), statically linked
```

Compile for other operating systems:
```
GOOS=windows go build main.go

$file main
main: Mach-O 64-bit executable x86_64
```

----

* e.g. build `windows/amd64` binary on `darwin/arm64`

```shell
GOOS=windows GOARCH=amd64 go build main.go
```

![windows-proof](img/HELLO_WORLD/02.png)

----

* e.g. build `darwin/arm64` binary on `windows/amd64`

```shell
$Env:GOOS="darwin"; $Env:GOARCH="amd64"; go build main.go
```

![windows-proof](img/HELLO_WORLD/03.png)

```shell
$ ./main
Hello World! This is Go.
```

----

### Possible Crosscompile Configurations
* [go.dev/doc/install/source#environment](https://go.dev/doc/install/source#environment)

![windows-proof](img/HELLO_WORLD/04.png)

----

### Lets try a real world example
* opentofu is the open source terraform

----

* [github.com/opentofu/opentofu](https://github.com/opentofu/opentofu)
* clone the opentofu repo

```bash
$ git clone git@github.com:opentofu/opentofu.git
```

----

* now check your `GOPATH` variables, go will install packages here

```bash
$ go env GOPATH
/Users/grohmio/go
```
* add your `GOBIN` path to your `PATH`, so binaries build by go can be found, if `GOBIN`=="" default is `${GOPATH}/bin`

```
#.zshrc
...
# go binaries
export PATH="/Users/grohmio/go/bin:$PATH"
```

----

* build the binary from source, for MacOS/Darwin build with `CGO_ENABLED=1`

```bash
$ cd opentofu/
$ go build -o /Users/grohmio/go/bin/ ./cmd/tofu
go: downloading github.com/apparentlymart/go-shquot v0.0.1
go: downloading github.com/mitchellh/cli v1.1.5
go: downloading github.com/mattn/go-shellwords v1.0.4
go: downloading github.com/hashicorp/terraform-svchost v0.1.1
```

----

* check that opentofu is installed, can be used instead of terraform cli

```bash
$ tofu -h
Usage: tofu [global options] <subcommand> [args]

The available commands for execution are listed below.
The primary workflow commands are given first, followed by
less common or more advanced commands.

Main commands:
  init          Prepare your working directory for other commands
  validate      Check whether the configuration is valid
  plan          Show changes required by the current configuration
  apply         Create or update infrastructure
  destroy       Destroy previously-created infrastructure
```

----

### What we have learned
* Go belongs to the C/Java syntactic family
* There are packages and imports, such as in Java
* Hello World example
* Crosscompiling in action
* Crosscompile Configurations
* How to build binaries for huge projects
* `opentofu` tool

----

### Further readings

* Crosscompile
  * [golangcookbook.com/chapters/running/cross-compiling/0](https://golangcookbook.com/chapters/running/cross-compiling/0)
* Crosscompile Configuration
  * [go.dev/doc/install/source#environment](https://go.dev/doc/install/source#environment)
* Open Tofu
  * [github.com/opentofu/opentofu](https://github.com/opentofu/opentofu)
  * [github.com/opentofu/opentofu/blob/main/BUILDING.md](https://github.com/opentofu/opentofu/blob/main/BUILDING.md)

Note: speaker notes FTW!

---

----

## Hello World Dockerized
This task is supposed to demonstrate Docker image build for Go applications.

The program should print the text `Hello World! This is Go.` to the standard output in a docker container.

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/hello-world-dockerized](https://github.com/go-gurus/go_tour_src/tree/main/hello-world-dockerized)

----

----

### Solution

```golang
// main.go
package main

import "fmt"

func main() {
	fmt.Println("Hello World! This is Go.")
}
```

----

```Dockerfile
# Dockerfile
# build stage
FROM golang:1.17.6-alpine AS build

RUN mkdir -p /app
WORKDIR /app

# app src
COPY . .
RUN GOOS=linux GOARCH=amd64 go build -o /bin/app main.go

# result stage
FROM scratch
COPY --from=build /bin/app /bin/app
ENTRYPOINT ["/bin/app"]
```

----

### Building and executing Go code
* build docker image

```bash
$ docker build -t hello-image .
```
* inspect image size

```bash
$ docker images hello-image                                
REPOSITORY   TAG      IMAGE ID       CREATED         SIZE
hello-image  latest   d23a3532deaf   4 minutes ago   1.77MB
```
* run container

```bash
$ docker run --rm -it --name hello-con hello-image
Hello World! This is Go.
```

----

### What we have learned
* How to write a Go Dockerfile
* Use build stages for Go applications
* Go Docker image sizes
* faster build and deployment time
* less server/cluster workload and resource consumption

----

### Further readings

* Golang Docker file
  * [hub.docker.com/_/golang](https://hub.docker.com/_/golang)

---

----

## Testing
In this task, you will learn about writing tests in Go by developing a prime tester in TDD-style.

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/prime-checker](https://github.com/go-gurus/go_tour_src/tree/main/prime-checker)

----

----

### Solution

* lets write a simple `main.go` file

```go
// main.go
package main

func main() {
}
```

----

* now, Lets write a test to specify what we expect from the prime checker yet to be developed.

```golang
// main_test.go
package main
import "testing"

func TestPrimeCheckerTheNaiveWay(t *testing.T) {
	t.Run("should return FALSE when no prime number given", func(t *testing.T) {
		if IsPrime(4) == true {
			t.Fatal("Reported IsPrime=true for 4")
		}
	})

t.Run("should return TRUE when prime number given", func(t *testing.T) {
		if IsPrime(7) == false {
			t.Fatal("Reported IsPrime=false for 7")
		}
	})
}
```

----

### Executing tests

```bash
go test main.go main_test.go

./main_test.go:9:6: undefined: IsPrime
./main_test.go:15:6: undefined: IsPrime
./main_test.go:35:14: undefined: IsPrime
FAIL    command-line-arguments [build failed]
FAIL
```

The test will fail, because the function `IsPrime` is yet to be implemented.

> We will learn a better way to run Go tests later

----

### Implement the (naive) IsPrime function

```golang
// main.go
// ...
import (
  "math"
)

func IsPrime(value int) (result bool) {
	for i := 2; i <= int(math.Floor(math.Sqrt(float64(value)))); i++ {
		if value %i == 0 {
			return false
		}
	}
	return value > 1
}
// ...
```

* run the tests again

```bash
go test main.go main_test.go
ok      command-line-arguments  0.102s
```

----

### Table-driven tests

Cut down redundancy in your tests:
```golang
// main_test.go
// ...
func TestPrimeCheckerTableDriven(t *testing.T) {
	cases := []struct {
		input          int
		expectedResult bool
	}{
		{1, false},
		{2, true},
		{3, true},
		{4, false},
		{7, true},
	}

for _, e := range cases {
		t.Run("Should return expected result ", func(t *testing.T) {
			result := IsPrime(e.input)
			if result != e.expectedResult {
				t.Fatalf("Unexpected Result input=%d expected=%t actual=%t", 
					e.input, 
					e.expectedResult, 
					result)
			}
		})
	}
}
```

----

### Code Coverage

* now lets execute the tests with coverage

```bash
$ go test -cover main.go main_test.go
ok      command-line-arguments  0.191s  coverage: 100.0% of statements
```

----

* lets add also a report

```bash
go test -coverprofile=coverage.out main.go main_test.go
```

```text
mode: set
/Users/grohmio/repos/cc/gophers/golang-for-developers/examples/03-prime-checker/main.go:7.14,8.2 0 0
/Users/grohmio/repos/cc/gophers/golang-for-developers/examples/03-prime-checker/main.go:10.39,11.67 1 1
/Users/grohmio/repos/cc/gophers/golang-for-developers/examples/03-prime-checker/main.go:16.2,16.18 1 1
/Users/grohmio/repos/cc/gophers/golang-for-developers/examples/03-prime-checker/main.go:11.67,12.19 1 1
/Users/grohmio/repos/cc/gophers/golang-for-developers/examples/03-prime-checker/main.go:12.19,14.4 1 1
```

----

* now lets use the go `coverage` tool to generate a graphical report

```bash
go tool cover -html=coverage.out main.go main_test.go
```

![go-playground](img/TESTING/02.png)

----

### What we have learned
* How to use the Go testing package
* How to run tests
* Write our first Go function with in and out parameters
* Basic loops and branching
* How to show code coverage
* How to create coverage reports

---

----

## Templating
In this task we want to write a small program that uses the GO templating engine to create an output for 3 different unit systems.

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/templating](https://github.com/go-gurus/go_tour_src/tree/main/templating)

----

### the task
![xss-result](img/TEMPLATING/01.jpg)

----

### motivation

Imagine you need to present data in a well-formatted output, e.g. in `text` or in files like `html`, `json`, `xml` or `yaml`.

----

### packages
* [pkg.go.dev/text/template](https://pkg.go.dev/text/template)
* [pkg.go.dev/html/template](https://pkg.go.dev/html/template)

Both packages are based on the same basic framework and offer similar functionalities, but are specialised for different purposes.

----

### text/template
* generic templating system for processing plain text
* generation of `text` files, e.g. `YAML`, `JSON`, `INI`, `sh`, `sql` ...
* general data transformation where no special security precautions are required
* no automatic escape logic for special characters
* greater flexibility in output (no HTML-specific restrictions)

----

### html/template
* templating system developed for generating secure `HTML` output
* creation of web pages or emails with `HTML` content
* automatic escape logic, `<`, `>`, `&`, `’` converted into `HTML` entities
* recognises certain `HTML` contexts (e.g. tags, attributes, JavaScript), adapts the escaping strategy
* prevent `XSS`, malicious scripts, displayed securely in browser
* overall: protection against security vulnerabilities in dynamic content

----

### advantages

* fast and lightweight
* part of the GO standard library, no need for additional dependencies
* type safety, strict type-checking during template execution reduces runtime errors
* extensibility, you can define custom template functions to extend functionality

----

### the 1st task

In the first part of the task, we want to create a formatted text output that shows us data in three different systems of units, the metric, the imperial or US system and the maritime and aeronautical system.

----

### unit systems

<table>
  <thead>
    <tr>
      <th>System</th>
      <th>Length</th>
      <th>Speed</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Metric</td>
      <td>m, km</td>
      <td>m/s, km/h</td>
    </tr>
    <tr>
      <td>Imperial/US</td>
      <td>in ("), mi</td>
      <td>ips, mph</td>
    </tr>
    <tr>
      <td>Maritime/Aviation</td>
      <td>nm</td>
      <td>kn</td>
    </tr>
  </tbody>
</table>

----

----

### text/template

```golang
//main.go
package main

import (
	"os"
	"text/template"
)

type Data struct {
	Distance     float64
	DistanceUnit string
	Speed        float64
	SpeedUnit    string
	Time         float64
	TimeUnit     string
}

...

```

----

```golang
//main.go
...

func main() {
	tmpl, err := template.New("example").Parse(`
Distance: {{.Distance}} {{.DistanceUnit}}
Speed:    {{.Speed}} {{.SpeedUnit}}
You are travelling at a speed of {{.Speed}} {{.SpeedUnit}}.
You will cover a distance of {{.Distance}} {{.DistanceUnit}} in {{.Time}} {{.TimeUnit}}.
`)
	if err != nil {
		panic(err)
	}

...

}

```

----

```golang
//main.go
...

func main() {

...
   
   // metric system
	metric_data := Data{1000, "km", 100, "km/h", 10, "h"}
	err = tmpl.Execute(os.Stdout, metric_data)
	if err != nil {
		panic(err)
	}

// imperial system
	imperial_data := Data{621.371, "mi", 62.1371, "mph", 10, "h"}
	err = tmpl.Execute(os.Stdout, imperial_data)
	if err != nil {
		panic(err)
	}
}

```

----

```golang
//main.go
...

func main() {

...
   
	//maritime/aviation system
	maritime_data := Data{539.957, "nm", 53.9957, "kn", 10, "h"}
	err = tmpl.Execute(os.Stdout, maritime_data)
	if err != nil {
		panic(err)
	}
}

```

----

```sh
$ go run main.go

Distance: 1000 km
Speed:    100 km/h
You are travelling at a speed of 100 km/h.
You will cover a distance of 1000 km in 10 h.

Distance: 621.371 mi
Speed:    62.1371 mph
You are travelling at a speed of 62.1371 mph.
You will cover a distance of 621.371 mi in 10 h.

Distance: 539.957 nm
Speed:    53.9957 kn
You are travelling at a speed of 53.9957 kn.
You will cover a distance of 539.957 nm in 10 h.
```

----

### the 2nd task

In the second half of the task we will try to create an `HTML` file that is exposed to an `XSS` attack. For this we will first use the package `text/template` in order to later apply and illustrate the functionality of the package `html/template`.

----

Lets write a new file.

```golang
//main.go
package main

import (
	"text/template"
	"os"
)

type Data struct {
	Distance     float64
	DistanceUnit string
	Speed        float64
	SpeedUnit    string
	Time         float64
	TimeUnit     string
}
...
```

----

```golang
//main.go
...
func main() {
	tmpl, err := template.New("example").Parse(`
<!DOCTYPE html>
    <title>Travel Information</title>
</head>
<body>
    <h1>Travel Information</h1>
    <p>Distance: {{.Distance}} {{.DistanceUnit}}</p>
    <p>Speed: {{.Speed}} {{.SpeedUnit}}</p>
    <p>You are travelling at a speed of {{.Speed}} {{.SpeedUnit}}.</p>
    <p>You will cover a distance of {{.Distance}} {{.DistanceUnit}} in {{.Time}} {{.TimeUnit}}.</p>
</body>
</html>
`)
	if err != nil {
		panic(err)
	}
	...
}
```

----

* the string `<script>alert('XSS-Angriff!')</script>` is our `XSS` attack

```golang
//main.go
...
func main() {
	...
	file, err := os.Create("output.html")
	if err != nil {
		panic(err)
	}
	defer file.Close()

metricData := Data{1000, "km", 100, "<script>alert('XSS-Angriff!')</script>", 10, "h"}
	err = tmpl.Execute(file, metricData)
	if err != nil {
		panic(err)
	}
	println("HTML file 'output.html' has been created.")
}
```

----

* now let's call the go script
	```golang
	$ go run main.go
	HTML file 'output.html' has been created.
	```
* then open the `HTML` file `output.html` in the browser

----

* here you can clearly see the successful XSS attack
![xss-result](img/TEMPLATING/02.jpg)

----

### html/template
* now let's change 1 line
	```golang
	//main.go
	package main

import (
		"html/template"
		...
	)
	...
	```
* then open the `HTML` file `output.html` in the browser again

----

* here you can clearly see the XSS attack has no effect
![xss-result](img/TEMPLATING/03.jpg)

----

* let's take a look at the `output.html` file
![xss-result](img/TEMPLATING/04.jpg)

----

### famous projects
* Helm, Kustomize
	```yaml
	apiVersion: apps/v1
	kind: Deployment
	metadata:
	name: {{ .Values.app.name }}
	spec:
	replicas: {{ .Values.app.replicas }}
	```
* Hugo, Staticman
	```html
	<html>
	<head>
		<title>{{ .Title }}</title>
	</head>
	<body>
		<h1>{{ .Title }}</h1>
		<p>{{ .Content }}</p>
	</body>
	</html>
	```
----

### famous projects
* Terraform/Tofu, Ansible
	```hcl
	data "template_file" "init" {
		template = <<EOT
		#!/bin/bash
		echo "Welcome {{ .Name }}"
	EOT

vars = {
			Name = "Go Templates in Terraform"
		}
	}
	```

----

### famous projects

* Docker Compose, Swarm
	```yaml
	version: '3'
	services:
	app:
		image: {{ .Image }}
		environment:
		- ENV={{ .Env.APP_ENV }}
	```
* Prometheus, Grafana-Dashboards

----

### What we have learned
* What templates in go are suitable for.
* How to use the `text/template` package.
* How to use the `html/template` package.
* Difference between `text/template` and `html/template`.
* How to avoid `XSS` in generated `HTML` files.
* Famous projects using GO template packages.

----

### Further readings 1/3

* go package text template
  * [pkg.go.dev/text/template](https://pkg.go.dev/text/template)
* go package html template
  * [https://pkg.go.dev/html/template](https://pkg.go.dev/html/template)
* source code
  * [github.com/go-gurus/go_tour_src/tree/main/templating](https://github.com/go-gurus/go_tour_src/tree/main/templating)
* Helm
  * [helm.sh](https://helm.sh/)
  * [github.com/helm/helm](https://github.com/helm/helm)
* Kustomize
  * [github.com/kubernetes-sigs/kustomize](https://github.com/kubernetes-sigs/kustomize)

----

### Further readings 2/3

* Hugo
  * [gohugo.io](https://gohugo.io/)
  * [github.com/gohugoio/hugo](https://github.com/gohugoio/hugo)
* Staticman
  * [staticman.net](https://staticman.net/)
  * [github.com/eduardoboucas/staticman](https://github.com/eduardoboucas/staticman)
* Terraform
  * [terraform.io](https://terraform.io/)
  * [github.com/hashicorp/terraform](https://github.com/hashicorp/terraform)
* openTofu
  * [opentofu.org](https://opentofu.org/)
  * [github.com/opentofu/opentofu](https://github.com/opentofu/opentofu)

----

### Further readings 3/3

* Ansible
  * [ansible.com/](https://ansible.com/)
* Docker-Compose
  * [docs.docker.com/compose](https://docs.docker.com/compose/)
  * [github.com/docker/compose](https://github.com/docker/compose)
* Docker-Swarm
  * [docs.docker.com/engine/swarm](https://docs.docker.com/engine/swarm/)
* Prometheus
  * [prometheus.io](https://prometheus.io/)
  * [github.com/prometheus/prometheus](https://github.com/prometheus/prometheus)
* Grafana-Dashboards
  * [grafana.com/grafana/dashboards](https://grafana.com/grafana/dashboards/)

---

----

## Documentation
In this task, we want to build and serve some golang documentation.
https://github.com/go-gurus/go_tour_src/tree/main/documentation

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/documentation](https://github.com/go-gurus/go_tour_src/tree/main/documentation)

----

----

### Create a module

* lets create a new folder and init a module

```shell
$ mkdir documentation
$ cd documentation
$ go mod init grohm.io/documentation
```

----

* lets create a file `main.go` with some documentation

```go
// Package documentation provides a prime number check function and is a documentation showcase.
package documentation

func main() {
}
```

----

* lets build a new sub folder and go file

```go
// prime_checker/prime_checker.go -- <REMOVE THIS COMMENT>

// Package prime_checker provides a prime number check function.
package prime_checker

import (
	"math"
)

// IsPrime check if int value is a prime number.
// It returns a boolean, true if it is prime number, false if not.
func IsPrime(value int) (result bool) {
	for i := 2; i <= int(math.Floor(math.Sqrt(float64(value)))); i++ {
		if value%i == 0 {
			return false
		}
	}
	return value > 1
}

```

----

* install the godoc tool

```shell
$ go install -v golang.org/x/tools/cmd/godoc@latest
```

* serve the documentation

```shell
$ ~/go/bin/godoc -http :6060
```

* visit [localhost:6060/pkg/grohm.io/documentation/](http://localhost:6060/pkg/grohm.io/documentation/)

----

you should see something like this
![documentation](img/DOCUMENTATION/02.png)

----

* now lets add a test file

```go
// prime_checker/prime_checker_example_test.go -- <REMOVE THIS COMMENT>

package prime_checker

import "fmt"

func ExampleIsPrime() {
	res := IsPrime(7)
	fmt.Println(res)
	//Output: true
}
```

----

* execute test case, change `//Output: false` and try again

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

* serve the documentation, check the example

```shell
$ ~/go/bin/godoc -http :6060
```

* visit [localhost:6060/pkg/grohm.io/documentation/](http://localhost:6060/pkg/grohm.io/documentation/)

----

you should see something like this
![documentation](img/DOCUMENTATION/03.png)

----

### What we have learned
* How to write documentation for golang
* How to serve documentation for golang
* How to add example testcases into the documentation

----

### Further readings
* [pkg.go.dev/golang.org/x/tools/cmd/godoc](https://pkg.go.dev/golang.org/x/tools/cmd/godoc)

---

----

## Modules
In this task we want to create different modules in GO. Every single module uses a different logging mechanism. We use `logrus`, `zap` and `golog` in our example.

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/modules](https://github.com/go-gurus/go_tour_src/tree/main/modules)

----

----

### logrus

Lets write a new file and import logrus.

```golang
//main.go
package main

import (
	log "github.com/sirupsen/logrus"
)

func main() {
	log.WithFields(log.Fields{
		"logger": "logrus",
	}).Info("Hello from logrus")
}
```

----

### Using modules

* init modules

```bash
$ go mod init grohm.io/hello-logrus/v2
```

* a new file `go.mod` will be generated

```golang
module grohm.io/hello-logrus/v2
go 1.17
```

----

* install go module, a new file `go.sum` is created

```bash
$ go get github.com/sirupsen/logrus
```

* execute file `main.go`

```bash
$ go run main.go
INFO[0000] Hello from logrus     logger=logrus
```

----

### zap

* quite a higher performance compared to logrus or other logging modules

Now lets write a new file and import zap.

----

```golang
//main.go
package main

import (
	"go.uber.org/zap"
	"time"
)

func main() {
	logger, _ := zap.NewProduction()
	defer logger.Sync()
	logger.Info("Hello from zap.",
		// Structured context as strongly typed Field values.
		zap.String("logger", "zap"),
		zap.Duration("backoff", time.Second),
	)
}
```

----

* init module, install zap and run `main.go`

```bash
$ go mod init grohm.io/hello-zap/v2
$ go get -u go.uber.org/zap
$ go run main.go
{"level":"info","ts":1644345019.7559521,"caller":"02-hello-zap/main.go:11","msg":"Hello from zap.","logger":"zap","backoff":1}
```

----

* `Dockerfile` for modules

```Dockerfile
# Dockerfile modules
# build stage
FROM golang:1.17.6-alpine AS build

RUN mkdir -p /app
WORKDIR /app

# build src
COPY go.mod .
COPY go.sum .
RUN go mod download

# app src
COPY . .
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /bin/app

# result stage
FROM scratch
COPY --from=build /bin/app /bin/app
ENTRYPOINT ["/bin/app"]

```

----

* what are the differences?

```Dockerfile
# Dockerfile
# ...
RUN GOOS=linux GOARCH=amd64 go build -o /bin/app main.go
# ...
```
```Dockerfile
# Dockerfile modules
# ...
# build src
COPY go.mod .
COPY go.sum .
RUN go mod download
# ...
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /bin/app
# ...
```

----

* build the image

```bash
$ docker build -t hello-zap-image .
```
* run the container

```bash
$ docker run --rm -it --name hello-zap-con hello-zap-image
{"level":"info","ts":1644350565.6308103,"caller":"app/main.go:11","msg":"Hello from zap.","logger":"zap","backoff":1}
```
----

### golog

* higher performance than logrus
* lower performance than zap
* easy to use

Now lets write a new file and import golog.

----

```golang
//main.go
package main
import ( "github.com/kataras/golog" )

func main() {
	golog.SetLevel("debug")

golog.Println("This is a raw message, no levels, no colors.")
	golog.Info("This is an info message, with colors (if the output is terminal)")
	golog.Warn("This is a warning message")
	golog.Error("This is an error message")
	golog.Debug("This is a debug message")
	golog.Fatal(`Fatal will exit no matter what,
    but it will also print the log message if logger's Level is >=FatalLevel`)
}
```

----

```bash
$ go mod init grohm.io/hello-golog/v2
$ go get -u github.com/kataras/golog
$ go run main.go
2022/02/09 19:12 This is a raw message, no levels, no colors.
[INFO] 2022/02/09 19:12 This is an info message, with colors (if the output is terminal)
[WARN] 2022/02/09 19:12 This is a warning message
[ERRO] 2022/02/09 19:12 This is an error message
[DBUG] 2022/02/09 19:12 This is a debug message
[FTAL] 2022/02/09 19:12 Fatal will exit no matter what,
    but it will also print the log message if logger's Level is >=FatalLevel
exit status 1
```

----

### Vendoring
* What if a go module repo will be renamed, deleted or moved?
* Go programs will only compile if all module dependencies will stay accessible in the future.
* This is not always the case.
* The solution: vendoring

In this task, we want to explicitly add all dependencies to one of our modules to bypass external dependencies in the build process. We use the vendoring feature of go for this.

----

----

```golang
//main.go
package main
import (
	"go.uber.org/zap"
	"time"
)
func main() {
	logger, _ := zap.NewProduction()
	defer logger.Sync()
	logger.Info("Hello from zap.",
		zap.String("logger", "zap"),
		zap.Duration("backoff", time.Second),
	)
}
```

----

* generate vendor folder

```bash
$ go mod init grohm.io/hello-zap-vendor
$ go get go.uber.org/zap
$ go mod vendor
```

----

* all dependencies are added

```bash
.
├── go.mod
├── go.sum
├── main.go
└── vendor
    ├── go.uber.org
    │   ├── atomic
    │   ├── multierr
    │   └── zap
    └── modules.txt

```

----

### What we have learned
* How to setup modules in go
* How to write Dockerfiles for go modules
* How to use logrus, zap and golog
* How to vendor all dependencies

----

### Further readings
* Go Modules
  * [go.dev/blog/using-go-modules](https://go.dev/blog/using-go-modules)
* Logrus
  * [github.com/sirupsen/logrus](https://github.com/sirupsen/logrus)
* zap
  * [github.com/uber-go/zap](https://github.com/uber-go/zap)
* golog
  * [github.com/kataras/golog](https://github.com/kataras/golog)
* Vendoring in go
  * [go.dev/ref/mod#vendoring](https://go.dev/ref/mod#vendoring)

---

----

## POINTER

In this task we want to create a program that initializes a memory intensive variable. In a refactoring we want to introduce pointers and clarify their advantages.

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/pointer](https://github.com/go-gurus/go_tour_src/tree/main/pointer)

----

* first create a function to init a slice of slices

```go
// main.go
func init_image(image [][]int) [][]int {
  for key_1, val_1 := range image {
    for key_2, _ := range val_1 {
      image[key_1][key_2] = rand.Intn(256)
    }
  }
  return image
}

```

----

* now lets add a `main` method create a slice matrix and define the ranges, finally use the init method and print result

```go
// main.go
// ...
func main() {
  image := make([][]int, 1000)
  for i := 0; i < 1000; i++ {
    image[i] = make([]int, 1000)
  }

image = init_image(image)
  fmt.Println(image)
}
```

----

### Refactoring
Now let's see how pointers improve the program and use less memory.

----

* type `*T` is a pointer to a `T` value, zero value is nil

```go
var p *int
```

* `&` operator generates a pointer to its operand

```go
i := 42
p = &i
```

* `*` operator denotes the pointer's underlying value

```go
fmt.Println(*p) // read i through the pointer p
*p = 21         // set i through the pointer p
```

----

* switch completely to pointers

```go
// main.go
package main

import (
	"fmt"
	"math/rand"
)

func init_image(image_pointer *[][]int) *[][]int {
	for key_1, val_1 := range *image_pointer {
		for key_2, _ := range val_1 {
			(*image_pointer)[key_1][key_2] = rand.Intn(256)
		}
	}
	return image_pointer
}

func main() {
	image := make([][]int, 1000)

for i := 0; i < 1000; i++ {
		image[i] = make([]int, 1000)
	}

pointer := &image

pointer = init_image(pointer)
	fmt.Println(*pointer)
}
```

----

* remove now the return value

```go
// main.go
package main

import (
	"fmt"
	"math/rand"
)

func init_image(image_pointer *[][]int) {
	for key_1, val_1 := range *image_pointer {
		for key_2, _ := range val_1 {
			(*image_pointer)[key_1][key_2] = rand.Intn(256)
		}
	}
}

func main() {
	image := make([][]int, 1000)

for i := 0; i < 1000; i++ {
		image[i] = make([]int, 1000)
	}

init_image(&image)
	fmt.Println(image)
}
```

----

### What we have learned
* Working with range loops
* Working with slices
* Working with pointers

----

### Further readings
* Working with range loops
  * [gobyexample.com/range](https://gobyexample.com/range)
* Working with slices
  * [go.dev/tour/moretypes/7](https://go.dev/tour/moretypes/7)
  * [go.dev/doc/effective_go#slices](https://go.dev/doc/effective_go#slices)
* Working with pointers
  * [go.dev/tour/moretypes/1](https://go.dev/tour/moretypes/1)
  * [go.dev/doc/effective_go#pointers_vs_values](https://go.dev/doc/effective_go#pointers_vs_values)
  * [gobyexample.com/pointers](https://gobyexample.com/pointers)

---

----

## Interface
In this task, we want to use interfaces to build a go service that is able to use logrus, zap and golog as logger.
The service is configured via environment variable `LOGGER=[logrus|zap|golog]`

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/interfaces](https://github.com/go-gurus/go_tour_src/tree/main/interfaces)

----

----

----

### Create an interface

```golang
// main.go
package main

type logInterface interface {
	Info(string)
	Error(string)
}
// ...
```

----

* now lets create some folders and files (a.k.a. packages)

```bash
golog_facade/
    golog_facade.go
logrus_facade/
    logrus_facade.go
zap_facade/
    zap_facade.go
main.go
```

----

* lets create the `logrus` logging facade
* notice: the struct `LogrusStruct` has the two methods that are needed to fulfill the interface `logInterface`

----

```golang
// logrus_facade/logrus_facade.go
package logrus_facade
import ("github.com/sirupsen/logrus")

type LogrusStruct struct{}
func (logger LogrusStruct) Info(msg string) { 
	logrus.Debug(msg + " (logrus)") 
}

func (logger LogrusStruct) Error(msg string) {
	logrus.Error(msg + " (logrus)") 
}
```

----

* lets write the `golog` logging facade

```golang
// golog_facade/golog_facade.go
package golog_facade
import ("github.com/kataras/golog")

type GologStruct struct{}
func (s GologStruct) Info(msg string) { 
	golog.Debug(msg + " (golog)") 
}

func (s GologStruct) Error(msg string) { 
	golog.Error(msg + " (golog)") 
}
```

----

* lets write the `zap` logging facade

```golang
// zap_facade/zap_facade.go
package zap_facade
import ("go.uber.org/zap")

type ZapStruct struct { logger zap.Logger}

func (s ZapStruct) Info(msg string) {
	defer s.logger.Sync()
	s.logger.Info(msg + " (zap)")
}
func (s ZapStruct) Error(msg string) {
	defer s.logger.Sync()
	s.logger.Debug(msg + " (zap)")
}
func NewZapStruct() ZapStruct {
	logger, _ := zap.NewProduction()
	result := ZapStruct{*logger}
	return result
}
```

----

* add a log resolver

```golang
// main.go
// ...
func resolveLogger() logInterface {
    var result logInterface
    if os.Getenv("LOGGER") == "logrus" {
        result = logrus_facade.LogrusStruct{}
    } else if os.Getenv("LOGGER") == "zap" {
        result = zap_facade.NewZapStruct()
    } else if os.Getenv("LOGGER") == "golog" {
        result = golog_facade.GologStruct{}
    } else {
        fmt.Println("Unknown logger, please set $LOGGER envvar.")
    }
    return result
}
```

----

* add a example function

```golang
// main.go
// ...
var logFacade logInterface = resolveLogger()

func doSomething() {
    logFacade.Info("I really dont care which logging tool is used to put this info")
    time.Sleep(time.Second)
    logFacade.Error("I really dont care which logging tool is used to put this error")
}
func main() { doSomething() }
```

----

* init project and download modules

```bash
$ go mod init grohm.io/interfaces/v2
$ go get github.com/sirupsen/logrus
$ go get -u go.uber.org/zap
$ go get -u github.com/kataras/golog
```

----

* execute with different configurations

```bash
$ LOGGER=golog go run main.go
[INFO] 2022/02/12 20:20 i really dont care which logging tool is used to put this info (golog)
[ERRO] 2022/02/12 20:20 i really dont care which logging tool is used to put this error (golog)
```

```bash
$ LOGGER=logrus go run main.go
INFO[0000] i really dont care which logging tool is used to put this info (logrus) 
ERRO[0001] i really dont care which logging tool is used to put this error (logrus)
```

```bash
$ LOGGER=zap go run main.go
{"level":"info","ts":1644693743.249532,"caller":"zap_facade/zap_facade.go:14","msg":"i really dont care which logging tool is used to put this info (zap)"}
{"level":"error","ts":1644693744.2508721,"caller":"zap_facade/zap_facade.go:19","msg":"i really dont care which logging tool is used to put this error (zap)",
"stacktrace":"grohm.io/interfaces/v2/zap_facade.ZapStruct.Error\n\t/Users/grohmio/repos/cc/gitlab/golang_workshop/examples/05_interfaces/zap_facade/zap_facade.go:19\nmain.doSomething\n\t/Users/grohmio/repos/cc/gitlab/golang_workshop/examples/05_interfaces/main.go:35\nmain.main\n\t/Users/grohmio/repos/cc/gitlab/golang_workshop/examples/05_interfaces/main.go:39\nruntime.main\n\t/usr/local/opt/go/libexec/src/runtime/proc.go:255"}
```

----

### Interface Mocking

In this task we want to inject a mock to be able to test function calls on the interface.

----

----

* install gomock

```bash
$ go install github.com/golang/mock/mockgen@v1.6.0
$ go get github.com/golang/mock/gomock
```

* generate mocks

```bash
$ mockgen -source=main.go -destination mock_main/mock_main.go
```

----

* result, mocked interface and some helper functions

```go
//./mock_main/mock_main.go
package mock_main
// ...
// MocklogInterface is a mock of logInterface interface.
type MocklogInterface struct {
	ctrl     *gomock.Controller
	recorder *MocklogInterfaceMockRecorder
}
//...
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MocklogInterface) EXPECT() *MocklogInterfaceMockRecorder {
	return m.recorder
}
// Error mocks base method.
func (m *MocklogInterface) Error(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Error", arg0)
}
//..
```

----

* now we need also to mock the function `func resolveLogger() logInterface`, change

```go
// main.go
// ...
func resolveLogger() logInterface {
// ...
```
```go
// main.go
// ...
var resolveLogger = func() logInterface {
// ...
```

----

* now lets write the test

```go
// main_test.go
package main
// ...
func Test_doSomething(t *testing.T) {
	ctrl := gomock.NewController(t)

// mock the log facade in main
	logFacadeMock := mock_main.NewMocklogInterface(ctrl)

// inject mock via mocked function
	resolveLogger = func() logInterface {
		return logFacadeMock
	}
	logFacade = resolveLogger()

// asserts that the first calls to Info() and Error() is passed the correct strings
	// anything else will fail
	logFacadeMock.EXPECT().Info("I really dont care which logging tool is used to put this info")
	logFacadeMock.EXPECT().Error("I really dont care which logging tool is used to put this error")

doSomething()
}
```

----

* execute the test

```bash
$ LOGGER=logrus go test
PASS
ok      grohm.io/interfaces/v2    1.444s
```

----

### What we have learned
* How to use interfaces
* How to use subpackages
* How to mock interfaces
* How to mock functions

----

### Further readings
* [go.dev/doc/effective_go#interfaces](https://go.dev/doc/effective_go#interfaces)
* [github.com/golang/mock](https://github.com/golang/mock)

---

----

## Error Handling

Let's talk about errors and error handling in Go.

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/error-handling](https://github.com/go-gurus/go_tour_src/tree/main/error-handling)

----

### Golang Error Key Principles

- Errors are values
- Errors don't directly affect control flow
- Developer is encouraged to explicitly handle errors

----

### Errors are Values

Function returning an error:

```golang
func fail() error {
    return fmt.Errorf("This did not work out.")
}
```

----

### Errors don't directly affect control flow
Check if an error occurred:

```golang
err := fail()
if err != nil {
	panic(err)
}
```
> An error has no effect unless actively handled

----

#### Distinguishing between multiple errors

Use-cases for distinguishable errors:
- Systematic logging
- Sophisticated remedy strategies

----

##### Distinguishing via Sentinel Values

```golang
var noStageNameProvided = errors.New("No Stage name provided")
var invalidStageNameProvidedError = errors.New("Invalid stage name provided")

func resolveService() (string, error) {
	stageName := os.Getenv(stageEnvironmentKey)

switch stageName {
	case "dev":
		return "https://dev.fake", nil
	case "staging":
		return "https://stage.my.cloud", nil
	case "":
		return "UNKNOWN_ENVIRONMENT", noStageNameProvided
	default:
		return "UNKNOWN_ENVIRONMENT", invalidStageNameProvidedError
	}
}
```

----

##### Distinguishing via Sentinel Values

```golang
...
serviceUrl, err := resolveService()

if err != nil {
    switch {
        case errors.Is(err, noStageNameProvided):
            fmt.Println("No stage name provided. Using default.")
            serviceUrl = "https://default.my.cloud"

case errors.Is(err, invalidStageNameProvidedError):
            panic(err)
    }
}
```

----

#### Wrapping errors
Use-Cases:
- Adding context to errors, such as custom exceptions
- Supporting an inner error construct

----

#### Wrapping errors
The previous function with wrapped errors:

```golang
var noStageNameProvided = errors.New("No Stage name provided")
var invalidStageNameProvidedError = errors.New("Invalid stage name provided")

func resolveService() (serviceUrl string, err error) {
	stageName := os.Getenv(stageEnvironmentKey)

serviceUrl = "UNKNOWN_ENVIRONMENT"
	switch stageName {
	case "dev":
		serviceUrl = "https://dev.fake"
	case "staging":
		serviceUrl = "https://stage.my.cloud"
	case "":
		err = noStageNameProvided
	default:
		err = fmt.Errorf("%w . %s is not a known stageName", 
			invalidStageNameProvidedError, stageName)
	}
	return
}
// ...
```
----

#### Wrapping errors
Handling an invalid input

```golang
//...
serviceUrl, err := resolveService()

if err != nil {
	switch {
	case errors.Is(err, noStageNameProvided):
		fmt.Println("No stage name provided. Using default.")
		serviceUrl = "https://default.my.cloud"

case errors.Is(err, invalidStageNameProvidedError):
		panic(err)
	}
}
```

Output:

```golang
panic: Invalid stage name provided . Gophers! is not a known stageName
```

----

### What we have learned
* Errors are values in Go
* Errors have to be handled explicitly
* How errors are thrown and detected
* How to add context to errors

----

### Further readings
* Working with Errors in Go 1.13
  * [go.dev/blog/go1.13-errors](https://go.dev/blog/go1.13-errors)
* Errors are Values
  * [go.dev/blog/errors-are-values](https://go.dev/blog/errors-are-values)

---

----

## Parallelization
In this task, we want to use go routines and channels to build a simple go load balancer.
The loadbalancer will spawn parallel go routines in the background, each of these routines will process a time intensive workload.

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/parallel](https://github.com/go-gurus/go_tour_src/tree/main/parallel)

----

----

### quick look on channels and go routines

```go
// main.go
package main

import ("fmt")

func SendDataToChannel(integerChannel chan int, value int) {
	integerChannel <- value
}

func main() {
	integerChannel := make(chan int)
	go SendDataToChannel(integerChannel, 42)
	value := <-integerChannel
	fmt.Println(value)
}
```

```go
➜ go run main.go
42

```

----

What is this program doing?
* define a function that puts values to an integer channel
* create a channel that serves integers
* executes function to put 42 to the channel in background
* get a value from channel
* print the value

----

----

### simple loadbalancer using channels and go routines

----

* first start with a function that sends random values to our channel
* the function will sleep for a short time frame
* infinite loop

```go
// main.go
package main

import (
	"fmt"
	"math/rand"
	"strconv"
	"time"
)

func sendDataToChannel(input chan int) {
	for {
		value := rand.Intn(50)
		input <- value
		time.Sleep(time.Duration(value))
	}
}
```

----

* lets create a worker function
* this function takes an integer from an input channel
* multiply the value with 1000
* sleeps a large time frame (to simulate workload)
* return a significant message
* all in an infinite loop

```golang
// main.go
// ...
func processChannel(id int, input chan int, output chan string) {
  for {
	  value, _ := <-input
	  result := value * 1000
	  time.Sleep(time.Duration(result))
	  output <- "worker: " + strconv.Itoa(id) + ", input: " + strconv.Itoa(value) + ", result: " + strconv.Itoa(result)
  }
}
```

----

* add load balancer
* create 2 channels, input (integer) and output (text)
* create subprocess to constantly add random values to input channel
* create x workers to handle the input channel and add results to output channel
* get and print values from output channel in an endless loop

----

```golang
// main.go
// ...
func main() {
    rand.Seed(time.Now().UnixNano())
    input := make(chan int)
	output := make(chan string)

go sendDataToChannel(input)
    go processChannel(0, input, output)
    go processChannel(1, input, output)
	//...
  
    for {
        select {
        case x, ok := <-output:
            if ok {
                fmt.Println(x)
            } else {
                fmt.Println("Channel closed!")
            }
        }
    }
}
```

----

* lets execute the load balancer (10 worker)
```shell
➜ go run main.go
worker: 8, input: 20, result: 20000
worker: 7, input: 14, result: 14000
worker: 5, input: 115, result: 115000
worker: 5, input: 16, result: 16000
worker: 3, input: 297, result: 297000
worker: 7, input: 232, result: 232000
worker: 6, input: 431, result: 431000
worker: 2, input: 719, result: 719000
worker: 0, input: 660, result: 660000
worker: 1, input: 682, result: 682000
worker: 9, input: 728, result: 728000
worker: 7, input: 389, result: 389000
worker: 8, input: 766, result: 766000
```

----

### Refactoring

----

* first lets add a loop, also change order of getting and sending data

```go
// main.go
func main() {
  // ... 
  for i := 0; i < 10; i++ {
    go processChannel(i, input, output)
  }
  go sendDataToChannel(input)
  // ...
}
```

----

* close the channels if not needed anymore

```go
// main.go
// ...
func main() {
  // ...
  input := make(chan int)
  output := make(chan string)
  defer close(input)
  defer close(output)
  // ...
}
```

----

* next, we just add a limited amount of messages to the input channel, this will break after 100 messages are handled

```go
// main.go
func sendDataToChannel(input chan int) {
  for i := 0; i < 100; i++ {
    value := rand.Intn(50)
    input <- value
    time.Sleep(time.Duration(value))
  }
}
```

----

* next, we will add non blocking channels

```go
// main.go
func processChannel(id int, input chan int, output chan string) {
  for {
    var result int
    select {
    case value := <-input:
      result = value * 1000
      output <- "worker: " + strconv.Itoa(id) + ", input: " + strconv.Itoa(value) + ", result: " + strconv.Itoa(result)
    default:
      // do nothing
    }
    time.Sleep(time.Duration(result))
  }
}
```

----

* at the end your main file should look like this

```go
// main.go
package main

import (
	"fmt"
	"math/rand"
	"strconv"
	"time"
)

func sendDataToChannel(input chan int) {
	for i := 0; i < 100; i++ {
		value := rand.Intn(50)
		input <- value
		time.Sleep(time.Duration(value))
	}
}

func processChannel(id int, input chan int, output chan string) {
	for {
		var result int
		select {
		case value := <-input:
			result = value * 1000
			output <- "worker: " + strconv.Itoa(id) + ", input: " + strconv.Itoa(value) + ", result: " + strconv.Itoa(result)
		default:
			// do nothing
		}
		time.Sleep(time.Duration(result))
	}
}

func main() {
	rand.Seed(time.Now().UnixNano())

input := make(chan int)
	output := make(chan string)
	defer close(input)
	defer close(output)

for i := 0; i < 10; i++ {
		go processChannel(i, input, output)
	}
	go sendDataToChannel(input)

for {
		select {
		case x, ok := <-output:
			if ok {
				fmt.Println(x)
			} else {
				fmt.Println("Channel closed!")
			}
		}
	}
}
```

----

### What we have learned
* How to use channels
* How to close channels
* How to use non blocking channels
* How to use multiple go routines
* How to use select statement to wait on channel results
* How to use endless loops
* How to build a simple loadbalancer

----

### Further readings
* [gobyexample.com/channels](https://gobyexample.com/channels)
* [go.dev/doc/effective_go#channels](https://go.dev/doc/effective_go#channels)
* [gobyexample.com/goroutines](https://gobyexample.com/goroutines)
* [go.dev/doc/effective_go#goroutines](https://go.dev/doc/effective_go#goroutines)
* [gobyexample.com/for](https://gobyexample.com/for)
* [go.dev/doc/effective_go#for](https://go.dev/doc/effective_go#for)
* [gobyexample.com/select](https://gobyexample.com/select)

---

----

## generics

We want to create a go program that provides various functions for processing lists of different types.
Then we will optimize this program with generics and refactor the functions to show their advantages.

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/generics](https://github.com/go-gurus/go_tour_src/tree/main/generics)

----

* first create a function that returns the sum of an integer map

```go
// main.go
package main

import "fmt"

func SumInts(m map[string]int64) int64 {
  var sum int64
  for _, val := range m {
    sum += val
  }
  return sum
}

```

----

* now lets create a similar function that returns the sum of an float map

```go
// main.go
// ...
func SumFloats(m map[string]float64) float64 {
  var sum float64
  for _, val := range m {
    sum += val
  }
  return sum
}
```

----

* now lets create the main function, create two maps and call the two functions

```go
// main.go
// ...
func main() {
  ints := map[string]int64{
    "1st": 34,
    "2nd": 12,
  }

floats := map[string]float64{
    "1st": 35.98,
	"2nd": 26.99,
  }

fmt.Printf("Non-Generic Sums: %v and %v\n",
    SumInts(ints),
    SumFloats(floats))
}
```

----

* execute the main function

```shell
$ go run main.go
Non-Generic Sums: 46 and 62.97
```

----

### Refactoring
Now lets switch to a generic function.

----

* add a function that can handle multiple types

```go
package main

import "fmt"

func SumIntsOrFloats[CompType comparable, ValueType int64 | float64](m map[CompType]ValueType) ValueType {
  var sum ValueType
  for _, val := range m {
    sum += val
  }
  return sum
}
```

----

* what is new here?
```
[CompType comparable, ValueType int64 | float64]
```
* the possible types for the function are defined
* the rest of the function uses the generic types
```go
func ... (m map[CompType]ValueType) ValueType {
```
```go
var sum ValueType
```

----

* lets create a `main` function again

```go
// main.go
// ...
func main() {
  ints := map[string]int64{
    "1st":  34,
	"2nd": 12,
  }

floats := map[string]float64{
    "1st":  35.98,
	"2nd": 26.99,
  }

fmt.Printf("Generic Sums: %v and %v\n",
    SumIntsOrFloats[string, int64](ints),
    SumIntsOrFloats[string, float64](floats))
}
```

----

* run the code

```shell
$ go run main.go
Generic Sums: 46 and 62.97
```

----

### Continue Refactoring
Now lets add some minor improvements to the code.

----

* lets add a type constraint

```go
// main.go
// ...
type Number interface {
  int64 | float64
}
```

----

* use the type constraint

```go
// main.go
// ...
func SumNumbers[CompType comparable, Number int64 | float64](m map[CompType]Number) Number {
  var sum Number
  for _, val := range m {
    sum += val
  }
  return sum
}
```

----

* adapt the main function, notice the `CompType` is not needed in the function call

```go
// main.go
// ...
func main() {

fmt.Printf("Generic Sums with Constraint: %v and %v\n",
    SumNumbers(ints),
    SumNumbers(floats))
}
```

```shell
$ go run main.go
Generic Sums with Constraint: 46 and 62.97
```

----

### generic library lo
[github.com/samber/lo](https://github.com/samber/lo) contains many helpers for:
* slices
  * Filter, Map, ForEach, Subset, ...
* maps
  * Keys, Invert, ...
* strings
  * Substring, ...
* channels
  * SliceToChannel, Batch, ChannelMerge, ...
* many more

----

### What we have learned
* How to use maps
* How to use generics
* have a look on generic library

----

### Further readings
* generics tutorial
  * [go.dev/doc/tutorial/generics](https://go.dev/doc/tutorial/generics)
  * [gobyexample.com/generics](https://gobyexample.com/generics)
* lo - generics library
  * [pkg.go.dev/github.com/samber/lo](https://pkg.go.dev/github.com/samber/lo)
  * [github.com/samber/lo](https://github.com/samber/lo)

---

----

## GraphQL

Our beer fridge provides HTTP/REST style APIs now. With Go, it is also possible to provide a GraphQL interface. Lets dive into
it.

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/graphql](https://github.com/go-gurus/go_tour_src/tree/main/graphql)

----

### GraphQL in Go

Approaches

* Code first
* Schema first

----

### Code first

- Generate GraphQL scheme from Go types
- Define relations by type relations and annotations

----

### Schema first

- Generate Go classes and Queries from GraphQL scheme

----

### Schema-first with GraphQLGen

----

### Micro Project: Beer Fridge

As a thirsty employee, I want:

- the same functionality as the REST API variant so I don't need two APIs
- a built in filter for beer IBU and origin to discover new beers

----

#### Generate Skeleton Project

```bash
go run github.com/99designs/gqlgen init
```

----

#### Write a simple beer schema

```graphql
# graph/beer.graphqls
type Beer {
    id: ID!
    manufacturer: String!
    name: String!
    origin: String!
    type: String!
    percentage : Float!
    ibu: Int
}
```

----

#### Write a simple beer schema

##### GraphQL type documentation

Of course the GraphQL type documentation is passed through to the generated Go code

```graphql
# graph/beer.graphqls
"""
Beer defines key criteria of a beer
"""
type Beer {
    id: ID!
    manufacturer: String!
    name: String!
    """
    Origin of the beer as ISO country code
    """
    origin: String!
    type: String!
    percentage : Float!
    ibu: Int
}
```

----

#### Provide a query specification

To expose data to clients, we need a Query specification.

```graphql
# graph/schema.graphqls
type Query {
    beers: [Beer!]!
}
```

----

#### Generate Go code from schema

```bash
go run github.com/99designs/gqlgen generate
```

----

#### Lets stick with a fake data source for now

```golang
// graph/resolver.go
type Resolver struct {
    BeerResolver func () []*model.Beer
}
```

```golang
// service/BeerService.go
func GetBeers() []*model.Beer {
    return funnyFakeBeerList
}
```

----

#### Implement resolver

```go
// graph/schema.resolvers.go

// Beers is the resolver for the beers field.
func (r *queryResolver) Beers(ctx context.Context) ([]*model.Beer, error) {
    return r.BeerResolver(), nil
}
```

----

#### How to issue a GraphQL Query

#### Web Interface
GraphiQL Web Interface: http://localhost:8080

#### Direct HTTP request 
```bash
curl 'http://localhost:8080/query' \  
  --data-raw '{"query":"..."'} \
```
----
#### Our first GraphQL Query

```graphql
query{
    beers {
        id
        name
        manufacturer
        ibu
        percentage
    }
}
```

```json
{
  "data": {
    "beers": [
      {
        "id": "OMTR",
        "name": "Oostmalle Trappist",
        "manufacturer": "Oostmalle",
        "ibu": 48,
        "percentage": 14.1
      } // more...
```

----

#### We care for certain properties only..

```graphql
query{
    beers {
        origin
        manufacturer
        percentage
    }
}
```

```json
"data": {
    "beers": [
        {
        "origin": "BE",
        "manufacturer": "Oostmalle",
        "percentage": 14.1
        }, ///more
```
----

----

----

<big>Haven't we mentioned filtering before?</big>

----

#### Provide a query with a filter

1. Update Query schema

```graphql
# graph/schema.graphqls

type Query {
    beers(minPercentage: Float = 0.0) : [Beer!]!
}
```

2. Re-Run code generator

```bash
go run github.com/99designs/gqlgen generate
```

----

#### Provide a query with a filter

3. Implement resolver

```golang
// graph/schema.resolvers.go

func (r *queryResolver) Beers(_ context.Context, 
	minPercentage *float64) ([]*model.Beer, error) {
    if *minPercentage < 0.0 {
        return nil, errors.New("percentage must be bigger or equal to 0")
    }
    
    beersFiltered := lo.Filter[*model.Beer](r.BeerResolver(), 
		func(it *model.Beer, _ int) bool {
        return it.Percentage >= *minPercentage
    })
    
    return beersFiltered, nil
}
```

----

#### Query with filters

Return all beers with >10% and where they are from.

```graphql
query{
    beers(minPercentage : 10) {
        name
        origin
        manufacturer
        percentage
    }
}
```

```json
{
  "data": {
    "beers": [
      {
        "name": "Rituel Quatorze",
        "origin": "BE",
        "manufacturer": "Grim Fandango",
        "percentage": 14.9
      }
      // more
    ]
  }
}
```

----

### Further readings

* [https://gqlgen.com/getting-started/(https://gqlgen.com/getting-started/)
* [https://graphql.org/](https://graphql.org/)

---

----

## gin

Gin is a web framework written in Go (Golang).
It features a martini-like API with performance that is up to 40 times faster thanks to httprouter.
If you need performance and good productivity, you will love Gin.

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/gin](https://github.com/go-gurus/go_tour_src/tree/main/gin)

----

### Getting started

* load gin modules

```bash
$ go get -u github.com/gin-gonic/gin
```

----

```go
// main.go
package main

import "github.com/gin-gonic/gin"

func main() {
	r := gin.Default()
	r.GET("/ping", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "pong",
		})
	})
	r.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
}
```

----

* start service

```bash
$ go run main.go
```

* visit your browser [0.0.0.0:8080/ping](http://0.0.0.0:8080/ping)
```json
{
  message: "pong"
}
```

----

* if errors show up

```bash
...  //go:linkname must refer to declared function or variable
```

* fix

```bash
$ go get -u golang.org/x/sys
```

----

* init and run project

```bash
$ go mod init grohm.io/gin-ping-pong
$ go run main.go
```

----

### A real world API Service
The Beer Fridge

- Serve temperature sensor values
- Provide information regarding the content

----

### A simple read function
in a functional style

```go
func SetupApi(r *gin.Engine, temperatureProvider func() float32) {
    api := r.Group("/api")
    {
        api.GET("/temperature", 
			composeGetTemperatureHandler(temperatureProvider))
    }
}
```

----

### A simple read function
in a functional style

```go
func getRandomTemperature() float32 {
    return 4 + rand.Float32()*3
}

func composeGetTemperatureHandler(
	    temperatureProvider func() float32) func(context *gin.Context) {
    return func(context *gin.Context) {
        context.JSON(200, gin.H{
            "temperature": temperatureProvider(),
        })
    }
}
```

----

### A simple read function
in a functional style

```bash
GET http://localhost:8080/api/temperature
```

```json
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Date: Fri, 17 Jun 2022 13:48:16 GMT
Content-Length: 24

{
"temperature": 5.813981
}
```

----

### Evaluating Query Parameters

```go
type GetBeersFilterQuery struct {
    Origin string `form:"origin"`
}

applyQueryFilter := func(context *gin.Context, beers []Beer) []Beer {
		var query GetBeersFilterQuery

if context.ShouldBindQuery(&query) == nil {
			// Evaluate query here
		}
		return beers
	}
```

----

### Evaluating Query Parameters
Filter method in Go 1.18 with generics
```go
if context.ShouldBindQuery(&query) == nil {
  beers = lo.Filter[Beer](beers, func(it Beer, _ int) bool {
    return query.Origin == "" || it.Origin == query.Origin
  })
}
```

----

### Mapping Result
i.E. adding HATEOAS

```go
mapHATEOAS := func(beers []Beer) []HAETEOASResource[Beer] {
		return lo.Map[Beer, HAETEOASResource[Beer]](beers, 
			func(it Beer, _ int) HAETEOASResource[Beer] {
			return HAETEOASResource[Beer]{
				Data: it,
				Links: map[string]string{
					"info":       "/" + it.urlsafePathToken(),
					"deposit":    "/" + it.urlsafePathToken() + "/deposit",
				},
			}
		})
	}
```

----

### What we have learned
* First look on gin webframework
* how to write microservices using gin
* how to build request handlers in a functional style
* how to setup a router
* how to evaluata query parameter
* how to use lodash for go

----

### Further readings
* gin
  * [github.com/gin-gonic/gin](https://github.com/gin-gonic/gin)

---

----

## go-swagger

We want to build the `beer-fridge` service again.
This service using the interface first approach with `go-swagger` code generation.

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/go-swagger](https://github.com/go-gurus/go_tour_src/tree/main/go-swagger)

----

----

### get go-swagger
* install `go-swagger` via docker on mac and linux

```shell
docker pull quay.io/goswagger/swagger
alias swagger='docker run --rm -it  --user $(id -u):$(id -g) -e \
GOPATH=$(go env GOPATH):/go -v $HOME:$HOME -w $(pwd) quay.io/goswagger/swagger'
swagger version
```

* install `go-swagger` via docker on windows

```shell
docker run --rm -it --env GOPATH=/go -v %CD%:/go/src -w /go/src quay.io/goswagger/swagger
```

* check swagger version

```shell
$ swagger version
version: v0.29.0
commit: 53696caa1e8a4e5b483c87895d54eda202beb3b0
```

----

* init a new project

```shell
swagger init spec \
  --title "A beer fridge service" \
  --description "Beer fridge service build with go-swagger" \
  --version 1.0.0 \
  --scheme http \
  --consumes application/io.grohm.go-workshop.beer-fridge.v1+json \
  --produces application/io.grohm.go-workshop.beer-fridge.v1+json
```

----

* check the result, file `swagger.yml`

```yaml
# swagger.yml
consumes:
- application/io.grohm.go-workshop.beer-fridge.v1+json
info:
  description: Beer fridge service build with go-swagger
  title: A beer fridge service
  version: 1.0.0
paths: {}
produces:
- application/io.grohm.go-workshop.beer-fridge.v1+json
schemes:
- http
swagger: "2.0"
```

----

* validate the interface file

```shell
➜ swagger validate swagger.yml 
2022/07/01 19:57:02 
The swagger spec at "swagger.yml" is valid against swagger specification 2.0
2022/07/01 19:57:02 
The swagger spec at "swagger.yml" showed up some valid but possibly unwanted constructs.
2022/07/01 19:57:02 See warnings below:
2022/07/01 19:57:02 - WARNING: spec has no valid path defined

```

----

* lets adapt the interface to our needs
* add definitions for `beer` and `teperature` of our fridge

```yaml
# swagger.yml
# ...
definitions:
  beer:
    type: object
    required:
      - title
      - origin
      - volume-percentage
    properties:
      id:
        type: integer
        format: int64
        readOnly: true
      title:
        type: string
        minLength: 1
      origin:
        type: string
        minLength: 1
      volume-percentage:
        type: number
        format: float
        minLength: 1
  temperature:
    type: integer
    format: int64
    readOnly: true
```

----

* add endpoints for `/beers` and `/temperature`

```yaml
paths:
  /beers:
    get:
      tags:
        - beers
      parameters:
        - name: limit
          in: query
          type: integer
          format: int32
          default: 10
      responses:
        200:
          description: list the beer operations
          schema:
            type: array
            items:
              $ref: "#/definitions/beer"
  /temperature:
    get:
      tags:
        - fridge
      responses:
        200:
          description: return the current fridge temperature
          schema:
            $ref: "#/definitions/temperature"
```

----

* init module, generate service and get modules

```shell
➜ go mod init grohm.io/beer-fridge-go-swagger
➜ swagger generate server -A beer-fridge -f ./swagger.yml
➜ go get -u -f ./...
```

----

* check generated code

```shell
➜ tree 
.
├── cmd
│ └── beer-fridge-server
│     └── main.go
├── go.mod
├── go.sum
├── models
│ ├── beer.go
│ └── temperature.go
├── restapi
│ ├── configure_beer_fridge.go
│ ├── doc.go
│ ├── embedded_spec.go
│ ├── operations
│ │ ├── beer_fridge_api.go
│ │ ├── beers
│ │ │ ├── get_beers.go
│ │ │ ├── get_beers_parameters.go
│ │ │ ├── get_beers_responses.go
│ │ │ └── get_beers_urlbuilder.go
│ │ └── fridge
│ │     ├── get_temperature.go
│ │     ├── get_temperature_parameters.go
│ │     ├── get_temperature_responses.go
│ │     └── get_temperature_urlbuilder.go
│ └── server.go
└── swagger.yml

7 directories, 19 files
```

----

* start service

```shell
➜ go run cmd/beer-fridge-server/main.go
2022/08/28 16:34:16 Serving beer fridge at http://127.0.0.1:54746
```

* visit service under [127.0.0.1:54746/beers](http://127.0.0.1:65480/beers) (take the custom port into account)

```html
"operation beers.GetBeers has not yet been implemented"
```

----

* build the server binary

```shell
➜ go build -o beer-fridge-server ./cmd/beer-fridge-server/main.go
➜ ./beer-fridge-server --help
```

* run the server as binary

```shell
➜ ./beer-fridge-server --port 8080
2022/08/05 19:18:18 Serving beer fridge at http://127.0.0.1:8080
```

* visit service under [127.0.0.1:8080/beers](http://127.0.0.1:8080/beers)

```html
"operation beers.GetBeers has not yet been implemented"
```

----

* add `error` definition
* enlarge endpoint `/beers`, add beer

```yaml
# swagger.yml
definitions:
  # ...
  error:
    type: object
    required:
      - message
    properties:
      code:
        type: integer
        format: int64
      message:
        type: string
# ...
paths:
  /beers:
    #...
    post:
      tags:
        - todos
      operationId: addOne
      parameters:
        - name: body
          in: body
          schema:
            $ref: "#/definitions/beer"
      responses:
        201:
          description: Created
          schema:
            $ref: "#/definitions/beer"
        default:
          description: error
          schema:
            $ref: "#/definitions/error" 
```

----

* enlarge endpoint `/beers`, delete a beer

```yaml
# swagger.yml
/paths:
  beers:
    delete:
      tags:
        - beers
      operationId: destroyOne
      responses:
        204:
          description: Deleted
        default:
          description: error
          schema:
            $ref: "#/definitions/error"
```

----

* final file should look like this

```yaml
consumes:
- application/io.grohm.go-workshop.beer-fridge.v1+json
info:
  description: Beer fridge service build with go-swagger
  title: A beer fridge service
  version: 1.0.0
produces:
- application/io.grohm.go-workshop.beer-fridge.v1+json
schemes:
- http
swagger: "2.0"
definitions:
  beer:
    type: object
    required:
      - title
      - origin
      - volume-percentage
    properties:
      id:
        type: integer
        format: int64
        readOnly: true
      title:
        type: string
        minLength: 1
      origin:
        type: string
        minLength: 1
      volume-percentage:
        type: number
        format: float
        minLength: 1
  temperature:
    type: integer
    format: int64
    readOnly: true
  error:
    type: object
    required:
      - message
    properties:
      code:
        type: integer
        format: int64
      message:
        type: string
paths:
  /beers:
    get:
      operationId: getAllBeers
      tags:
        - beers
      parameters:
        - name: limit
          in: query
          type: integer
          format: int32
          default: 20
      responses:
        200:
          description: list the beer operations
          schema:
            type: array
            items:
              $ref: "#/definitions/beer"
    post:
      tags:
        - beers
      operationId: addOne
      parameters:
        - name: body
          in: body
          schema:
            $ref: "#/definitions/beer"
      responses:
        201:
          description: Created
          schema:
            $ref: "#/definitions/beer"
        default:
          description: error
          schema:
            $ref: "#/definitions/error"
  /beers/{id}:
    delete:
      tags:
        - beers
      operationId: destroyOne
      parameters:
        - type: integer
          format: int64
          name: id
          in: path
          required: true
      responses:
        204:
          description: Deleted
        default:
          description: error
          schema:
            $ref: "#/definitions/error"
  /temperature:
    get:
      operationId: getTemperature
      tags:
        - fridge
      responses:
        200:
          description: return the current fridge temperature
          schema:
            $ref: "#/definitions/temperature"
```

----

* build the server again

```shell
swagger generate server -A beer-fridge -f ./swagger.yml
go get -u -f ./...
```

* lets add a simple beer data container

```go
// beer_container/beer_container.go
package beers

import (
	"grohm.io/beer-fridge-go-swagger/models"
	"github.com/go-openapi/errors"
	"sync"
	"sync/atomic"
)

var beerList = make(map[int64]*models.Beer)
var lastID int64
var beerListLock = &sync.Mutex{}

func newBeerID() int64 {
	return atomic.AddInt64(&lastID, 1)
}
```

----

* add a beer to list

```go
// beer_container/beer_container.go
//...
func AddBeer(beer *models.Beer) error {
	if beer == nil {
		return errors.New(500, "beer must be present")
	}

beerListLock.Lock()
	defer beerListLock.Unlock()

newID := newBeerID()
	beer.ID = newID
	beerList[newID] = beer

return nil
}
```

----

* drink and remove a beer from list

```go
// beer_container/beer_container.go
//...
func DeleteBeer(id int64) error {
	beerListLock.Lock()
	defer beerListLock.Unlock()

_, exists := beerList[id]
	if !exists {
		return errors.NotFound("not found: item %d", id)
	}

delete(beerList, id)
	return nil
}
```

----

* show all beer's on list

```go
// beer_container/beer_container.go
//...
func AllBeers(limit int32) (result []*models.Beer) {
	result = make([]*models.Beer, 0)
	for _, beer := range beerList {
		if len(result) >= int(limit) {
			return
		}
		result = append(result, beer)
	}
	return
}
```

----

* now lets integrate the beer container into the api, add following lines

```go
// restapi/configure_beer_fridge.go
// ...
func configureAPI(api *operations.BeerFridgeAPI) http.Handler {
	// ...
	api.BeersAddOneHandler = beers.AddOneHandlerFunc(func(params beers.AddOneParams) middleware.Responder {
	    if err := beer_container.AddBeer(params.Body); err != nil {
	        return beers.NewAddOneDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
	    }
	    return beers.NewAddOneCreated().WithPayload(params.Body)
	})

api.BeersDestroyOneHandler = beers.DestroyOneHandlerFunc(func(params beers.DestroyOneParams) middleware.Responder {
	    beer_container.DeleteBeer(params.ID)
	    return beers.NewDestroyOneNoContent()
	})

api.BeersGetAllBeersHandler = beers.GetAllBeersHandlerFunc(func(params beers.GetAllBeersParams) middleware.Responder {
	    mergedParams := beers.NewGetAllBeersParams()
	    if params.Limit != nil {
	        mergedParams.Limit = params.Limit
	    }
	    return beers.NewGetAllBeersOK().WithPayload(beer_container.AllBeers(*mergedParams.Limit))
	})
}
```

----

* dont forget to add the endpoint `temperature`

```go
// temperature/temperature.go
package temperature

import (
	"grohm.io/beer-fridge-go-swagger/models"
	"math/rand"
)

func GetTemperature() models.Temperature {
	min := 5
	max := 10
	return models.Temperature(rand.Intn(max-min) + min)
}

```

----

* also integrate the temperature into the api, add following lines

```go
// restapi/configure_beer_fridge.go
// ...
func configureAPI(api *operations.BeerFridgeAPI) http.Handler {
	// ...
	api.FridgeGetTemperatureHandler = fridge.GetTemperatureHandlerFunc(func(params fridge.GetTemperatureParams) middleware.Responder {
        return fridge.NewGetTemperatureOK().WithPayload(temperature.GetTemperature())
	})
}
```

----

* rebuild and start the server

```shell
go build -o beer-fridge-server ./cmd/beer-fridge-server/main.go
./beer-fridge-server --port 8080
```

* add 3 beers

```shell
curl -i localhost:8080/beers -d "{\"title\":\"Three Floyds Brewing Co.\", \"origin\":\"Munster, Ind.\", \"volume-percentage\": 5}" -H 'Content-Type: application/io.grohm.go-workshop.beer-fridge.v1+json'
curl -i localhost:8080/beers -d "{\"title\":\"The Alchemist Heady Topper\", \"origin\":\"Waterbury, Vt.\", \"volume-percentage\": 6}" -H 'Content-Type: application/io.grohm.go-workshop.beer-fridge.v1+json'
curl -i localhost:8080/beers -d "{\"title\":\"Founders KBS (Kentucky Breakfast Stout)\", \"origin\":\"Grand Rapids, Mich.\", \"volume-percentage\": 7}" -H 'Content-Type: application/io.grohm.go-workshop.beer-fridge.v1+json'
```

----

* get all beers

```shell
curl -i localhost:8080/beers
```

* get the temperature

```shell
curl -i localhost:8080/temperature
```

----

* delete a beer

```shell
curl -i localhost:8080/beers/1 -X DELETE -H 'Content-Type: application/io.grohm.go-workshop.beer-fridge.v1+json'
```

* lets try something

```shell
$ curl -i localhost:8080/beers/3 -H 'Content-Type: application/io.grohm.go-workshop.beer-fridge.v1+json'
HTTP/1.1 405 Method Not Allowed
Allow: DELETE
Content-Type: application/json
Date: Sat, 27 Aug 2022 17:56:28 GMT
Content-Length: 68

{"code":405,"message":"method GET is not allowed, but [DELETE] are"}%  
```

----

* specific Dockerfile for this service

```dockerfile
# build stage
FROM golang:1.17.6-alpine AS build

RUN mkdir -p /app
WORKDIR /app

# build src
COPY go.mod .
COPY go.sum .
RUN go mod download

# app src
COPY . .
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o beer-fridge-server ./cmd/beer-fridge-server/main.go

# result stage
FROM scratch
COPY --from=build /app/beer-fridge-server /beer-fridge-server
EXPOSE 8080
EXPOSE 443
EXPOSE 80
ENTRYPOINT ["/beer-fridge-server", "--port", "8080"]
```

----

### What we have learned
* How to write an open api yml file.
* How to install and use go-swagger.
* How to build an REST API from ground up.
* How to develop with interface first approach.

----

### Further readings
* go-swagger
    * [goswagger.io/](https://goswagger.io/)
    * [github.com/go-swagger/go-swagger](https://github.com/go-swagger/go-swagger)
* install go-swagger
    * [goswagger.io/install.html](https://goswagger.io/install.html)
* go-swagger tutorial
    * [goswagger.io/tutorial/todo-list.html](https://goswagger.io/tutorial/todo-list.html)
* go-swagger complete example
    * [github.com/go-swagger/go-swagger/tree/master/examples/tutorials/todo-list/server-complete](https://github.com/go-swagger/go-swagger/tree/master/examples/tutorials/todo-list/server-complete)

---
[//]: # (## chi web framework)

[//]: # ()
[//]: # (We want to build the `beer-fridge` service again.)

[//]: # (This service using `chi` an other web framework.)

[//]: # (COMING NEXT)

[//]: # ()
[//]: # (----)

[//]: # (### Further readings)

[//]: # (COMING NEXT)

[//]: # ()
[//]: # (---)

----

## Website Scoring

Let's build a simple CLI tool and learn something about parsing commandlines, first-class functions and function types in Go along with a little generics.

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/website-scoring](https://github.com/go-gurus/go_tour_src/tree/main/website-scoring)

----

### Objectives

Compute a credibility score for a website, taking into account

- Links. Affiliate Links might mean the website is bad
- Word Count. Much text might mean that the site has real content

----

### Strategy

- Download the website to a queryable document
- Build a set of features the document is evaluated against
- Build a tiny registry to manage those features
- Let the features compute an individual score
- Combine scores into one total score

----

### Tooling

We won't reinvent the wheel, so we will use:

- [goquery](https://github.com/PuerkitoBio/goquery) for parsing HTML documents
- [lo](https://github.com/samber/lo") for Java Streams/C# LINQ like expressions

----

### Types
#### Features

A feature computes a score from a document.
```golang
// pkg/scoring/scoring.go

type Feature func(document *goquery.Document) float64
```

A set of features:
```golang
//pkg/scoring/scoring.go

type FeatureSet []Feature
```

----

### Types
#### Feature Registry

A feature registry contains a set of registrations
```golang
// pkg/scoring/scoringFeatureRegistry.go

type FeatureRegistry struct {
    registrations []FeatureRegistration
}
```

----

A registration consists of:
```golang
// pkg/scoring/scoringFeatureRegistry.go

type FeatureRegistration struct {
    Feature
    Title string
    Tags  []string
}
```

----

### Feature Registry
#### Registering new Features
Lets start with describing our expectations in a test

```golang
// pkg/scoring/scoringFeatureRegistry_test.go

func TestRegisterScoringFeature(t *testing.T) {
    fakeFeature := func(_ *goquery.Document) float64 {
        return 1
    }

fakeRegistration := FeatureRegistration{
        Feature: fakeFeature,
        Title:   "FAKE_REGISTRATION",
        Tags:    []string{"FAKE"},
    }
    
    t.Run("should return the previously registered feature when only one registered", func(t *testing.T) {
        registry := FeatureRegistry{}
        registry.Register(fakeRegistration)
        features := registry.GetFeatures()
        assert.Len(t, features, 1)
    })
```

----

### Feature Registry
#### Registering new Features

```golang
//pkg/scoring/scoringFeatureRegistry.go

func (f *FeatureRegistry) Register(registrations ...FeatureRegistration) {
	for _, registration := range registrations {
		f.registrations = append(f.registrations, registration)
	}
}

func (f *FeatureRegistry) GetFeatures() FeatureSet {
	return f.registrations
}
```

----

### Feature Registry
#### Filter support

```golang
// pkg/scoring/scoringFeatureRegistry_test.go

func TestRegisterScoringFeature(t *testing.T) {
	// ...

fakeRegistration := FeatureRegistration{
		Feature: fakeFeature,
		Title:   "FAKE_REGISTRATION",
		Tags:    []string{"FAKE"},
	}

fakeRegistration2 := FeatureRegistration{
		Feature: fakeFeature,
		Title:   "FAKE_REGISTRATION2",
		Tags:    []string{"FAKE2"},
	}
	
	t.Run("should return all registered features when multiple registered and no filter provided", func(t *testing.T) {
		registry := FeatureRegistry{}
		registry.Register(fakeRegistration, fakeRegistration2)
		features := registry.GetFeatures()
		assert.Len(t, features, 2)
	})

t.Run("should return features matching filter", func(t *testing.T) {
		registry := FeatureRegistry{}
		registry.Register(fakeRegistration, fakeRegistration2)
		features := registry.GetFeatures("FAKE2")
		assert.Len(t, features, 1)
	})
}
```

----

### Feature Registry
#### Filter support

Lets use *lo* to filter our subscriptions.

```golang
// pkg/scoring/scoringFeatureRegistry.go

func (f *FeatureRegistry) GetFeatures(includeTags ...string) FeatureSet {
	filteredRegistrations := lo.Filter[FeatureRegistration](f.registrations, 
	    func(it FeatureRegistration, _ int) bool {
		    return len(includeTags) == 0 || lo.Some[string](includeTags, it.Tags)
	})

return lo.Map[FeatureRegistration, Feature](filteredRegistrations, 
	    func(it FeatureRegistration, _ int) Feature {
		    return it.Feature
	})
}
```

----

### Features
#### Word Count

The result datatype

```golang
// pkg/scoring/wordCount.go

type WordFrequencyResult struct {
	TotalWords   int            
	CountedWords int            
	WordCounts   map[string]int 
}
```

----

### Features
#### Word Count

```golang
// pkg/scoring/wordCount.go

func WordCount(doc *goquery.Document) WordFrequencyResult {
	result := WordFrequencyResult{
		WordCounts: make(map[string]int),
	}

text := doc.Find("p").Contents().Text()
	words := strings.Split(text, " ")
	result.TotalWords = len(words)

for i := 0; i < len(words); i++ {
		wordSanitized := strings.ToUpper(sanitizeString.ReplaceAllString(words[i], ""))
		if len(wordSanitized) > 4 {
			result.WordCounts[wordSanitized]++
		}
	}

for _, v := range result.WordCounts {
		result.CountedWords += v
	}

return result
}
```

----

### Putting it all together
#### Registering the Word Counter

```golang
// pkg/scoring/wordCount.go

func wordCountRegistration() FeatureRegistration {
	return FeatureRegistration{
		Feature: ScoreWrapper[WordFrequencyResult](WordCount),
		Title:   "Word Count",
		Tags:    []string{"CONTENT"},
	}
}
```

```golang
// pkg/scoring/scoringFeatureRegistry.go

func NewDefaultRegistry() (r FeatureRegistry) {
	r.Register(affiliateLinkCountRegistration())
	return
}
```

----

### Putting it all together
#### The score wrapper

```golang
// pkg/scoring/scoreWrapper.go

// Scoreable constraints to types providing a method to be scored
type Scoreable interface {
	Score() float64
}

// ScoreWrapper returns a function converting its result to a score
func ScoreWrapper[T Scoreable](scoreFunction func(doc *goquery.Document) T) Feature {
	return func(document *goquery.Document) float64 {
		result := scoreFunction(document)
		return result.Score()
	}
}
```

----

### Putting it all together
#### Commandline Interface

```golang
// cmd/score/score.go

func main() {
	var targetUrl = flag.String("url", "", "URL of the site to be parsed")
	flag.Parse()
	if len(*targetUrl) == 0 {
		flag.Usage()
	}
	score := scoring.Score(*targetUrl)
	fmt.Printf("Website=%s Score=%f", *targetUrl, score)
}
```

----

### Putting it all together
#### Feature Runner and Combiner

```golang
// pkg/scoring/scoring.go

func computeScore(features FeatureSet, document *goquery.Document) (score float64) {
	for _, feature := range features {
		score += feature(document)
	}
	return
}

func Score(url string, featureTags ...string) (score float64) {
	registry := NewDefaultRegistry()
	features := registry.GetFeatures(featureTags...)
	document, _ := download.DownloadWebsite(url)
	return computeScore(features, document)
}
```

----

### Run it

```bash
$ website_score --url https://grohm.io
Website=https://grohm.io Score=244.200000
```

----

## Lets add a second feature!

----

### Affiliate Link Count
#### Type definition

```golang
// pkg/scoring/affiliateLinkCount.go
type LinkCountResult struct {
	TotalLinks           int `json:"TotalLinks"`
	LocalLinks           int `json:"LocalLinks"`
	AffiliateLinks       int `json:"AffiliateLinks"`
	MaskedAffiliateLinks int `json:"MaskedAffiliateLinks"`
	ShortendedUrls       int `json:"ShortendedUrls"`
}

func (l LinkCountResult) Score() float64 {
	return float64(l.TotalLinks + l.LocalLinks - l.AffiliateLinks*2 - l.MaskedAffiliateLinks*4 - l.ShortendedUrls)
}
```

----

### Affiliate Link Count
#### The actual link count

```golang
// pkg/scoring/affiliateLinkCount.go

var affiliateLinksExpression, _ = regexp.Compile("(\\.amazon\\.)")
var maskedAffiliateLinksExpression, _ = regexp.Compile("(amzn\\.to)")
var shortenedUrlExpression, _ = regexp.Compile("(bit\\.ly|tinyurl\\.com)")

func AffiliateLinkCount(doc *goquery.Document) LinkCountResult {
	result := LinkCountResult{}
	localdomain := doc.Url.Host

doc.Find("a").Each(func(i int, s *goquery.Selection) {
		result.TotalLinks++
		link, exists := s.Attr("href")

if exists {
			if strings.Contains(link, localdomain) {
				result.LocalLinks++
			}

if affiliateLinksExpression.MatchString(link) {
				result.AffiliateLinks++
			}

if maskedAffiliateLinksExpression.MatchString(link) {
				result.MaskedAffiliateLinks++
			}

if shortenedUrlExpression.MatchString(link) {
				result.ShortendedUrls++
			}
		}

})
	return result
}
```

----

### Affiliate Link Count
#### The registration

```golang
// pkg/scoring/affiliateLinkCount.go

func affiliateLinkCountRegistration() FeatureRegistration {
	return FeatureRegistration{
		Feature: ScoreWrapper[LinkCountResult](AffiliateLinkCount),
		Title:   "Affiliate Link Count",
		Tags:    []string{"MARKETING", "AFFILIATE", "UNTRUSTWORTHY"},
	}
}
```

```golang
// pkg/scoring/scoringFeatureRegistry.go

func NewDefaultRegistry() (r FeatureRegistry) {
	r.Register(affiliateLinkCountRegistration(), wordCountRegistration())
	return
}
```

----

### What we have learned

- Types can also be functions
- Functions can be values
- Functions can return functions
- The ... operator allows readable and flexible argument lists and substitutes optional arguments

----

# Bonus

Implement a CLI parameter to specify the feature filter query

----

### Further readings
* [Programming with go / first class functions](https://livebook.manning.com/book/get-programming-with-go/chapter-14/31)
* [variadic function parameters](https://go.dev/ref/spec#Passing_arguments_to_..._parameters)

---

----

## pipelines

We want to build a simple pipeline for one of our go services.

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/pipelines](https://github.com/go-gurus/go_tour_src/tree/main/pipelines)
* see it action here [gitlab.com/grohmio/go-tour-pipelines-showcase](https://gitlab.com/grohmio/go-tour-pipelines-showcase)

----

### GitLab

* first add file `main.go`

```go
// main.go
package main

import (
	"fmt"
	"math"
)

func main() {
	var i int
	fmt.Printf("Enter a number to check: ")
	_, _ = fmt.Scanf("%d", &i)
	var result = IsPrime(i)
	fmt.Printf("result=%t ", result)
}

func IsPrime(value int) (result bool) {
	for i := 2; i <= int(math.Floor(math.Sqrt(float64(value)))); i++ {
		if value%i == 0 {
			return false
		}
	}
	return value > 1
}
```

----

* next add testcases, add file `main_test.go`

```go
// main_test.go
package main

import (
	"testing"
)

t.Run("should return TRUE when prime number given", func(t *testing.T) {
		if IsPrime(7) == false {
			t.Fatal("Reported IsPrime=true for 7")
		}
	})
}

func TestPrimeCheckerTableDriven(t *testing.T) {
	cases := []struct {
		input          int
		expectedResult bool
	}{
		{1, false},
		{2, true},
		{3, true},
		{4, false},
		{7, true},
	}

for _, e := range cases {
		t.Run("Should return expected result ", func(t *testing.T) {
			result := IsPrime(e.input)
			if result != e.expectedResult {
				t.Fatalf("Unexpected Result input=%d expected=%t actual=%t", e.input, e.expectedResult, result)
			}
		})
	}
}
```

----

* initialize module

```bash
go mod init grohm.io/pipelines_showcase
```

* create empty file `go.sum`

----

* create pipeline file `.gitlab-ci.yml`

```yaml
# .gitlab-ci.yml
image: golang:1.19-alpine
```

----

* next add stages for our pipeline

```yaml
# .gitlab-ci.yml
# ...
stages:
  - lint
  - test
  - build
```

----

* add the fmt job

```yaml
# .gitlab-ci.yml
# ...
fmt:
  stage: lint
  script:
    - go fmt
    - go vet
```

----

* add the test job, get the coverage report artifact

```yaml
# .gitlab-ci.yml
# ...
test:
  stage: test
  script:
    - go test -coverprofile=coverage.out
    - go tool cover -html=coverage.out -o coverage.html
  artifacts:
    paths:
      - coverage.html
    expire_in: 1 week
```

----

* add the build job, get the binary artifact

```yaml
# .gitlab-ci.yml
# ...
build:
  stage: build
  script:
    - go build
  artifacts:
    paths:
      - pipelines_showcase
    expire_in: 1 week
```

----

* now lets add the docker build

```dockerfile
# Dockerfile
# build stage
FROM golang:1.19-alpine AS build

RUN mkdir -p /app
WORKDIR /app

# build src
COPY go.mod .
COPY go.sum .
RUN go mod download

# app src
COPY . .
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /bin/app

# result stage
FROM scratch
COPY --from=build /bin/app /bin/app
ENTRYPOINT ["/bin/app"]
```

----

```yaml
# .gitlab-ci.yml
# ...
docker-build:
  stage: containerize
  image:
    name: gcr.io/kaniko-project/executor:debug
    entrypoint: [ "" ]
  variables:
    KUBERNETES_CPU_REQUEST: 1
    KUBERNETES_CPU_LIMIT: 1
    KUBERNETES_MEMORY_REQUEST: 2048Mi
    KUBERNETES_MEMORY_LIMIT: 2048Mi
  needs: ["build"]
  script:
    - mkdir -p /kaniko/.docker
    - echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"}}}" > /kaniko/.docker/config.json
    - /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --destination $CI_REGISTRY_IMAGE:$CI_PIPELINE_IID
```

----

* to be complete, lets add a release tag process

```yaml
# .gitlab-ci.yml
# ...
release_job:
  stage: release_tagging
  image: registry.gitlab.com/gitlab-org/release-cli:latest
  needs:
    - job: docker-build
      artifacts: true
  script:
    - echo "running release_job for $CI_PIPELINE_IID"
  release:
    name: 'Release $CI_PIPELINE_IID'
    description: 'Created using the release-cli'
    tag_name: '$CI_PIPELINE_IID'
    ref: '$CI_COMMIT_SHA'
```

----

* lets add stages and avoid running on tag pipelines

```yaml
# .gitlab-ci.yml
# ...
stages:
  - lint
  - test
  - build
  - containerize
  - release_tagging

workflow:
  rules:
    - if: $CI_COMMIT_TAG
      when: never
    - when: always
# ...
```

----

* add changes, commit and push
* the pipeline should look like this

![GitLab](img/PIPELINES/01.png)

----

* enter the test job, check the coverage, check artifacts

![GitLab](img/PIPELINES/02.png)

----

* check coverage report artifact

![GitLab](img/PIPELINES/03.png)

----

* report should look like this

![GitLab](img/PIPELINES/04.png)

----

* check also the docker image in the registry

![GitLab](img/PIPELINES/05.png)

----

### What we have learned

* How to build a GitLab pipeline for go services

----

### Further readings
* GitLab Pipelines
    * [docs.gitlab.com/ee/ci/pipelines](https://docs.gitlab.com/ee/ci/pipelines/)
* Golang GitLab Template
    * [gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/templates/Go.gitlab-ci.yml](https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/templates/Go.gitlab-ci.yml)

---

----

## deployment

We want to deploy a simple go service from sources.
We use `fly.io` as a simple solution.

----

### Too fast? Find source code here:
* [github.com/go-gurus/go_tour_src/tree/main/deployment](https://github.com/go-gurus/go_tour_src/tree/main/deployment)

----

[//]: # ()
[//]: # ()

[//]: # (----)

### fly.io
* alternative to heroku
* provides a simple and free cloud deployment for a lot of apps, services and container
* see also [fly.io](https://fly.io/)
![fly.io](img/DEPLOYMENT/02.png)

----

* create an account
* credit card is needed, but its free
![fly.io](img/DEPLOYMENT/03.png)

----

### flyctl
* flyctl is the fly.io command line interface
* install on MacOS

```bash
brew install flyctl
```
* install on Linux

```bash
curl -L https://fly.io/install.sh | sh
```
* install on Windows

```bash
iwr https://fly.io/install.ps1 -useb | iex
```

----

* sign up

```bash
flyctl auth signup
```

* sign in

```bash
flyctl auth login
```

----

* add a `main.go` file

```go
// main.go
package main

import (
    "embed"
    "html/template"
    "log"
    "net/http"
    "os"
)

//go:embed templates/*
var resources embed.FS

var t = template.Must(template.ParseFS(resources, "templates/*"))

func main() {
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        data := map[string]string{
            "Region": os.Getenv("FLY_REGION"),
        }

t.ExecuteTemplate(w, "index.html.tmpl", data)
    })

log.Println("listening on", port)
    log.Fatal(http.ListenAndServe(":"+port, nil))
}
```

----

* add file `templates/index.html.tmpl`

```text
<!DOCTYPE html>
<html lang="en">
  <head>
  </head>
  <body>
    <h1>Golang for Developers Workshop on Fly.io</h1>
    {{ if .Region }}
      <h2>I'm running in the {{.Region}} region</h2>
    {{end}}
  </body>
</html>
```

----

* init module

```bash
go mod init grohm.io/flyio
```

----

* launch the app

```bash
$ flyctl launch
Creating app in /Users/grohmio/repos/cc/gophers/golang-for-developers/examples/17-deployment/beer-fridge-gs
Scanning source code
Detected a Go app
Using the following build configuration:
        Builder: paketobuildpacks/builder:base
        Buildpacks: gcr.io/paketo-buildpacks/go
? Choose an app name (leave blank to generate one): flyio-grohmio

```

----

* new `fly.toml` is generated

```text
# fly.toml file generated for flyio-grohmio on 2022-12-10T00:26:40+01:00

app = "flyio-grohmio"
kill_signal = "SIGINT"
kill_timeout = 5
processes = []

[build]
  builder = "paketobuildpacks/builder:base"
  buildpacks = ["gcr.io/paketo-buildpacks/go"]

[env]
  PORT = "8080"

[experimental]
  allowed_public_ports = []
  auto_rollback = true

[[services]]
  http_checks = []
  internal_port = 8080
  processes = ["app"]
  protocol = "tcp"
  script_checks = []
  [services.concurrency]
    hard_limit = 25
    soft_limit = 20
    type = "connections"

[[services.ports]]
    force_https = true
    handlers = ["http"]
    port = 80

[[services.ports]]
    handlers = ["tls", "http"]
    port = 443

[[services.tcp_checks]]
    grace_period = "1s"
    interval = "15s"
    restart_limit = 0
    timeout = "2s"

```

----

* deploy the app

```bash
$ flyctl deploy
```

----

* look at your apps in [fly.io/dashboard](https://fly.io/dashboard)

![fly.io](img/DEPLOYMENT/04.png)

----

* look at your specific app

![fly.io](img/DEPLOYMENT/05.png)

----

* check the link

![fly.io](img/DEPLOYMENT/06.png)

----

### What we have learned
* Good and easy way to deploy go apps, fly.io.
* How to deploy go apps with `flyctl`

----

### Further readings
* fly.io
    * [fly.io](https://fly.io/)
    * [fly.io/docs/hands-on/install-flyctl](https://fly.io/docs/hands-on/install-flyctl/)
    * [fly.io/docs/languages-and-frameworks/golang/](https://fly.io/docs/languages-and-frameworks/golang/)
    * [fly.io/dashboard](https://fly.io/dashboard)

---

----

## What's new?

----

### go 1.18

* Generics [go.dev/doc/tutorial/generics](https://go.dev/doc/tutorial/generics)
* Test Fuzzing - testing.F instead of testing.T [go.dev/doc/tutorial/fuzz](https://go.dev/doc/tutorial/fuzz)
* Workspaces for Modules [go.dev/doc/tutorial/workspaces](https://go.dev/doc/tutorial/workspaces)
* 20% Performance Improvements

----

### go 1.19

* links, lists, and clearer heading syntax in doc comments [go.dev/doc/comment](https://go.dev/doc/comment)
* improvements for generics
* ...

----

### go 1.20

* preview of profile-guided optimization (PGO) [go.dev/doc/pgo](https://go.dev/doc/pgo)
    * 3–4% compiler speed up
* couple of language changes
* tool improvements
    * cover tool can collect coverage profiles of programs, not just unit tests [go.dev/testing/coverage/](https://go.dev/testing/coverage/)
    * ...
* standard library additions
* performance improvements

----

### go 1.21

* language changes
    * min, max, clear [go.dev/ref/spec#Min_and_max](https://go.dev/ref/spec#Min_and_max), [go.dev/ref/spec#Clear](https://go.dev/ref/spec#Clear)
    * ...
* standard library additions
    * log/slog package for structured logging [go.dev/pkg/log/slog](https://go.dev/pkg/log/slog)
    * slices package, sorting functions, faster and more ergonomic than the sort package [go.dev/pkg/slices](https://go.dev/pkg/slices)
    * maps package foroperations on maps of any key or element type [go.dev/pkg/maps](https://go.dev/pkg/maps)
    * cmp package, comparing ordered values [go.dev/pkg/cmp](https://go.dev/pkg/cmp)
* tool improvements

----

### Further Readings
* [go.dev/doc/devel/release](https://go.dev/doc/devel/release)
* [go.dev/doc/go1.18](https://go.dev/doc/go1.18)
* [go.dev/blog/go1.18](https://go.dev/blog/go1.18)
* [go.dev/doc/go1.19](https://go.dev/doc/go1.19)
* [go.dev/blog/go1.19](https://go.dev/blog/go1.19)
* [go.dev/doc/go1.20](https://go.dev/doc/go1.20)
* [go.dev/blog/go1.20](https://go.dev/blog/go1.20)
* [go.dev/doc/go1.21](https://go.dev/doc/go1.21)
* [go.dev/blog/go1.20](https://go.dev/blog/go1.20)

---

----

## Abstract

----

### Books

----

* [Learning Go](https://www.oreilly.com/library/view/learning-go/9781492077206/)

![learning go](img/ABSTRACT/learning_go_book.jpg)
* [Learning Go - Examples](https://github.com/learning-go-book)

----

* [Microservices mit Go](https://www.rheinwerk-verlag.de/microservices-mit-go-konzepte-werkzeuge-best-practices/)

![Microservices mit Go](img/ABSTRACT/microservices_mit_go_book.png)

----

### Useful links
* [github.com/avelino/awesome-go](https://github.com/avelino/awesome-go)
* [github.com/trending/go](https://github.com/trending/go)
* [github.com/inancgumus/learngo](https://github.com/inancgumus/learngo)
* [github.com/golang-standards/project-layout](https://github.com/golang-standards/project-layout)
* [github.com/go-kit/kit](https://github.com/go-kit/kit)
* [github.com/tmrts/go-patterns](https://github.com/tmrts/go-patterns)
* [github.com/SigNoz/signoz](https://github.com/SigNoz/signoz)
* [github.com/quii/learn-go-with-tests](https://github.com/quii/learn-go-with-tests)
* [github.com/ardanlabs/gotraining](https://github.com/ardanlabs/gotraining)

----

### Some nice go projects

* [github.com/OpenDiablo2/OpenDiablo2](https://github.com/OpenDiablo2/OpenDiablo2)
* [github.com/wtfutil/wtf](https://github.com/wtfutil/wtf/)
* [github.com/sqshq/sampler](https://github.com/sqshq/sampler)

----

### Further Readings
* [go.dev/doc](https://go.dev/doc/)
* [gobyexample.com](https://gobyexample.com/)

----

### The End

* stay in contact [go-gurus.slack.com](https://go-gurus.slack.com)
* participate [github.com/go-gurus](https://github.com/go-gurus)
* see us soon on [youtube.com/@go-gurus](https://www.youtube.com/@go-gurus)

![youtube](img/WHATS_NEW/01.png)

---