DEV Community: Adiatma Kamaarudin

Golang http/net middleware

Adiatma Kamaarudin — Thu, 26 Aug 2021 02:05:46 +0000

middleware provide a mechanism for filtering or inspecting http requests entering to your application, example you need to verify user authentication or authorization before access something request to your http, middleware running before and and after request happened.

Today we can try the middleware with package http/net.

Step 1 - Create simple http server

touch main.go

...next open main.go with your code editor.

package main

import (
  "http/net"
  "io"
)

func main() {
   r := http.NewServeMux()

   r.HandleFunc("/", func(rw http.ResponseWriter, r *http.Request) {
       io.WriteString(rw, `{"message": "hello world.."}`)
   })

   http.ListenAndServe(":8000", r)
}

...execute main.go with go run

go run main.go

...open another terminal then run curl http://localhost:8000

curl http://localhost:8000
{"message": "hello world.."}

Step 2 - Add middleware

Open main.go then write function middleware.

func TheLogger(next http.Handler) http.Handler {
    return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
        fmt.Println(fmt.Sprintf("%s %s", r.Method, r.URL.Path))
        next.ServeHTTP(rw, r)
    })
}

Interface http.Handler is a handler response to an HTTP request. http.Handler have return ServeHTTP to reply headers and data to the ResponseWriter.

I name middleware with TheLogger to get response method, and url path.

Next, in main function we just wrap the router with TheLogger middleware, cause http.NewServeMux also implement interface http.Router, and for more please check in next steps.

Step 3 - Use `TheLogger` in http server.

package main

import (
    "fmt"
    "io"
    "net/http"
)

func TheLogger(next http.Handler) http.Handler {
    return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
        fmt.Println(fmt.Sprintf("%s %s", r.Method, r.URL.Path))
        next.ServeHTTP(rw, r)
    })
}

func main() {
    r := http.NewServeMux()

    r.HandleFunc("/", func(rw http.ResponseWriter, r *http.Request) {
        io.WriteString(rw, `{"message": "hello world.."}`)
    })

    m := TheLogger(r)
    http.ListenAndServe(":8000", m)
}

...save and run with go run main.go

curl http://localhost:8000

❯ go run main.go
GET / --> log from middleware

Ok, next we need to add context in middleware.

Step - 4 Add context in middleware

// create context
ctx := context.WithValue(r.Context(), "data", "data:test")

Please learn more about the context in here

Step - 5 Add `http.Request` context to `TheLogger` middleware.

func TheLogger(next http.Handler) http.Handler {
    return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
        fmt.Println(fmt.Sprintf("%s %s", r.Method, r.URL.Path))
        // create context
        ctx := context.WithValue(r.Context(), "data", "data:test")
        // inject the context in http.Request with r.WithContext
        next.ServeHTTP(rw, r.WithContext(ctx))
    })
}

Step - 6 Get context data.

 getContextData := r.Context().Value("data")

r http.Request get context with r.Context().Value(<context_key>)

...
func main() {
    r := http.NewServeMux()

    r.HandleFunc("/", func(rw http.ResponseWriter, r *http.Request) {
        // get context data
        getContextData := r.Context().Value("data")
        fmt.Println(getContextData)
        io.WriteString(rw, `{"message": "hello world.."}`)
    })

    m := TheLogger(r)

    http.ListenAndServe(":8000", m)
}

❯ go run main.go
GET / -> log from middleware
data:test -> context from middleware

...full code

package main

import (
    "context"
    "fmt"
    "io"
    "net/http"
)

func TheLogger(next http.Handler) http.Handler {
    return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
        // print log r.Method and r.URL.Path
        fmt.Println(fmt.Sprintf("%s %s", r.Method, r.URL.Path))
        // create context
        ctx := context.WithValue(r.Context(), "data", "data:test")
        // inject the context in http.Request with r.WithContext
        next.ServeHTTP(rw, r.WithContext(ctx))
    })
}

func main() {
    r := http.NewServeMux()

    r.HandleFunc("/", func(rw http.ResponseWriter, r *http.Request) {
        // get context data
        getContextData := r.Context().Value("data")
        fmt.Println(getContextData)
        io.WriteString(rw, `{"message": "hello world.."}`)
    })

    m := TheLogger(r)

    http.ListenAndServe(":8000", m)
}

Final, In real case you can using middleware to validate authorization user and etc, and request with context for sharing data via http.Request.

Reference:

Create CRUD Apps with http/net Golang without database

Adiatma Kamaarudin — Sun, 22 Aug 2021 06:58:48 +0000

This article just have a purpose to show how to create CRUD (Create, Read, Update & Delete) Apps just using http/net.

First step we need to create project directory.

mkdir golang-basic-http # create directory project
cd golang-basic-http # go to project
go mod init golang-basic-http # initialize go module inside the project

Next, please create file main.go, with touch main.go inside the project directory.

package main

import "fmt"

func main() {
   fmt.Println("Hello world")
}

Than, execute the main.go.

go run main.go
Hello world # the result

Next, we need to import http/net and create the http server.

package main

import (
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(rw http.ResponseWriter, r *http.Request) {
        rw.Write([]byte("Hello World"))
    })

    log.Fatal(http.ListenAndServe(":8000", nil))
}

Ok, http.HandleFunc have 2 parameters, to fill with route path and handler, path describe the route, and handler is a function, and the function have 2 parameters http.ResponseWriter to write the output, and http.Request to catch the request from http.

Next, inside handler we need to create response Hello World if user access the path.

// rw is http.ResponseWriter
rw.Write([]byte("Hello world"))

And to listens on the TCP network we using http.ListenAndServer.

http.ListenAndServer(":8000", nil)

http.ListenAndServer have 2 parameters, first parameter fill with the port address, and next with route config, because we don't use router configuration, for this time, second parameter in http.ListenAndServer we can fill with nil.

If you access the http with port 8000 using curl in the terminal.

curl -i http://localhost:8000

HTTP/1.1 200 OK
Date: Sun, 22 Aug 2021 04:58:38 GMT
Content-Length: 11
Content-Type: text/plain; charset=utf-8

Hello world%

Yes, congratulations.

Next, we need create methods GET, POST, DELETE, and PUT inside the handler.

To get methods, we need access r in http.Request.

 switch r.Method {
    case "GET":
      rw.Write([]byte("GET/ Hello World"))
    case "POST":
      rw.Write([]byte("POST/ Hello World"))
 }

Try to access GET

curl -i http://localhost:8000

HTTP/1.1 200 OK
Date: Sun, 22 Aug 2021 05:26:01 GMT
Content-Length: 16
Content-Type: text/plain; charset=utf-8

GET/ Hello World%

Next, try to access POST

curl -i -X POST http://localhost:8000

HTTP/1.1 200 OK
Date: Sun, 22 Aug 2021 05:25:44 GMT
Content-Length: 17
Content-Type: text/plain; charset=utf-8

POST/ Hello World%

Ok, next we need to define data, example Todo with have Task and ID.

type Todo struct {
    ID   int
    Task string
}

func main() {
...

...and, define collection of Todo, in todos variable.

type Todo struct {
    ID   int
    Task string
}

var todos []Todo

func main() {
...

...next we need to access todos, inside handler.

switch r.Method {
case "GET":
  json.NewEncoder(rw).Encode(todos)
...

json.NewEncoder(rw).Encode(todos) convert todos and encode to json format as the result.

Save, and next run go run main.go

HTTP/1.1 200 OK
Date: Sun, 22 Aug 2021 05:54:23 GMT
Content-Length: 5
Content-Type: text/plain; charset=utf-8

null

Oops, the result is null cause todos is empty, we need to create post to fill todos with new value.

case "POST":
   // create variable to save todo
   var todo Todo
   // decode `r.Body` `r *http.Request` to get data from request
   // decode the result to todo
   json.NewDecoder(r.Body).Decode(&todo)
   // append new todo in todos
   todos = append(todos, todo)
   // finally, encode again create the resutl with json format
   json.NewEncoder(rw).Encode(todo)
}

...next, save and try again, we need to access POST to save new value.

curl -i -X POST -d '{"ID": 1, "Task": "Coding..."}' http://localhost:8000

HTTP/1.1 200 OK
Date: Sun, 22 Aug 2021 06:01:37 GMT
Content-Length: 28
Content-Type: text/plain; charset=utf-8

{"ID":1,"Task":"Coding..."}

...next, access GET.

curl -i http://localhost:8000

HTTP/1.1 200 OK
Date: Sun, 22 Aug 2021 06:01:59 GMT
Content-Length: 30
Content-Type: text/plain; charset=utf-8

[{"ID":1,"Task":"Coding..."}]

Next, we need add method DELETE to remove todo base on the ID in todo.

case "DELETE":
  // http/net not support path variable like this `/:id`
  // and to handle it, we using `r.URL.Query` to get the query url
  // http://localhost:8000?id=1
  query := r.URL.Query()
  // id result have a type string
  // we need `strconv.Atoi` to convert string into int
  id, _ := strconv.Atoi(query.Get("id"))

  // next we need to loop todos, and match the id with todo.ID
  for index, todo := range todos {
     if todo.ID == id {
        // splice and replace the todo
        todos = append(todos[:index], todos[index+1:]...)
        rw.Write([]byte("Success to deleted todo"))
     }
  }

...save, and run again

curl -i http://localhost:8000

HTTP/1.1 200 OK
Date: Sun, 22 Aug 2021 06:25:21 GMT
Content-Length: 30
Content-Type: text/plain; charset=utf-8

[{"ID":1,"Task":"Coding..."}]

curl -i -X DELETE http://localhost:8000\?id\=1

HTTP/1.1 200 OK
Date: Sun, 22 Aug 2021 06:26:30 GMT
Content-Length: 23
Content-Type: text/plain; charset=utf-8

Success to deleted todo%

curl -i http://localhost:8000

HTTP/1.1 200 OK
Date: Sun, 22 Aug 2021 06:27:00 GMT
Content-Length: 3
Content-Type: text/plain; charset=utf-8

[]

 case "PUT":
    query := r.URL.Query()
    id, _ := strconv.Atoi(query.Get("id"))

    for index, todo := range todos {
       json.NewDecoder(r.Body).Decode(&todo)

       if todo.ID == id {
          todos[index].ID = todo.ID
          todos[index].Task = todo.Task

          rw.Write([]byte("Success to update todo"))
       }
    }
}

...yup, save, and run again

curl -i -X POST -d '{"ID": 1, "Task": "Coding..."}' http://localhost:8000

HTTP/1.1 200 OK
Date: Sun, 22 Aug 2021 06:33:35 GMT
Content-Length: 28
Content-Type: text/plain; charset=utf-8

{"ID":1,"Task":"Coding..."}

---
curl -i http://localhost:8000

HTTP/1.1 200 OK
Date: Sun, 22 Aug 2021 06:34:10 GMT
Content-Length: 30
Content-Type: text/plain; charset=utf-8

[{"ID":1,"Task":"Coding..."}]

...update data

curl -i -X PUT -d '{"ID": 1, "Task": "Bobo siang"}' http://localhost:8000\?id\=1

HTTP/1.1 200 OK
Date: Sun, 22 Aug 2021 06:35:32 GMT
Content-Length: 22
Content-Type: text/plain; charset=utf-8

Success to update todo%

---
curl -i http://localhost:8000

HTTP/1.1 200 OK
Date: Sun, 22 Aug 2021 06:39:24 GMT
Content-Length: 35
Content-Type: text/plain; charset=utf-8

[{"ID": 1, "Task": "Bobo siang"}]

Yes, congratulations!, and next we need to custom header, and need a little refactor.

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "strconv"
)

type Todo struct {
    ID   int
    Task string
}

var todos []Todo

func main() {
    http.HandleFunc("/", func(rw http.ResponseWriter, r *http.Request) {
        rw.Header().Add("Content-Type", "application/json")
        rw.Header().Add("Access-Control-Allow-Origin", "*")

        query := r.URL.Query()
        id, _ := strconv.Atoi(query.Get("id"))

        switch r.Method {
        case "GET":
            rw.WriteHeader(http.StatusOK)
            json.NewEncoder(rw).Encode(todos)
        case "POST":
            var todo Todo
            json.NewDecoder(r.Body).Decode(&todo)
            todos = append(todos, todo)
            rw.WriteHeader(http.StatusOK)
            json.NewEncoder(rw).Encode(todo)
        case "DELETE":
            for index, todo := range todos {
                if todo.ID == id {
                    todos = append(todos[:index], todos[index+1:]...)
                    rw.WriteHeader(http.StatusOK)
                    rw.Write([]byte(`{"message": "Success to delete todo"}`))
                }
            }
        case "PUT":
            for index, todo := range todos {
                if todo.ID == id {
                    json.NewDecoder(r.Body).Decode(&todo)
                    todos[index].ID = todo.ID
                    todos[index].Task = todo.Task
                    rw.WriteHeader(http.StatusOK)
                    rw.Write([]byte(`{"message": "Success to update todo"}`))
                }
            }
        }
    })

    log.Fatal(http.ListenAndServe(":8000", nil))
}

curl http://localhost:8000 -v

*   Trying ::1...
* TCP_NODELAY set
* Connected to localhost (::1) port 8000 (#0)
> GET / HTTP/1.1
> Host: localhost:8000
> User-Agent: curl/7.64.1
> Accept: */*
>
< HTTP/1.1 200 OK
< Access-Control-Allow-Origin: *
< Content-Type: application/json
< Date: Sun, 22 Aug 2021 06:54:01 GMT
< Content-Length: 5
<
null
* Connection #0 to host localhost left intact
* Closing connection 0

Yes, hopefully you can learn something with this basic article about http server in golang.

Build a simple CLI with Bash

Adiatma Kamaarudin — Sat, 06 Mar 2021 16:00:49 +0000

Bash is a unix shell and command language, and this article has a purpose to introduce how to using bash for building a simple CLI (Command Line Interface).

Prerequisite

Terminal, iTerm2, or Alacritty
VSCode, Vim, or Neovim
MaxOS or Linux

Getting Started

Please create a new folder with the name bash-cli then create a file with the name bash-cli.sh inside of bash-cli folder, and open the file bash-cli.sh.

#!/bin/bash

echo "Hello World"

#!/bin/bash line of script to inform your machine os that is a bash scripting.

Next, we need to make sure the scripts work. you just need to execute with source ./bash-cli.sh inside of bash-cli directory, or you can access directly ./bash-cli but you need to enable access permissions with command chmod, simply just type chmod +x ./bash-cli.sh.

./bash-cli.sh
Hello World

Yes, congratulations bro, and next we need to add more syntax to build a simple project CLI.

#!/bin/bash

# catch first arguments with $1
case "$1" in
 -s|--scan)
  # execute if arguments in $1 to equal "-s" or "--scan"
  echo "scan..."
  ;;
 *)
  # else
  echo "Usage: (-s|--scan)"
  ;;
esac

if we execute the bash with ./bash-cli.sh -s the result to showing text "scan..." in your terminal.

./bash-cli.sh -s
scan...

next, add more functionality to scan something on the internet, or we can use curl to fetch or download data from the internet.

#!/bin/bash

scan_your_ip() {
  command curl "https://ipecho.net/plain"
}

# catch first arguments with $1
case "$1" in
 -s|--scan)
  # execute if arguments in $1 to equal "-s" or "--scan"
  echo scan_your_ip
  ;;
 *)
  # else
  echo "Usage: (-s|--scan)"
  ;;
esac

Finish, let's try with execute ./bash-cli.sh -s and expected you get your network ip as result, like this.

./bash-cli.sh -s
36.75.151.87

Conclusion

I hope you need basic experience in using bash for building a simple CLI, for more reference you can build a more complex CLI, please check out this repo https://github.com/adiatma/intip as references.