commit d16142029dd6b58d364125c5f2cf69c72f5667e6 · nel.pet/core

+34 -1

appview/state/middleware.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
       +
       	"fmt"

     

       5
       6
        
       	"log"

     

       6
       7
        
       	"net/http"

     

       7
       8
        
       	"strconv"

     
···

       131
       132
        
       			if err != nil {

     

       132
       133
        
       				// invalid did or handle

     

       133
       134
        
       				log.Println("failed to resolve repo")

     

       134
       134
       -
       				w.WriteHeader(http.StatusNotFound)

     

       135
       135
       +
       				s.pages.Error404(w)

     

       135
       136
        
       				return

     

       136
       137
        
       			}

     

       137
       138
        
       

     
···

       175
       176
        
       		})

     

       176
       177
        
       	}

     

       177
       178
        
       }

     

       179
       179
       +
       

     

       180
       180
       +
       // this should serve the go-import meta tag even if the path is technically

     

       181
       181
       +
       // a 404 like tangled.sh/oppi.li/go-git/v5

     

       182
       182
       +
       func GoImport(s *State) middleware.Middleware {

     

       183
       183
       +
       	return func(next http.Handler) http.Handler {

     

       184
       184
       +
       		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       185
       185
       +
       			f, err := s.fullyResolvedRepo(r)

     

       186
       186
       +
       			if err != nil {

     

       187
       187
       +
       				log.Println("failed to fully resolve repo", err)

     

       188
       188
       +
       				http.Error(w, "invalid repo url", http.StatusNotFound)

     

       189
       189
       +
       				return

     

       190
       190
       +
       			}

     

       191
       191
       +
       

     

       192
       192
       +
       			fullName := f.OwnerHandle() + "/" + f.RepoName

     

       193
       193
       +
       

     

       194
       194
       +
       			if r.Header.Get("User-Agent") == "Go-http-client/1.1" {

     

       195
       195
       +
       				if r.URL.Query().Get("go-get") == "1" {

     

       196
       196
       +
       					html := fmt.Sprintf(

     

       197
       197
       +
       						`<meta name="go-import" content="tangled.sh/%s git https://tangled.sh/%s"/>`,

     

       198
       198
       +
       						fullName,

     

       199
       199
       +
       						fullName,

     

       200
       200
       +
       					)

     

       201
       201
       +
       					w.Header().Set("Content-Type", "text/html")

     

       202
       202
       +
       					w.Write([]byte(html))

     

       203
       203
       +
       					return

     

       204
       204
       +
       				}

     

       205
       205
       +
       			}

     

       206
       206
       +
       

     

       207
       207
       +
       			next.ServeHTTP(w, r)

     

       208
       208
       +
       		})

     

       209
       209
       +
       	}

     

       210
       210
       +
       }

appview/state/router.go

···

       58
       58
        
       		r.Get("/", s.Profile)

     

       59
       59
        
       

     

       60
       60
        
       		r.With(ResolveRepo(s)).Route("/{repo}", func(r chi.Router) {

     

       61
       61
       +
       			r.Use(GoImport(s))

     

       62
       62
       +
       

     

       61
       63
        
       			r.Get("/", s.RepoIndex)

     

       62
       64
        
       			r.Get("/commits/{ref}", s.RepoLog)

     

       63
       65
        
       			r.Route("/tree/{ref}", func(r chi.Router) {