pages-server/server/upstream/upstream.go

package upstream

import (
	"errors"
	"fmt"
	"io"
	"net/http"
	"strings"
	"time"

	"github.com/rs/zerolog/log"

	"codeberg.org/codeberg/pages/html"
	"codeberg.org/codeberg/pages/server/context"
	"codeberg.org/codeberg/pages/server/gitea"
)

const (
	headerContentType     = "Content-Type"
	headerETag            = "ETag"
	headerLastModified    = "Last-Modified"
	headerIfModifiedSince = "If-Modified-Since"

	rawMime = "text/plain; charset=utf-8"
)

// upstreamIndexPages lists pages that may be considered as index pages for directories.
var upstreamIndexPages = []string{
	"index.html",
}

// upstreamNotFoundPages lists pages that may be considered as custom 404 Not Found pages.
var upstreamNotFoundPages = []string{
	"404.html",
}

// Options provides various options for the upstream request.
type Options struct {
	TargetOwner,
	TargetRepo,
	TargetBranch,
	TargetPath,

	// Used for debugging purposes.
	Host string

	TryIndexPages   bool
	BranchTimestamp time.Time
	// internal
	appendTrailingSlash bool
	redirectIfExists    string

	ServeRaw bool
}

// Upstream requests a file from the Gitea API at GiteaRoot and writes it to the request context.
func (o *Options) Upstream(ctx *context.Context, giteaClient *gitea.Client) (final bool) {
	log := log.With().Strs("upstream", []string{o.TargetOwner, o.TargetRepo, o.TargetBranch, o.TargetPath}).Logger()

	if o.TargetOwner == "" || o.TargetRepo == "" {
		html.ReturnErrorPage(ctx, "either repo owner or name info is missing", http.StatusBadRequest)
		return true
	}

	// Check if the branch exists and when it was modified
	if o.BranchTimestamp.IsZero() {
		branch := GetBranchTimestamp(giteaClient, o.TargetOwner, o.TargetRepo, o.TargetBranch)

		if branch == nil || branch.Branch == "" {
			html.ReturnErrorPage(ctx,
				fmt.Sprintf("could not get timestamp of branch '%s'", o.TargetBranch),
				http.StatusFailedDependency)
			return true
		}
		o.TargetBranch = branch.Branch
		o.BranchTimestamp = branch.Timestamp
	}

	// Check if the browser has a cached version
	if ifModifiedSince, err := time.Parse(time.RFC1123, string(ctx.Response().Header.Get(headerIfModifiedSince))); err == nil {
		if !ifModifiedSince.Before(o.BranchTimestamp) {
			ctx.RespWriter.WriteHeader(http.StatusNotModified)
			return true
		}
	}

	log.Debug().Msg("Preparing")

	reader, res, err := giteaClient.ServeRawContent(o.TargetOwner, o.TargetRepo, o.TargetBranch, o.TargetPath)
	if reader != nil {
		defer reader.Close()
	}

	log.Debug().Msg("Aquisting")

	// Handle errors
	if (err != nil && errors.Is(err, gitea.ErrorNotFound)) || (res == nil) {
		if o.TryIndexPages {
			// copy the o struct & try if an index page exists
			optionsForIndexPages := *o
			optionsForIndexPages.TryIndexPages = false
			optionsForIndexPages.appendTrailingSlash = true
			for _, indexPage := range upstreamIndexPages {
				optionsForIndexPages.TargetPath = strings.TrimSuffix(o.TargetPath, "/") + "/" + indexPage
				if optionsForIndexPages.Upstream(ctx, giteaClient) {
					return true
				}
			}
			// compatibility fix for GitHub Pages (/example → /example.html)
			optionsForIndexPages.appendTrailingSlash = false
			optionsForIndexPages.redirectIfExists = strings.TrimSuffix(ctx.Path(), "/") + ".html"
			optionsForIndexPages.TargetPath = o.TargetPath + ".html"
			if optionsForIndexPages.Upstream(ctx, giteaClient) {
				return true
			}
		}

		ctx.Response().StatusCode = http.StatusNotFound
		if o.TryIndexPages {
			// copy the o struct & try if a not found page exists
			optionsForNotFoundPages := *o
			optionsForNotFoundPages.TryIndexPages = false
			optionsForNotFoundPages.appendTrailingSlash = false
			for _, notFoundPage := range upstreamNotFoundPages {
				optionsForNotFoundPages.TargetPath = "/" + notFoundPage
				if optionsForNotFoundPages.Upstream(ctx, giteaClient) {
					return true
				}
			}
		}
		return false
	}
	if res != nil && (err != nil || res.StatusCode != http.StatusOK) {
		log.Printf("Couldn't fetch contents (status code %d): %v\n", res.StatusCode, err)
		html.ReturnErrorPage(ctx, fmt.Sprintf("%v", err), http.StatusInternalServerError)
		return true
	}

	// Append trailing slash if missing (for index files), and redirect to fix filenames in general
	// o.appendTrailingSlash is only true when looking for index pages
	if o.appendTrailingSlash && !strings.HasSuffix(ctx.Path(), "/") {
		ctx.Redirect(ctx.Path()+"/", http.StatusTemporaryRedirect)
		return true
	}
	if strings.HasSuffix(ctx.Path(), "/index.html") {
		ctx.Redirect(strings.TrimSuffix(ctx.Path(), "index.html"), http.StatusTemporaryRedirect)
		return true
	}
	if o.redirectIfExists != "" {
		ctx.Redirect(o.redirectIfExists, http.StatusTemporaryRedirect)
		return true
	}

	log.Debug().Msg("Handling error")

	// Set ETag & MIME
	if res != nil {
		ctx.Response().Header.Set(headerETag, res.Header.Get(headerETag))
		if o.ServeRaw {
			ctx.Response().Header.Set(headerContentType, res.Header.Get(headerContentType))
		} else {
			ctx.Response().Header.Set(headerContentType, rawMime)
		}
	}

	if ctx.Response().StatusCode != http.StatusNotFound {
		// Everything's okay so far
		ctx.Response().StatusCode = http.StatusOK
	}
	ctx.Response().Header.Set(headerLastModified, o.BranchTimestamp.In(time.UTC).Format(time.RFC1123))

	log.Debug().Msg("Prepare response")

	// Write the response body to the original request
	if reader != nil {
		_, err := io.Copy(ctx.RespWriter, reader)
		if err != nil {
			log.Printf("Couldn't write body: %s\n", err)
			html.ReturnErrorPage(ctx, "", http.StatusInternalServerError)
			return true
		}
	}

	log.Debug().Msg("Sending response")

	return true
}