Removes unused code

.gitattributes

@@ -0,0 +1 @@
+*.snapshot binary

__snapshots__/dozzle.snapshot

@@ -0,0 +1,15 @@
+/* snapshot: /api/containers.json */
+HTTP/1.1 200 OK
+Connection: close
+Content-Type: text/plain; charset=utf-8
+
+[{"id":"1234567890","names":null,"name":"test","image":"image","imageId":"image_id","command":"command","created":0,"state":"state","status":"status"}]
+
+/* snapshot: /api/logs/stream */
+HTTP/1.1 200 OK
+Connection: close
+Cache-Control: no-cache
+Connection: keep-alive
+Content-Type: text/event-stream
+
+data: INFO Testing logs...

assets/index.html

@@ -5,6 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>Dozzle</title>
     <link href="https://fonts.googleapis.com/css?family=Roboto|Roboto+Mono|Gafata" rel="stylesheet" />
+    <link rel="manifest" href="manifest.webmanifest" />
     <link href="styles.scss" rel="stylesheet" />
     <script>
       window["BASE_PATH"] = "{{ .Base }}";

assets/manifest.webmanifest

@@ -0,0 +1,9 @@
+{
+  "name": "Dozzle Log Viewer",
+  "short_name": "Dozzle",
+  "theme_color": "#111111",
+  "background_color": "#111111",
+  "display": "standalone",
+  "scope": "/",
+  "start_url": "/"
+}

main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+    "bytes"
     "context"
     "encoding/binary"
     "encoding/json"
@@ -8,31 +9,54 @@ import (
     "github.com/amir20/dozzle/docker"
     "github.com/gobuffalo/packr"
     "github.com/gorilla/mux"
+    log "github.com/sirupsen/logrus"
     flag "github.com/spf13/pflag"
     "html/template"
-    "log"
+    "io"
     "net/http"
     "strings"
 )
 
 var (
-    dockerClient docker.Client
-    addr         = ""
-    base         = "/"
-    version      = "dev"
-    commit       = "none"
-    date         = "unknown"
+    addr    = ""
+    base    = ""
+    level   = ""
+    version = "dev"
+    commit  = "none"
+    date    = "unknown"
 )
 
+type handler struct {
+    client docker.Client
+    box    packr.Box
+}
+
 func init() {
     flag.StringVar(&addr, "addr", ":8080", "http service address")
     flag.StringVar(&base, "base", "/", "base address of the application to mount")
-
-    dockerClient = docker.NewClient()
+    flag.StringVar(&level, "level", "info", "logging level")
     flag.Parse()
+
+    l, _ := log.ParseLevel(level)
+    log.SetLevel(l)
+
+    log.SetFormatter(&log.TextFormatter{
+        DisableTimestamp:       true,
+        DisableLevelTruncation: true,
+    })
 }
 
 func main() {
+    dockerClient := docker.NewClient()
+    _, err := dockerClient.ListContainers()
+
+    if err != nil {
+        log.Fatalf("Could not connect to Docker Engine: %v", err)
+    }
+
+    box := packr.NewBox("./static")
+    h := &handler{dockerClient, box}
+
     r := mux.NewRouter()
 
     if base != "/" {
@@ -42,33 +66,43 @@ func main() {
     }
 
     s := r.PathPrefix(base).Subrouter()
-    box := packr.NewBox("./static")
+    s.HandleFunc("/api/containers.json", h.listContainers)
+    s.HandleFunc("/api/logs/stream", h.streamLogs)
+    s.HandleFunc("/api/events/stream", h.streamEvents)
+    s.HandleFunc("/version", h.version)
+    s.PathPrefix("/").Handler(http.StripPrefix(base, http.HandlerFunc(h.index)))
 
-    s.HandleFunc("/api/containers.json", listContainers)
-    s.HandleFunc("/api/logs/stream", streamLogs)
-    s.HandleFunc("/api/events/stream", streamEvents)
-    s.HandleFunc("/version", versionHandler)
-    s.PathPrefix("/").Handler(http.StripPrefix(base, http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-        fileServer := http.FileServer(box)
-        if box.Has(req.URL.Path) && req.URL.Path != "" && req.URL.Path != "/" {
-            fileServer.ServeHTTP(w, req)
-        } else {
-            handleIndex(box, w)
-        }
-    })))
-
-    log.Printf("Accepting connections on %s", addr)
+    log.Infof("Accepting connections on %s", addr)
     log.Fatal(http.ListenAndServe(addr, r))
 }
 
-func versionHandler(w http.ResponseWriter, r *http.Request) {
-    fmt.Fprintln(w, version)
-    fmt.Fprintln(w, commit)
-    fmt.Fprintln(w, date)
+func (h *handler) index(w http.ResponseWriter, req *http.Request) {
+    fileServer := http.FileServer(h.box)
+    if h.box.Has(req.URL.Path) && req.URL.Path != "" && req.URL.Path != "/" {
+        fileServer.ServeHTTP(w, req)
+    } else {
+        text, _ := h.box.FindString("index.html")
+        text = strings.Replace(text, "__BASE__", "{{ .Base }}", -1)
+        tmpl, err := template.New("index.html").Parse(text)
+        if err != nil {
+            panic(err)
+        }
+
+        path := ""
+        if base != "/" {
+            path = base
+        }
+
+        data := struct{ Base string }{path}
+        err = tmpl.Execute(w, data)
+        if err != nil {
+            http.Error(w, err.Error(), http.StatusInternalServerError)
+        }
+    }
 }
 
-func listContainers(w http.ResponseWriter, r *http.Request) {
-    containers, err := dockerClient.ListContainers()
+func (h *handler) listContainers(w http.ResponseWriter, r *http.Request) {
+    containers, err := h.client.ListContainers()
     if err != nil {
         http.Error(w, err.Error(), http.StatusInternalServerError)
         return
@@ -80,27 +114,7 @@ func listContainers(w http.ResponseWriter, r *http.Request) {
     }
 }
 
-func handleIndex(box packr.Box, w http.ResponseWriter) {
-    text, _ := box.FindString("index.html")
-    text = strings.Replace(text, "__BASE__", "{{ .Base }}", -1)
-    tmpl, err := template.New("index.html").Parse(text)
-    if err != nil {
-        panic(err)
-    }
-
-    path := ""
-    if base != "/" {
-        path = base
-    }
-
-    data := struct{ Base string }{path}
-    err = tmpl.Execute(w, data)
-    if err != nil {
-        panic(err)
-    }
-}
-
-func streamLogs(w http.ResponseWriter, r *http.Request) {
+func (h *handler) streamLogs(w http.ResponseWriter, r *http.Request) {
     id := r.URL.Query().Get("id")
     if id == "" {
         http.Error(w, "id is required", http.StatusBadRequest)
@@ -115,7 +129,7 @@ func streamLogs(w http.ResponseWriter, r *http.Request) {
 
     ctx, cancel := context.WithCancel(context.Background())
     defer cancel()
-    reader, err := dockerClient.ContainerLogs(ctx, id)
+    reader, err := h.client.ContainerLogs(ctx, id)
     if err != nil {
         log.Println(err)
         http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -132,27 +146,33 @@ func streamLogs(w http.ResponseWriter, r *http.Request) {
     w.Header().Set("Connection", "keep-alive")
     w.Header().Set("Transfer-Encoding", "chunked")
 
+    log.Debugf("Starting to stream logs for %s", id)
     hdr := make([]byte, 8)
-    content := make([]byte, 1024, 1024*1024)
+    var buffer bytes.Buffer
     for {
         _, err := reader.Read(hdr)
         if err != nil {
+            log.Debugf("Error while reading from log stream: %v", err)
             break
         }
         count := binary.BigEndian.Uint32(hdr[4:])
-        n, err := reader.Read(content[:count])
+        _, err = io.CopyN(&buffer, reader, int64(count))
+
         if err != nil {
+            log.Debugf("Error while reading from log stream: %v", err)
             break
         }
-        _, err = fmt.Fprintf(w, "data: %s\n\n", content[:n])
+        _, err = fmt.Fprintf(w, "data: %s\n\n", buffer.String())
+        buffer.Reset()
         if err != nil {
+            log.Debugf("Error while writing to log stream: %v", err)
             break
         }
         f.Flush()
     }
 }
 
-func streamEvents(w http.ResponseWriter, r *http.Request) {
+func (h *handler) streamEvents(w http.ResponseWriter, r *http.Request) {
     f, ok := w.(http.Flusher)
     if !ok {
         http.Error(w, "Streaming unsupported!", http.StatusInternalServerError)
@@ -166,35 +186,41 @@ func streamEvents(w http.ResponseWriter, r *http.Request) {
 
     ctx, cancel := context.WithCancel(context.Background())
     defer cancel()
-    messages, _ := dockerClient.Events(ctx)
+    messages, err := h.client.Events(ctx)
 
 Loop:
     for {
         select {
-        case message, closed := <-messages:
-            if closed {
+        case message, ok := <-messages:
+            if !ok {
                 break Loop
             }
             switch message.Action {
-            case "connect":
-                fallthrough
-            case "disconnect":
-                fallthrough
-            case "create":
-                fallthrough
-            case "destroy":
+            case "connect", "disconnect", "create", "destroy", "start", "stop":
+                log.Debugf("Triggering docker event: %v", message.Action)
                 _, err := fmt.Fprintf(w, "event: containers-changed\n")
                 _, err = fmt.Fprintf(w, "data: %s\n\n", message.Action)
 
                 if err != nil {
-                    log.Println(err)
+                    log.Debugf("Error while writing to event stream: %v", err)
                     break
                 }
                 f.Flush()
+            default:
+                log.Debugf("Ignoring docker event: %v", message.Action)
             }
         case <-r.Context().Done():
             cancel()
             break Loop
+        case <-err:
+            cancel()
+            break Loop
         }
     }
 }
+
+func (h *handler) version(w http.ResponseWriter, r *http.Request) {
+    io.WriteString(w, version)
+    io.WriteString(w, commit)
+    io.WriteString(w, date)
+}

main_test.go

@@ -0,0 +1,107 @@
+package main
+
+import (
+    "bytes"
+    "context"
+    "encoding/binary"
+    "io"
+    "io/ioutil"
+    "net/http"
+    "net/http/httptest"
+    "os"
+    "testing"
+
+    "github.com/amir20/dozzle/docker"
+    "github.com/beme/abide"
+    "github.com/stretchr/testify/mock"
+    "github.com/stretchr/testify/require"
+)
+
+type MockedClient struct {
+    mock.Mock
+    docker.Client
+}
+
+func (m *MockedClient) ListContainers() ([]docker.Container, error) {
+    args := m.Called()
+    containers, ok := args.Get(0).([]docker.Container)
+    if !ok {
+        panic("containers is not of type []docker.Container")
+    }
+    return containers, args.Error(1)
+}
+
+func (m *MockedClient) ContainerLogs(ctx context.Context, id string) (io.ReadCloser, error) {
+    args := m.Called(ctx, id)
+    reader, ok := args.Get(0).(io.ReadCloser)
+    if !ok {
+        panic("reader is not of type io.ReadCloser")
+    }
+    return reader, args.Error(1)
+}
+
+func Test_handler_listContainers(t *testing.T) {
+    req, err := http.NewRequest("GET", "/api/containers.json", nil)
+    require.NoError(t, err, "NewRequest should not return an error.")
+
+    rr := httptest.NewRecorder()
+
+    mockedClient := new(MockedClient)
+    containers := []docker.Container{
+        {
+            ID:      "1234567890",
+            Status:  "status",
+            State:   "state",
+            Name:    "test",
+            Created: 0,
+            Command: "command",
+            ImageID: "image_id",
+            Image:   "image",
+        },
+    }
+    mockedClient.On("ListContainers", mock.Anything).Return(containers, nil)
+
+    h := handler{client: mockedClient}
+
+    handler := http.HandlerFunc(h.listContainers)
+
+    handler.ServeHTTP(rr, req)
+    abide.AssertHTTPResponse(t, "/api/containers.json", rr.Result())
+    mockedClient.AssertExpectations(t)
+}
+
+func Test_handler_streamLogs(t *testing.T) {
+    id := "123456"
+    req, err := http.NewRequest("GET", "/api/logs/stream", nil)
+    q := req.URL.Query()
+    q.Add("id", "123456")
+    req.URL.RawQuery = q.Encode()
+    require.NoError(t, err, "NewRequest should not return an error.")
+
+    rr := httptest.NewRecorder()
+
+    mockedClient := new(MockedClient)
+    log := "INFO Testing logs..."
+    b := make([]byte, 8)
+
+    binary.BigEndian.PutUint32(b[4:], uint32(len(log)))
+    b = append(b, []byte(log)...)
+
+    var reader io.ReadCloser
+    reader = ioutil.NopCloser(bytes.NewReader(b))
+    mockedClient.On("ContainerLogs", mock.Anything, id).Return(reader, nil)
+
+    h := handler{client: mockedClient}
+
+    handler := http.HandlerFunc(h.streamLogs)
+
+    handler.ServeHTTP(rr, req)
+    abide.AssertHTTPResponse(t, "/api/logs/stream", rr.Result())
+    mockedClient.AssertExpectations(t)
+}
+
+func TestMain(m *testing.M) {
+    exit := m.Run()
+    abide.Cleanup()
+    os.Exit(exit)
+}

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "dozzle",
-  "version": "1.3.4",
+  "version": "1.4.1",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -9263,9 +9263,9 @@
       "dev": true
     },
     "yargs": {
-      "version": "12.0.4",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-12.0.4.tgz",
-      "integrity": "sha512-f5esswlPO351AnejaO2A1ZZr0zesz19RehQKwiRDqWtrraWrJy16tsUIKgDXFMVytvNOHPVmTiaTh3wO67I0fQ==",
+      "version": "12.0.5",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-12.0.5.tgz",
+      "integrity": "sha512-Lhz8TLaYnxq/2ObqHDql8dX8CJi97oHxrjUcYtzKbbykPtVW9WB+poxI+NM2UIzsMgNCZTIf0AQwsjK5yMAqZw==",
       "dev": true,
       "requires": {
         "cliui": "^4.0.0",
@@ -9279,13 +9279,13 @@
         "string-width": "^2.0.0",
         "which-module": "^2.0.0",
         "y18n": "^3.2.1 || ^4.0.0",
-        "yargs-parser": "^11.1.0"
+        "yargs-parser": "^11.1.1"
       }
     },
     "yargs-parser": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-11.1.0.tgz",
-      "integrity": "sha512-lGA5HsbjkpCfekDBHAhgE5OE8xEoqiUDylowr+BvhRCwG1xVYTsd8hx2CYC0NY4k9RIgJeybFTG2EZW4P2aN1w==",
+      "version": "11.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-11.1.1.tgz",
+      "integrity": "sha512-C6kB/WJDiaxONLJQnF8ccx9SEeoTTLek8RVbaOIsrAUS8VrBEXfmeSnCZxygc+XC2sNMBIwOOnfcxiynjHsVSQ==",
       "dev": true,
       "requires": {
         "camelcase": "^5.0.0",

package.json

@@ -1,12 +1,13 @@
 {
  "name": "dozzle",
- "version": "1.3.4",
+ "version": "1.4.1",
  "description": "",
  "main": "index.js",
  "scripts": {
   "prestart": "npm run clean",
-  "start": "DOCKER_API_VERSION=1.38 concurrently 'gin -a 8080 -i run main.go' 'npm run watch-assets'",
+  "start": "DOCKER_API_VERSION=1.38 concurrently 'npm run watch-server' 'npm run watch-assets'",
   "watch-assets": "parcel watch --public-url '__BASE__' assets/index.html -d static",
+  "watch-server": "reflex -g '*.go' -R '^node_modules/' -R '^static/' -R '^.cache/' -G '*_test.go' -s -- go run main.go --level debug",
   "prebuild": "npm run clean",
   "build": "parcel build --no-source-maps --public-url '__BASE__' assets/index.html -d static",
   "clean": "rm -rf static/ a_main-packr.go",