improve code quality

Disable keepalive function

Author: JojiiOfficial

Dockerfile

@@ -1,5 +1,5 @@
 
-FROM golang:1.14.1-alpine3.11 as builder1
+FROM golang:1.14.2-alpine as builder1
 
 # Setting up environment for builder1
 ENV GO111MODULE=on

handlers/AuthHandler.go

@@ -6,40 +6,44 @@ import (
 	"strings"
 )
 
+/*
+	The AuthHandler is a wrapper for supported Authorization mechanisms. Currently
+	Only Bearer token are supported which are provided by an "Authorization" header inside the request
+*/
+
 var (
-	//ErrorTokenInvalid error if token is invalid
+	// ErrorTokenInvalid error if token is invalid
 	ErrorTokenInvalid error = errors.New("Token invalid")
-	//ErrorTokenEmpty error if token is empty
-	ErrorTokenEmpty error = errors.New("Token empty")
 )
 
-//AuthHandler handler for http auth
+// AuthHandler handler for http auth
 type AuthHandler struct {
 	Request *http.Request
 }
 
-//NewAuthHandler returns a new AuthHandler
+// NewAuthHandler returns a new AuthHandler
 func NewAuthHandler(request *http.Request) *AuthHandler {
 	return &AuthHandler{
 		Request: request,
 	}
 }
 
-//GetBearer return the bearer token
+// GetBearer return the bearer token
 func (authHandler AuthHandler) GetBearer() string {
 	authHeader, has := authHandler.Request.Header["Authorization"]
-	//Validate bearer token
+	// Validate bearer token
 	if !has || len(authHeader) == 0 || !strings.HasPrefix(authHeader[0], "Bearer") {
 		return ""
 	}
 	return tokenFromBearerHeader(authHeader[0])
 }
 
+// Parse the Authorization header and return its real value (the token)
 func tokenFromBearerHeader(header string) string {
 	return strings.TrimSpace(strings.ReplaceAll(header, "Bearer", ""))
 }
 
-//IsInvalid return true if err is invalid
+// IsInvalid return true if err is invalid
 func (authHandler AuthHandler) IsInvalid(err error) bool {
 	return err == ErrorTokenInvalid
 }

handlers/FileAttrHandler.go

@@ -10,7 +10,9 @@ import (
 	"github.com/jinzhu/gorm"
 )
 
-//AttributeHandler handler for attributes
+// AttributeHandler handler for file attributes.
+// Implements update, delete, get and create functions
+// for tags and groups
 func AttributeHandler(handlerData web.HandlerData, w http.ResponseWriter, r *http.Request) {
 	// Get vars
 	vars := mux.Vars(r)
@@ -250,7 +252,6 @@ func UserAttributeHandler(handlerData web.HandlerData, w http.ResponseWriter, r
 		return
 	}
 
-	// create map
 	nsMap := make(map[string][]models.Group)
 
 	// Create map with namespace as key

handlers/FileHandler.go

@@ -405,6 +405,7 @@ func FileHandler(handlerData web.HandlerData, w http.ResponseWriter, r *http.Req
 		},
 		Name:      request.Name,
 		Namespace: namespace,
+		// TODO add group/tag filter
 	})
 
 	if LogError(err) {

handlers/NamespaceHandler.go

@@ -108,7 +108,6 @@ func NamespaceActionHandler(handlerData web.HandlerData, w http.ResponseWriter,
 		return
 	}
 
-	// Send success
 	sendResponse(w, models.ResponseSuccess, "", models.StringResponse{
 		String: namespace.Name,
 	})

handlers/PingHandler.go

@@ -7,7 +7,7 @@ import (
 	"github.com/DataManager-Go/DataManagerServer/models"
 )
 
-//Ping handles ping request
+// Ping handles ping request
 func Ping(handlerData web.HandlerData, w http.ResponseWriter, r *http.Request) {
 	var request models.PingRequest
 	if !readRequestLimited(w, r, &request, handlerData.Config.Webserver.MaxRequestBodyLength) {

handlers/Responses.go

@@ -12,6 +12,7 @@ func handleAndSendError(err error, w http.ResponseWriter, message string, status
 	if !LogError(err) {
 		return false
 	}
+
 	sendResponse(w, models.ResponseError, message, nil, statusCode)
 	return true
 }

handlers/Router.go

@@ -3,7 +3,6 @@ package handlers
 import (
 	"fmt"
 	"net/http"
-	"net/http/pprof"
 	"time"
 
 	"github.com/DataManager-Go/DataManagerServer/handlers/web"
@@ -16,7 +15,7 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
-//Route for REST
+// Route for REST
 type Route struct {
 	Name        string
 	Method      HTTPMethod
@@ -25,10 +24,10 @@ type Route struct {
 	HandlerType requestType
 }
 
-//HTTPMethod http method. GET, POST, DELETE, HEADER, etc...
+// HTTPMethod http method. GET, POST, DELETE, HEADER, etc...
 type HTTPMethod string
 
-//HTTP methods
+// HTTP methods
 const (
 	GetMethod    HTTPMethod = "GET"
 	POSTMethod   HTTPMethod = "POST"
@@ -44,13 +43,13 @@ const (
 	optionalTokenRequest
 )
 
-//Routes all REST routes
+// Routes all REST routes
 type Routes []Route
 
-//RouteFunction function for handling a route
+// RouteFunction function for handling a route
 type RouteFunction func(web.HandlerData, http.ResponseWriter, *http.Request)
 
-//Routes
+// Routes
 var (
 	routes = Routes{
 		// Ping
@@ -147,10 +146,11 @@ var (
 			HandlerFunc: NamespaceListHandler,
 			HandlerType: sessionRequest,
 		},
+		// TODO add stats
 	}
 )
 
-//NewRouter create new router
+// NewRouter create new router and its required components
 func NewRouter(config *models.Config, db *gorm.DB) *mux.Router {
 	handlerData := web.HandlerData{
 		Config: config,
@@ -166,30 +166,13 @@ func NewRouter(config *models.Config, db *gorm.DB) *mux.Router {
 			Handler(RouteHandler(route.HandlerType, &handlerData, route.HandlerFunc, route.Name))
 	}
 
-	//Adding custom routes
+	// Adding custom routes
 	addCustomRoutes(router, &handlerData)
 
-	// Add profiler func if profiling is enabled
-	if config.Webserver.Profiling {
-		addProfilerFuncs(router)
-	}
-
 	return router
 }
 
-// add pprof funcs
-func addProfilerFuncs(router *mux.Router) {
-	router.HandleFunc("/debug/pprof/", pprof.Index)
-	router.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
-	router.HandleFunc("/debug/pprof/profile", pprof.Profile)
-	router.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
-	router.Handle("/debug/pprof/heap", pprof.Handler("heap"))
-	router.Handle("/debug/pprof/goroutine", pprof.Handler("goroutine"))
-	router.Handle("/debug/pprof/block", pprof.Handler("block"))
-	router.Handle("/debug/pprof/threadcreate", pprof.Handler("threadcreate"))
-}
-
-//Add custom web-routes
+// Add custom web-routes
 func addCustomRoutes(router *mux.Router, handlerData *web.HandlerData) {
 	// 404 Handler
 	router.NotFoundHandler = RouteHandler(defaultRequest, handlerData, web.NotFoundHandler, "not found")
@@ -204,18 +187,17 @@ func addCustomRoutes(router *mux.Router, handlerData *web.HandlerData) {
 	router.PathPrefix("/static/").Handler(http.StripPrefix("/static/", http.FileServer(http.Dir("./html/static"))))
 }
 
-//RouteHandler logs stuff
+// RouteHandler logs stuff
 func RouteHandler(requestType requestType, handlerData *web.HandlerData, inner RouteFunction, name string) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		defer func() {
-			err := r.Body.Close()
-			if err != nil {
+			if err := r.Body.Close(); err != nil {
 				log.Info(err)
 			}
 		}()
 
+		// Only debug routes which have a names
 		needDebug := len(name) > 0
-
 		if needDebug {
 			log.Infof("[%s] %s\n", r.Method, name)
 		}
@@ -226,33 +208,41 @@ func RouteHandler(requestType requestType, handlerData *web.HandlerData, inner R
 			return
 		}
 
-		//Validate request by requestType
+		// Validate request by requestType
 		if !requestType.validate(handlerData, r, w) {
 			return
 		}
 
-		//Process request
+		// Process request
 		inner(*handlerData, w, r)
 
-		//Print duration of processing
+		// Print duration of processing
 		if needDebug {
 			printProcessingDuration(start)
 		}
 	})
 }
 
-//Return false on error
+// Validate the given request based on its requestType
+// if validate returns false, the request has to abort
 func (requestType requestType) validate(handlerData *web.HandlerData, r *http.Request, w http.ResponseWriter) bool {
 	switch requestType {
 	case sessionRequest:
 		{
+			// SessionRequest requires a valid session token
+			// which identifies a specific user
+
+			// Create an AuthHandler using r
 			authHandler := NewAuthHandler(r)
+
+			// Check Token validity by its length
 			if len(authHandler.GetBearer()) != 64 {
 				log.Error("Invalid token len %d", len(authHandler.GetBearer()))
 				sendResponse(w, models.ResponseError, "Invalid token", http.StatusUnauthorized)
 				return false
 			}
 
+			// Try to retrieve the user by the requestToken
 			user, err := models.GetUserFromSession(handlerData.Db, authHandler.GetBearer())
 			if LogError(err) || user == nil {
 				if user == nil && err == nil {
@@ -263,14 +253,16 @@ func (requestType requestType) validate(handlerData *web.HandlerData, r *http.Re
 				return false
 			}
 
+			// Set the handlerData.User which is
+			// required by all endpoint functions
 			handlerData.User = user
 		}
 	}
 
 	return true
 }
 
-//Prints the duration of handling the function
+// Prints the duration of handling the function
 func printProcessingDuration(startTime time.Time) {
 	dur := time.Since(startTime)
 
@@ -281,13 +273,13 @@ func printProcessingDuration(startTime time.Time) {
 	}
 }
 
-//Return true on error
+// Return true on error
 func validateHeader(config *models.Config, w http.ResponseWriter, r *http.Request) bool {
 	headerSize := gaw.GetHeaderSize(r.Header)
 
-	//Send error if header are too big. MaxHeaderLength is stored in b
+	// Send error if header are too big. MaxHeaderLength is stored in b
 	if headerSize > uint32(config.Webserver.MaxHeaderLength) {
-		//Send error response
+		// Send error response
 		w.WriteHeader(http.StatusRequestEntityTooLarge)
 		fmt.Fprint(w, "413 request too large")
 

handlers/UserHandler.go

@@ -9,8 +9,7 @@ import (
 	"github.com/JojiiOfficial/gaw"
 )
 
-//Login login handler
-//-> /user/login
+// Login login handler
 func Login(handlerData web.HandlerData, w http.ResponseWriter, r *http.Request) {
 	var request models.CredentialsRequest
 
@@ -44,8 +43,7 @@ func Login(handlerData web.HandlerData, w http.ResponseWriter, r *http.Request)
 	}
 }
 
-//Register register handler
-//-> /user/create
+// Register register handler
 func Register(handlerData web.HandlerData, w http.ResponseWriter, r *http.Request) {
 	if !handlerData.Config.Server.AllowRegistration {
 		sendResponse(w, models.ResponseError, "Server doesn't accept registrations", nil, http.StatusForbidden)

services/APIService.go

@@ -37,6 +37,8 @@ func NewAPIService(config *models.Config, db *gorm.DB) *APIService {
 			WriteTimeout:      config.Webserver.WriteTimeout,
 			IdleTimeout:       0 * time.Second,
 		}
+
+		httpServer.SetKeepAlivesEnabled(false)
 	}
 
 	//Init https server
@@ -48,6 +50,8 @@ func NewAPIService(config *models.Config, db *gorm.DB) *APIService {
 			WriteTimeout: config.Webserver.WriteTimeout,
 			IdleTimeout:  0 * time.Second,
 		}
+
+		httpsServer.SetKeepAlivesEnabled(false)
 	}
 
 	apiService := &APIService{
@@ -60,9 +64,9 @@ func NewAPIService(config *models.Config, db *gorm.DB) *APIService {
 	return apiService
 }
 
-//Start the API service
+// Start the API service
 func (service *APIService) Start() {
-	//Start HTTPS if enabled
+	// Start HTTPS if enabled
 	if service.HTTPTLSServer != nil {
 		log.Infof("Server started TLS on port (%s)\n", service.config.Webserver.HTTPS.ListenAddress)
 		go (func() {
@@ -74,7 +78,7 @@ func (service *APIService) Start() {
 		})()
 	}
 
-	//Start HTTP if enabled
+	// Start HTTP if enabled
 	if service.HTTPServer != nil {
 		log.Infof("Server started HTTP on port (%s)\n", service.config.Webserver.HTTP.ListenAddress)
 		go (func() {
@@ -86,20 +90,3 @@ func (service *APIService) Start() {
 		})()
 	}
 }
-
-// ConnContext: func(ctx context.Context, c net.Conn) context.Context {
-// 	connectionCancel, cancelWriteTimeout := context.WithCancel(ctx)
-// 	go func() {
-// 		defer cancelWriteTimeout()
-// 		_ = <-connectionCancel.Done()
-// 		if err := connectionCancel.Err(); err == context.DeadlineExceeded {
-// 			fmt.Println("a")
-// 			c.Close()
-// 		}
-// 	}()
-// 	return context.WithValue(ctx, ctx.Value(http.ServerContextKey), cancelWriteTimeout)
-// },
-// if f, ok := ctx.Value(ctx.Value(http.ServerContextKey)).(context.CancelFunc); ok {
-// 							f()
-// 						}
-// 						// sendResponse(w, models.ResponseError, "timeout", nil, http.StatusRequestTimeout)