sour-is/go-tools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 4 Wiki Activity

chore: add apps from go.sour.is/ev

Browse Source
This commit is contained in:
xuu
2023-09-29 10:31:25 -06:00
parent 976ce36be2
commit bec2c14d51
80 changed files with 13030 additions and 439 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
cmd/ev/app.msgbus.go Normal file
View File

@@ -0,0 +1,34 @@
package main
import (
"context"
"fmt"
"go.sour.is/ev"
"go.sour.is/tools/app/msgbus"
"go.sour.is/ev/driver/projecter"
"go.sour.is/pkg/lg"
"go.sour.is/pkg/service"
"go.sour.is/pkg/slice"
)
var _ = apps.Register(50, func(ctx context.Context, svc *service.Harness) error {
ctx, span := lg.Span(ctx)
defer span.End()
span.AddEvent("Enable Msgbus")
eventstore, ok := slice.Find[*ev.EventStore](svc.Services...)
if !ok {
return fmt.Errorf("*es.EventStore not found in services")
}
eventstore.Option(projecter.New(ctx, msgbus.Projector))
msgbus, err := msgbus.New(ctx, eventstore)
if err != nil {
span.RecordError(err)
return err
}
svc.Add(msgbus)
return nil
})

44
cmd/ev/app.peerfinder.go Normal file
View File

@@ -0,0 +1,44 @@
package main
import (
"context"
"fmt"
"go.sour.is/pkg/env"
"go.sour.is/pkg/lg"
"go.sour.is/pkg/service"
"go.sour.is/pkg/slice"
"go.sour.is/ev"
"go.sour.is/tools/app/peerfinder"
"go.sour.is/ev/driver/projecter"
)
var _ = apps.Register(50, func(ctx context.Context, svc *service.Harness) error {
ctx, span := lg.Span(ctx)
defer span.End()
span.AddEvent("Enable Peers")
eventstore, ok := slice.Find[*ev.EventStore](svc.Services...)
if !ok {
return fmt.Errorf("*es.EventStore not found in services")
}
eventstore.Option(projecter.New(ctx, peerfinder.Projector))
peers, err := peerfinder.New(ctx, eventstore, env.Secret("PEER_STATUS", "").Secret())
if err != nil {
span.RecordError(err)
return err
}
svc.RunOnce(ctx, peers.RefreshJob)
svc.NewCron("0,15,30,45", peers.RefreshJob)
svc.RunOnce(ctx, peers.CleanJob)
svc.NewCron("0 1", peers.CleanJob)
svc.OnStart(peers.Run)
svc.OnStop(peers.Stop)
svc.Add(peers)
return nil
})

64
cmd/ev/app.salty.go Normal file
View File

@@ -0,0 +1,64 @@
package main
import (
"context"
"fmt"
"net/http"
"net/url"
"os"
"path/filepath"
"strings"
"go.sour.is/ev"
"go.sour.is/tools/app/salty"
"go.sour.is/pkg/env"
"go.sour.is/pkg/lg"
"go.sour.is/pkg/service"
"go.sour.is/pkg/slice"
)
var _ = apps.Register(50, func(ctx context.Context, svc *service.Harness) error {
ctx, span := lg.Span(ctx)
defer span.End()
span.AddEvent("Enable Salty")
eventstore, ok := slice.Find[*ev.EventStore](svc.Services...)
if !ok {
return fmt.Errorf("*es.EventStore not found in services")
}
addr := "localhost"
if ht, ok := slice.Find[*http.Server](svc.Services...); ok {
addr = ht.Addr
}
var opts []salty.Option
base, err := url.JoinPath(env.Default("SALTY_BASE_URL", "http://"+addr), "inbox")
if err != nil {
span.RecordError(err)
return err
}
opts = append(opts, salty.WithBaseURL(base))
if p := env.Default("SALTY_BLOB_DIR", ""); p != "" {
if strings.HasPrefix(p, "~/") {
home, _ := os.UserHomeDir()
p = filepath.Join(home, strings.TrimPrefix(p, "~/"))
}
opts = append(opts, salty.WithBlobStore(p))
}
salty, err := salty.New(
ctx,
eventstore,
opts...,
)
if err != nil {
span.RecordError(err)
return err
}
svc.Add(salty)
return nil
})

17
cmd/ev/app.twtxt.go Normal file
View File

@@ -0,0 +1,17 @@
package main
import (
"context"
"go.sour.is/pkg/lg"
"go.sour.is/pkg/service"
)
var _ = apps.Register(50, func(ctx context.Context, svc *service.Harness) error {
_, span := lg.Span(ctx)
defer span.End()
span.AddEvent("Enable Twtxt")
return nil
})

52
cmd/ev/app.webfinger.go Normal file
View File

@@ -0,0 +1,52 @@
package main
import (
"context"
"fmt"
"strings"
"time"
"github.com/patrickmn/go-cache"
"go.sour.is/ev"
"go.sour.is/tools/app/webfinger"
"go.sour.is/pkg/env"
"go.sour.is/pkg/lg"
"go.sour.is/pkg/service"
"go.sour.is/pkg/slice"
)
var (
defaultExpire = 3 * time.Minute
cleanupInterval = 10 * time.Minute
)
var _ = apps.Register(50, func(ctx context.Context, svc *service.Harness) error {
ctx, span := lg.Span(ctx)
defer span.End()
span.AddEvent("Enable WebFinger")
eventstore, ok := slice.Find[*ev.EventStore](svc.Services...)
if !ok {
return fmt.Errorf("*es.EventStore not found in services")
}
cache := cache.New(defaultExpire, cleanupInterval)
var withCache webfinger.WithCache = (func(s string) bool {
if _, ok := cache.Get(s); ok {
return true
}
cache.SetDefault(s, true)
return false
})
var withHostnames webfinger.WithHostnames = strings.Fields(env.Default("WEBFINGER_DOMAINS", "sour.is"))
wf, err := webfinger.New(ctx, eventstore, withCache, withHostnames)
if err != nil {
span.RecordError(err)
return err
}
svc.Add(wf)
return nil
})

41
cmd/ev/main.go Normal file
View File

@@ -0,0 +1,41 @@
package main
import (
"context"
"errors"
"log"
"net/http"
"os"
"os/signal"
"go.sour.is/pkg/lg"
"go.sour.is/pkg/service"
)
var apps service.Apps
var appName, version = service.AppName()
func main() {
ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, os.Kill)
go func() {
<-ctx.Done()
defer cancel() // restore interrupt function
}()
if err := run(ctx); err != nil {
log.Fatal(err)
os.Exit(1)
}
}
func run(ctx context.Context) error {
svc := &service.Harness{}
ctx, stop := lg.Init(ctx, appName)
svc.OnStop(stop)
svc.Add(lg.NewHTTP(ctx))
svc.Setup(ctx, apps.Apps()...)
// Run application
if err := svc.Run(ctx, appName, version); err != nil && !errors.Is(err, http.ErrServerClosed) {
return err
}
return nil
}

54
cmd/ev/svc.es.go Normal file
View File

@@ -0,0 +1,54 @@
package main
import (
"context"
"go.sour.is/pkg/env"
"go.sour.is/pkg/lg"
"go.sour.is/pkg/service"
"go.uber.org/multierr"
"go.sour.is/ev"
diskstore "go.sour.is/ev/driver/disk-store"
memstore "go.sour.is/ev/driver/mem-store"
"go.sour.is/ev/driver/projecter"
resolvelinks "go.sour.is/ev/driver/resolve-links"
"go.sour.is/ev/driver/streamer"
"go.sour.is/ev/event"
gql_ev "go.sour.is/ev/gql"
)
var _ = apps.Register(10, func(ctx context.Context, svc *service.Harness) error {
ctx, span := lg.Span(ctx)
defer span.End()
// setup eventstore
err := multierr.Combine(
ev.Init(ctx),
event.Init(ctx),
diskstore.Init(ctx),
memstore.Init(ctx),
)
if err != nil {
span.RecordError(err)
return err
}
eventstore, err := ev.Open(
ctx,
env.Default("EV_DATA", "mem:"),
resolvelinks.New(),
streamer.New(ctx),
projecter.New(
ctx,
projecter.DefaultProjection,
),
)
if err != nil {
span.RecordError(err)
return err
}
svc.Add(eventstore, &gql_ev.EventStore{EventStore: eventstore})
return nil
})

40
cmd/ev/svc.gql.go Normal file
View File

@@ -0,0 +1,40 @@
package main
import (
"context"
"net/http"
"go.sour.is/pkg/gql/resolver"
"go.sour.is/pkg/lg"
"go.sour.is/pkg/mux"
"go.sour.is/pkg/service"
"go.sour.is/pkg/slice"
"go.sour.is/tools/app/gql"
)
var _ = apps.Register(90, func(ctx context.Context, svc *service.Harness) error {
ctx, span := lg.Span(ctx)
defer span.End()
span.AddEvent("Enable GraphQL")
gql, err := resolver.New(ctx, &gql.Resolver{}, slice.FilterType[resolver.IsResolver](svc.Services...)...)
if err != nil {
span.RecordError(err)
return err
}
gql.CheckOrigin = func(r *http.Request) bool {
switch r.Header.Get("Origin") {
case "https://ev.sour.is", "https://www.graphqlbin.com", "http://localhost:8080":
return true
default:
return false
}
}
svc.Add(gql)
svc.Add(mux.RegisterHTTP(func(mux *http.ServeMux) {
mux.Handle("/", http.RedirectHandler("/playground", http.StatusTemporaryRedirect))
}))
return nil
})

47
cmd/ev/svc.http.go Normal file
View File

@@ -0,0 +1,47 @@
package main
import (
"context"
"log"
"net/http"
"strings"
"github.com/rs/cors"
"go.sour.is/pkg/env"
"go.sour.is/pkg/lg"
"go.sour.is/pkg/mux"
"go.sour.is/pkg/service"
"go.sour.is/pkg/slice"
)
var _ = apps.Register(20, func(ctx context.Context, svc *service.Harness) error {
s := &http.Server{}
svc.Add(s)
mux := mux.New()
s.Handler = cors.AllowAll().Handler(mux)
// s.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// log.Println(r.URL.Path)
// mux.ServeHTTP(w, r)
// })
s.Addr = env.Default("EV_HTTP", ":8080")
if strings.HasPrefix(s.Addr, ":") {
s.Addr = "[::]" + s.Addr
}
svc.OnStart(func(ctx context.Context) error {
_, span := lg.Span(ctx)
defer span.End()
log.Print("Listen on ", s.Addr)
span.AddEvent("begin listen and serve on " + s.Addr)
mux.Add(slice.FilterType[interface{ RegisterHTTP(*http.ServeMux) }](svc.Services...)...)
return s.ListenAndServe()
})
svc.OnStop(s.Shutdown)
return nil
})