rename backend to pkg

pkg/api/api.go

@@ -0,0 +1,81 @@
+package api
+
+import (
+	"html/template"
+
+	log "github.com/alecthomas/log4go"
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/sessions"
+	"github.com/torkelo/grafana-pro/pkg/components"
+	"github.com/torkelo/grafana-pro/pkg/stores"
+)
+
+type HttpServer struct {
+	port     string
+	shutdown chan bool
+	store    stores.Store
+	renderer *components.PhantomRenderer
+	router   *gin.Engine
+}
+
+var sessionStore = sessions.NewCookieStore([]byte("something-very-secret"))
+
+// var hashKey = []byte("very-secret")
+// var blockKey = []byte("a-lot-secret")
+// var s = securecookie.New(hashKey, blockKey)
+
+func NewHttpServer(port string, store stores.Store) *HttpServer {
+	self := &HttpServer{}
+	self.port = port
+	self.store = store
+	self.renderer = &components.PhantomRenderer{ImagesDir: "data/png", PhantomDir: "_vendor/phantomjs"}
+
+	return self
+}
+
+func (self *HttpServer) ListenAndServe() {
+	log.Info("Starting Http Listener on port %v", self.port)
+	defer func() { self.shutdown <- true }()
+
+	self.router = gin.Default()
+	self.router.Use(CacheHeadersMiddleware())
+
+	self.router.Static("/public", "./public")
+	self.router.Static("/app", "./public/app")
+	self.router.Static("/img", "./public/img")
+
+	// register & parse templates
+	templates := template.New("templates")
+	templates.Delims("[[", "]]")
+	templates.ParseFiles("./views/index.html")
+	self.router.SetHTMLTemplate(templates)
+
+	for _, fn := range routeHandlers {
+		fn(self)
+	}
+
+	// register default route
+	self.router.GET("/", self.authMiddleware(), self.index)
+	self.router.GET("/dashboard/*_", self.authMiddleware(), self.index)
+
+	self.router.Run(":" + self.port)
+}
+
+func (self *HttpServer) index(c *gin.Context) {
+	c.HTML(200, "index.html", &indexViewModel{title: "hello from go"})
+}
+
+func CacheHeadersMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.Writer.Header().Add("Cache-Control", "max-age=0, public, must-revalidate, proxy-revalidate")
+	}
+}
+
+// Api Handler Registration
+var routeHandlers = make([]routeHandlerRegisterFn, 0)
+
+type routeHandlerRegisterFn func(self *HttpServer)
+
+func addRoutes(fn routeHandlerRegisterFn) {
+	routeHandlers = append(routeHandlers, fn)
+}

pkg/api/api_dashboard.go

@@ -0,0 +1,52 @@
+package api
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/torkelo/grafana-pro/pkg/models"
+)
+
+func init() {
+	addRoutes(func(self *HttpServer) {
+		self.router.GET("/api/dashboards/:id", self.getDashboard)
+		self.router.GET("/api/search/", self.search)
+		self.router.POST("/api/dashboard", self.postDashboard)
+	})
+}
+
+func (self *HttpServer) getDashboard(c *gin.Context) {
+	id := c.Params.ByName("id")
+
+	dash, err := self.store.GetById(id)
+	if err != nil {
+		c.JSON(404, newErrorResponse("Dashboard not found"))
+		return
+	}
+
+	c.JSON(200, dash.Data)
+}
+
+func (self *HttpServer) search(c *gin.Context) {
+	query := c.Params.ByName("q")
+
+	results, err := self.store.Query(query)
+	if err != nil {
+		c.JSON(500, newErrorResponse("Failed"))
+		return
+	}
+
+	c.JSON(200, results)
+}
+
+func (self *HttpServer) postDashboard(c *gin.Context) {
+	var command saveDashboardCommand
+
+	if c.EnsureBody(&command) {
+		err := self.store.Save(&models.Dashboard{Data: command.Dashboard})
+		if err == nil {
+			c.JSON(200, gin.H{"status": "saved"})
+			return
+		}
+	}
+
+	c.JSON(500, gin.H{"error": "bad request"})
+}

pkg/api/api_login.go

@@ -0,0 +1,46 @@
+package api
+
+import "github.com/gin-gonic/gin"
+
+func init() {
+	addRoutes(func(self *HttpServer) {
+		self.router.GET("/login/*_", self.index)
+		self.router.POST("/login", self.loginPost)
+	})
+}
+
+type loginJsonModel struct {
+	Email    string `json:"email" binding:"required"`
+	Password string `json:"password" binding:"required"`
+	Remember bool   `json:"remember"`
+}
+
+func (self *HttpServer) loginPost(c *gin.Context) {
+	var loginModel loginJsonModel
+
+	if c.EnsureBody(&loginModel) {
+		if loginModel.Email == "manu" && loginModel.Password == "123" {
+
+			session, _ := sessionStore.Get(c.Request, "grafana-session")
+			session.Values["login"] = true
+			session.Save(c.Request, c.Writer)
+
+			c.JSON(200, gin.H{"status": "you are logged in"})
+		} else {
+			c.JSON(401, gin.H{"status": "unauthorized"})
+		}
+	}
+}
+
+func (self *HttpServer) authMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		session, _ := sessionStore.Get(c.Request, "grafana-session")
+
+		if c.Request.URL.Path != "/login" && session.Values["login"] == nil {
+			c.Writer.Header().Set("Location", "/login")
+			c.Abort(302)
+		}
+
+		session.Save(c.Request, c.Writer)
+	}
+}

pkg/api/api_models.go

@@ -0,0 +1,19 @@
+package api
+
+type saveDashboardCommand struct {
+	Id        string `json:"id"`
+	Title     string `json:"title"`
+	Dashboard map[string]interface{}
+}
+
+type errorResponse struct {
+	Message string `json:"message"`
+}
+
+type indexViewModel struct {
+	title string
+}
+
+func newErrorResponse(message string) *errorResponse {
+	return &errorResponse{Message: message}
+}

pkg/api/api_render.go

@@ -0,0 +1,20 @@
+package api
+
+import "github.com/gin-gonic/gin"
+
+func init() {
+	addRoutes(func(self *HttpServer) {
+		self.router.GET("/api/render", self.renderToPng)
+	})
+}
+
+func (self *HttpServer) renderToPng(c *gin.Context) {
+	qs := c.Request.URL.Query()
+	url := qs["url"][0]
+	pngPath, err := self.renderer.RenderToPng(url)
+	if err != nil {
+		c.HTML(500, "error.html", nil)
+	}
+
+	c.File(pngPath)
+}

pkg/api/api_test.go

@@ -0,0 +1 @@
+package api