Terraform Stateserver Using Go

1
• Using Virtualbox Ubuntu 20.10 and links listed below
2
• Run as http server
3
• Change to https
4
• For a future test terraform http backend locking feature and/or include locking in server

1
• https://www.terraform.io/docs/language/settings/backends/http.html
2
• https://linuxhint.com/install-golang-ubuntu/
3
• https://github.com/MerlinDMC/go-terraform-stateserver
4
• https://github.com/denji/golang-tls

1
$ cat main.go
2
package main
3
import "fmt"
4
func main() {
5
fmt.Println("Hello World");
6
}

1
• file not found if no file exist during init is expected
2
• if file same and already there GET fine during init
3
• plan does a GET
4
• apply does a POST
5
• did not observe a DELETE

1
• https://appdividend.com/2019/11/29/golang-json-example-how-to-use-json-with-go/
2
• https://www.golangprograms.com/web-application-to-read-and-write-json-data-in-json-file.html
3
• https://tutorialedge.net/golang/parsing-json-with-golang/
4
• https://dzone.com/articles/how-to-write-a-http-rest-api-server-in-go-in-minut

1
$ cat tf-stateserver.go
2
package main
3
//https://github.com/MerlinDMC/go-terraform-stateserver/blob/master/main.go
4

5
import (
6
    "flag"
7
    "io"
8
    "log"
9
    "net/http"
10
    "os"
11
    "path/filepath"
12
)
13

14
var (
15
    flagDataPath string
16
    flagCertFile string
17
    flagKeyFile  string
18

19
    flagListenAddress string
20
)
21

22
func init() {
23
    flag.StringVar(&flagCertFile, "certfile", "", "path to the certs file for https")
24
    flag.StringVar(&flagKeyFile, "keyfile", "", "path to the keyfile for https")
25
    flag.StringVar(&flagDataPath, "data_path", os.TempDir(), "path to the data storage directory")
26

27
    flag.StringVar(&flagListenAddress, "listen_address", "0.0.0.0:8080", "address:port to bind listener on")
28
    //flag.StringVar(&flagListenAddress, "listen_address", "192.168.1.235:8080", "address:port to bind listener on")
29
}
30

31
func main() {
32
    if !flag.Parsed() {
33
        flag.Parse()
34
    }
35

36
    router := http.NewServeMux()
37
    router.HandleFunc("/", requestHandler)
38

39
    if flagCertFile != "" && flagKeyFile != "" {
40
          log.Fatal(http.ListenAndServeTLS(flagListenAddress, flagCertFile, flagKeyFile, router))
41
    } else {
42
          log.Fatal(http.ListenAndServe(flagListenAddress, router))
43
    }
44
}
45

46
func requestHandler(res http.ResponseWriter, req *http.Request) {
47
    if req.URL.Path == "/" {
48
        http.NotFound(res, req)
49
        return
50
    }
51

52
    stateStorageFile := filepath.Join(flagDataPath, req.URL.Path)
53
    stateStorageDir := filepath.Dir(stateStorageFile)
54

55
    switch req.Method {
56
    case "GET":
57
        log.Printf("received GET for state file: %s\n", stateStorageFile)
58
        fh, err := os.Open(stateStorageFile)
59
        if err != nil {
60
            log.Printf("during GET cannot open file: %s\n", err)
61
            goto not_found
62
        }
63
        defer fh.Close()
64

65
        res.WriteHeader(200)
66

67
        io.Copy(res, fh)
68

69
        return
70
    case "POST":
71
        log.Printf("received POST for state file: %s\n", stateStorageFile)
72
        if err := os.MkdirAll(stateStorageDir, 0750); err != nil && !os.IsExist(err) {
73
            log.Printf("during POST cannot create parent directories: %s\n", err)
74
            goto not_found
75
        }
76

77
        fh, err := os.OpenFile(stateStorageFile, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
78
        if err != nil {
79
            log.Printf("cannot open file: %s\n", err)
80
            goto not_found
81
        }
82
        defer fh.Close()
83

84
        if _, err := io.Copy(fh, req.Body); err != nil {
85
            log.Printf("failed to stream data into statefile: %s\n", err)
86
            goto not_found
87
        }
88

89
        res.WriteHeader(200)
90

91
        return
92
    case "DELETE":
93
        log.Printf("received DELETE for state file: %s\n", stateStorageFile)
94
        //if os.RemoveAll(stateStorageFile) != nil {
95
        if err := os.RemoveAll(stateStorageFile); err != nil {
96
            log.Printf("cannot remove file: %s\n", err)
97
            goto not_found
98
        }
99

100
        res.WriteHeader(200)
101

102
        return
103
    }
104

105
not_found:
106
    http.NotFound(res, req)
107
}