primal/athens
1
0
Fork 0
mirror of https://github.com/gomods/athens synced 2026-02-03 12:10:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove Buffalo (#1010)

Browse Source 
* Remove Buffalo

* gofmt

* pr fixes

* fix subrouter

* bring back secure middleware + pr fixes

* better place for subrouter

* vendor
This commit is contained in:
Marwan Sulaiman
2018-12-22 20:24:25 -05:00
committed by GitHub
parent 36aba5915c
commit 5870aeee8d
1129 changed files with 465 additions and 371408 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/download/addons/with_pool_test.go
+1 -1
View File
@@ -63,7 +63,7 @@ func TestPoolWrapper(t *testing.T) {
m.inputVer = ver
m.list = []string{"v0.0.0", "v0.1.0"}
m.catalog = []paths.AllPathParams{
{"pkg", "v0.1.0"},
{Module: "pkg", Version: "v0.1.0"},
}
givenList, err := dp.List(ctx, mod)
if err != m.err {
pkg/download/catalog.go
+16 -11
View File
@@ -1,14 +1,14 @@
package download
import (
"encoding/json"
"net/http"
"strconv"
"github.com/gobuffalo/buffalo"
"github.com/gobuffalo/buffalo/render"
"github.com/gomods/athens/pkg/errors"
"github.com/gomods/athens/pkg/log"
"github.com/gomods/athens/pkg/paths"
"github.com/gorilla/mux"
)
// PathCatalog URL.
@@ -21,29 +21,34 @@ type catalogRes struct {
}
// CatalogHandler implements GET baseURL/catalog
func CatalogHandler(dp Protocol, lggr log.Entry, eng *render.Engine) buffalo.Handler {
func CatalogHandler(dp Protocol, lggr log.Entry) http.Handler {
const op errors.Op = "download.CatalogHandler"
return func(c buffalo.Context) error {
token := c.Param("token")
pageSize, err := getLimitFromParam(c.Param("pagesize"))
f := func(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
token := vars["token"]
pageSize, err := getLimitFromParam(vars["pagesize"])
if err != nil {
lggr.SystemErr(err)
return c.Render(http.StatusInternalServerError, nil)
w.WriteHeader(http.StatusInternalServerError)
return
}
modulesAndVersions, newToken, err := dp.Catalog(c, token, pageSize)
modulesAndVersions, newToken, err := dp.Catalog(r.Context(), token, pageSize)
if err != nil {
if errors.Kind(err) != errors.KindNotImplemented {
lggr.SystemErr(errors.E(op, err))
}
return c.Render(errors.Kind(err), eng.JSON(errors.KindText(err)))
w.WriteHeader(errors.Kind(err))
return
}
res := catalogRes{modulesAndVersions, newToken}
return c.Render(http.StatusOK, eng.JSON(res))
if err = json.NewEncoder(w).Encode(res); err != nil {
lggr.SystemErr(errors.E(op, err))
}
}
return http.HandlerFunc(f)
}
func getLimitFromParam(param string) (int, error) {
pkg/download/doc.go
+1 -1
View File
@@ -1,3 +1,3 @@
// Package download provides buffalo handlers that implement vgo's Download
// Package download provides http handlers that implement vgo's Download
// Protocol.
package download
pkg/download/get_module_params.go
+4 -3
View File
@@ -1,13 +1,14 @@
package download
import (
"github.com/gobuffalo/buffalo"
"net/http"
"github.com/gomods/athens/pkg/errors"
"github.com/gomods/athens/pkg/paths"
)
func getModuleParams(c buffalo.Context, op errors.Op) (mod string, vers string, err error) {
params, err := paths.GetAllParams(c)
func getModuleParams(r *http.Request, op errors.Op) (mod string, ver string, err error) {
params, err := paths.GetAllParams(r)
if err != nil {
return "", "", errors.E(op, err, errors.KindBadRequest)
}
pkg/download/handler.go
+20 -20
View File
@@ -1,54 +1,54 @@
package download
import (
"github.com/gobuffalo/buffalo"
"github.com/gobuffalo/buffalo/render"
"net/http"
"github.com/gomods/athens/pkg/log"
"github.com/gomods/athens/pkg/middleware"
"github.com/gorilla/mux"
)
// ProtocolHandler is a function that takes all that it needs to return
// a ready-to-go buffalo handler that serves up cmd/go's download protocol.
type ProtocolHandler func(dp Protocol, lggr log.Entry, eng *render.Engine) buffalo.Handler
// a ready-to-go http handler that serves up cmd/go's download protocol.
type ProtocolHandler func(dp Protocol, lggr log.Entry) http.Handler
// HandlerOpts are the generic options
// for a ProtocolHandler
type HandlerOpts struct {
Protocol Protocol
Logger *log.Logger
Engine *render.Engine
}
// LogEntryHandler pulls a log entry from the buffalo context. Thanks to the
// LogEntryHandler pulls a log entry from the request context. Thanks to the
// LogEntryMiddleware, we should have a log entry stored in the context for each
// request with request-specific fields. This will grab the entry and pass it to
// the protocol handlers
func LogEntryHandler(ph ProtocolHandler, opts *HandlerOpts) buffalo.Handler {
return func(c buffalo.Context) error {
ent := log.EntryFromContext(c)
handler := ph(opts.Protocol, ent, opts.Engine)
return handler(c)
func LogEntryHandler(ph ProtocolHandler, opts *HandlerOpts) http.Handler {
f := func(w http.ResponseWriter, r *http.Request) {
ent := log.EntryFromContext(r.Context())
handler := ph(opts.Protocol, ent)
handler.ServeHTTP(w, r)
}
return http.HandlerFunc(f)
}
// RegisterHandlers is a convenience method that registers
// all the download protocol paths for you.
func RegisterHandlers(app *buffalo.App, opts *HandlerOpts) {
func RegisterHandlers(r *mux.Router, opts *HandlerOpts) {
// If true, this would only panic at boot time, static nil checks anyone?
if opts == nil || opts.Protocol == nil || opts.Engine == nil || opts.Logger == nil {
if opts == nil || opts.Protocol == nil || opts.Logger == nil {
panic("absolutely unacceptable handler opts")
}
noCacheMw := middleware.CacheControl("no-cache, no-store, must-revalidate")
listHandler := LogEntryHandler(ListHandler, opts)
app.GET(PathList, noCacheMw(listHandler))
r.Handle(PathList, noCacheMw(listHandler))
latestHandler := LogEntryHandler(LatestHandler, opts)
app.GET(PathLatest, noCacheMw(latestHandler))
r.Handle(PathLatest, noCacheMw(latestHandler)).Methods(http.MethodGet)
app.GET(PathVersionInfo, LogEntryHandler(VersionInfoHandler, opts))
app.GET(PathVersionModule, LogEntryHandler(VersionModuleHandler, opts))
app.GET(PathVersionZip, LogEntryHandler(VersionZipHandler, opts))
app.GET(PathCatalog, LogEntryHandler(CatalogHandler, opts))
r.Handle(PathVersionInfo, LogEntryHandler(InfoHandler, opts)).Methods(http.MethodGet)
r.Handle(PathVersionModule, LogEntryHandler(ModuleHandler, opts)).Methods(http.MethodGet)
r.Handle(PathVersionZip, LogEntryHandler(ZipHandler, opts)).Methods(http.MethodGet)
r.Handle(PathCatalog, LogEntryHandler(CatalogHandler, opts)).Methods(http.MethodGet)
}
pkg/download/latest.go
+13 -9
View File
@@ -1,10 +1,9 @@
package download
import (
"encoding/json"
"net/http"
"github.com/gobuffalo/buffalo"
"github.com/gobuffalo/buffalo/render"
"github.com/gomods/athens/pkg/errors"
"github.com/gomods/athens/pkg/log"
"github.com/gomods/athens/pkg/paths"
@@ -14,21 +13,26 @@ import (
const PathLatest = "/{module:.+}/@latest"
// LatestHandler implements GET baseURL/module/@latest
func LatestHandler(dp Protocol, lggr log.Entry, eng *render.Engine) buffalo.Handler {
func LatestHandler(dp Protocol, lggr log.Entry) http.Handler {
const op errors.Op = "download.LatestHandler"
return func(c buffalo.Context) error {
mod, err := paths.GetModule(c)
f := func(w http.ResponseWriter, r *http.Request) {
mod, err := paths.GetModule(r)
if err != nil {
lggr.SystemErr(errors.E(op, err))
return c.Render(http.StatusInternalServerError, nil)
w.WriteHeader(http.StatusInternalServerError)
return
}
info, err := dp.Latest(c, mod)
info, err := dp.Latest(r.Context(), mod)
if err != nil {
lggr.SystemErr(errors.E(op, err))
return c.Render(errors.Kind(err), eng.JSON(errors.KindText(err)))
w.WriteHeader(errors.Kind(err))
return
}
return c.Render(http.StatusOK, eng.JSON(info))
if err = json.NewEncoder(w).Encode(info); err != nil {
lggr.SystemErr(errors.E(op, err))
}
}
return http.HandlerFunc(f)
}
pkg/download/list.go
+11 -9
View File
@@ -1,11 +1,10 @@
package download
import (
"fmt"
"net/http"
"strings"
"github.com/gobuffalo/buffalo"
"github.com/gobuffalo/buffalo/render"
"github.com/gomods/athens/pkg/errors"
"github.com/gomods/athens/pkg/log"
"github.com/gomods/athens/pkg/paths"
@@ -15,21 +14,24 @@ import (
const PathList = "/{module:.+}/@v/list"
// ListHandler implements GET baseURL/module/@v/list
func ListHandler(dp Protocol, lggr log.Entry, eng *render.Engine) buffalo.Handler {
func ListHandler(dp Protocol, lggr log.Entry) http.Handler {
const op errors.Op = "download.ListHandler"
return func(c buffalo.Context) error {
mod, err := paths.GetModule(c)
f := func(w http.ResponseWriter, r *http.Request) {
mod, err := paths.GetModule(r)
if err != nil {
lggr.SystemErr(errors.E(op, err))
return c.Render(http.StatusInternalServerError, nil)
w.WriteHeader(http.StatusInternalServerError)
return
}
versions, err := dp.List(c, mod)
versions, err := dp.List(r.Context(), mod)
if err != nil {
lggr.SystemErr(errors.E(op, err))
return c.Render(errors.Kind(err), eng.JSON(errors.KindText(err)))
w.WriteHeader(errors.Kind(err))
return
}
return c.Render(http.StatusOK, eng.String(strings.Join(versions, "\n")))
fmt.Fprint(w, strings.Join(versions, "\n"))
}
return http.HandlerFunc(f)
}
pkg/download/version_info.go
+11 -11
View File
@@ -3,8 +3,6 @@ package download
import (
"net/http"
"github.com/gobuffalo/buffalo"
"github.com/gobuffalo/buffalo/render"
"github.com/gomods/athens/pkg/errors"
"github.com/gomods/athens/pkg/log"
)
@@ -12,21 +10,23 @@ import (
// PathVersionInfo URL.
const PathVersionInfo = "/{module:.+}/@v/{version}.info"
// VersionInfoHandler implements GET baseURL/module/@v/version.info
func VersionInfoHandler(dp Protocol, lggr log.Entry, eng *render.Engine) buffalo.Handler {
const op errors.Op = "download.VersionInfoHandler"
return func(c buffalo.Context) error {
mod, ver, err := getModuleParams(c, op)
// InfoHandler implements GET baseURL/module/@v/version.info
func InfoHandler(dp Protocol, lggr log.Entry) http.Handler {
const op errors.Op = "download.InfoHandler"
f := func(w http.ResponseWriter, r *http.Request) {
mod, ver, err := getModuleParams(r, op)
if err != nil {
lggr.SystemErr(err)
return c.Render(errors.Kind(err), nil)
w.WriteHeader(errors.Kind(err))
return
}
info, err := dp.Info(c, mod, ver)
info, err := dp.Info(r.Context(), mod, ver)
if err != nil {
lggr.SystemErr(errors.E(op, err, errors.M(mod), errors.V(ver)))
return c.Render(errors.Kind(err), nil)
w.WriteHeader(errors.Kind(err))
}
return c.Render(http.StatusOK, eng.String(string(info)))
w.Write(info)
}
return http.HandlerFunc(f)
}
pkg/download/version_module.go
+13 -14
View File
@@ -1,34 +1,33 @@
package download
import (
"github.com/gobuffalo/buffalo"
"github.com/gobuffalo/buffalo/render"
"net/http"
"github.com/gomods/athens/pkg/errors"
"github.com/gomods/athens/pkg/log"
"net/http"
)
// PathVersionModule URL.
const PathVersionModule = "/{module:.+}/@v/{version}.mod"
// VersionModuleHandler implements GET baseURL/module/@v/version.mod
func VersionModuleHandler(dp Protocol, lggr log.Entry, eng *render.Engine) buffalo.Handler {
// ModuleHandler implements GET baseURL/module/@v/version.mod
func ModuleHandler(dp Protocol, lggr log.Entry) http.Handler {
const op errors.Op = "download.VersionModuleHandler"
return func(c buffalo.Context) error {
mod, ver, err := getModuleParams(c, op)
f := func(w http.ResponseWriter, r *http.Request) {
mod, ver, err := getModuleParams(r, op)
if err != nil {
lggr.SystemErr(err)
return c.Render(errors.Kind(err), nil)
w.WriteHeader(errors.Kind(err))
return
}
modBts, err := dp.GoMod(c, mod, ver)
modBts, err := dp.GoMod(r.Context(), mod, ver)
if err != nil {
err = errors.E(op, errors.M(mod), errors.V(ver), err)
lggr.SystemErr(err)
return c.Render(errors.Kind(err), nil)
w.WriteHeader(errors.Kind(err))
return
}
// Calling c.Response().Write will write the header directly
// and we would get a 0 status in the buffalo logs.
return c.Render(http.StatusOK, eng.String(string(modBts)))
w.Write(modBts)
}
return http.HandlerFunc(f)
}
pkg/download/version_zip.go
+12 -17
View File
@@ -4,8 +4,6 @@ import (
"io"
"net/http"
"github.com/gobuffalo/buffalo"
"github.com/gobuffalo/buffalo/render"
"github.com/gomods/athens/pkg/errors"
"github.com/gomods/athens/pkg/log"
)
@@ -13,31 +11,28 @@ import (
// PathVersionZip URL.
const PathVersionZip = "/{module:.+}/@v/{version}.zip"
// VersionZipHandler implements GET baseURL/module/@v/version.zip
func VersionZipHandler(dp Protocol, lggr log.Entry, eng *render.Engine) buffalo.Handler {
const op errors.Op = "download.VersionZipHandler"
return func(c buffalo.Context) error {
mod, ver, err := getModuleParams(c, op)
// ZipHandler implements GET baseURL/module/@v/version.zip
func ZipHandler(dp Protocol, lggr log.Entry) http.Handler {
const op errors.Op = "download.ZipHandler"
f := func(w http.ResponseWriter, r *http.Request) {
mod, ver, err := getModuleParams(r, op)
if err != nil {
lggr.SystemErr(err)
return c.Render(errors.Kind(err), nil)
w.WriteHeader(errors.Kind(err))
return
}
zip, err := dp.Zip(c, mod, ver)
zip, err := dp.Zip(r.Context(), mod, ver)
if err != nil {
lggr.SystemErr(err)
return c.Render(errors.Kind(err), nil)
w.WriteHeader(errors.Kind(err))
return
}
defer zip.Close()
// Calling c.Response().Write will write the header directly
// and we would get a 0 status in the buffalo logs.
c.Render(http.StatusOK, nil)
_, err = io.Copy(c.Response(), zip)
_, err = io.Copy(w, zip)
if err != nil {
lggr.SystemErr(errors.E(op, errors.M(mod), errors.V(ver), err))
}
return nil
}
return http.HandlerFunc(f)
}