feat: add resolvelinks

2022-10-30 09:18:08 -06:00
parent 5bf052580f
commit 6569c58e37
18 changed files with 421 additions and 106 deletions
--- a/app/gql/resolver.go
+++ b/app/gql/resolver.go
@@ -7,9 +7,16 @@ import (
 	"os"
 	"reflect"
 	"runtime/debug"
+	"time"

+	"github.com/99designs/gqlgen/graphql"
 	"github.com/99designs/gqlgen/graphql/handler"
+	"github.com/99designs/gqlgen/graphql/handler/extension"
+	"github.com/99designs/gqlgen/graphql/handler/lru"
+	"github.com/99designs/gqlgen/graphql/handler/transport"
+	"github.com/gorilla/websocket"
 	"github.com/ravilushqa/otelgqlgen"
+	"github.com/sour-is/ev/app/gql/graphiql"
 	"github.com/sour-is/ev/app/gql/playground"
 	"github.com/sour-is/ev/app/msgbus"
 	"github.com/sour-is/ev/app/salty"
@@ -86,11 +93,13 @@ func (r *Resolver) ChainMiddlewares(h http.Handler) http.Handler {
 }

 func (r *Resolver) RegisterHTTP(mux *http.ServeMux) {
-	gql := handler.NewDefaultServer(generated.NewExecutableSchema(generated.Config{Resolvers: r}))
+	gql := NewServer(generated.NewExecutableSchema(generated.Config{Resolvers: r}))
+
 	gql.SetRecoverFunc(NoopRecover)
 	gql.Use(otelgqlgen.Middleware())
-	mux.Handle("/", playground.Handler("GraphQL playground", "/gql"))
+	mux.Handle("/graphiql", graphiql.Handler("GraphiQL playground", "/gql"))
 	mux.Handle("/gql", lg.Htrace(r.ChainMiddlewares(gql), "gql"))
+	mux.Handle("/playground", playground.Handler("GraphQL playground", "/gql"))
 }

 type noop struct{}
@@ -130,3 +139,34 @@ func (*noop) EventAdded(ctx context.Context, streamID string, after int64) (<-ch
 }

 func (*noop) RegisterHTTP(*http.ServeMux) {}
+
+func NewServer(es graphql.ExecutableSchema) *handler.Server {
+	srv := handler.New(es)
+
+	srv.AddTransport(transport.Websocket{
+		Upgrader: websocket.Upgrader{
+			CheckOrigin: func(r *http.Request) bool {
+				switch r.Header.Get("Origin") {
+				case "https://ev.sour.is", "https://www.graphqlbin.com":
+					return true
+				default:
+					return false
+				}
+			},
+		},
+		KeepAlivePingInterval: 10 * time.Second,
+	})
+	srv.AddTransport(transport.Options{})
+	srv.AddTransport(transport.GET{})
+	srv.AddTransport(transport.POST{})
+	srv.AddTransport(transport.MultipartForm{})
+
+	srv.SetQueryCache(lru.New(1000))
+
+	srv.Use(extension.Introspection{})
+	srv.Use(extension.AutomaticPersistedQuery{
+		Cache: lru.New(100),
+	})
+
+	return srv
+}
--- a/app/peerfinder/peer.go
+++ b/app/peerfinder/peer.go
@@ -11,26 +11,58 @@ import (
 	"github.com/sour-is/ev/pkg/es/event"
 )

-type Request struct {
+type Request struct{
+	event.AggregateRoot
+
+	RequestIP string `json:"req_ip"`
+	Hidden    bool   `json:"hide,omitempty"`
+
+	Responses []Response `json:"responses"`
+}
+
+var _ event.Aggregate = (*Request)(nil)
+func (a *Request) ApplyEvent(lis ...event.Event) {
+	for _, e := range lis {
+		switch e:=e.(type) {
+		case *RequestSubmitted:
+			a.RequestIP = e.RequestIP
+			a.Hidden = e.Hidden
+		case *ResultSubmitted:
+				a.Responses = append(a.Responses, Response{
+					PeerID: e.PeerID,
+					PeerVersion: e.PeerVersion,
+					Latency: e.Latency,
+				})
+		}
+	}
+}
+
+type Response struct {
+	PeerID      string  `json:"peer_id"`
+	PeerVersion string  `json:"peer_version"`
+	Latency     float64 `json:"latency,omitempty"`
+}
+
+type RequestSubmitted struct {
 	eventMeta event.Meta

 	RequestIP string `json:"req_ip"`
 	Hidden    bool   `json:"hide,omitempty"`
 }

-func (r *Request) StreamID() string {
+func (r *RequestSubmitted) StreamID() string {
 	return r.EventMeta().GetEventID()
 }
-func (r *Request) RequestID() string {
+func (r *RequestSubmitted) RequestID() string {
 	return r.EventMeta().GetEventID()
 }
-func (r *Request) Created() time.Time {
+func (r *RequestSubmitted) Created() time.Time {
 	return r.EventMeta().Created()
 }
-func (r *Request) CreatedString() string {
+func (r *RequestSubmitted) CreatedString() string {
 	return r.Created().Format("2006-01-02 15:04:05")
 }
-func (r *Request) Family() int {
+func (r *RequestSubmitted) Family() int {
 	if r == nil {
 		return 0
 	}
@@ -46,26 +78,26 @@ func (r *Request) Family() int {
 	}
 }

-var _ event.Event = (*Request)(nil)
+var _ event.Event = (*RequestSubmitted)(nil)

-func (e *Request) EventMeta() event.Meta {
+func (e *RequestSubmitted) EventMeta() event.Meta {
 	if e == nil {
 		return event.Meta{}
 	}
 	return e.eventMeta
 }
-func (e *Request) SetEventMeta(m event.Meta) {
+func (e *RequestSubmitted) SetEventMeta(m event.Meta) {
 	if e != nil {
 		e.eventMeta = m
 	}
 }
-func (e *Request) MarshalBinary() (text []byte, err error) {
+func (e *RequestSubmitted) MarshalBinary() (text []byte, err error) {
 	return json.Marshal(e)
 }
-func (e *Request) UnmarshalBinary(b []byte) error {
+func (e *RequestSubmitted) UnmarshalBinary(b []byte) error {
 	return json.Unmarshal(b, e)
 }
-func (e *Request) MarshalEnviron() ([]byte, error) {
+func (e *RequestSubmitted) MarshalEnviron() ([]byte, error) {
 	if e == nil {
 		return nil, nil
 	}
@@ -92,7 +124,7 @@ func (e *Request) MarshalEnviron() ([]byte, error) {
 	return b.Bytes(), nil
 }

-type Result struct {
+type ResultSubmitted struct {
 	eventMeta event.Meta

 	RequestID   string  `json:"req_id"`
@@ -101,30 +133,30 @@ type Result struct {
 	Latency     float64 `json:"latency,omitempty"`
 }

-func (r *Result) Created() time.Time {
+func (r *ResultSubmitted) Created() time.Time {
 	return r.eventMeta.Created()
 }

-var _ event.Event = (*Result)(nil)
+var _ event.Event = (*ResultSubmitted)(nil)

-func (e *Result) EventMeta() event.Meta {
+func (e *ResultSubmitted) EventMeta() event.Meta {
 	if e == nil {
 		return event.Meta{}
 	}
 	return e.eventMeta
 }
-func (e *Result) SetEventMeta(m event.Meta) {
+func (e *ResultSubmitted) SetEventMeta(m event.Meta) {
 	if e != nil {
 		e.eventMeta = m
 	}
 }
-func (e *Result) MarshalBinary() (text []byte, err error) {
+func (e *ResultSubmitted) MarshalBinary() (text []byte, err error) {
 	return json.Marshal(e)
 }
-func (e *Result) UnmarshalBinary(b []byte) error {
+func (e *ResultSubmitted) UnmarshalBinary(b []byte) error {
 	return json.Unmarshal(b, e)
 }
-func (e *Result) String() string {
+func (e *ResultSubmitted) String() string {
 	return fmt.Sprintf("id: %s\npeer: %s\nversion: %s\nlatency: %0.4f", e.RequestID, e.PeerID, e.PeerVersion, e.Latency)
 }

--- a/app/peerfinder/service.go
+++ b/app/peerfinder/service.go
@@ -2,8 +2,12 @@ package peerfinder

 import (
 	"context"
+	"embed"
 	"encoding/json"
+	"html/template"
 	"io"
+	"io/fs"
+	"log"
 	"net"
 	"net/http"
 	"strconv"
@@ -16,24 +20,39 @@ import (
 	"github.com/sour-is/ev/internal/lg"
 	"github.com/sour-is/ev/pkg/es"
 	"github.com/sour-is/ev/pkg/es/event"
+	"github.com/sour-is/ev/pkg/locker"
 )

 const (
-	queueRequests  = "pf-requests"
-	queueResponses = "pf-response-"
 	aggInfo        = "pf-info"
+	queueRequests  = "pf-requests"
+	queueResponses = "pf-request-"
+	queuePeers     = "pf-peer-"
 	initVersion    = "1.1.0"
 )

+var (
+	//go:embed pages/* layouts/* assets/*
+	files     embed.FS
+	templates map[string]*template.Template
+)
+
 type service struct {
 	es *es.EventStore
+
+	State locker.Locked[state]
+}
+
+type state struct {
+	Version  string
+	Requests []Request
 }

 func New(ctx context.Context, es *es.EventStore) (*service, error) {
 	ctx, span := lg.Span(ctx)
 	defer span.End()

-	if err := event.Register(ctx, &Request{}, &Result{}, &VersionChanged{}); err != nil {
+	if err := event.Register(ctx, &RequestSubmitted{}, &ResultSubmitted{}, &VersionChanged{}); err != nil {
 		span.RecordError(err)
 		return nil, err
 	}
@@ -43,8 +62,13 @@ func New(ctx context.Context, es *es.EventStore) (*service, error) {
 	return svc, nil
 }
 func (s *service) RegisterHTTP(mux *http.ServeMux) {
-	mux.Handle("/peers/", lg.Htrace(s, "peers"))
+	loadTemplates()
+	a, err := fs.Sub(files, "assets")
+	log.Println(err)
+	assets := http.StripPrefix("/peers/assets/", http.FileServer(http.FS(a)))

+	mux.Handle("/peers/assets/", lg.Htrace(assets, "peer-assets"))
+	mux.Handle("/peers/", lg.Htrace(s, "peers"))
 }
 func (s *service) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
@@ -66,7 +90,8 @@ func (s *service) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 			return

 		default:
-			w.WriteHeader(http.StatusNotFound)
+			t := templates["home.tpl"]
+			t.Execute(w, nil)
 			return
 		}
 	case http.MethodPost:
@@ -113,7 +138,7 @@ func (s *service) getPending(w http.ResponseWriter, r *http.Request, uuid string
 		return
 	}

-	responses, err := s.es.Read(ctx, queueResponses+uuid, -1, -30)
+	responses, err := s.es.Read(ctx, queuePeers+uuid, -1, -30)
 	if err != nil {
 		span.RecordError(err)
 		w.WriteHeader(http.StatusInternalServerError)
@@ -199,19 +224,17 @@ func (s *service) postRequest(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
-
-	req := &Request{
+	req := &RequestSubmitted{
 		RequestIP: ip.String(),
 	}
+	if hidden, err := strconv.ParseBool(r.Form.Get("req_hidden")); err != nil {
+		req.Hidden = hidden
+	}

 	span.SetAttributes(
 		attribute.Stringer("req_ip", ip),
 	)

-	if hidden, err := strconv.ParseBool(r.Form.Get("req_hidden")); err != nil {
-		req.Hidden = hidden
-	}
-
 	s.es.Append(ctx, queueRequests, event.NewEvents(req))
 }
 func (s *service) postResult(w http.ResponseWriter, r *http.Request, id string) {
@@ -238,25 +261,36 @@ func (s *service) postResult(w http.ResponseWriter, r *http.Request, id string)
 		return
 	}

-	req := &Result{
+	req := &ResultSubmitted{
 		RequestID:   id,
 		PeerID:      r.Form.Get("peer_id"),
 		PeerVersion: r.Form.Get("peer_version"),
 		Latency:     latency,
 	}
+
 	span.SetAttributes(
 		attribute.Stringer("result", req),
 	)

-	s.es.Append(ctx, queueResponses+id, event.NewEvents(req))
+	idx, err := s.es.LastIndex(ctx, queueResponses+id)
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+	if idx == 0 {
+		w.WriteHeader(http.StatusNotFound)
+		return
+	}
+
+	s.es.Append(ctx, queueRequests, event.NewEvents(req))
 }

-func filter(requests, responses event.Events) *Request {
+func filter(requests, responses event.Events) *RequestSubmitted {
 	have := make(map[string]struct{}, len(responses))
-	for _, res := range toList[Result](responses...) {
+	for _, res := range toList[ResultSubmitted](responses...) {
 		have[res.RequestID] = struct{}{}
 	}
-	for _, req := range reverse(toList[Request](requests...)...) {
+	for _, req := range reverse(toList[RequestSubmitted](requests...)...) {
 		if _, ok := have[req.RequestID()]; !ok {
 			return req
 		}
@@ -297,3 +331,50 @@ func encodeTo(w io.Writer, fns ...func() ([]byte, error)) (int, error) {
 	}
 	return i, nil
 }
+func loadTemplates() error {
+	if templates != nil {
+		return nil
+	}
+	templates = make(map[string]*template.Template)
+	tmplFiles, err := fs.ReadDir(files, "pages")
+	if err != nil {
+		return err
+	}
+
+	for _, tmpl := range tmplFiles {
+		if tmpl.IsDir() {
+			continue
+		}
+		log.Println(tmpl.Name())
+		pt, err := template.ParseFS(files, "pages/"+tmpl.Name(), "layouts/*.tpl")
+		if err != nil {
+			return err
+		}
+
+		templates[tmpl.Name()] = pt
+	}
+	return nil
+}
+
+func Projector(e event.Event) []event.Event {
+	m := e.EventMeta()
+	streamID := m.StreamID
+	streamPos := m.Position
+
+	switch e := e.(type) {
+	case *RequestSubmitted:
+		e1 := event.NewPtr(streamID, streamPos)
+		event.SetStreamID(queueResponses+e.RequestID(), e1)
+
+		return []event.Event{e1}
+	case *ResultSubmitted:
+		e1 := event.NewPtr(streamID, streamPos)
+		event.SetStreamID(queueResponses+e.RequestID, e1)
+
+		e2 := event.NewPtr(streamID, streamPos)
+		event.SetStreamID(queuePeers+e.PeerID, e2)
+
+		return []event.Event{e1, e2}
+	}
+	return nil
+}