go-latestver/api.go

267 lines
6.9 KiB
Go
Raw Normal View History

2021-11-22 02:39:25 +00:00
package main
import (
"encoding/json"
"fmt"
"net/http"
2021-11-22 15:05:03 +00:00
"net/url"
"path"
2021-11-22 02:39:25 +00:00
"strconv"
2021-11-22 15:05:03 +00:00
"strings"
"time"
2021-11-22 02:39:25 +00:00
2021-11-22 15:05:03 +00:00
"github.com/gorilla/feeds"
2021-11-22 02:39:25 +00:00
"github.com/gorilla/mux"
2021-11-22 15:05:03 +00:00
"github.com/pkg/errors"
2021-11-22 02:39:25 +00:00
log "github.com/sirupsen/logrus"
"github.com/Luzifer/go-latestver/internal/config"
"github.com/Luzifer/go-latestver/internal/database"
"github.com/Luzifer/go-latestver/internal/fetcher"
2021-11-22 02:39:25 +00:00
)
type (
APICatalogEntry struct {
database.CatalogEntry
database.CatalogMeta
}
)
func buildFullURL(u *url.URL, _ error) string {
2021-11-22 15:05:03 +00:00
return strings.Join([]string{
strings.TrimRight(cfg.BaseURL, "/"),
strings.TrimLeft(u.String(), "/"),
}, "/")
}
func catalogEntryToAPICatalogEntry(ce database.CatalogEntry) (APICatalogEntry, error) {
cm, err := storage.Catalog.GetMeta(&ce)
if err != nil {
return APICatalogEntry{}, errors.Wrap(err, "fetching catalog meta")
}
for _, l := range fetcher.Get(ce.Fetcher).Links(&ce.FetcherConfig) {
var found bool
for _, el := range ce.Links {
if l.Name == el.Name {
found = true
break
}
}
if !found {
ce.Links = append(ce.Links, l)
}
}
return APICatalogEntry{CatalogEntry: ce, CatalogMeta: *cm}, nil
}
func handleBadgeRedirect(w http.ResponseWriter, r *http.Request) {
var (
compare = r.FormValue("compare")
vars = mux.Vars(r)
name, tag = vars["name"], vars["tag"]
)
ce, err := configFile.CatalogEntryByTag(name, tag)
if errors.Is(err, config.ErrCatalogEntryNotFound) {
http.Error(w, "Not found", http.StatusNotFound)
return
}
cm, err := storage.Catalog.GetMeta(&ce)
if err != nil {
http.Error(w, "Unable to fetch catalog data", http.StatusInternalServerError)
return
}
color := "green"
if compare != "" && compare != cm.CurrentVersion {
color = "red"
}
target, err := url.Parse(cfg.BadgeGenInstance)
if err != nil {
http.Error(w, "Misconfigured BadgeGenInstance", http.StatusInternalServerError)
return
}
target.Path = path.Join(target.Path, "static", ce.Key(), cm.CurrentVersion, color)
http.Redirect(w, r, target.String(), http.StatusFound)
}
2021-11-22 02:39:25 +00:00
func handleCatalogGet(w http.ResponseWriter, r *http.Request) {
var (
vars = mux.Vars(r)
name, tag = vars["name"], vars["tag"]
)
ce, err := configFile.CatalogEntryByTag(name, tag)
if errors.Is(err, config.ErrCatalogEntryNotFound) {
http.Error(w, "Not found", http.StatusNotFound)
return
}
ae, err := catalogEntryToAPICatalogEntry(ce)
2021-11-22 02:39:25 +00:00
if err != nil {
log.WithError(err).Error("Unable to fetch catalog data")
http.Error(w, "Unable to fetch catalog data", http.StatusInternalServerError)
2021-11-22 02:39:25 +00:00
return
}
w.Header().Set("Content-Type", "application/json")
if err = json.NewEncoder(w).Encode(ae); err != nil {
2021-11-22 02:39:25 +00:00
log.WithError(err).Error("Unable to encode catalog entry")
http.Error(w, "Unable to encode catalog meta", http.StatusInternalServerError)
return
}
}
func handleCatalogGetVersion(w http.ResponseWriter, r *http.Request) {
var (
vars = mux.Vars(r)
name, tag = vars["name"], vars["tag"]
)
ce, err := configFile.CatalogEntryByTag(name, tag)
if errors.Is(err, config.ErrCatalogEntryNotFound) {
http.Error(w, "Not found", http.StatusNotFound)
return
}
cm, err := storage.Catalog.GetMeta(&ce)
if err != nil {
log.WithError(err).Error("Unable to fetch catalog meta")
http.Error(w, "Unable to fetch catalog meta", http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "text/plain")
fmt.Fprint(w, cm.CurrentVersion)
}
func handleCatalogList(w http.ResponseWriter, r *http.Request) {
out := make([]APICatalogEntry, len(configFile.Catalog))
2021-11-22 02:39:25 +00:00
for i := range configFile.Catalog {
ce := configFile.Catalog[i]
ae, err := catalogEntryToAPICatalogEntry(ce)
2021-11-22 02:39:25 +00:00
if err != nil {
log.WithError(err).Error("Unable to fetch catalog data")
http.Error(w, "Unable to fetch catalog data", http.StatusInternalServerError)
2021-11-22 02:39:25 +00:00
return
}
out[i] = ae
2021-11-22 02:39:25 +00:00
}
w.Header().Set("Content-Type", "application/json")
if err := json.NewEncoder(w).Encode(out); err != nil {
log.WithError(err).Error("Unable to encode catalog entry list")
http.Error(w, "Unable to encode catalog meta", http.StatusInternalServerError)
return
}
}
func handleLog(w http.ResponseWriter, r *http.Request) {
2021-11-22 15:05:03 +00:00
logs, err := prepareLogForRequest(r)
switch err {
case nil:
// This is fine
case config.ErrCatalogEntryNotFound:
http.Error(w, "Not found", http.StatusNotFound)
default:
http.Error(w, "Unable to fetch logs", http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
if err = json.NewEncoder(w).Encode(logs); err != nil {
log.WithError(err).Error("Unable to encode logs")
http.Error(w, "Unable to encode logs", http.StatusInternalServerError)
return
}
}
func handleLogFeed(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
logs, err := prepareLogForRequest(r)
switch err {
case nil:
// This is fine
case config.ErrCatalogEntryNotFound:
http.Error(w, "Not found", http.StatusNotFound)
default:
http.Error(w, "Unable to fetch logs", http.StatusInternalServerError)
return
}
feed := &feeds.Feed{
Description: "Generated by go-latestver: https://github.com/Luzifer/go-latestver",
Link: &feeds.Link{Href: buildFullURL(router.Get("catalog").URL())},
Title: "Latestver Update Log",
}
if vars["name"] != "" {
feed.Title = fmt.Sprintf("Latestver Update Log of %s:%s", vars["name"], vars["tag"])
feed.Link.Href = buildFullURL(router.Get("catalog-entry").URL("name", vars["name"], "tag", vars["tag"]))
2021-11-22 15:05:03 +00:00
}
for _, le := range logs {
feed.Add(&feeds.Item{
Created: le.Timestamp.UTC(),
Description: fmt.Sprintf("%s:%s updated to version %s from %s", le.CatalogName, le.CatalogTag, le.VersionTo, le.VersionFrom),
Id: fmt.Sprintf("%s:%s-%s", le.CatalogName, le.CatalogTag, le.Timestamp.UTC().Format(time.RFC3339)),
Link: &feeds.Link{Href: buildFullURL(router.Get("catalog-entry").URL("name", le.CatalogName, "tag", le.CatalogTag))},
2021-11-22 15:05:03 +00:00
Title: fmt.Sprintf("%s:%s %s", le.CatalogName, le.CatalogTag, le.VersionTo),
})
}
w.Header().Set("Content-Type", "application/rss+xml; charset=utf-8")
if err = feed.WriteRss(w); err != nil {
log.WithError(err).Error("Unable to render RSS")
http.Error(w, "Unable to render RSS", http.StatusInternalServerError)
return
}
}
func prepareLogForRequest(r *http.Request) ([]database.LogEntry, error) {
2021-11-22 02:39:25 +00:00
var (
vars = mux.Vars(r)
name, tag = vars["name"], vars["tag"]
num, page = 25, 0
err error
logs []database.LogEntry
)
if v, err := strconv.Atoi(r.FormValue("num")); err == nil && v > 0 && v < 100 {
num = v
}
if v, err := strconv.Atoi(r.FormValue("page")); err == nil && v >= 0 {
page = v
}
if name == "" && tag == "" {
logs, err = storage.Logs.List(num, page)
} else {
ce, err := configFile.CatalogEntryByTag(name, tag)
if errors.Is(err, config.ErrCatalogEntryNotFound) {
2021-11-22 15:05:03 +00:00
return nil, config.ErrCatalogEntryNotFound
2021-11-22 02:39:25 +00:00
}
logs, err = storage.Logs.ListForCatalogEntry(&ce, num, page)
}
2021-11-22 15:05:03 +00:00
return logs, errors.Wrap(err, "listing log entries")
2021-11-22 02:39:25 +00:00
}