Added Static File Handler

examples/serving-static-files/configs/.env

@@ -0,0 +1,2 @@
+APP_NAME="serving-static-files"
+HTTP_PORT=9000

examples/serving-static-files/main.go

@@ -0,0 +1,10 @@
+package main
+
+import (
+	"gofr.dev/pkg/gofr"
+)
+
+func main() {
+	app := gofr.New()
+	app.Run()
+}

examples/serving-static-files/main_test.go

@@ -0,0 +1,87 @@
+package main
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFileServer(t *testing.T) {
+	const host = "http://localhost:9000"
+	go main()
+	time.Sleep(time.Second * 3)
+	tests := []struct {
+		desc                       string
+		method                     string
+		path                       string
+		body                       []byte
+		statusCode                 int
+		expectedBody               string
+		expectedBodyLength         int
+		expectedResponseHeaderType string
+	}{
+		{
+			desc:         "check static files",
+			method:       http.MethodGet,
+			path:         "/public/",
+			statusCode:   http.StatusOK,
+			expectedBody: "<pre>\n<a href=\"hardhat.jpeg\">hardhat.jpeg</a>\n<a href=\"industrial.jpeg\">industrial.jpeg</a>\n<a href=\"skross.png\">skross.png</a>\n</pre>\n",
+		},
+		{
+			desc:                       "check file content hardhat.jpeg",
+			method:                     http.MethodGet,
+			path:                       "/public/hardhat.jpeg",
+			statusCode:                 http.StatusOK,
+			expectedBodyLength:         14779,
+			expectedResponseHeaderType: "image/jpeg",
+		},
+		{
+			desc:                       "check file content industrial.jpeg",
+			method:                     http.MethodGet,
+			path:                       "/public/industrial.jpeg",
+			statusCode:                 http.StatusOK,
+			expectedBodyLength:         11228,
+			expectedResponseHeaderType: "image/jpeg",
+		},
+		{
+			desc:                       "check file content skross.png",
+			method:                     http.MethodGet,
+			path:                       "/public/skross.png",
+			statusCode:                 http.StatusOK,
+			expectedBodyLength:         76239,
+			expectedResponseHeaderType: "image/png",
+		},
+		{
+			desc:       "check public endpoint",
+			method:     http.MethodGet,
+			path:       "/public",
+			statusCode: http.StatusNotFound,
+		},
+	}
+
+	for it, tc := range tests {
+		request, _ := http.NewRequest(tc.method, host+tc.path, bytes.NewBuffer(tc.body))
+		request.Header.Set("Content-Type", "application/json")
+		client := http.Client{}
+		resp, err := client.Do(request)
+		bodyBytes, _ := io.ReadAll(resp.Body)
+		body := string(bodyBytes)
+		assert.Nil(t, err, "TEST[%d], Failed.\n%s", it, tc.desc)
+		assert.Equal(t, tc.statusCode, resp.StatusCode, "TEST[%d], Failed with Status Body.\n%s", it, tc.desc)
+		if tc.expectedBody != "" {
+			assert.Equal(t, tc.expectedBody, body, "TEST [%d], Failed with Expected Body. \n%s", it, tc.desc)
+		}
+		if tc.expectedBodyLength != 0 {
+			contentLength, _ := strconv.Atoi(resp.Header.Get("Content-Length"))
+			assert.Equal(t, tc.expectedBodyLength, contentLength, "TEST [%d], Failed at Content-Length.\n %s", it, tc.desc)
+		}
+		if tc.expectedResponseHeaderType != "" {
+			assert.Equal(t, tc.expectedResponseHeaderType, resp.Header.Get("Content-Type"), "TEST [%d], Failed at Expected Content-Type.\n%s", it, tc.desc)
+		}
+	}
+}

pkg/gofr/gofr.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"net/http"
 	"os"
+	"runtime"
 	"strconv"
 	"strings"
 	"sync"
@@ -76,7 +77,7 @@ func New() *App {
 	app.metricServer = newMetricServer(port)
 
 	// HTTP Server
-	port, err = strconv.Atoi(app.Config.Get("HTTP_PORT"))
+	port, err = strconv.Atoi(app.Config.GetOrDefault("HTTP_PORT", "6333"))
 	if err != nil || port <= 0 {
 		port = defaultHTTPPort
 	}
@@ -93,9 +94,52 @@ func New() *App {
 
 	app.subscriptionManager = newSubscriptionManager(app.container)
 
+	// static fileserver
+	currentWd, _ := os.Getwd()
+	checkDirectory := fmt.Sprintf("%s%spublic", currentWd, getFilePathSplitter())
+
+	if _, err := os.Stat(checkDirectory); !os.IsNotExist(err) {
+		app.AddStaticFiles("public", checkDirectory)
+	}
+
 	return app
 }
 
+func getFilePathSplitter() string {
+	fileSplitter := ""
+
+	switch runtime.GOOS {
+	case "windows":
+		fileSplitter = "\\"
+	case "linux":
+	case "darwin":
+	case "android":
+	case "ios":
+		fileSplitter = "/"
+	}
+	return fileSplitter
+}
+
+func (a *App) AddStaticFiles(endpoint, filePath string) {
+	a.httpRegistered = true
+	dupFilePath := ""
+	fileSplitter := getFilePathSplitter()
+	if filePath[:2] == "./" {
+		dupFilePath, _ = os.Getwd()
+		dupFilePath += fileSplitter + filePath + fileSplitter
+	} else {
+		dupFilePath = filePath
+	}
+	if endpoint[0] != '/' {
+		endpoint = "/" + endpoint
+	}
+	if _, err := os.Stat(dupFilePath); err == nil {
+		a.httpServer.router.AddStaticFiles(endpoint, dupFilePath)
+	} else {
+		a.container.Logger.Errorf("Couldn't register %s static endpoint", endpoint)
+	}
+}
+
 // NewCMD creates a command-line application.
 func NewCMD() *App {
 	app := &App{}

pkg/gofr/http/router.go

@@ -38,6 +38,11 @@ func (rou *Router) Add(method, pattern string, handler http.Handler) {
 	rou.Router.NewRoute().Methods(method).Path(pattern).Handler(h)
 }
 
+func (rou *Router) AddStaticFiles(endpoint, directory string) {
+	fileServer := http.FileServer(http.Dir(directory))
+	rou.Router.NewRoute().PathPrefix(endpoint + "/").Handler(http.StripPrefix(endpoint, fileServer))
+}
+
 // UseMiddleware registers middlewares to the router.
 func (rou *Router) UseMiddleware(mws ...Middleware) {
 	middlewares := make([]mux.MiddlewareFunc, 0, len(mws))