Content inside aldanin
(The raw file follows this syntax highlighted file.)
package aldanin
import (
"compress/zlib"
"embed"
"fmt"
"html/template"
"io"
"mime"
"net/http"
"os"
"path"
"path/filepath"
"runtime/debug"
"strconv"
"strings"
"github.com/Masterminds/sprig/v3"
"github.com/NYTimes/gziphandler"
)
var gzh func(http.Handler) http.Handler
func init() {
tmpgzh, err := gziphandler.GzipHandlerWithOpts(gziphandler.ContentTypes([]string{"text/html", "text/css", "application/javascript", "image/png", "image/svg+xml", "image/vnd.microsoft.icon"}))
if err != nil {
panic(fmt.Sprintf("Failed to create gziphandler: %v", err))
}
gzh = tmpgzh
}
type Base struct {
// Used when a required template isn't found, or when a panic is caught
Printf func(format string, a ...any) (n int, err error)
// Zero-value sets the HTTP Cache-Control Header value to "no-cache, must-revalidate"
CacheHeaderMaxAge int
/* Structure expected inside Files:
www/
(should have any non-template file needed, like css, js, favicon.ico, etc.)
templates/
index.html
blob.html
commitLine.html
directRepo.html
header.html
repos.html
refLine.html
treeLine.html
*/
Files embed.FS
Repos []struct {
Name string
Description string
Meta string // Can be any value. Available to templates for customization
}
Root string // Something like `/repos`
BrowseRoot string // Something like `/browse`
}
func (c Base) gt(s string) []byte {
bs, err := c.gf(filepath.Join("templates", s))
if err != nil {
panic(fmt.Sprintf("Failed to get required template %s: %s", s, err))
}
return bs
}
func (c Base) gf(s string) ([]byte, error) { return c.Files.ReadFile(filepath.Join("www", s)) }
func (c Base) withTemplate(t string, w http.ResponseWriter, crd crd, onErr string) {
if err := template.Must(template.New("").Parse(string(c.gt(t)))).Funcs(sprig.FuncMap()).Execute(w, crd); err != nil {
c.Printf("%s %s", onErr, err.Error())
fmt.Fprint(w, onErr)
}
}
func (c Base) ServeHTTP(w http.ResponseWriter, r *http.Request) {
defer func(w http.ResponseWriter, r *http.Request) {
if err := recover(); err != nil {
c.Printf("[PANIC CAUGHT]:%s STACK:%s", err, string(debug.Stack()))
}
}(w, r)
w.Header().Set("Cache-Control", "no-cache, must-revalidate")
if c.CacheHeaderMaxAge > 0 {
w.Header().Set("Cache-Control", fmt.Sprintf("public, max-age=%d", c.CacheHeaderMaxAge))
}
if bs, err := c.gf(r.URL.Path); err == nil {
gzh(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", mime.TypeByExtension(filepath.Ext(r.URL.Path)))
fmt.Fprint(w, string(bs))
})).ServeHTTP(w, r)
return
}
combined := crd{strings.Split(r.Host, ":")[0], c.BrowseRoot, []rs{}, blob{}, object{}}
for _, repo := range c.Repos {
repoKey := fmt.Sprintf("/%s.git", repo.Name)
repoMetaKey := strings.TrimSuffix(repoKey, ".git")
combined.Repos = append(combined.Repos, rs{repo.Name, repo.Description, repo.Meta, repoKey, repoMetaKey})
}
if strings.HasPrefix(r.URL.Path, c.BrowseRoot) {
if r.URL.Path == c.BrowseRoot {
w.Header().Set("Content-Type", "text/html")
c.withTemplate("repos.html", w, combined, "98d4fa3e")
return
} else if strings.HasSuffix(r.URL.Path, ".git") {
repo := path.Base(r.URL.Path)
fc := filtered(combined, repo)
w.Header().Set("Content-Type", "text/html")
c.withTemplate("header.html", w, fc, "461de048")
resp, err := http.Get(fmt.Sprintf("https://%s/%s/info/refs", fc.Hostname, repo))
if err != nil {
fmt.Fprint(w, "e729d902")
return
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
for _, line := range strings.Split(string(body), "\n") {
if parts := strings.Split(line, "\t"); len(parts) == 2 {
fc.Object.SHAPrefix = parts[0][0:2]
fc.Object.SHASuffix = parts[0][2:]
fc.Object.Name = parts[1]
c.withTemplate("refLine.html", w, fc, "85a536f3")
}
}
return
}
askingForRepoObjects := false
for _, repo := range c.Repos {
if strings.HasPrefix(r.URL.Path, fmt.Sprintf("%s/%s.git/objects", c.BrowseRoot, repo.Name)) {
askingForRepoObjects = true
break
}
}
if askingForRepoObjects {
repo := strings.Split(strings.Split(r.URL.Path, fmt.Sprintf("%s/", c.BrowseRoot))[1], ".git")[0]
fc := filtered(combined, repo)
w.Header().Set("Content-Type", "text/html")
c.withTemplate("header.html", w, fc, "743178c1")
newURL := strings.Replace(r.URL.String(), fmt.Sprintf("%s/", c.BrowseRoot), "/", 1)
resp, err := http.Get("https://" + fc.Hostname + newURL)
if err != nil {
fmt.Fprint(w, "2ad390f8")
return
}
defer resp.Body.Close()
zr, err := zlib.NewReader(resp.Body)
if err != nil {
fmt.Fprint(w, "757b720f")
return
}
bs, err := io.ReadAll(zr)
if err != nil {
fmt.Fprint(w, "8fc0b7d5")
return
}
zr.Close()
body := string(bs)
if strings.HasPrefix(body, "commit ") {
rest := strings.TrimPrefix(body, "commit ")
_, err := strconv.Atoi(rest[:strings.Index(rest, "\u0000")])
if err != nil {
fmt.Fprint(w, "9306f726")
return
}
lines := rest[strings.Index(rest, "\u0000")+1:]
if !strings.HasPrefix(lines, "tree ") {
fmt.Fprint(w, "efb2fc3b")
return
}
var hash string
if _, err := fmt.Sscanf(lines, "tree %40x", &hash); err != nil {
fmt.Fprint(w, "9247a399")
return
}
formattedHash := fmt.Sprintf("%x", hash)
treeURL := fmt.Sprintf(
"https://%s/%s.git/objects/%s/%s",
fc.Hostname, repo, formattedHash[0:2], formattedHash[2:],
)
treeResp, err := http.Get(treeURL)
if err != nil {
fmt.Fprint(w, "522f2da9")
return
}
defer treeResp.Body.Close()
treezr, err := zlib.NewReader(treeResp.Body)
if err != nil {
fmt.Fprint(w, "a6c20868")
return
}
treebs, err := io.ReadAll(treezr)
if err != nil {
fmt.Fprint(w, "5a48aacb")
return
}
treezr.Close()
treeBody := string(treebs)
treeRest := strings.TrimPrefix(treeBody, "tree ")
_, err = strconv.Atoi(treeRest[:strings.Index(treeRest, "\u0000")])
if err != nil {
fmt.Fprint(w, "68fae5c9")
return
}
treeLines := treeRest[strings.Index(treeRest, "\u0000")+1:]
getting := 0
m := []byte{}
n := []byte{}
h := []byte{}
for i := 0; i < len(treeLines); i++ {
b := treeLines[i]
if getting == 0 && b == ' ' {
getting = 1
continue
} else if getting == 1 && b == 0 {
getting = 2
continue
}
if getting == 0 {
m = append(m, b)
} else if getting == 1 {
n = append(n, b)
} else if getting == 2 {
h = append(h, b)
if len(h) == 20 {
sh := fmt.Sprintf("%x", string(h))
fc.Object.Message = string(m)
fc.Object.SHAPrefix = sh[0:2]
fc.Object.SHASuffix = sh[2:]
fc.Object.Name = string(n)
c.withTemplate("commitLine.html", w, fc, "06a8f645")
m = []byte{}
n = []byte{}
h = []byte{}
getting = 0
}
}
}
} else if strings.HasPrefix(body, "tree ") {
rest := strings.TrimPrefix(body, "tree ")
_, err := strconv.Atoi(rest[:strings.Index(rest, "\u0000")])
if err != nil {
fmt.Fprint(w, "406dc2ca")
return
}
lines := rest[strings.Index(rest, "\u0000")+1:]
if strings.HasPrefix(lines, "tree ") {
fmt.Fprint(w, "29196ce3")
fmt.Fprint(w, lines)
return
}
getting := 0
m := []byte{}
n := []byte{}
h := []byte{}
for i := 0; i < len(lines); i++ {
b := lines[i]
if getting == 0 && b == ' ' {
getting = 1
continue
} else if getting == 1 && b == 0 {
getting = 2
continue
}
if getting == 0 {
m = append(m, b)
} else if getting == 1 {
n = append(n, b)
} else if getting == 2 {
h = append(h, b)
if len(h) == 20 {
sh := fmt.Sprintf("%x", string(h))
fc.Object.Message = string(m)
fc.Object.SHAPrefix = sh[0:2]
fc.Object.SHASuffix = sh[2:]
fc.Object.Name = string(n)
c.withTemplate("treeLine.html", w, fc, "d4849a62")
m = []byte{}
n = []byte{}
h = []byte{}
getting = 0
}
}
}
} else if strings.HasPrefix(body, "blob ") {
rest := strings.TrimPrefix(body, "blob ")
_, err := strconv.Atoi(rest[:strings.Index(rest, "\u0000")])
if err != nil {
fmt.Fprint(w, "2ee82c74")
return
}
fc.Blob.Lines = rest[strings.Index(rest, "\u0000")+1:]
c.withTemplate("blob.html", w, fc, "5b35cc26")
} else { // When does this run??
fmt.Fprint(w, body[:20])
}
return
}
}
for _, repo := range c.Repos {
fc := filtered(combined, repo.Name)
k := fc.Repos[0].RepoKey
if strings.HasPrefix(r.URL.Path, k) { // When getting something from the repo - serve it from the repo
baseDir := fmt.Sprintf("%s%s/.git", c.Root, strings.TrimSuffix(k, ".git"))
http.StripPrefix(k, http.FileServer(justFilesFilesystem{http.Dir(baseDir)})).ServeHTTP(w, r)
return
}
metak := fc.Repos[0].RepoMetaKey
if strings.HasPrefix(r.URL.Path, metak) {
c.withTemplate("directRepo.html", w, fc, "714510d9")
return
}
}
c.withTemplate("index.html", w, combined, "3ad50046")
}
type crd struct {
Hostname string
BrowseRoot string
Repos []rs
Blob blob
Object object
}
type rs struct {
RepoName string
RepoDescription string
RepoMeta string
RepoKey string
RepoMetaKey string
}
type blob struct {
Lines string
}
type object struct {
Message string
SHAPrefix string
SHASuffix string
Name string
}
func filtered(givenCrd crd, repo string) crd {
repo = strings.TrimSuffix(repo, ".git")
result := crd{givenCrd.Hostname, givenCrd.BrowseRoot, []rs{}, givenCrd.Blob, givenCrd.Object}
foundMatch := false
for _, r := range givenCrd.Repos {
if r.RepoName == repo {
result.Repos = append(result.Repos, r)
foundMatch = true
}
}
if !foundMatch {
panic(fmt.Sprintf("Unable to find match for %s in: %#v", repo, givenCrd))
}
return result
}
type justFilesFilesystem struct{ fs http.FileSystem }
func (fs justFilesFilesystem) Open(name string) (http.File, error) {
f, err := fs.fs.Open(name)
if err != nil {
return nil, err
}
return limitedReaddirFile{f}, nil
}
type limitedReaddirFile struct{ http.File }
func (f limitedReaddirFile) Readdir(count int) ([]os.FileInfo, error) { return nil, nil }
The raw file follows...
package aldanin
import (
"compress/zlib"
"embed"
"fmt"
"html/template"
"io"
"mime"
"net/http"
"os"
"path"
"path/filepath"
"runtime/debug"
"strconv"
"strings"
"github.com/Masterminds/sprig/v3"
"github.com/NYTimes/gziphandler"
)
var gzh func(http.Handler) http.Handler
func init() {
tmpgzh, err := gziphandler.GzipHandlerWithOpts(gziphandler.ContentTypes([]string{"text/html", "text/css", "application/javascript", "image/png", "image/svg+xml", "image/vnd.microsoft.icon"}))
if err != nil {
panic(fmt.Sprintf("Failed to create gziphandler: %v", err))
}
gzh = tmpgzh
}
type Base struct {
// Used when a required template isn't found, or when a panic is caught
Printf func(format string, a ...any) (n int, err error)
// Zero-value sets the HTTP Cache-Control Header value to "no-cache, must-revalidate"
CacheHeaderMaxAge int
/* Structure expected inside Files:
www/
(should have any non-template file needed, like css, js, favicon.ico, etc.)
templates/
index.html
blob.html
commitLine.html
directRepo.html
header.html
repos.html
refLine.html
treeLine.html
*/
Files embed.FS
Repos []struct {
Name string
Description string
Meta string // Can be any value. Available to templates for customization
}
Root string // Something like `/repos`
BrowseRoot string // Something like `/browse`
}
func (c Base) gt(s string) []byte {
bs, err := c.gf(filepath.Join("templates", s))
if err != nil {
panic(fmt.Sprintf("Failed to get required template %s: %s", s, err))
}
return bs
}
func (c Base) gf(s string) ([]byte, error) { return c.Files.ReadFile(filepath.Join("www", s)) }
func (c Base) withTemplate(t string, w http.ResponseWriter, crd crd, onErr string) {
if err := template.Must(template.New("").Parse(string(c.gt(t)))).Funcs(sprig.FuncMap()).Execute(w, crd); err != nil {
c.Printf("%s %s", onErr, err.Error())
fmt.Fprint(w, onErr)
}
}
func (c Base) ServeHTTP(w http.ResponseWriter, r *http.Request) {
defer func(w http.ResponseWriter, r *http.Request) {
if err := recover(); err != nil {
c.Printf("[PANIC CAUGHT]:%s STACK:%s", err, string(debug.Stack()))
}
}(w, r)
w.Header().Set("Cache-Control", "no-cache, must-revalidate")
if c.CacheHeaderMaxAge > 0 {
w.Header().Set("Cache-Control", fmt.Sprintf("public, max-age=%d", c.CacheHeaderMaxAge))
}
if bs, err := c.gf(r.URL.Path); err == nil {
gzh(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", mime.TypeByExtension(filepath.Ext(r.URL.Path)))
fmt.Fprint(w, string(bs))
})).ServeHTTP(w, r)
return
}
combined := crd{strings.Split(r.Host, ":")[0], c.BrowseRoot, []rs{}, blob{}, object{}}
for _, repo := range c.Repos {
repoKey := fmt.Sprintf("/%s.git", repo.Name)
repoMetaKey := strings.TrimSuffix(repoKey, ".git")
combined.Repos = append(combined.Repos, rs{repo.Name, repo.Description, repo.Meta, repoKey, repoMetaKey})
}
if strings.HasPrefix(r.URL.Path, c.BrowseRoot) {
if r.URL.Path == c.BrowseRoot {
w.Header().Set("Content-Type", "text/html")
c.withTemplate("repos.html", w, combined, "98d4fa3e")
return
} else if strings.HasSuffix(r.URL.Path, ".git") {
repo := path.Base(r.URL.Path)
fc := filtered(combined, repo)
w.Header().Set("Content-Type", "text/html")
c.withTemplate("header.html", w, fc, "461de048")
resp, err := http.Get(fmt.Sprintf("https://%s/%s/info/refs", fc.Hostname, repo))
if err != nil {
fmt.Fprint(w, "e729d902")
return
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
for _, line := range strings.Split(string(body), "\n") {
if parts := strings.Split(line, "\t"); len(parts) == 2 {
fc.Object.SHAPrefix = parts[0][0:2]
fc.Object.SHASuffix = parts[0][2:]
fc.Object.Name = parts[1]
c.withTemplate("refLine.html", w, fc, "85a536f3")
}
}
return
}
askingForRepoObjects := false
for _, repo := range c.Repos {
if strings.HasPrefix(r.URL.Path, fmt.Sprintf("%s/%s.git/objects", c.BrowseRoot, repo.Name)) {
askingForRepoObjects = true
break
}
}
if askingForRepoObjects {
repo := strings.Split(strings.Split(r.URL.Path, fmt.Sprintf("%s/", c.BrowseRoot))[1], ".git")[0]
fc := filtered(combined, repo)
w.Header().Set("Content-Type", "text/html")
c.withTemplate("header.html", w, fc, "743178c1")
newURL := strings.Replace(r.URL.String(), fmt.Sprintf("%s/", c.BrowseRoot), "/", 1)
resp, err := http.Get("https://" + fc.Hostname + newURL)
if err != nil {
fmt.Fprint(w, "2ad390f8")
return
}
defer resp.Body.Close()
zr, err := zlib.NewReader(resp.Body)
if err != nil {
fmt.Fprint(w, "757b720f")
return
}
bs, err := io.ReadAll(zr)
if err != nil {
fmt.Fprint(w, "8fc0b7d5")
return
}
zr.Close()
body := string(bs)
if strings.HasPrefix(body, "commit ") {
rest := strings.TrimPrefix(body, "commit ")
_, err := strconv.Atoi(rest[:strings.Index(rest, "\u0000")])
if err != nil {
fmt.Fprint(w, "9306f726")
return
}
lines := rest[strings.Index(rest, "\u0000")+1:]
if !strings.HasPrefix(lines, "tree ") {
fmt.Fprint(w, "efb2fc3b")
return
}
var hash string
if _, err := fmt.Sscanf(lines, "tree %40x", &hash); err != nil {
fmt.Fprint(w, "9247a399")
return
}
formattedHash := fmt.Sprintf("%x", hash)
treeURL := fmt.Sprintf(
"https://%s/%s.git/objects/%s/%s",
fc.Hostname, repo, formattedHash[0:2], formattedHash[2:],
)
treeResp, err := http.Get(treeURL)
if err != nil {
fmt.Fprint(w, "522f2da9")
return
}
defer treeResp.Body.Close()
treezr, err := zlib.NewReader(treeResp.Body)
if err != nil {
fmt.Fprint(w, "a6c20868")
return
}
treebs, err := io.ReadAll(treezr)
if err != nil {
fmt.Fprint(w, "5a48aacb")
return
}
treezr.Close()
treeBody := string(treebs)
treeRest := strings.TrimPrefix(treeBody, "tree ")
_, err = strconv.Atoi(treeRest[:strings.Index(treeRest, "\u0000")])
if err != nil {
fmt.Fprint(w, "68fae5c9")
return
}
treeLines := treeRest[strings.Index(treeRest, "\u0000")+1:]
getting := 0
m := []byte{}
n := []byte{}
h := []byte{}
for i := 0; i < len(treeLines); i++ {
b := treeLines[i]
if getting == 0 && b == ' ' {
getting = 1
continue
} else if getting == 1 && b == 0 {
getting = 2
continue
}
if getting == 0 {
m = append(m, b)
} else if getting == 1 {
n = append(n, b)
} else if getting == 2 {
h = append(h, b)
if len(h) == 20 {
sh := fmt.Sprintf("%x", string(h))
fc.Object.Message = string(m)
fc.Object.SHAPrefix = sh[0:2]
fc.Object.SHASuffix = sh[2:]
fc.Object.Name = string(n)
c.withTemplate("commitLine.html", w, fc, "06a8f645")
m = []byte{}
n = []byte{}
h = []byte{}
getting = 0
}
}
}
} else if strings.HasPrefix(body, "tree ") {
rest := strings.TrimPrefix(body, "tree ")
_, err := strconv.Atoi(rest[:strings.Index(rest, "\u0000")])
if err != nil {
fmt.Fprint(w, "406dc2ca")
return
}
lines := rest[strings.Index(rest, "\u0000")+1:]
if strings.HasPrefix(lines, "tree ") {
fmt.Fprint(w, "29196ce3")
fmt.Fprint(w, lines)
return
}
getting := 0
m := []byte{}
n := []byte{}
h := []byte{}
for i := 0; i < len(lines); i++ {
b := lines[i]
if getting == 0 && b == ' ' {
getting = 1
continue
} else if getting == 1 && b == 0 {
getting = 2
continue
}
if getting == 0 {
m = append(m, b)
} else if getting == 1 {
n = append(n, b)
} else if getting == 2 {
h = append(h, b)
if len(h) == 20 {
sh := fmt.Sprintf("%x", string(h))
fc.Object.Message = string(m)
fc.Object.SHAPrefix = sh[0:2]
fc.Object.SHASuffix = sh[2:]
fc.Object.Name = string(n)
c.withTemplate("treeLine.html", w, fc, "d4849a62")
m = []byte{}
n = []byte{}
h = []byte{}
getting = 0
}
}
}
} else if strings.HasPrefix(body, "blob ") {
rest := strings.TrimPrefix(body, "blob ")
_, err := strconv.Atoi(rest[:strings.Index(rest, "\u0000")])
if err != nil {
fmt.Fprint(w, "2ee82c74")
return
}
fc.Blob.Lines = rest[strings.Index(rest, "\u0000")+1:]
c.withTemplate("blob.html", w, fc, "5b35cc26")
} else { // When does this run??
fmt.Fprint(w, body[:20])
}
return
}
}
for _, repo := range c.Repos {
fc := filtered(combined, repo.Name)
k := fc.Repos[0].RepoKey
if strings.HasPrefix(r.URL.Path, k) { // When getting something from the repo - serve it from the repo
baseDir := fmt.Sprintf("%s%s/.git", c.Root, strings.TrimSuffix(k, ".git"))
http.StripPrefix(k, http.FileServer(justFilesFilesystem{http.Dir(baseDir)})).ServeHTTP(w, r)
return
}
metak := fc.Repos[0].RepoMetaKey
if strings.HasPrefix(r.URL.Path, metak) {
c.withTemplate("directRepo.html", w, fc, "714510d9")
return
}
}
c.withTemplate("index.html", w, combined, "3ad50046")
}
type crd struct {
Hostname string
BrowseRoot string
Repos []rs
Blob blob
Object object
}
type rs struct {
RepoName string
RepoDescription string
RepoMeta string
RepoKey string
RepoMetaKey string
}
type blob struct {
Lines string
}
type object struct {
Message string
SHAPrefix string
SHASuffix string
Name string
}
func filtered(givenCrd crd, repo string) crd {
repo = strings.TrimSuffix(repo, ".git")
result := crd{givenCrd.Hostname, givenCrd.BrowseRoot, []rs{}, givenCrd.Blob, givenCrd.Object}
foundMatch := false
for _, r := range givenCrd.Repos {
if r.RepoName == repo {
result.Repos = append(result.Repos, r)
foundMatch = true
}
}
if !foundMatch {
panic(fmt.Sprintf("Unable to find match for %s in: %#v", repo, givenCrd))
}
return result
}
type justFilesFilesystem struct{ fs http.FileSystem }
func (fs justFilesFilesystem) Open(name string) (http.File, error) {
f, err := fs.fs.Open(name)
if err != nil {
return nil, err
}
return limitedReaddirFile{f}, nil
}
type limitedReaddirFile struct{ http.File }
func (f limitedReaddirFile) Readdir(count int) ([]os.FileInfo, error) { return nil, nil }