Add POST /query. It calls gitbase and returns json

Signed-off-by: Carlos Martín <[email protected]>

Author: carlosms

cmd/server/main.go

@@ -1,25 +1,33 @@
 package main
 
 import (
+	"database/sql"
 	"fmt"
 	"net/http"
 
 	"github.com/src-d/gitbase-playground/server"
 	"github.com/src-d/gitbase-playground/server/handler"
 	"github.com/src-d/gitbase-playground/server/service"
 
+	_ "github.com/go-sql-driver/mysql"
 	"github.com/kelseyhightower/envconfig"
 )
 
 // version will be replaced automatically by the CI build.
 // See https://github.com/src-d/ci/blob/v1/Makefile.main#L56
 var version = "dev"
 
+// Note: maxAllowedPacket must be explicitly set for go-sql-driver/mysql v1.3.
+// Otherwise gitbase will be asked for the max_allowed_packet column and the
+// query will fail.
+// The next release should make this parameter optional for us:
+// https://github.com/go-sql-driver/mysql/pull/680
 type appConfig struct {
 	Env       string `envconfig:"ENV" default:"production"`
 	Host      string `envconfig:"HOST" default:"0.0.0.0"`
 	Port      int    `envconfig:"PORT" default:"8080"`
 	ServerURL string `envconfig:"SERVER_URL"`
+	DBConn    string `envconfig:"DB_CONNECTION" default:"root@tcp(localhost:3306)/none?maxAllowedPacket=4194304"`
 }
 
 func main() {
@@ -33,11 +41,18 @@ func main() {
 	// logger
 	logger := service.NewLogger(conf.Env)
 
+	// database
+	db, err := sql.Open("mysql", conf.DBConn)
+	if err != nil {
+		logger.Fatalf("error opening the database: %s", err)
+	}
+	defer db.Close()
+
 	static := handler.NewStatic("build", conf.ServerURL)
 
 	// start the router
-	router := server.Router(logger, static, version)
+	router := server.Router(logger, static, version, db)
 	logger.Infof("listening on %s:%d", conf.Host, conf.Port)
-	err := http.ListenAndServe(fmt.Sprintf("%s:%d", conf.Host, conf.Port), router)
+	err = http.ListenAndServe(fmt.Sprintf("%s:%d", conf.Host, conf.Port), router)
 	logger.Fatal(err)
 }

server/handler/query.go

@@ -0,0 +1,88 @@
+package handler
+
+import (
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/src-d/gitbase-playground/server/serializer"
+)
+
+type queryRequest struct {
+	Query string `json:"query"`
+	Limit int    `json:"limit"`
+}
+
+// genericVals returns a slice of interface{}, each one a pointer to a NullString
+func genericVals(nColumns int) []interface{} {
+	columnVals := make([]sql.NullString, nColumns)
+	columnValsPtr := make([]interface{}, nColumns)
+
+	for i := range columnVals {
+		columnValsPtr[i] = &columnVals[i]
+	}
+
+	return columnValsPtr
+}
+
+// Query returns a function that forwards an SQL query to gitbase and returns
+// the rows as JSON
+func Query(db *sql.DB) RequestProcessFunc {
+	return func(r *http.Request) (*serializer.Response, error) {
+		var queryRequest queryRequest
+		body, err := ioutil.ReadAll(r.Body)
+		defer r.Body.Close()
+		if err == nil {
+			err = json.Unmarshal(body, &queryRequest)
+		}
+
+		if err != nil {
+			return nil, err
+		}
+
+		// TODO (carlosms) this only works if the query does not end in ;
+		// and does not have a limit. It will also fail for queries like
+		// DESCRIBE TABLE
+		query := fmt.Sprintf("%s LIMIT %d", queryRequest.Query, queryRequest.Limit)
+		rows, err := db.Query(query)
+		if err != nil {
+			return nil, serializer.NewHTTPError(http.StatusBadRequest, err.Error())
+		}
+		defer rows.Close()
+
+		columnNames, _ := rows.Columns()
+		nColumns := len(columnNames)
+		columnValsPtr := genericVals(nColumns)
+
+		tableData := make([]map[string]string, 0)
+
+		for rows.Next() {
+			if err := rows.Scan(columnValsPtr...); err != nil {
+				return nil, err
+			}
+
+			colData := make(map[string]string)
+
+			for i, val := range columnValsPtr {
+				var st string
+				sqlSt, _ := val.(*sql.NullString)
+
+				if sqlSt.Valid {
+					st = sqlSt.String
+				}
+
+				colData[columnNames[i]] = st
+			}
+
+			tableData = append(tableData, colData)
+		}
+
+		if err := rows.Err(); err != nil {
+			return nil, err
+		}
+
+		return serializer.NewQueryResponse(tableData, columnNames), nil
+	}
+}

server/router.go

@@ -1,6 +1,7 @@
 package server
 
 import (
+	"database/sql"
 	"net/http"
 
 	"github.com/src-d/gitbase-playground/server/handler"
@@ -17,6 +18,7 @@ func Router(
 	logger *logrus.Logger,
 	static *handler.Static,
 	version string,
+	db *sql.DB,
 ) http.Handler {
 
 	// cors options
@@ -33,6 +35,8 @@ func Router(
 	r.Use(cors.New(corsOptions).Handler)
 	r.Use(lg.RequestLogger(logger))
 
+	r.Post("/query", handler.APIHandlerFunc(handler.Query(db)))
+
 	r.Get("/version", handler.APIHandlerFunc(handler.Version(version)))
 
 	r.Get("/static/*", static.ServeHTTP)

server/serializer/serializers.go

@@ -15,6 +15,7 @@ type HTTPError interface {
 type Response struct {
 	Status int         `json:"status"`
 	Data   interface{} `json:"data,omitempty"`
+	Meta   interface{} `json:"meta,omitempty"`
 	Errors []HTTPError `json:"errors,omitempty"`
 }
 
@@ -47,16 +48,17 @@ func NewHTTPError(statusCode int, msg ...string) HTTPError {
 	return httpError{Status: statusCode, Title: strings.Join(msg, " ")}
 }
 
-func newResponse(c interface{}) *Response {
-	if c == nil {
+func newResponse(data interface{}, meta interface{}) *Response {
+	if data == nil {
 		return &Response{
 			Status: http.StatusNoContent,
 		}
 	}
 
 	return &Response{
 		Status: http.StatusOK,
-		Data:   c,
+		Data:   data,
+		Meta:   meta,
 	}
 }
 
@@ -71,5 +73,14 @@ type versionResponse struct {
 
 // NewVersionResponse returns a Response with current version of the server
 func NewVersionResponse(version string) *Response {
-	return newResponse(versionResponse{version})
+	return newResponse(versionResponse{version}, nil)
+}
+
+type queryMetaResponse struct {
+	Headers []string `json:"headers"`
+}
+
+// NewQueryResponse returns a Response with table headers and row contents
+func NewQueryResponse(rows []map[string]string, columnNames []string) *Response {
+	return newResponse(rows, queryMetaResponse{columnNames})
 }