1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// main.go

package main

import (
    "context"
    "log"
    "net/http"
    "os"

    "cloud.google.com/go/datastore"
)

var datastoreClient *datastore.Client

func main() {
    ctx := context.Background()
    var err error

    datastoreClient, err = datastore.NewClient(ctx, "aaaaa")
    if err != nil {
        log.Fatal(err)
    }

    port := os.Getenv("PORT")
    if port == "" {
        port = "8000"
        log.Printf("Defaulting to port %s", port)
    }

    log.Printf("Listening on port %s", port)

    if err := http.ListenAndServe(":"+port, Router()); err != nil {
        log.Fatal(err)
    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// router.go
package main

import (
    "log"
    "os"
    "time"

    "github.com/go-chi/chi"
    "github.com/go-chi/chi/middleware"
    "github.com/go-chi/render"
)

func Router() chi.Router {
    r := chi.NewRouter()

    middleware.DefaultLogger = middleware.RequestLogger(
        &middleware.DefaultLogFormatter{
            Logger: newLogger(),
        },
    )

    r.Use(middleware.Logger)
    r.Use(middleware.RealIP)
    r.Use(middleware.Recoverer)

    r.Use(middleware.Timeout(60 * time.Second))

    r.Use(render.SetContentType(render.ContentTypeJSON))

    r.Get("/", Index)

    return r
}

func newLogger() *log.Logger {
    return log.New(os.Stdout, "chi-log: ", log.Lshortfile)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

// handler.go

package main

import (
    "context"
    "fmt"
    "net/http"
    "time"

    "cloud.google.com/go/datastore"
    "github.com/go-chi/render"
)

func Index(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()

    // Get a list of the most recent visits.
    visits, err := queryVisits(ctx, 10)
    if err != nil {
        msg := fmt.Sprintf("Could not save visit: %v", err)
        http.Error(w, msg, http.StatusInternalServerError)
        return
    }

    // Record this visit.
    if err := recordVisit(ctx, time.Now(), r.RemoteAddr); err != nil {
        msg := fmt.Sprintf("Could not save visit: %v", err)
        http.Error(w, msg, http.StatusInternalServerError)
        return
    }

    render.Status(r, http.StatusOK)

    list := []render.Renderer{}
    for _, visit := range visits {
        response := &visitResponse{visit: visit}
        list = append(list, response)
    }

    render.RenderList(w, r, list)
}

type visit struct {
    Timestamp time.Time `json:"time"`
    UserIP    string    `json:"ip"`
}

type visitResponse struct {
    *visit
}

func (vr *visitResponse) Render(w http.ResponseWriter, r *http.Request) error {
    return nil
}

func recordVisit(ctx context.Context, now time.Time, userIP string) error {
    v := &visit{
        Timestamp: now,
        UserIP:    userIP,
    }

    k := datastore.IncompleteKey("Visit", nil)

    _, err := datastoreClient.Put(ctx, k, v)
    return err
}

func queryVisits(ctx context.Context, limit int64) ([]*visit, error) {
    q := datastore.NewQuery("Visit").Order("-Timestamp").Limit(10)

    visits := make([]*visit, 0)
    _, err := datastoreClient.GetAll(ctx, q, &visits)
    return visits, err
}