1 files changed, 51 insertions, 27 deletions
diff --git a/http/http.go b/http/http.go
index dac035c..98ca90d 100644
--- a/http/http.go
+++ b/http/http.go
@@ -7,6 +7,7 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/mpolden/zdns/cache"
 	"github.com/mpolden/zdns/dns"
 	"github.com/mpolden/zdns/log"
 )
@@ -14,13 +15,15 @@ import (
 // A Server defines paramaters for running an HTTP server. The HTTP server serves an API for inspecting cache contents
 // and request log.
 type Server struct {
-	server *http.Server
+	cache  *cache.Cache
 	logger *log.Logger
+	server *http.Server
 }
 
-type logEntry struct {
+type entry struct {
 	Time       string   `json:"time"`
-	RemoteAddr net.IP   `json:"remote_addr"`
+	TTL        int64    `json:"ttl,omitempty"`
+	RemoteAddr net.IP   `json:"remote_addr,omitempty"`
 	Qtype      string   `json:"type"`
 	Question   string   `json:"question"`
 	Answers    []string `json:"answers"`
@@ -32,18 +35,22 @@ type httpError struct {
 	Message string `json:"message"`
 }
 
-// NewServer creates a new HTTP server, serving logs from the given logger and listening on listenAddr.
-func NewServer(logger *log.Logger, listenAddr string) *Server {
-	server := &http.Server{Addr: listenAddr}
-	s := &Server{logger: logger, server: server}
+// NewServer creates a new HTTP server, serving logs from the given logger and listening on addr.
+func NewServer(logger *log.Logger, cache *cache.Cache, addr string) *Server {
+	server := &http.Server{Addr: addr}
+	s := &Server{
+		cache:  cache,
+		logger: logger,
+		server: server,
+	}
 	s.server.Handler = s.handler()
 	return s
 }
 
 func (s *Server) handler() http.Handler {
 	mux := http.NewServeMux()
+	mux.Handle("/cache/v1/", appHandler(s.cacheHandler))
 	mux.Handle("/log/v1/", appHandler(s.logHandler))
-	//mux.Handle("/cache/v1")
 	mux.Handle("/", appHandler(notFoundHandler))
 	return requestFilter(mux)
 }
@@ -85,6 +92,33 @@ func notFoundHandler(w http.ResponseWriter, r *http.Request) (interface{}, *http
 	}
 }
 
+func (s *Server) cacheHandler(w http.ResponseWriter, r *http.Request) (interface{}, *httpError) {
+	cacheValues := s.cache.List(100)
+	entries := make([]entry, 0, len(cacheValues))
+	for _, v := range cacheValues {
+		entries = append(entries, entry{
+			Time:     v.CreatedAt.UTC().Format(time.RFC3339),
+			TTL:      int64(v.TTL().Truncate(time.Second).Seconds()),
+			Qtype:    qtype(v.Qtype),
+			Question: v.Question,
+			Answers:  v.Answers,
+		})
+	}
+	return entries, nil
+}
+
+func qtype(qtype uint16) string {
+	switch qtype {
+	case dns.TypeA:
+		return "A"
+	case dns.TypeAAAA:
+		return "AAAA"
+	case dns.TypeMX:
+		return "MX"
+	}
+	return ""
+}
+
 func (s *Server) logHandler(w http.ResponseWriter, r *http.Request) (interface{}, *httpError) {
 	logEntries, err := s.logger.Get(100)
 	if err != nil {
@@ -93,25 +127,15 @@ func (s *Server) logHandler(w http.ResponseWriter, r *http.Request) (interface{}
 			Status: http.StatusInternalServerError,
 		}
 	}
-	entries := make([]logEntry, 0, len(logEntries))
-	for _, entry := range logEntries {
-		dnsType := ""
-		switch entry.Qtype {
-		case dns.TypeA:
-			dnsType = "A"
-		case dns.TypeAAAA:
-			dnsType = "AAAA"
-		case dns.TypeMX:
-			dnsType = "MX"
-		}
-		e := logEntry{
-			Time:       entry.Time.UTC().Format(time.RFC3339),
-			RemoteAddr: entry.RemoteAddr,
-			Qtype:      dnsType,
-			Question:   entry.Question,
-			Answers:    entry.Answers,
-		}
-		entries = append(entries, e)
+	entries := make([]entry, 0, len(logEntries))
+	for _, le := range logEntries {
+		entries = append(entries, entry{
+			Time:       le.Time.UTC().Format(time.RFC3339),
+			RemoteAddr: le.RemoteAddr,
+			Qtype:      qtype(le.Qtype),
+			Question:   le.Question,
+			Answers:    le.Answers,
+		})
 	}
 	return entries, nil
 }