RoadSign/pkg/navi/responder.go

package navi

import (
	"errors"
	"fmt"
	"github.com/fasthttp/websocket"
	"github.com/gofiber/fiber/v2"
	"github.com/gofiber/fiber/v2/middleware/proxy"
	"github.com/gofiber/fiber/v2/utils"
	"github.com/rs/zerolog/log"
	"github.com/samber/lo"
	"github.com/valyala/fasthttp"
	"io/fs"
	"net/http"
	"path/filepath"
	"strconv"
	"strings"
	"time"
)

func makeUnifiedResponse(c *fiber.Ctx, dest *Destination) error {
	if websocket.FastHTTPIsWebSocketUpgrade(c.Context()) {
		// Handle websocket
		return makeWebsocketResponse(c, dest)
	} else {
		// TODO Impl SSE with https://github.com/gofiber/recipes/blob/master/sse/main.go
		// Handle normal http request
		return makeHypertextResponse(c, dest)
	}
}

func makeHypertextResponse(c *fiber.Ctx, dest *Destination) error {
	_, queries := dest.GetRawUri()
	raw := lo.Ternary(len(queries.Get("timeout")) > 0, queries.Get("timeout"), "5000")
	num, err := strconv.Atoi(raw)
	if err != nil {
		num = 5000
	}

	limit := time.Duration(num) * time.Millisecond
	uri := dest.BuildUri(c)
	return proxy.Do(c, uri, &fasthttp.Client{
		ReadTimeout:  limit,
		WriteTimeout: limit,
	})
}

var wsUpgrader = websocket.FastHTTPUpgrader{}

func makeWebsocketResponse(c *fiber.Ctx, dest *Destination) error {
	uri := dest.MakeWebsocketUri(c)

	// Upgrade connection
	return wsUpgrader.Upgrade(c.Context(), func(conn *websocket.Conn) {
		// Dial the destination
		remote, _, err := websocket.DefaultDialer.Dial(uri, nil)
		if err != nil {
			return
		}
		defer remote.Close()

		// Read messages from remote
		disconnect := make(chan struct{})
		signal := make(chan struct {
			head int
			data []byte
		})
		go func() {
			defer close(disconnect)
			for {
				mode, message, err := remote.ReadMessage()
				if err != nil {
					log.Warn().Err(err).Msg("An error occurred during the websocket proxying...")
					return
				} else {
					signal <- struct {
						head int
						data []byte
					}{head: mode, data: message}
				}
			}
		}()

		// Relay the destination websocket to client
		for {
			select {
			case <-disconnect:
			case val := <-signal:
				if err := conn.WriteMessage(val.head, val.data); err != nil {
					return
				}
			default:
				if head, data, err := conn.ReadMessage(); err != nil {
					return
				} else {
					remote.WriteMessage(head, data)
				}
			}
		}
	})
}

func makeFileResponse(c *fiber.Ctx, dest *Destination) error {
	uri, queries := dest.GetRawUri()
	root := http.Dir(uri)

	method := c.Method()

	// We only serve static assets for GET and HEAD methods
	if method != fiber.MethodGet && method != fiber.MethodHead {
		return c.Next()
	}

	// Strip prefix
	prefix := c.Route().Path
	path := strings.TrimPrefix(c.Path(), prefix)
	if !strings.HasPrefix(path, "/") {
		path = "/" + path
	}

	// Add prefix
	if queries.Get("prefix") != "" {
		path = queries.Get("prefix") + path
	}

	if len(path) > 1 {
		path = utils.TrimRight(path, '/')
	}

	file, err := root.Open(path)
	if err != nil && errors.Is(err, fs.ErrNotExist) {
		if queries.Get("suffix") != "" {
			file, err = root.Open(path + queries.Get("suffix"))
		}
		if err != nil && queries.Get("fallback") != "" {
			file, err = root.Open(queries.Get("fallback"))
		}
	}
	if err != nil {
		if errors.Is(err, fs.ErrNotExist) {
			return fiber.ErrNotFound
		}
		return fmt.Errorf("failed to open: %w", err)
	}

	stat, err := file.Stat()
	if err != nil {
		return fmt.Errorf("failed to stat: %w", err)
	}

	// Serve index if the path is a directory
	if stat.IsDir() {
		indexFile := lo.Ternary(len(queries.Get("index")) > 0, queries.Get("index"), "index.html")
		indexPath := filepath.Join(path, indexFile)
		index, err := root.Open(indexPath)
		if err == nil {
			indexStat, err := index.Stat()
			if err == nil {
				file = index
				stat = indexStat
			}
		}
	}

	c.Status(fiber.StatusOK)

	modTime := stat.ModTime()
	contentLength := int(stat.Size())

	// Set Content-Type header
	if queries.Get("charset") == "" {
		c.Type(filepath.Ext(stat.Name()))
	} else {
		c.Type(filepath.Ext(stat.Name()), queries.Get("charset"))
	}

	// Set Last-Modified header
	if !modTime.IsZero() {
		c.Set(fiber.HeaderLastModified, modTime.UTC().Format(http.TimeFormat))
	}

	if method == fiber.MethodGet {
		maxAge, err := strconv.Atoi(queries.Get("maxAge"))
		if lo.Ternary(err != nil, maxAge, 0) > 0 {
			c.Set(fiber.HeaderCacheControl, "public, max-age="+queries.Get("maxAge"))
		}
		c.Response().SetBodyStream(file, contentLength)
		return nil
	}
	if method == fiber.MethodHead {
		c.Request().ResetBody()
		c.Response().SkipBody = true
		c.Response().Header.SetContentLength(contentLength)
		if err := file.Close(); err != nil {
			return fmt.Errorf("failed to close: %w", err)
		}
		return nil
	}

	return fiber.ErrNotFound
}