DEV Community: George Calianu

Server side application skeleton for Go language

George Calianu — Tue, 23 Apr 2019 08:54:30 +0000

Writing web application in Go can be pretty hard if you take care about login process wich include signing in, singing out, password recovery and minimal user management (like changing name, password and deleting account).

The solution can be a high level skeleton to help all those developers to focus on the application content.

Project is a work in progress, hosted on Github and is documented with code examples and some pictures.

https://github.com/geosoft1/ssas

How the things works? Supposing you have some experience with Go language and Mysql database, download the project from repository and compile.

You must create a database on your server and import database.sql file into (adjust before the file with your database name). In model folder you will find a model for Mysql Workbench application. You can use this model to sincronize with an existing database.

Next, you must complete the configuration file conf.json. Basically you must set the database connection informations like ip/domain, user, password and schema name.

Also, you may need to set the mailer for password recovery procedure. No big deal here, use a mailbox created for this purpose.

If you run the skeleton for the first time you will be asked to add a new user (or signup).

Feel free to do this and then login

After that you must see the home page

You can manage local user account, logout and recovery forgotten password by clicking on the options from the top right bar.

A nice part is that you have a fallback offline page for network fails.

Now you are ready to write your applications, take a look over how to add simple application section from documentation to see how to extend the skeleton with new functionalities. A dummy example explain this.

Note that you will need a HTML5 browser to see the application but you shouldn't have problems with modern browsers. You can also use Chrome application mode for an experience more closest to native applications.

Enjoy.

Versioning your API in Go

George Calianu — Mon, 24 Dec 2018 08:33:26 +0000

At some point in time your API need to have versions like /v1 or /v2 (like github API).
To implement this in Go I will use gorilla/mux router and I will assume you have a functional Go environment.

We will make a new project with the following main.go file:

package main

import (
    "flag"
    "net/http"

    "github.com/gorilla/mux"
)

var (
    port = flag.String("port", "8080", "port")
)

func main() {
    flag.Parse()
    var router = mux.NewRouter()
    var api = router.PathPrefix("/api").Subrouter()
    api.NotFoundHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusNotFound)
    })
    http.ListenAndServe(":"+*port, router)
}

On short we have created a new router with a nice soubrouter for handling /api which represent the base of our versioned routes.
The routes will show like /api/v1/endpoint,/api/v2/endpoint and so on.

Also we have defined a not found handler attached to the subrouter who just returns a status code.

Note that we will use in the following various return codes to understand what routine is executed at each moment of time.

In this step we can attach a middleware to our subrouter to print what route is currently requested.

api.Use(func(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Println(r.RequestURI)
        next.ServeHTTP(w, r)
    })
})

Now we are ready to add our first version of API

var api1 = api.PathPrefix("/v1").Subrouter()
api1.HandleFunc("/status", func(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
})
api1.NotFoundHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusForbidden)
})

In the same manner like /api creation, add /v1 subrouter and coresponding not found handler. Note that the base of this subrouter is api subrouter not main router. Also we have defined the handler function for an endpoint named /status. Similarly we can create the /v2. Just paste this code and replace 1 with 2 and our code become

func main() {
    flag.Parse()
    var router = mux.NewRouter()
    var api = router.PathPrefix("/api").Subrouter()
    api.NotFoundHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusNotFound)
    })
    api.Use(func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            log.Println(r.RequestURI)
            next.ServeHTTP(w, r)
        })
    })
    var api1 = api.PathPrefix("/v1").Subrouter()
    api1.HandleFunc("/status", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
    })
    api1.NotFoundHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusForbidden)
    })
    var api2 = api.PathPrefix("/v2").Subrouter()
    api2.HandleFunc("/status", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusAccepted)
    })
    api2.NotFoundHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusNoContent)
    })
    http.ListenAndServe(":"+*port, router)
}

We are ready to test our API. For this run the project and use curl.

curl -I 'localhost:8080/api/'
HTTP/1.1 403 Not Found

curl -I 'localhost:8080/api/v1/'
HTTP/1.1 404 Forbidden

curl -I 'localhost:8080/api/v1/status'
HTTP/1.1 200 OK

curl -I 'localhost:8080/api/v2/'
HTTP/1.1 204 No Content

curl -I 'localhost:8080/api/v2/status'
HTTP/1.1 200 Accepted

Tests looks ok but we miss the authentications for our API. First idea is to simply use a MatcherFunc with a token and the following line

var api = router.PathPrefix("/api").Subrouter()

become

var api = router.MatcherFunc(func(r *http.Request, rm *mux.RouteMatch) bool {
    return r.Header.Get("x-auth-token") == "admin"
}).PathPrefix("/api").Subrouter()

Test again

curl -I 'localhost:8080/api/v1/status' -H "x-auth-token: admin"
HTTP/1.1 202 OK

curl -I 'localhost:8080/api/v1/status' -H "x-auth-token: notadmin"
HTTP/1.1 404 Not Found

Not good, if i enter a wrong password i will receive not found error code. Basically is nothing wrong with this but i want to see that i'm not authorised. So, we will move the authentication code on the middleware and our finally code looks like that:

package main

import (
    "flag"
    "net/http"
    "log"

    "github.com/gorilla/mux"
)

var (
    port = flag.String("port", "8080", "port")
)

func main() {
    flag.Parse()
    var router = mux.NewRouter()
    var api = router.PathPrefix("/api").Subrouter()
    api.NotFoundHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusNotFound)
    })
    api.Use(func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            if r.Header.Get("x-auth-token") != "admin" {
                w.WriteHeader(http.StatusUnauthorized)
                return
            }
            log.Println(r.RequestURI)
            next.ServeHTTP(w, r)
        })
    })
    var api1 = api.PathPrefix("/v1").Subrouter()
    api1.HandleFunc("/status", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
    })
    api1.NotFoundHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusForbidden)
    })
    var api2 = api.PathPrefix("/v2").Subrouter()
    api2.HandleFunc("/status", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusAccepted)
    })
    api2.NotFoundHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusNoContent)
    })
    http.ListenAndServe(":"+*port, router)
}

Final test

curl -I 'localhost:8080/api/v1/status' -H "x-auth-token: admin"
HTTP/1.1 200 OK

curl -I 'localhost:8080/api/v1/status' -H "x-auth-token: notadmin"
HTTP/1.1 401 Unauthorized

Yay, we did it. We have versioned API with some authentication. See the project on github.

Enjoy.

Conditional compilation and runtime module names in Go

George Calianu — Thu, 06 Dec 2018 10:15:26 +0000

Conditional compilation in Go language is a very nice feature but what if we want to know at runtime what modules we just compiled (do not confuse with the new Go modules!). We can define a file as a particular module of our application. So, knowing that if the files are compiled or not can be interesting but we haven't a standard mechanism to do this at runtime.

Let supose we have three dummy files main.go, module1.go and module2.go doing nothing and part of package main.

main.go file

package main

func main() {
}

module1.go file

//+build module1

package main

module2.go file

//+build module2

package main

Build arguments are given at compile time as tags, eg.:

 go build -tags="module1 module2" -o test

Unfortunately the build args are no more accesible after the compiling process, nowhere are writen what was compiled and what not. If we want for example at runtime to print the efective compiled files we simply can't.

Here it come the tricky part. In Go runtime package we have the Caller() function who knows the current invocation file and can be used to identify if the file is compiled or not. So, our dummy program become like following.

main.go file

package main

import (
    "fmt"
    "path/filepath"
    "runtime"
    "strings"
)

var mods []string

// include this in every init() function to detect linked modules
func _init() {
    _, file, _, _ := runtime.Caller(1)
    mods = append(mods, strings.TrimSuffix(filepath.Base(file), ".go"))

}
func init() {
    _init()
}

func main() {
    fmt.Println(mods)
}

module1.go file

//+build module1

package main

func init() {
    _init()
}

module2.go file

//+build module2

package main

func init() {
    _init()
}

We has defined _init() function which we will include in every init() functions from every module. At runtime init() functions will update an array of names which can be easy printed. The Caller() parameter mean the nesting level.

Running again.

go build -tags="module1 module2" -o test
./test
[main module1 module2]
go build -tags="module1" -o test
[main module1]

This technique suppose that you will have a consistency between the file name and build tags, so, be care to this aspect to avoid confusion.

Enjoy.

Gopei explained

George Calianu — Thu, 06 Sep 2018 08:17:56 +0000

Basically installing Go working environment means downloading the compiler from https://golang.org, doing some things with PATH and GOPATH (where many people get stuck here) and installing an IDE. There are a lot of tutorials around but let see a smart tool which can make the installation easier.

We talk about Unix/Linux world so make sure you have a Mac or a Linux distro with bash,curl and git installed. If you don't have a github.com account then make yourself one. I typically use it on Ubuntu but Gopei should work on any machine which has bash.

We will use Gopei (Go Programming Environment Installer) toolbox wich is an installer and an customizer for entire Go environment to bring a better experience especially for the new users. Gopei install the Go compiler, LiteIDE (a very lite and quick IDE made for Go language) set PATH, GOPATH and link all together. Also, comes with some tools for github and deploy in the cloud.

Gopei options are well documented on the project wiki page.

First of all download Gopei toolbox from here in your local Downloads folder, unpack it and execute:

Downloads/tools-master/gopei -h

Golang Programming Environment Installer
Usage: gopei [options]
Options:
-c        enable classroom mode (Linux only)
-g        enable git suppport
-h        show this help message and exit
-k        show key fingerprint
-s        server mode, install golang only
-u        uninstall
-U        uninstall including .gitconfig file and .ssh folder
-q [name] set theme (eg. -q webstorm)
-x [name] set color scheme (eg. -x sublime)
-v        version

Basically you will need to go in Downloads folder (but not mandatory) and run:

./gopei

./gopei -g

-g is for github. Use it if you want to work with github repositories.

After the installation on some systems you will find a launcher icon with a nice gopher for IDE. On Gnome systems you will need to search in dash for the launcher. On Mac you will find the original IDE icon on dock bar.

If you want to use other IDE (like VSCode, Atom, Sublime or whatever) consider using this command:

./gopei -sg

-s is for server mode (no default IDE). Now you can install your favorite IDE and Go compiler but also Gopei toolbox (like the cloud tool) will be available from your IDE or from Terminal.

Another interesting mode, useful for people who learn, is the classroom mode. Using -c flag any settings you make in the IDE are lost after closing.

Let say now you have many instalations and you want to locate your local key in github keys list. This is hard job because github don't allow you to give a name for each key. So, you can use the following command to see the local machine ssh key fingerprint.

./gopei -k

As you already saw you have two options to uninstall. The main difference is that -U also delete .ssh folder. Uninstall with -u if you want just to update tools.

Another new nice options added in Gopei version 2 are about setting themes designed for big screens. To set the theme from installation use -q and -x flags.

./gopei -g -q webstorm -x sublime

Hope that you found out this tool useful. Enjoy.