chore: add mercury
This commit is contained in:
parent
b1cc2af8d8
commit
87ec157e5a
GPG Key ID:
8B3B0604F164E04F
23
.vscode/launch.json
vendored
Normal file
23
.vscode/launch.json
vendored
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
{
|
||||
// Use IntelliSense to learn about possible attributes.
|
||||
// Hover to view descriptions of existing attributes.
|
||||
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
|
||||
"version": "0.2.0",
|
||||
"configurations": [
|
||||
{
|
||||
"name": "Launch Package",
|
||||
"type": "go",
|
||||
"request": "launch",
|
||||
"mode": "auto",
|
||||
"program": "${fileDirname}",
|
||||
"cwd": "${workspaceFolder}"
|
||||
},
|
||||
{
|
||||
"name": "Attach to Process",
|
||||
"type": "go",
|
||||
"request": "attach",
|
||||
"mode": "local",
|
||||
"processId": 0
|
||||
}
|
||||
]
|
||||
}
|
||||
97
cmd/mercury/app.mercury.go
Normal file
97
cmd/mercury/app.mercury.go
Normal file
|
|
@ -0,0 +1,97 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"strings"
|
||||
|
||||
_ "github.com/lib/pq"
|
||||
|
||||
"go.sour.is/pkg/lg"
|
||||
"go.sour.is/pkg/mercury/app"
|
||||
"go.sour.is/pkg/mercury/http"
|
||||
"go.sour.is/pkg/mercury/mqtt"
|
||||
"go.sour.is/pkg/mercury/pg"
|
||||
"go.sour.is/pkg/service"
|
||||
"go.sour.is/pkg/xdg"
|
||||
|
||||
"go.sour.is/pkg/mercury"
|
||||
)
|
||||
var baseConfig = `
|
||||
# mercury.source [handler] [name]
|
||||
#@mercury.source.http-notify.default
|
||||
|
||||
#match :0 *
|
||||
#endpoint :http://example.com/webhook
|
||||
@mercury.source.http-notify.default
|
||||
|
||||
#@mercury.source.mqtt-notify.default
|
||||
#match :0 *
|
||||
#endpoint :mqtt://example.com/topic
|
||||
@mercury.source.http-notify.default
|
||||
|
||||
@mercury.source.mercury-default.default
|
||||
match :1 mercury
|
||||
|
||||
@mercury.source.mercury-environ.default
|
||||
match :1 mercury.host,mercury.environ,mercury.priority,mercury.source.*
|
||||
`
|
||||
|
||||
var _ = apps.Register(50, func(ctx context.Context, svc *service.Harness) error {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
conf, err := readConfig(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
app.Register(conf)
|
||||
http.Register()
|
||||
mqtt.Register()
|
||||
pg.Register()
|
||||
|
||||
err = mercury.Registry.Configure(conf)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
span.AddEvent("Enable Mercury")
|
||||
svc.Add(mercury.NewHTTP())
|
||||
|
||||
return nil
|
||||
})
|
||||
|
||||
func readConfig(ctx context.Context) (mercury.SpaceMap, error) {
|
||||
_, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
conf, err := mercury.ParseText(strings.NewReader(baseConfig))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
wd, err := os.Getwd()
|
||||
if err != err {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
for _, fn := range xdg.Find(wd+":"+xdg.EnvConfigDirs, "config.mercury") {
|
||||
span.AddEvent(fmt.Sprint("config:", fn))
|
||||
|
||||
fd, err := os.Open(fn)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer fd.Close()
|
||||
|
||||
c, err := mercury.ParseText(fd)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
conf.MergeMap(c)
|
||||
}
|
||||
|
||||
return conf, nil
|
||||
}
|
||||
44
cmd/mercury/main.go
Normal file
44
cmd/mercury/main.go
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
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{}
|
||||
os.Setenv("TRACE_ENDPOINT", "atombox:4318")
|
||||
os.Setenv("EV_TRACE_SAMPLE", "always")
|
||||
ctx, stop := lg.Init(ctx, appName+"-mercury")
|
||||
svc.OnStop(stop)
|
||||
|
||||
svc.Add(lg.NewHTTP(ctx))
|
||||
svc.Setup(ctx, apps.Apps()...)
|
||||
|
||||
// Run application
|
||||
if err := svc.Run(ctx, appName+"-mercury", version); err != nil && !errors.Is(err, http.ErrServerClosed) {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
47
cmd/mercury/svc.http.go
Normal file
47
cmd/mercury/svc.http.go
Normal 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", ":4088")
|
||||
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
|
||||
})
|
||||
24
config.mercury
Normal file
24
config.mercury
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
# mercury.source [handler] [name]
|
||||
@mercury.source.sql.local
|
||||
# match [priority] [pattern...]
|
||||
match :100 *
|
||||
dbtype :postgres
|
||||
user :mercury_user
|
||||
password :exception-reflection-pool-harvest
|
||||
dbname :mercury
|
||||
search_path :public
|
||||
host :localhost
|
||||
port :5432
|
||||
sslmode :disable
|
||||
|
||||
@mercury.source.sql.remote
|
||||
# match [priority] [pattern...]
|
||||
match :200 *
|
||||
dbtype :postgres
|
||||
user :phoenix_user
|
||||
password :exception-reflection-pool-harvest
|
||||
dbname :sourisdb
|
||||
search_path :phoenix
|
||||
host :172.22.141.171
|
||||
port :5432
|
||||
sslmode :disable
|
||||
11
go.mod
11
go.mod
|
|
@ -22,6 +22,8 @@ require (
|
|||
github.com/cespare/xxhash/v2 v2.2.0 // indirect
|
||||
github.com/felixge/httpsnoop v1.0.3 // indirect
|
||||
github.com/hashicorp/golang-lru/v2 v2.0.3 // indirect
|
||||
github.com/lann/builder v0.0.0-20180802200727-47ae307949d0 // indirect
|
||||
github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0 // indirect
|
||||
github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
|
||||
github.com/mitchellh/mapstructure v1.5.0 // indirect
|
||||
github.com/prometheus/client_model v0.4.1-0.20230718164431-9a2bf3000d16 // indirect
|
||||
|
|
@ -33,12 +35,18 @@ require (
|
|||
)
|
||||
|
||||
require (
|
||||
github.com/BurntSushi/toml v1.3.2
|
||||
github.com/Masterminds/squirrel v1.5.4
|
||||
github.com/cenkalti/backoff/v4 v4.2.1 // indirect
|
||||
github.com/go-logr/logr v1.2.4 // indirect
|
||||
github.com/go-logr/stdr v1.2.2 // indirect
|
||||
github.com/golang/gddo v0.0.0-20210115222349-20d68f94ee1f
|
||||
github.com/golang/protobuf v1.5.3 // indirect
|
||||
github.com/grpc-ecosystem/grpc-gateway/v2 v2.16.0 // indirect
|
||||
github.com/lib/pq v1.10.9
|
||||
github.com/prometheus/client_golang v1.17.0
|
||||
github.com/rs/cors v1.10.1
|
||||
go.nhat.io/otelsql v0.12.0
|
||||
go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.44.0
|
||||
go.opentelemetry.io/contrib/instrumentation/runtime v0.42.0
|
||||
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.18.0 // indirect
|
||||
|
|
@ -47,9 +55,10 @@ require (
|
|||
go.opentelemetry.io/otel/sdk v1.18.0
|
||||
go.opentelemetry.io/otel/trace v1.18.0
|
||||
go.opentelemetry.io/proto/otlp v1.0.0 // indirect
|
||||
golang.org/x/exp v0.0.0-20240112132812-db7319d0e0e3
|
||||
golang.org/x/net v0.17.0 // indirect
|
||||
golang.org/x/sys v0.13.0 // indirect
|
||||
golang.org/x/text v0.13.0 // indirect
|
||||
google.golang.org/grpc v1.58.0 // indirect
|
||||
google.golang.org/grpc v1.58.3 // indirect
|
||||
google.golang.org/protobuf v1.31.0 // indirect
|
||||
)
|
||||
|
|
|
|||
59
go.sum
59
go.sum
|
|
@ -1,5 +1,11 @@
|
|||
cloud.google.com/go v0.16.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
|
||||
github.com/99designs/gqlgen v0.17.34 h1:5cS5/OKFguQt+Ws56uj9FlG2xm1IlcJWNF2jrMIKYFQ=
|
||||
github.com/99designs/gqlgen v0.17.34/go.mod h1:Axcd3jIFHBVcqzixujJQr1wGqE+lGTpz6u4iZBZg1G8=
|
||||
github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
|
||||
github.com/BurntSushi/toml v1.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8=
|
||||
github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
|
||||
github.com/Masterminds/squirrel v1.5.4 h1:uUcX/aBc8O7Fg9kaISIUsHXdKuqehiXAMQTYX8afzqM=
|
||||
github.com/Masterminds/squirrel v1.5.4/go.mod h1:NNaOrjSoIDfDA40n7sr2tPNZRfjzjA400rg+riTZj10=
|
||||
github.com/agnivade/levenshtein v1.1.1 h1:QY8M92nrzkmr798gCo3kmMyqXFzdQVpxLlGPRBij0P8=
|
||||
github.com/agnivade/levenshtein v1.1.1/go.mod h1:veldBMzWxcCG2ZvUTKD2kJNRdCk5hVbJomOvKkmgYbo=
|
||||
github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883 h1:bvNMNQO63//z+xNgfBlViaCIJKLlCJ6/fmUseuG0wVQ=
|
||||
|
|
@ -8,6 +14,7 @@ github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0 h1:jfIu9sQUG6Ig
|
|||
github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0/go.mod h1:t2tdKJDJF9BV14lnkjHmOQgcvEKgtqs5a1N3LNdJhGE=
|
||||
github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
|
||||
github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
|
||||
github.com/bradfitz/gomemcache v0.0.0-20170208213004-1952afaa557d/go.mod h1:PmM6Mmwb0LSuEubjR8N7PtNe1KxZLtOUHtbeikc5h60=
|
||||
github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM=
|
||||
github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
|
||||
github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
|
||||
|
|
@ -19,35 +26,60 @@ github.com/dgryski/trifles v0.0.0-20200323201526-dd97f9abfb48 h1:fRzb/w+pyskVMQ+
|
|||
github.com/dgryski/trifles v0.0.0-20200323201526-dd97f9abfb48/go.mod h1:if7Fbed8SFyPtHLHbg49SI7NAdJiC5WIA09pe59rfAA=
|
||||
github.com/felixge/httpsnoop v1.0.3 h1:s/nj+GCswXYzN5v2DpNMuMQYe+0DDwt5WVCU6CWBdXk=
|
||||
github.com/felixge/httpsnoop v1.0.3/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
|
||||
github.com/fsnotify/fsnotify v1.4.3-0.20170329110642-4da3e2cfbabc/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
|
||||
github.com/garyburd/redigo v1.1.1-0.20170914051019-70e1b1943d4f/go.mod h1:NR3MbYisc3/PwhQ00EMzDiPmrwpPxAn5GI05/YaO1SY=
|
||||
github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
|
||||
github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ=
|
||||
github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
|
||||
github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
|
||||
github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
|
||||
github.com/go-stack/stack v1.6.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
|
||||
github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg=
|
||||
github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
|
||||
github.com/golang/gddo v0.0.0-20210115222349-20d68f94ee1f h1:16RtHeWGkJMc80Etb8RPCcKevXGldr57+LOyZt8zOlg=
|
||||
github.com/golang/gddo v0.0.0-20210115222349-20d68f94ee1f/go.mod h1:ijRvpgDJDI262hYq/IQVYgf8hd8IHUs93Ol0kvMBAx4=
|
||||
github.com/golang/glog v1.1.0 h1:/d3pCKDPWNnvIWe0vVUpNP32qc8U3PDVxySP/y360qE=
|
||||
github.com/golang/lint v0.0.0-20170918230701-e5d664eb928e/go.mod h1:tluoj9z5200jBnyusfRPU2LqT6J+DAorxEvtC7LHB+E=
|
||||
github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
|
||||
github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
|
||||
github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
|
||||
github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
|
||||
github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
|
||||
github.com/golang/snappy v0.0.0-20170215233205-553a64147049/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
|
||||
github.com/google/go-cmp v0.1.1-0.20171103154506-982329095285/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
|
||||
github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
|
||||
github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
|
||||
github.com/googleapis/gax-go v2.0.0+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
|
||||
github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
|
||||
github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
|
||||
github.com/gregjones/httpcache v0.0.0-20170920190843-316c5e0ff04e/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
|
||||
github.com/grpc-ecosystem/grpc-gateway/v2 v2.16.0 h1:YBftPWNWd4WwGqtY2yeZL2ef8rHAxPBD8KFhJpmcqms=
|
||||
github.com/grpc-ecosystem/grpc-gateway/v2 v2.16.0/go.mod h1:YN5jB8ie0yfIUg6VvR9Kz84aCaG7AsGZnLjhHbUqwPg=
|
||||
github.com/hashicorp/golang-lru/v2 v2.0.3 h1:kmRrRLlInXvng0SmLxmQpQkpbYAvcXm7NPDrgxJa9mE=
|
||||
github.com/hashicorp/golang-lru/v2 v2.0.3/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
|
||||
github.com/hashicorp/hcl v0.0.0-20170914154624-68e816d1c783/go.mod h1:oZtUIOe8dh44I2q6ScRibXws4Ajl+d+nod3AaR9vL5w=
|
||||
github.com/inconshreveable/log15 v0.0.0-20170622235902-74a0988b5f80/go.mod h1:cOaXtrgN4ScfRrD9Bre7U1thNq5RtJ8ZoP4iXVGRj6o=
|
||||
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
|
||||
github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
|
||||
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
|
||||
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
|
||||
github.com/lann/builder v0.0.0-20180802200727-47ae307949d0 h1:SOEGU9fKiNWd/HOJuq6+3iTQz8KNCLtVX6idSoTLdUw=
|
||||
github.com/lann/builder v0.0.0-20180802200727-47ae307949d0/go.mod h1:dXGbAdH5GtBTC4WfIxhKZfyBF/HBFgRZSWwZ9g/He9o=
|
||||
github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0 h1:P6pPBnrTSX3DEVR4fDembhRWSsG5rVo6hYhAB/ADZrk=
|
||||
github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0/go.mod h1:vmVJ0l/dxyfGW6FmdpVm2joNMFikkuWg0EoCKLGUMNw=
|
||||
github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
|
||||
github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
|
||||
github.com/magiconair/properties v1.7.4-0.20170902060319-8d7837e64d3c/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
|
||||
github.com/matryer/is v1.4.1 h1:55ehd8zaGABKLXQUe2awZ99BD/PTc2ls+KV/dXphgEQ=
|
||||
github.com/matryer/is v1.4.1/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU=
|
||||
github.com/mattn/go-colorable v0.0.10-0.20170816031813-ad5389df28cd/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
|
||||
github.com/mattn/go-isatty v0.0.2/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
|
||||
github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo=
|
||||
github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
|
||||
github.com/mitchellh/mapstructure v0.0.0-20170523030023-d0303fe80992/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
|
||||
github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
|
||||
github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
|
||||
github.com/pelletier/go-toml v1.0.1-0.20170904195809-1d6b12b7cb29/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
|
||||
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
|
||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||
github.com/prometheus/client_golang v1.17.0 h1:rl2sfwZMtSthVU752MqfjQozy7blglC+1SOtjMAMh+Q=
|
||||
|
|
@ -60,13 +92,23 @@ github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k
|
|||
github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo=
|
||||
github.com/ravilushqa/otelgqlgen v0.13.1 h1:V+zFE75iDd2/CSzy5kKnb+Fi09SsE5535wv9U2nUEFE=
|
||||
github.com/ravilushqa/otelgqlgen v0.13.1/go.mod h1:ZIyWykK2paCuNi9k8gk5edcNSwDJuxZaW90vZXpafxw=
|
||||
github.com/rs/cors v1.10.1 h1:L0uuZVXIKlI1SShY2nhFfo44TYvDPQ1w4oFkUJNfhyo=
|
||||
github.com/rs/cors v1.10.1/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU=
|
||||
github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
|
||||
github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
|
||||
github.com/spf13/afero v0.0.0-20170901052352-ee1bd8ee15a1/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
|
||||
github.com/spf13/cast v1.1.0/go.mod h1:r2rcYCSwa1IExKTDiTfzaxqT2FNHs8hODu4LnUfgKEg=
|
||||
github.com/spf13/jwalterweatherman v0.0.0-20170901151539-12bd96e66386/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
|
||||
github.com/spf13/pflag v1.0.1-0.20170901120850-7aff26db30c1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
|
||||
github.com/spf13/viper v1.0.0/go.mod h1:A8kyI5cUJhb8N+3pkfONlcEcZbueH6nhAm0Fq7SrnBM=
|
||||
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
|
||||
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
|
||||
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
|
||||
github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
|
||||
github.com/vektah/gqlparser/v2 v2.5.6 h1:Ou14T0N1s191eRMZ1gARVqohcbe1e8FrcONScsq8cRU=
|
||||
github.com/vektah/gqlparser/v2 v2.5.6/go.mod h1:z8xXUff237NntSuH8mLFijZ+1tjV1swDbpDqjJmk6ME=
|
||||
go.nhat.io/otelsql v0.12.0 h1:/rBhWZiwHFLpCm5SGdafm+Owm0OmGmnF31XWxgecFtY=
|
||||
go.nhat.io/otelsql v0.12.0/go.mod h1:39Hc9/JDfCl7NGrBi1uPP3QPofqwnC/i5SFd7gtDMWM=
|
||||
go.opentelemetry.io/contrib v1.16.1 h1:EpASvVyGx6/ZTlmXzxYfTMZxHROelCeXXa2uLiwltcs=
|
||||
go.opentelemetry.io/contrib v1.16.1/go.mod h1:gIzjwWFoGazJmtCaDgViqOSJPde2mCWzv60o0bWPcZs=
|
||||
go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.44.0 h1:KfYpVmrjI7JuToy5k8XV3nkapjWx48k4E4JOtVstzQI=
|
||||
|
|
@ -93,23 +135,40 @@ go.opentelemetry.io/proto/otlp v1.0.0 h1:T0TX0tmXU8a3CbNXzEKGeU5mIVOdf0oykP+u2lI
|
|||
go.opentelemetry.io/proto/otlp v1.0.0/go.mod h1:Sy6pihPLfYHkr3NkUbEhGHFhINUSI/v80hjKIs5JXpM=
|
||||
go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
|
||||
go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
|
||||
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
|
||||
golang.org/x/exp v0.0.0-20240112132812-db7319d0e0e3 h1:hNQpMuAJe5CtcUqCXaWga3FHu+kQvCqcsoVaQgSV60o=
|
||||
golang.org/x/exp v0.0.0-20240112132812-db7319d0e0e3/go.mod h1:idGWGoKP1toJGkd5/ig9ZLuPcZBC3ewk7SzmH0uou08=
|
||||
golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
|
||||
golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
|
||||
golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
|
||||
golang.org/x/oauth2 v0.0.0-20170912212905-13449ad91cb2/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
|
||||
golang.org/x/sync v0.0.0-20170517211232-f52d1811a629/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
|
||||
golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
|
||||
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
||||
golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE=
|
||||
golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
|
||||
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
|
||||
golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
|
||||
golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
|
||||
golang.org/x/time v0.0.0-20170424234030-8be79e1e0910/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
|
||||
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
|
||||
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
|
||||
google.golang.org/api v0.0.0-20170921000349-586095a6e407/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
|
||||
google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
|
||||
google.golang.org/genproto v0.0.0-20170918111702-1e559d0a00ee/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
|
||||
google.golang.org/genproto v0.0.0-20230711160842-782d3b101e98 h1:Z0hjGZePRE0ZBWotvtrwxFNrNE9CUAGtplaDK5NNI/g=
|
||||
google.golang.org/genproto/googleapis/api v0.0.0-20230711160842-782d3b101e98 h1:FmF5cCW94Ij59cfpoLiwTgodWmm60eEV0CjlsVg2fuw=
|
||||
google.golang.org/genproto/googleapis/api v0.0.0-20230711160842-782d3b101e98/go.mod h1:rsr7RhLuwsDKL7RmgDDCUc6yaGr1iqceVb5Wv6f6YvQ=
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20230711160842-782d3b101e98 h1:bVf09lpb+OJbByTj913DRJioFFAjf/ZGxEz7MajTp2U=
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20230711160842-782d3b101e98/go.mod h1:TUfxEVdsvPg18p6AslUXFoLdpED4oBnGwyqk3dV1XzM=
|
||||
google.golang.org/grpc v1.2.1-0.20170921194603-d4b75ebd4f9f/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
|
||||
google.golang.org/grpc v1.58.0 h1:32JY8YpPMSR45K+c3o6b8VL73V+rR8k+DeMIr4vRH8o=
|
||||
google.golang.org/grpc v1.58.0/go.mod h1:tgX3ZQDlNJGU96V6yHh1T/JeoBQ2TXdr43YbYSsCJk0=
|
||||
google.golang.org/grpc v1.58.3 h1:BjnpXut1btbtgN/6sp+brB2Kbm2LjNXnidYujAVbSoQ=
|
||||
google.golang.org/grpc v1.58.3/go.mod h1:tgX3ZQDlNJGU96V6yHh1T/JeoBQ2TXdr43YbYSsCJk0=
|
||||
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
|
||||
google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
|
||||
google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
|
||||
|
|
|
|||
157
mercury/app/app_test.go
Normal file
157
mercury/app/app_test.go
Normal file
|
|
@ -0,0 +1,157 @@
|
|||
package app
|
||||
|
||||
import (
|
||||
"context"
|
||||
"reflect"
|
||||
"testing"
|
||||
|
||||
"go.sour.is/pkg/mercury"
|
||||
)
|
||||
|
||||
type mockUser struct {
|
||||
active bool
|
||||
roles map[string]struct{}
|
||||
}
|
||||
|
||||
func (m mockUser) GetIdentity() string { return "user" }
|
||||
func (m mockUser) IsActive() bool { return m.active }
|
||||
func (m mockUser) HasRole(roles ...string) bool {
|
||||
var found bool
|
||||
for _, role := range roles {
|
||||
if _, ok := m.roles[role]; ok {
|
||||
found = true
|
||||
}
|
||||
}
|
||||
|
||||
return found
|
||||
}
|
||||
|
||||
func Test_appConfig_GetRules(t *testing.T) {
|
||||
type args struct {
|
||||
u mercury.Ident
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
args args
|
||||
wantLis mercury.Rules
|
||||
}{
|
||||
{"normal", args{mockUser{}}, nil},
|
||||
{
|
||||
"admin",
|
||||
args{
|
||||
mockUser{
|
||||
active: true,
|
||||
roles: map[string]struct{}{"admin": {}},
|
||||
},
|
||||
},
|
||||
mercury.Rules{
|
||||
mercury.Rule{
|
||||
Role: "read",
|
||||
Type: "NS",
|
||||
Match: "mercury.source.*",
|
||||
},
|
||||
mercury.Rule{
|
||||
Role: "read",
|
||||
Type: "NS",
|
||||
Match: "mercury.priority",
|
||||
},
|
||||
mercury.Rule{
|
||||
Role: "read",
|
||||
Type: "NS",
|
||||
Match: "mercury.host",
|
||||
},
|
||||
mercury.Rule{
|
||||
Role: "read",
|
||||
Type: "NS",
|
||||
Match: "mercury.environ",
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
a := mercuryEnviron{}
|
||||
if gotLis, _ := a.GetRules(context.TODO(), tt.args.u); !reflect.DeepEqual(gotLis, tt.wantLis) {
|
||||
t.Errorf("appConfig.GetRules() = %v, want %v", gotLis, tt.wantLis)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// func Test_appConfig_GetIndex(t *testing.T) {
|
||||
// type args struct {
|
||||
// search mercury.NamespaceSearch
|
||||
// in1 *rsql.Program
|
||||
// }
|
||||
// tests := []struct {
|
||||
// name string
|
||||
// args args
|
||||
// wantLis mercury.Config
|
||||
// }{
|
||||
// {"nil", args{
|
||||
// nil,
|
||||
// nil,
|
||||
// }, nil},
|
||||
|
||||
// {"app.settings", args{
|
||||
// mercury.ParseNamespace("app.settings"),
|
||||
// nil,
|
||||
// }, mercury.Config{&mercury.Space{Space: "app.settings"}}},
|
||||
// }
|
||||
// for _, tt := range tests {
|
||||
// t.Run(tt.name, func(t *testing.T) {
|
||||
// a := mercuryEnviron{}
|
||||
// if gotLis, _ := a.GetIndex(tt.args.search, tt.args.in1); !reflect.DeepEqual(gotLis, tt.wantLis) {
|
||||
// t.Errorf("appConfig.GetIndex() = %#v, want %#v", gotLis, tt.wantLis)
|
||||
// }
|
||||
// })
|
||||
// }
|
||||
// }
|
||||
|
||||
// func Test_appConfig_GetObjects(t *testing.T) {
|
||||
// cfg, err := mercury.ParseText(strings.NewReader(`
|
||||
// @mercury.source.mercury-settings.default
|
||||
// match :0 *
|
||||
// `))
|
||||
|
||||
// type args struct {
|
||||
// search mercury.NamespaceSearch
|
||||
// in1 *rsql.Program
|
||||
// in2 []string
|
||||
// }
|
||||
// tests := []struct {
|
||||
// name string
|
||||
// args args
|
||||
// wantLis mercury.Config
|
||||
// }{
|
||||
// {"nil", args{
|
||||
// nil,
|
||||
// nil,
|
||||
// nil,
|
||||
// }, nil},
|
||||
|
||||
// {"app.settings", args{
|
||||
// mercury.ParseNamespace("app.settings"),
|
||||
// nil,
|
||||
// nil,
|
||||
// }, mercury.Config{
|
||||
// &mercury.Space{
|
||||
// Space: "app.settings",
|
||||
// List: []mercury.Value{{
|
||||
// Space: "app.settings",
|
||||
// Name: "app.setting",
|
||||
// Values: []string{"TRUE"}},
|
||||
// },
|
||||
// },
|
||||
// }},
|
||||
// }
|
||||
// for _, tt := range tests {
|
||||
// cfg, err :=
|
||||
// t.Run(tt.name, func(t *testing.T) {
|
||||
// a := appConfig{cfg: }
|
||||
// if gotLis, _ := a.GetConfig(tt.args.search, tt.args.in1, tt.args.in2); !reflect.DeepEqual(gotLis, tt.wantLis) {
|
||||
// t.Errorf("appConfig.GetIndex() = %#v, want %#v", gotLis, tt.wantLis)
|
||||
// }
|
||||
// })
|
||||
// }
|
||||
// }
|
||||
63
mercury/app/default-rules.go
Normal file
63
mercury/app/default-rules.go
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
package app
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"go.sour.is/pkg/mercury"
|
||||
)
|
||||
|
||||
type mercuryDefault struct{}
|
||||
|
||||
var (
|
||||
_ mercury.GetRules = (*mercuryDefault)(nil)
|
||||
|
||||
_ mercury.GetIndex = (*mercuryEnviron)(nil)
|
||||
_ mercury.GetConfig = (*mercuryEnviron)(nil)
|
||||
_ mercury.GetRules = (*mercuryEnviron)(nil)
|
||||
)
|
||||
|
||||
// GetRules returns default rules for user role.
|
||||
func (mercuryDefault) GetRules(ctx context.Context, i mercury.Ident) (lis mercury.Rules, err error) {
|
||||
u, ok := i.(hasRole)
|
||||
if !ok {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
if u.HasRole("admin") {
|
||||
lis = append(lis,
|
||||
mercury.Rule{
|
||||
Role: "admin",
|
||||
Type: "NS",
|
||||
Match: "*",
|
||||
},
|
||||
mercury.Rule{
|
||||
Role: "write",
|
||||
Type: "NS",
|
||||
Match: "*",
|
||||
},
|
||||
mercury.Rule{
|
||||
Role: "admin",
|
||||
Type: "GR",
|
||||
Match: "*",
|
||||
},
|
||||
)
|
||||
} else if u.HasRole("write") {
|
||||
lis = append(lis,
|
||||
mercury.Rule{
|
||||
Role: "write",
|
||||
Type: "NS",
|
||||
Match: "*",
|
||||
},
|
||||
)
|
||||
} else if u.HasRole("read") {
|
||||
lis = append(lis,
|
||||
mercury.Rule{
|
||||
Role: "read",
|
||||
Type: "NS",
|
||||
Match: "*",
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
return lis, nil
|
||||
}
|
||||
225
mercury/app/environ.go
Normal file
225
mercury/app/environ.go
Normal file
|
|
@ -0,0 +1,225 @@
|
|||
package app
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/user"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"go.sour.is/pkg/mercury"
|
||||
"go.sour.is/pkg/rsql"
|
||||
)
|
||||
|
||||
const (
|
||||
mercurySource = "mercury.source.*"
|
||||
mercuryPriority = "mercury.priority"
|
||||
mercuryHost = "mercury.host"
|
||||
appDotEnviron = "mercury.environ"
|
||||
)
|
||||
|
||||
func Register(cfg mercury.SpaceMap) {
|
||||
for _, c := range cfg {
|
||||
c.Tags = append(c.Tags, "RO")
|
||||
}
|
||||
mercury.Registry.Register("mercury-default", func(s *mercury.Space) any { return &mercuryDefault{} })
|
||||
mercury.Registry.Register("mercury-environ", func(s *mercury.Space) any { return &mercuryEnviron{cfg: cfg} })
|
||||
}
|
||||
|
||||
type hasRole interface {
|
||||
HasRole(r ...string) bool
|
||||
}
|
||||
|
||||
type mercuryEnviron struct {
|
||||
cfg mercury.SpaceMap
|
||||
}
|
||||
|
||||
// Index returns nil
|
||||
func (app *mercuryEnviron) GetIndex(ctx context.Context, search mercury.NamespaceSearch, _ *rsql.Program) (lis mercury.Config, err error) {
|
||||
|
||||
if search.Match(mercurySource) {
|
||||
for _, s := range app.cfg.ToArray() {
|
||||
if search.Match(s.Space) {
|
||||
lis = append(lis, &mercury.Space{Space: s.Space, Tags: []string{"RO"}})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if search.Match(mercuryPriority) {
|
||||
lis = append(lis, &mercury.Space{Space: mercuryPriority, Tags: []string{"RO"}})
|
||||
}
|
||||
|
||||
if search.Match(mercuryHost) {
|
||||
lis = append(lis, &mercury.Space{Space: mercuryHost, Tags: []string{"RO"}})
|
||||
}
|
||||
|
||||
if search.Match(appDotEnviron) {
|
||||
lis = append(lis, &mercury.Space{Space: appDotEnviron, Tags: []string{"RO"}})
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// Objects returns nil
|
||||
func (app *mercuryEnviron) GetConfig(ctx context.Context, search mercury.NamespaceSearch, _ *rsql.Program, _ []string) (lis mercury.Config, err error) {
|
||||
if search.Match(mercurySource) {
|
||||
for _, s := range app.cfg.ToArray() {
|
||||
if search.Match(s.Space) {
|
||||
lis = append(lis, s)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if search.Match(mercuryPriority) {
|
||||
space := mercury.Space{
|
||||
Space: mercuryPriority,
|
||||
Tags: []string{"RO"},
|
||||
}
|
||||
|
||||
// for i, key := range mercury.Registry {
|
||||
// space.List = append(space.List, mercury.Value{
|
||||
// Space: appDotPriority,
|
||||
// Seq: uint64(i),
|
||||
// Name: key.Match,
|
||||
// Values: []string{fmt.Sprint(key.Priority)},
|
||||
// })
|
||||
// }
|
||||
|
||||
lis = append(lis, &space)
|
||||
}
|
||||
|
||||
if search.Match(mercuryHost) {
|
||||
if usr, err := user.Current(); err == nil {
|
||||
space := mercury.Space{
|
||||
Space: mercuryHost,
|
||||
Tags: []string{"RO"},
|
||||
}
|
||||
|
||||
hostname, _ := os.Hostname()
|
||||
wd, _ := os.Getwd()
|
||||
grp, _ := usr.GroupIds()
|
||||
space.List = []mercury.Value{
|
||||
{
|
||||
Space: mercuryHost,
|
||||
Seq: 1,
|
||||
Name: "hostname",
|
||||
Values: []string{hostname},
|
||||
},
|
||||
{
|
||||
Space: mercuryHost,
|
||||
Seq: 2,
|
||||
Name: "username",
|
||||
Values: []string{usr.Username},
|
||||
},
|
||||
{
|
||||
Space: mercuryHost,
|
||||
Seq: 3,
|
||||
Name: "uid",
|
||||
Values: []string{usr.Uid},
|
||||
},
|
||||
{
|
||||
Space: mercuryHost,
|
||||
Seq: 4,
|
||||
Name: "gid",
|
||||
Values: []string{usr.Gid},
|
||||
},
|
||||
{
|
||||
Space: mercuryHost,
|
||||
Seq: 5,
|
||||
Name: "display",
|
||||
Values: []string{usr.Name},
|
||||
},
|
||||
{
|
||||
Space: mercuryHost,
|
||||
Seq: 6,
|
||||
Name: "home",
|
||||
Values: []string{usr.HomeDir},
|
||||
},
|
||||
{
|
||||
Space: mercuryHost,
|
||||
Seq: 7,
|
||||
Name: "groups",
|
||||
Values: grp,
|
||||
},
|
||||
{
|
||||
Space: mercuryHost,
|
||||
Seq: 8,
|
||||
Name: "pid",
|
||||
Values: []string{fmt.Sprintf("%v", os.Getpid())},
|
||||
},
|
||||
{
|
||||
Space: mercuryHost,
|
||||
Seq: 9,
|
||||
Name: "wd",
|
||||
Values: []string{wd},
|
||||
},
|
||||
}
|
||||
|
||||
lis = append(lis, &space)
|
||||
}
|
||||
}
|
||||
|
||||
if search.Match(appDotEnviron) {
|
||||
env := os.Environ()
|
||||
space := mercury.Space{
|
||||
Space: appDotEnviron,
|
||||
Tags: []string{"RO"},
|
||||
}
|
||||
|
||||
sort.Strings(env)
|
||||
for i, s := range env {
|
||||
key, val, _ := strings.Cut(s, "=")
|
||||
|
||||
vals := []string{val}
|
||||
if strings.Contains(key, "PATH") || strings.Contains(key, "XDG") {
|
||||
vals = strings.Split(val, ":")
|
||||
}
|
||||
|
||||
space.List = append(space.List, mercury.Value{
|
||||
Space: appDotEnviron,
|
||||
Seq: uint64(i),
|
||||
Name: key,
|
||||
Values: vals,
|
||||
})
|
||||
}
|
||||
lis = append(lis, &space)
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// Rules returns nil
|
||||
func (mercuryEnviron) GetRules(ctx context.Context, id mercury.Ident) (lis mercury.Rules, err error) {
|
||||
u, ok := id.(hasRole)
|
||||
if !ok {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
if u.HasRole("admin") {
|
||||
lis = append(lis,
|
||||
mercury.Rule{
|
||||
Role: "read",
|
||||
Type: "NS",
|
||||
Match: mercurySource,
|
||||
},
|
||||
mercury.Rule{
|
||||
Role: "read",
|
||||
Type: "NS",
|
||||
Match: mercuryPriority,
|
||||
},
|
||||
mercury.Rule{
|
||||
Role: "read",
|
||||
Type: "NS",
|
||||
Match: mercuryHost,
|
||||
},
|
||||
mercury.Rule{
|
||||
Role: "read",
|
||||
Type: "NS",
|
||||
Match: appDotEnviron,
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
return lis, nil
|
||||
}
|
||||
63
mercury/http/notify.go
Normal file
63
mercury/http/notify.go
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
package http
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/tls"
|
||||
"crypto/x509"
|
||||
"fmt"
|
||||
"net/http"
|
||||
|
||||
"go.sour.is/pkg/lg"
|
||||
"go.sour.is/pkg/mercury"
|
||||
)
|
||||
|
||||
type httpNotify struct{}
|
||||
|
||||
func (httpNotify) SendNotify(ctx context.Context, n mercury.Notify) error {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
cl := &http.Client{}
|
||||
caCertPool, err := x509.SystemCertPool()
|
||||
if err != nil {
|
||||
caCertPool = x509.NewCertPool()
|
||||
}
|
||||
|
||||
// Setup HTTPS client
|
||||
tlsConfig := &tls.Config{
|
||||
RootCAs: caCertPool,
|
||||
}
|
||||
|
||||
transport := &http.Transport{TLSClientConfig: tlsConfig}
|
||||
|
||||
cl.Transport = transport
|
||||
|
||||
var req *http.Request
|
||||
req, err = http.NewRequestWithContext(ctx, n.Method, n.URL, bytes.NewBufferString(""))
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
return err
|
||||
}
|
||||
req.Header.Set("content-type", "application/json")
|
||||
|
||||
span.AddEvent(fmt.Sprint("URL: ", n.URL))
|
||||
res, err := cl.Do(req)
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
return err
|
||||
}
|
||||
res.Body.Close()
|
||||
span.AddEvent(fmt.Sprint(res.Status))
|
||||
if res.StatusCode != 200 {
|
||||
span.RecordError(err)
|
||||
err = fmt.Errorf("unable to read config")
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func Register() {
|
||||
mercury.Registry.Register("http-notify", func(s *mercury.Space) any { return httpNotify{} })
|
||||
}
|
||||
616
mercury/mercury.go
Normal file
616
mercury/mercury.go
Normal file
|
|
@ -0,0 +1,616 @@
|
|||
package mercury
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"golang.org/x/exp/maps"
|
||||
)
|
||||
|
||||
type Config []*Space
|
||||
|
||||
func NewConfig(spaces ...*Space) Config {
|
||||
return spaces
|
||||
}
|
||||
func (c *Config) AddSpace(spaces ...*Space) *Config {
|
||||
*c = append(*c, spaces...)
|
||||
return c
|
||||
}
|
||||
|
||||
// Len implements Len for sort.interface
|
||||
func (lis Config) Len() int {
|
||||
return len(lis)
|
||||
}
|
||||
|
||||
// Less implements Less for sort.interface
|
||||
func (lis Config) Less(i, j int) bool {
|
||||
return lis[i].Space < lis[j].Space
|
||||
}
|
||||
|
||||
// Swap implements Swap for sort.interface
|
||||
func (lis Config) Swap(i, j int) { lis[i], lis[j] = lis[j], lis[i] }
|
||||
|
||||
// StringList returns the space names as a list
|
||||
func (lis Config) StringList() string {
|
||||
var buf strings.Builder
|
||||
for _, o := range lis {
|
||||
if len(o.Notes) > 0 {
|
||||
buf.WriteString("# ")
|
||||
buf.WriteString(strings.Join(o.Notes, "\n# "))
|
||||
buf.WriteRune('\n')
|
||||
}
|
||||
buf.WriteRune('@')
|
||||
buf.WriteString(o.Space)
|
||||
if len(o.Tags) > 0 {
|
||||
buf.WriteRune(' ')
|
||||
buf.WriteString(strings.Join(o.Tags, " "))
|
||||
}
|
||||
buf.WriteRune('\n')
|
||||
}
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
// ToSpaceMap formats as SpaceMap
|
||||
func (lis Config) ToSpaceMap() SpaceMap {
|
||||
out := make(SpaceMap)
|
||||
for _, c := range lis {
|
||||
out[c.Space] = c
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// String format config as string
|
||||
func (lis Config) String() string {
|
||||
attLen := 0
|
||||
tagLen := 0
|
||||
|
||||
for _, o := range lis {
|
||||
for _, v := range o.List {
|
||||
l := len(v.Name)
|
||||
if attLen <= l {
|
||||
attLen = l
|
||||
}
|
||||
|
||||
t := len(strings.Join(v.Tags, " "))
|
||||
if tagLen <= t {
|
||||
tagLen = t
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var buf strings.Builder
|
||||
for _, o := range lis {
|
||||
if len(o.Notes) > 0 {
|
||||
buf.WriteString("# ")
|
||||
buf.WriteString(strings.Join(o.Notes, "\n# "))
|
||||
buf.WriteRune('\n')
|
||||
}
|
||||
|
||||
buf.WriteRune('@')
|
||||
buf.WriteString(o.Space)
|
||||
if len(o.Tags) > 0 {
|
||||
buf.WriteRune(' ')
|
||||
buf.WriteString(strings.Join(o.Tags, " "))
|
||||
}
|
||||
buf.WriteRune('\n')
|
||||
|
||||
for _, v := range o.List {
|
||||
if len(v.Notes) > 0 {
|
||||
buf.WriteString("# ")
|
||||
buf.WriteString(strings.Join(v.Notes, "\n# "))
|
||||
buf.WriteString("\n")
|
||||
}
|
||||
|
||||
buf.WriteString(v.Name)
|
||||
buf.WriteString(strings.Repeat(" ", attLen-len(v.Name)+1))
|
||||
|
||||
if len(v.Tags) > 0 {
|
||||
t := strings.Join(v.Tags, " ")
|
||||
buf.WriteString(t)
|
||||
buf.WriteString(strings.Repeat(" ", tagLen-len(t)+1))
|
||||
} else {
|
||||
buf.WriteString(strings.Repeat(" ", tagLen+1))
|
||||
}
|
||||
|
||||
switch len(v.Values) {
|
||||
case 0:
|
||||
buf.WriteString("\n")
|
||||
case 1:
|
||||
buf.WriteString(" :")
|
||||
buf.WriteString(v.Values[0])
|
||||
buf.WriteString("\n")
|
||||
default:
|
||||
buf.WriteString(" :")
|
||||
buf.WriteString(v.Values[0])
|
||||
buf.WriteString("\n")
|
||||
for _, s := range v.Values[1:] {
|
||||
buf.WriteString(strings.Repeat(" ", attLen+tagLen+3))
|
||||
buf.WriteString(":")
|
||||
buf.WriteString(s)
|
||||
buf.WriteString("\n")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
buf.WriteRune('\n')
|
||||
}
|
||||
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
// EnvString format config as environ
|
||||
func (lis Config) EnvString() string {
|
||||
var buf strings.Builder
|
||||
for _, o := range lis {
|
||||
for _, v := range o.List {
|
||||
buf.WriteString(o.Space)
|
||||
for _, t := range o.Tags {
|
||||
buf.WriteRune(' ')
|
||||
buf.WriteString(t)
|
||||
}
|
||||
buf.WriteRune(':')
|
||||
buf.WriteString(v.Name)
|
||||
for _, t := range v.Tags {
|
||||
buf.WriteRune(' ')
|
||||
buf.WriteString(t)
|
||||
}
|
||||
switch len(v.Values) {
|
||||
case 0:
|
||||
buf.WriteRune('=')
|
||||
buf.WriteRune('\n')
|
||||
case 1:
|
||||
buf.WriteRune('=')
|
||||
buf.WriteString(v.Values[0])
|
||||
buf.WriteRune('\n')
|
||||
default:
|
||||
buf.WriteRune('+')
|
||||
buf.WriteRune('=')
|
||||
buf.WriteString(v.Values[0])
|
||||
buf.WriteRune('\n')
|
||||
for _, s := range v.Values[1:] {
|
||||
buf.WriteString(o.Space)
|
||||
buf.WriteRune(':')
|
||||
buf.WriteString(v.Name)
|
||||
buf.WriteRune('+')
|
||||
buf.WriteRune('=')
|
||||
buf.WriteString(s)
|
||||
buf.WriteRune('\n')
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
// IniString format config as ini
|
||||
func (lis Config) IniString() string {
|
||||
var buf strings.Builder
|
||||
for _, o := range lis {
|
||||
buf.WriteRune('[')
|
||||
buf.WriteString(o.Space)
|
||||
buf.WriteRune(']')
|
||||
buf.WriteRune('\n')
|
||||
for _, v := range o.List {
|
||||
buf.WriteString(v.Name)
|
||||
switch len(v.Values) {
|
||||
case 0:
|
||||
buf.WriteRune('=')
|
||||
buf.WriteRune('\n')
|
||||
case 1:
|
||||
buf.WriteRune('=')
|
||||
buf.WriteString(v.Values[0])
|
||||
buf.WriteRune('\n')
|
||||
default:
|
||||
buf.WriteRune('[')
|
||||
buf.WriteRune('0')
|
||||
buf.WriteRune(']')
|
||||
|
||||
buf.WriteRune('=')
|
||||
buf.WriteString(v.Values[0])
|
||||
buf.WriteRune('\n')
|
||||
for i, s := range v.Values[1:] {
|
||||
buf.WriteString(v.Name)
|
||||
buf.WriteRune('[')
|
||||
buf.WriteString(fmt.Sprintf("%d", i))
|
||||
buf.WriteRune(']')
|
||||
buf.WriteRune('=')
|
||||
buf.WriteString(s)
|
||||
buf.WriteRune('\n')
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
// Space stores a registry of spaces
|
||||
type Space struct {
|
||||
Space string `json:"space"`
|
||||
Tags []string `json:"tags,omitempty"`
|
||||
Notes []string `json:"notes,omitempty"`
|
||||
List []Value `json:"list,omitempty"`
|
||||
}
|
||||
|
||||
func NewSpace(space string) *Space {
|
||||
return &Space{Space: space}
|
||||
}
|
||||
|
||||
// HasTag returns true if needle is found
|
||||
// If the needle ends with a / it will be treated
|
||||
// as a prefix for tag meta data.
|
||||
func (s *Space) HasTag(needle string) bool {
|
||||
isPrefix := strings.HasSuffix(needle, "/")
|
||||
for i := range s.Tags {
|
||||
switch isPrefix {
|
||||
case true:
|
||||
if strings.HasPrefix(s.Tags[i], needle) {
|
||||
return true
|
||||
}
|
||||
case false:
|
||||
if s.Tags[i] == needle {
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// GetTagMeta retuns the value after a '/' in a tag.
|
||||
// Tags are in the format 'name' or 'name/value'
|
||||
// This function returns the value.
|
||||
func (s *Space) GetTagMeta(needle string, offset int) string {
|
||||
if !strings.HasSuffix(needle, "/") {
|
||||
needle += "/"
|
||||
}
|
||||
|
||||
for i := range s.Tags {
|
||||
if strings.HasPrefix(s.Tags[i], needle) {
|
||||
if offset > 0 {
|
||||
offset--
|
||||
continue
|
||||
}
|
||||
|
||||
return strings.TrimPrefix(s.Tags[i], needle)
|
||||
}
|
||||
}
|
||||
|
||||
return ""
|
||||
}
|
||||
|
||||
// FirstTagMeta returns the first meta tag value.
|
||||
func (s *Space) FirstTagMeta(needle string) string {
|
||||
return s.GetTagMeta(needle, 0)
|
||||
}
|
||||
|
||||
// GetValues that match name
|
||||
func (s *Space) GetValues(name string) (lis []Value) {
|
||||
for i := range s.List {
|
||||
if s.List[i].Name == name {
|
||||
lis = append(lis, s.List[i])
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// FirstValue that matches name
|
||||
func (s *Space) FirstValue(name string) Value {
|
||||
for i := range s.List {
|
||||
if s.List[i].Name == name {
|
||||
return s.List[i]
|
||||
}
|
||||
}
|
||||
return Value{}
|
||||
}
|
||||
|
||||
func (s *Space) SetTags(tags ...string) *Space {
|
||||
s.Tags = tags
|
||||
return s
|
||||
}
|
||||
func (s *Space) AddTags(tags ...string) *Space {
|
||||
s.Tags = append(s.Tags, tags...)
|
||||
return s
|
||||
}
|
||||
func (s *Space) SetNotes(notes ...string) *Space {
|
||||
s.Notes = notes
|
||||
return s
|
||||
}
|
||||
func (s *Space) AddNotes(notes ...string) *Space {
|
||||
s.Notes = append(s.Notes, notes...)
|
||||
return s
|
||||
}
|
||||
func (s *Space) SetKeys(keys ...*Value) *Space {
|
||||
for i := range keys {
|
||||
k := *keys[i]
|
||||
k.Seq = uint64(i)
|
||||
s.List = append(s.List, k)
|
||||
}
|
||||
|
||||
return s
|
||||
}
|
||||
func (s *Space) AddKeys(keys ...*Value) *Space {
|
||||
l := uint64(len(s.List))
|
||||
for i := range keys {
|
||||
k := *keys[i]
|
||||
k.Seq = uint64(i) + l
|
||||
s.List = append(s.List, k)
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
// SpaceMap generic map of space values
|
||||
type SpaceMap map[string]*Space
|
||||
|
||||
// Rule is a type of rule
|
||||
type Rule struct {
|
||||
Role string
|
||||
Type string
|
||||
Match string
|
||||
}
|
||||
|
||||
// Rules is a list of rules
|
||||
type Rules []Rule
|
||||
|
||||
// GetNamespaceSearch returns a default search for users rules.
|
||||
func (r Rules) GetNamespaceSearch() (lis NamespaceSearch) {
|
||||
for _, o := range r {
|
||||
if o.Type == "NS" && (o.Role == "read" || o.Role == "write") {
|
||||
lis = append(lis, NamespaceStar(o.Match))
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Check if name matches rule
|
||||
func (r Rule) Check(name string) bool {
|
||||
ok, err := filepath.Match(r.Match, name)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
return ok
|
||||
}
|
||||
|
||||
// CheckNamespace verifies user has access
|
||||
func (r Rules) CheckNamespace(search NamespaceSearch) bool {
|
||||
for _, ns := range search {
|
||||
if !r.GetRoles("NS", ns.Value()).HasRole("read", "write") {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
func (r Rules) Less(i, j int) bool {
|
||||
si, sj := scoreRule(r[i]), scoreRule(r[j])
|
||||
if si != sj {
|
||||
return si < sj
|
||||
}
|
||||
return len(r[i].Match) < len(r[j].Match)
|
||||
}
|
||||
func (r Rules) Swap(i, j int) { r[i], r[j] = r[j], r[i] }
|
||||
func (r Rules) Len() int { return len(r) }
|
||||
|
||||
func scoreRule(r Rule) int {
|
||||
score := 0
|
||||
if r.Type == "GR" {
|
||||
score += 1000
|
||||
}
|
||||
switch r.Role {
|
||||
case "admin":
|
||||
score += 100
|
||||
case "write":
|
||||
score += 50
|
||||
case "read":
|
||||
score += 10
|
||||
}
|
||||
return score
|
||||
}
|
||||
|
||||
// ReduceSearch verifies user has access
|
||||
func (r Rules) ReduceSearch(search NamespaceSearch) (out NamespaceSearch) {
|
||||
rules := r.GetNamespaceSearch()
|
||||
skip := make(map[string]struct{})
|
||||
out = make(NamespaceSearch, 0, len(rules))
|
||||
|
||||
for _, rule := range rules {
|
||||
if _, ok := skip[rule.Raw()]; ok {
|
||||
continue
|
||||
}
|
||||
for _, ck := range search {
|
||||
if _, ok := skip[ck.Raw()]; ok {
|
||||
continue
|
||||
} else if rule.Match(ck.Raw()) {
|
||||
skip[ck.Raw()] = struct{}{}
|
||||
out = append(out, ck)
|
||||
} else if ck.Match(rule.Raw()) {
|
||||
out = append(out, rule)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// Roles is a list of roles for a resource
|
||||
type Roles map[string]struct{}
|
||||
|
||||
// GetRoles returns a list of Roles
|
||||
func (r Rules) GetRoles(typ, name string) (lis Roles) {
|
||||
lis = make(Roles)
|
||||
for _, o := range r {
|
||||
if typ == o.Type && o.Check(name) {
|
||||
lis[o.Role] = struct{}{}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// HasRole is a valid role
|
||||
func (r Roles) HasRole(roles ...string) bool {
|
||||
for _, role := range roles {
|
||||
if _, ok := r[role]; ok {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// func (rules Rules) filterSpace(lis Config) (out Config, err error) {
|
||||
// accessList := make(map[string]struct{})
|
||||
// for _, o := range lis {
|
||||
// if _, ok := accessList[o.Space]; ok {
|
||||
// out = append(out, o)
|
||||
// continue
|
||||
// }
|
||||
|
||||
// if role := rules.GetRoles("NS", o.Space); role.HasRole("read", "write") && !role.HasRole("deny") {
|
||||
// accessList[o.Space] = struct{}{}
|
||||
// out = append(out, o)
|
||||
// }
|
||||
// }
|
||||
|
||||
// return
|
||||
// }
|
||||
|
||||
// ToArray converts SpaceMap to ArraySpace
|
||||
func (m SpaceMap) ToArray() Config {
|
||||
a := make(Config, 0, len(m))
|
||||
for _, s := range m {
|
||||
a = append(a, s)
|
||||
}
|
||||
return a
|
||||
}
|
||||
func (m *SpaceMap) MergeMap(s SpaceMap) {
|
||||
m.Merge(maps.Values(s)...)
|
||||
}
|
||||
func (m *SpaceMap) Merge(lis ...*Space) {
|
||||
for _, s := range lis {
|
||||
// Only accept first version based on priority.
|
||||
if _, ok := (*m)[s.Space]; ok {
|
||||
continue
|
||||
}
|
||||
|
||||
(*m)[s.Space] = s
|
||||
|
||||
// // Merge values together.
|
||||
// c, ok := (*m)[s.Space]
|
||||
// if ok {
|
||||
// c = &Space{}
|
||||
// }
|
||||
// c.Notes = append(c.Notes, s.Notes...)
|
||||
// c.Tags = append(c.Tags, s.Tags...)
|
||||
// last := c.List[len(c.List)-1].Seq
|
||||
// for i := range s.List {
|
||||
// v := s.List[i]
|
||||
// v.Seq += last
|
||||
// c.List = append(c.List, v)
|
||||
// }
|
||||
// (*m)[s.Space] = c
|
||||
}
|
||||
}
|
||||
|
||||
// Value stores the attributes for space values
|
||||
type Value struct {
|
||||
Space string `json:"-" db:"space"`
|
||||
Seq uint64 `json:"-" db:"seq"`
|
||||
Name string `json:"name"`
|
||||
Values []string `json:"values"`
|
||||
Notes []string `json:"notes"`
|
||||
Tags []string `json:"tags"`
|
||||
}
|
||||
|
||||
// func (v *Value) ID() string {
|
||||
// return gql.FmtID("MercurySpace:%v:%v", v.Space, v.Seq)
|
||||
// }
|
||||
|
||||
// HasTag returns true if needle is found
|
||||
// If the needle ends with a / it will be treated
|
||||
// as a prefix for tag meta data.
|
||||
func (v Value) HasTag(needle string) bool {
|
||||
isPrefix := strings.HasSuffix(needle, "/")
|
||||
for i := range v.Tags {
|
||||
switch isPrefix {
|
||||
case true:
|
||||
if strings.HasPrefix(v.Tags[i], needle) {
|
||||
return true
|
||||
}
|
||||
case false:
|
||||
if v.Tags[i] == needle {
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// GetTagMeta retuns the value after a '/' in a tag.
|
||||
// Tags are in the format 'name' or 'name/value'
|
||||
// This function returns the value.
|
||||
func (v Value) GetTagMeta(needle string, offset int) string {
|
||||
if !strings.HasSuffix(needle, "/") {
|
||||
needle += "/"
|
||||
}
|
||||
|
||||
for i := range v.Tags {
|
||||
if strings.HasPrefix(v.Tags[i], needle) {
|
||||
if offset > 0 {
|
||||
offset--
|
||||
continue
|
||||
}
|
||||
|
||||
return strings.TrimPrefix(v.Tags[i], needle)
|
||||
}
|
||||
}
|
||||
|
||||
return ""
|
||||
}
|
||||
|
||||
// FirstTagMeta returns the first meta tag value.
|
||||
func (v Value) FirstTagMeta(needle string) string {
|
||||
return v.GetTagMeta(needle, 0)
|
||||
}
|
||||
|
||||
// First value in array.
|
||||
func (v Value) First() string {
|
||||
if len(v.Values) < 1 {
|
||||
return ""
|
||||
}
|
||||
|
||||
return v.Values[0]
|
||||
}
|
||||
|
||||
// Join values with newlines.
|
||||
func (v Value) Join() string {
|
||||
return strings.Join(v.Values, "\n")
|
||||
}
|
||||
|
||||
func NewValue(name string) *Value {
|
||||
return &Value{Name: name}
|
||||
}
|
||||
func (v *Value) SetTags(tags ...string) *Value {
|
||||
v.Tags = tags
|
||||
return v
|
||||
}
|
||||
func (v *Value) AddTags(tags ...string) *Value {
|
||||
v.Tags = append(v.Tags, tags...)
|
||||
return v
|
||||
}
|
||||
func (v *Value) SetNotes(notes ...string) *Value {
|
||||
v.Notes = notes
|
||||
return v
|
||||
}
|
||||
func (v *Value) AddNotes(notes ...string) *Value {
|
||||
v.Notes = append(v.Notes, notes...)
|
||||
return v
|
||||
}
|
||||
func (v *Value) SetValues(values ...string) *Value {
|
||||
v.Values = values
|
||||
return v
|
||||
}
|
||||
func (v *Value) AddValues(values ...string) *Value {
|
||||
v.Values = append(v.Values, values...)
|
||||
return v
|
||||
}
|
||||
27
mercury/mqtt/notify.go
Normal file
27
mercury/mqtt/notify.go
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
package mqtt
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"go.sour.is/pkg/lg"
|
||||
"go.sour.is/pkg/mercury"
|
||||
)
|
||||
|
||||
type mqttNotify struct{}
|
||||
|
||||
func (mqttNotify) SendNotify(ctx context.Context, n mercury.Notify) {
|
||||
_, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
// var m mqtt.Message
|
||||
// m, err = mqtt.NewMessage(n.URL, n)
|
||||
// if err != nil {
|
||||
// return
|
||||
// }
|
||||
// log.Debug(n)
|
||||
// err = mqtt.Publish(m)
|
||||
// return
|
||||
}
|
||||
|
||||
func Register() {
|
||||
mercury.Registry.Register("mqtt-notify", func(s *mercury.Space) any { return &mqttNotify{} })
|
||||
}
|
||||
125
mercury/namespace.go
Normal file
125
mercury/namespace.go
Normal file
|
|
@ -0,0 +1,125 @@
|
|||
package mercury
|
||||
|
||||
import (
|
||||
"path/filepath"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// NamespaceSpec implements a parsed namespace search
|
||||
type NamespaceSpec interface {
|
||||
Value() string
|
||||
String() string
|
||||
Raw() string
|
||||
Match(string) bool
|
||||
}
|
||||
|
||||
// NamespaceSearch list of namespace specs
|
||||
type NamespaceSearch []NamespaceSpec
|
||||
|
||||
// ParseNamespace returns a list of parsed values
|
||||
func ParseNamespace(ns string) (lis NamespaceSearch) {
|
||||
for _, part := range strings.Split(ns, ";") {
|
||||
if strings.HasPrefix(part, "trace:") {
|
||||
for _, s := range strings.Split(part[6:], ",") {
|
||||
lis = append(lis, NamespaceTrace(s))
|
||||
}
|
||||
} else {
|
||||
for _, s := range strings.Split(part, ",") {
|
||||
if strings.Contains(s, "*") {
|
||||
lis = append(lis, NamespaceStar(s))
|
||||
} else {
|
||||
lis = append(lis, NamespaceNode(s))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// String output string value
|
||||
func (n NamespaceSearch) String() string {
|
||||
lis := make([]string, 0, len(n))
|
||||
|
||||
for _, v := range n {
|
||||
lis = append(lis, v.String())
|
||||
}
|
||||
return strings.Join(lis, ",")
|
||||
}
|
||||
|
||||
// Match returns true if any match.
|
||||
func (n NamespaceSearch) Match(s string) bool {
|
||||
for _, m := range n {
|
||||
ok, err := filepath.Match(m.Raw(), s)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
if ok {
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
// NamespaceNode implements a node search value
|
||||
type NamespaceNode string
|
||||
|
||||
// String output string value
|
||||
func (n NamespaceNode) String() string { return string(n) }
|
||||
|
||||
// Quote return quoted value.
|
||||
// func (n NamespaceNode) Quote() string { return `'` + n.Value() + `'` }
|
||||
|
||||
// Value to return the value
|
||||
func (n NamespaceNode) Value() string { return string(n) }
|
||||
|
||||
// Raw return raw value.
|
||||
func (n NamespaceNode) Raw() string { return string(n) }
|
||||
|
||||
// Match returns true if any match.
|
||||
func (n NamespaceNode) Match(s string) bool { return match(n, s) }
|
||||
|
||||
// NamespaceTrace implements a trace search value
|
||||
type NamespaceTrace string
|
||||
|
||||
// String output string value
|
||||
func (n NamespaceTrace) String() string { return "trace:" + string(n) }
|
||||
|
||||
// Quote return quoted value.
|
||||
// func (n NamespaceTrace) Quote() string { return `'` + n.Value() + `'` }
|
||||
|
||||
// Value to return the value
|
||||
func (n NamespaceTrace) Value() string { return strings.Replace(string(n), "*", "%", -1) }
|
||||
|
||||
// Raw return raw value.
|
||||
func (n NamespaceTrace) Raw() string { return string(n) }
|
||||
|
||||
// Match returns true if any match.
|
||||
func (n NamespaceTrace) Match(s string) bool { return match(n, s) }
|
||||
|
||||
// NamespaceStar implements a trace search value
|
||||
type NamespaceStar string
|
||||
|
||||
// String output string value
|
||||
func (n NamespaceStar) String() string { return string(n) }
|
||||
|
||||
// Quote return quoted value.
|
||||
// func (n NamespaceStar) Quote() string { return `'` + n.Value() + `'` }
|
||||
|
||||
// Value to return the value
|
||||
func (n NamespaceStar) Value() string { return strings.Replace(string(n), "*", "%", -1) }
|
||||
|
||||
// Raw return raw value.
|
||||
func (n NamespaceStar) Raw() string { return string(n) }
|
||||
|
||||
// Match returns true if any match.
|
||||
func (n NamespaceStar) Match(s string) bool { return match(n, s) }
|
||||
|
||||
func match(n NamespaceSpec, s string) bool {
|
||||
ok, err := filepath.Match(n.Raw(), s)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
return ok
|
||||
}
|
||||
110
mercury/parse.go
Normal file
110
mercury/parse.go
Normal file
|
|
@ -0,0 +1,110 @@
|
|||
package mercury
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"io"
|
||||
"strings"
|
||||
)
|
||||
|
||||
func ParseText(body io.Reader) (config SpaceMap, err error) {
|
||||
config = make(SpaceMap)
|
||||
|
||||
var space string
|
||||
var name string
|
||||
var tags []string
|
||||
var notes []string
|
||||
var seq uint64
|
||||
|
||||
scanner := bufio.NewScanner(body)
|
||||
for scanner.Scan() {
|
||||
line := scanner.Text()
|
||||
|
||||
if len(line) == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
if strings.HasPrefix(line, "#") {
|
||||
notes = append(notes, strings.TrimPrefix(line, "# "))
|
||||
continue
|
||||
}
|
||||
|
||||
if strings.HasPrefix(line, "@") {
|
||||
var c *Space
|
||||
var ok bool
|
||||
|
||||
sp := strings.Fields(strings.TrimPrefix(line, "@"))
|
||||
space = sp[0]
|
||||
|
||||
if c, ok = config[space]; !ok {
|
||||
c = &Space{Space: space}
|
||||
}
|
||||
|
||||
c.Notes = append(make([]string, 0, len(notes)), notes...)
|
||||
c.Tags = append(make([]string, 0, len(sp[1:])), sp[1:]...)
|
||||
|
||||
config[space] = c
|
||||
notes = notes[:0]
|
||||
tags = tags[:0]
|
||||
|
||||
continue
|
||||
}
|
||||
|
||||
if space == "" {
|
||||
continue
|
||||
}
|
||||
|
||||
sp := strings.SplitN(line, ":", 2)
|
||||
if len(sp) < 2 {
|
||||
continue
|
||||
}
|
||||
|
||||
if strings.TrimSpace(sp[0]) == "" {
|
||||
var c *Space
|
||||
var ok bool
|
||||
|
||||
if c, ok = config[space]; !ok {
|
||||
c = &Space{Space: space}
|
||||
}
|
||||
|
||||
c.List[len(c.List)-1].Values = append(c.List[len(c.List)-1].Values, sp[1])
|
||||
config[space] = c
|
||||
|
||||
continue
|
||||
}
|
||||
|
||||
fields := strings.Fields(sp[0])
|
||||
name = fields[0]
|
||||
if len(fields) > 1 {
|
||||
tags = fields[1:]
|
||||
}
|
||||
|
||||
var c *Space
|
||||
var ok bool
|
||||
|
||||
if c, ok = config[space]; !ok {
|
||||
c = &Space{Space: space}
|
||||
}
|
||||
|
||||
seq++
|
||||
c.List = append(
|
||||
c.List,
|
||||
Value{
|
||||
Seq: seq,
|
||||
Name: name,
|
||||
Tags: append(make([]string, 0, len(tags)), tags...),
|
||||
Notes: append(make([]string, 0, len(notes)), notes...),
|
||||
Values: []string{sp[1]},
|
||||
},
|
||||
)
|
||||
config[space] = c
|
||||
|
||||
notes = notes[:0]
|
||||
tags = tags[:0]
|
||||
}
|
||||
|
||||
if err = scanner.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
120
mercury/pg/list-string.go
Normal file
120
mercury/pg/list-string.go
Normal file
|
|
@ -0,0 +1,120 @@
|
|||
package pg
|
||||
|
||||
import (
|
||||
"database/sql/driver"
|
||||
"fmt"
|
||||
"strings"
|
||||
"unicode"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
// ListStrings is a list of String values.
|
||||
type listString []string
|
||||
|
||||
// Scan implements the Scanner interface for ListIDs.
|
||||
func (e *listString) Scan(value interface{}) (err error) {
|
||||
|
||||
var str string
|
||||
switch v := value.(type) {
|
||||
case string:
|
||||
str = v
|
||||
case []byte:
|
||||
str = string(v)
|
||||
case []rune:
|
||||
str = string(v)
|
||||
default:
|
||||
return fmt.Errorf("array must be uint64, got: %T", value)
|
||||
}
|
||||
|
||||
if e == nil {
|
||||
*e = listString{}
|
||||
}
|
||||
|
||||
str = trim(str, '{', '}')
|
||||
if len(str) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
for _, s := range splitComma(string(str)) {
|
||||
*e = append(*e, s)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Value implements the driver Valuer interface for ListStrings.
|
||||
func (e listString) Value() (v driver.Value, err error) {
|
||||
var b strings.Builder
|
||||
|
||||
if len(e) == 0 {
|
||||
return "{}", nil
|
||||
}
|
||||
|
||||
_, err = b.WriteRune('{')
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
var arr []string
|
||||
for _, s := range e {
|
||||
arr = append(arr, `"`+s+`"`)
|
||||
}
|
||||
_, err = b.WriteString(strings.Join(arr, ","))
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
_, err = b.WriteRune('}')
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
return b.String(), nil
|
||||
}
|
||||
|
||||
func splitComma(s string) []string {
|
||||
lastQuote := rune(0)
|
||||
f := func(c rune) bool {
|
||||
switch {
|
||||
case c == lastQuote:
|
||||
lastQuote = rune(0)
|
||||
return false
|
||||
case lastQuote != rune(0):
|
||||
return false
|
||||
case unicode.In(c, unicode.Quotation_Mark):
|
||||
lastQuote = c
|
||||
return false
|
||||
default:
|
||||
return c == ','
|
||||
}
|
||||
}
|
||||
lis := strings.FieldsFunc(s, f)
|
||||
|
||||
var out []string
|
||||
for _, s := range lis {
|
||||
s = trim(s, '"', '"')
|
||||
out = append(out, s)
|
||||
}
|
||||
|
||||
return out
|
||||
}
|
||||
|
||||
func trim(s string, start, end rune) string {
|
||||
r0, size0 := utf8.DecodeRuneInString(s)
|
||||
if size0 == 0 {
|
||||
return s
|
||||
}
|
||||
if r0 != start {
|
||||
return s
|
||||
}
|
||||
|
||||
r1, size1 := utf8.DecodeLastRuneInString(s)
|
||||
if size1 == 0 {
|
||||
return s
|
||||
}
|
||||
if r1 != end {
|
||||
return s
|
||||
}
|
||||
|
||||
return s[size0 : len(s)-size1]
|
||||
}
|
||||
45
mercury/pg/notify.go
Normal file
45
mercury/pg/notify.go
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
package pg
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/Masterminds/squirrel"
|
||||
|
||||
"go.sour.is/pkg/mercury"
|
||||
)
|
||||
|
||||
// Notify stores the attributes for a registry space
|
||||
type Notify struct {
|
||||
Name string `json:"name" view:"mercury_notify_vw"`
|
||||
Match string `json:"match"`
|
||||
Event string `json:"event"`
|
||||
Method string `json:"-" db:"method"`
|
||||
URL string `json:"-" db:"url"`
|
||||
}
|
||||
|
||||
// GetNotify get list of rules
|
||||
func (pgm *postgresHandler) GetNotify(event string) (lis mercury.ListNotify, err error) {
|
||||
|
||||
rows, err := squirrel.Select("name", "match", "event", "method", "url").
|
||||
From("mercury_notify_vw").
|
||||
Where(squirrel.Eq{"event": event}).
|
||||
PlaceholderFormat(squirrel.Dollar).
|
||||
RunWith(pgm.db).
|
||||
QueryContext(context.TODO())
|
||||
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
defer rows.Close()
|
||||
for rows.Next() {
|
||||
var s mercury.Notify
|
||||
err = rows.Scan(&s.Name, &s.Match, &s.Event, &s.Method, &s.URL)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
lis = append(lis, s)
|
||||
}
|
||||
|
||||
return lis, rows.Err()
|
||||
}
|
||||
35
mercury/pg/otel.go
Normal file
35
mercury/pg/otel.go
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
package pg
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
|
||||
"go.nhat.io/otelsql"
|
||||
semconv "go.opentelemetry.io/otel/semconv/v1.20.0"
|
||||
)
|
||||
|
||||
func openDB(driver, dsn string) (*sql.DB, error) {
|
||||
// Register the otelsql wrapper for the provided postgres driver.
|
||||
driverName, err := otelsql.Register(driver,
|
||||
otelsql.AllowRoot(),
|
||||
otelsql.TraceQueryWithoutArgs(),
|
||||
otelsql.TraceRowsClose(),
|
||||
otelsql.TraceRowsAffected(),
|
||||
// otelsql.WithDatabaseName("my_database"), // Optional.
|
||||
otelsql.WithSystem(semconv.DBSystemPostgreSQL), // Optional.
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Connect to a Postgres database using the postgres driver wrapper.
|
||||
db, err := sql.Open(driverName, dsn)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err := otelsql.RecordStats(db); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return db, nil
|
||||
}
|
||||
398
mercury/pg/postgres.go
Normal file
398
mercury/pg/postgres.go
Normal file
|
|
@ -0,0 +1,398 @@
|
|||
package pg
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"fmt"
|
||||
"log"
|
||||
"strings"
|
||||
|
||||
sq "github.com/Masterminds/squirrel"
|
||||
"go.sour.is/pkg/lg"
|
||||
"go.sour.is/pkg/mercury"
|
||||
"go.sour.is/pkg/rsql"
|
||||
"golang.org/x/exp/maps"
|
||||
)
|
||||
|
||||
type postgresHandler struct {
|
||||
db *sql.DB
|
||||
}
|
||||
|
||||
var (
|
||||
_ mercury.GetIndex = (*postgresHandler)(nil)
|
||||
_ mercury.GetConfig = (*postgresHandler)(nil)
|
||||
_ mercury.GetRules = (*postgresHandler)(nil)
|
||||
_ mercury.WriteConfig = (*postgresHandler)(nil)
|
||||
)
|
||||
|
||||
func Register() {
|
||||
mercury.Registry.Register("sql", func(s *mercury.Space) any {
|
||||
var dsn strings.Builder
|
||||
var dbtype string
|
||||
for _, c := range s.List {
|
||||
if c.Name == "match" {
|
||||
continue
|
||||
}
|
||||
if c.Name == "dbtype" {
|
||||
dbtype = c.First()
|
||||
continue
|
||||
}
|
||||
fmt.Fprintln(&dsn, c.Name, "=", c.First())
|
||||
}
|
||||
|
||||
db, err := openDB(dbtype, dsn.String())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err = db.Ping(); err != nil {
|
||||
return err
|
||||
}
|
||||
return &postgresHandler{db}
|
||||
})
|
||||
}
|
||||
|
||||
type Space struct {
|
||||
mercury.Space
|
||||
ID uint64
|
||||
}
|
||||
type Value struct {
|
||||
mercury.Value
|
||||
ID uint64
|
||||
}
|
||||
|
||||
func (p *postgresHandler) GetIndex(ctx context.Context, search mercury.NamespaceSearch, pgm *rsql.Program) (mercury.Config, error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
cols := rsql.GetDbColumns(mercury.Space{})
|
||||
where, err := getWhere(search, cols)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
lis, err := p.listSpace(ctx, nil, where)
|
||||
if err != nil {
|
||||
log.Println(err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
config := make(mercury.Config, len(lis))
|
||||
for i, s := range lis {
|
||||
config[i] = &s.Space
|
||||
}
|
||||
|
||||
return config, nil
|
||||
}
|
||||
|
||||
func (p *postgresHandler) GetConfig(ctx context.Context, search mercury.NamespaceSearch, pgm *rsql.Program, fields []string) (mercury.Config, error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
idx, err := p.GetIndex(ctx, search, pgm)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
spaceMap := make(map[string]int, len(idx))
|
||||
for u, s := range idx {
|
||||
spaceMap[s.Space] = u
|
||||
}
|
||||
|
||||
where, err := getWhere(search, rsql.GetDbColumns(mercury.Value{}))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
rows, err := sq.Select("space", "name", "seq", "notes", "tags", "values").
|
||||
From("mercury_registry_vw").
|
||||
Where(where).
|
||||
OrderBy("space asc", "name asc").
|
||||
PlaceholderFormat(sq.Dollar).
|
||||
RunWith(p.db).
|
||||
QueryContext(ctx)
|
||||
|
||||
if err != nil {
|
||||
log.Println(err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
defer rows.Close()
|
||||
for rows.Next() {
|
||||
var (
|
||||
s mercury.Value
|
||||
notes listString
|
||||
tags listString
|
||||
values listString
|
||||
)
|
||||
err = rows.Scan(&s.Space, &s.Name, &s.Seq, ¬es, &tags, &values)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
s.Notes = notes
|
||||
s.Tags = tags
|
||||
s.Values = values
|
||||
if u, ok := spaceMap[s.Space]; ok {
|
||||
idx[u].List = append(idx[u].List, s)
|
||||
}
|
||||
}
|
||||
|
||||
err = rows.Err()
|
||||
span.RecordError(err)
|
||||
|
||||
span.AddEvent(fmt.Sprint("read index ", len(idx)))
|
||||
return idx, err
|
||||
}
|
||||
|
||||
func (p *postgresHandler) listSpace(ctx context.Context, tx sq.BaseRunner, where sq.Sqlizer) ([]*Space, error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
if tx == nil {
|
||||
tx = p.db
|
||||
}
|
||||
|
||||
rows, err := sq.Select("id", "space", "tags", "notes").
|
||||
From("mercury_spaces").
|
||||
Where(where).
|
||||
OrderBy("space asc").
|
||||
PlaceholderFormat(sq.Dollar).
|
||||
RunWith(tx).
|
||||
QueryContext(ctx)
|
||||
|
||||
if err != nil {
|
||||
log.Println(err)
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var lis []*Space
|
||||
for rows.Next() {
|
||||
var (
|
||||
s Space
|
||||
name string
|
||||
tags = &listString{}
|
||||
notes = &listString{}
|
||||
)
|
||||
err = rows.Scan(&s.ID, &name, tags, notes)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
s.Space.Space = name
|
||||
s.Space.Notes = *notes
|
||||
s.Space.Tags = *tags
|
||||
lis = append(lis, &s)
|
||||
}
|
||||
|
||||
err = rows.Err()
|
||||
span.RecordError(err)
|
||||
|
||||
span.AddEvent(fmt.Sprint("read config ", len(lis)))
|
||||
return lis, err
|
||||
}
|
||||
|
||||
// WriteConfig writes a config map to database
|
||||
func (p *postgresHandler) WriteConfig(ctx context.Context, config mercury.Config) (err error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
// Delete spaces that are present in input but are empty.
|
||||
deleteSpaces := make(map[string]struct{})
|
||||
|
||||
// get names of each space
|
||||
var names = make(map[string]int)
|
||||
for i, v := range config {
|
||||
names[v.Space] = i
|
||||
|
||||
if len(v.Tags) == 0 && len(v.Notes) == 0 && len(v.List) == 0 {
|
||||
deleteSpaces[v.Space] = struct{}{}
|
||||
}
|
||||
}
|
||||
|
||||
tx, err := p.db.Begin()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer func() {
|
||||
if err != nil && tx != nil {
|
||||
tx.Rollback()
|
||||
}
|
||||
}()
|
||||
|
||||
// get current spaces
|
||||
lis, err := p.listSpace(ctx, tx, sq.Eq{"space": maps.Keys(names)})
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
// determine which are being updated
|
||||
var deleteIDs []uint64
|
||||
var updateIDs []uint64
|
||||
var currentNames = make(map[string]struct{}, len(lis))
|
||||
var updateSpaces []*mercury.Space
|
||||
var insertSpaces []*mercury.Space
|
||||
|
||||
for _, s := range lis {
|
||||
spaceName := s.Space.Space
|
||||
currentNames[spaceName] = struct{}{}
|
||||
|
||||
if _, ok := deleteSpaces[spaceName]; ok {
|
||||
deleteIDs = append(deleteIDs, s.ID)
|
||||
continue
|
||||
}
|
||||
|
||||
updateSpaces = append(updateSpaces, config[names[spaceName]])
|
||||
updateIDs = append(updateIDs, s.ID)
|
||||
}
|
||||
for _, s := range config {
|
||||
spaceName := s.Space
|
||||
if _, ok := currentNames[spaceName]; !ok {
|
||||
insertSpaces = append(insertSpaces, s)
|
||||
}
|
||||
}
|
||||
|
||||
// delete spaces
|
||||
if ids := deleteIDs; len(ids) > 0 {
|
||||
_, err = sq.Delete("mercury_spaces").Where(sq.Eq{"id": ids}).RunWith(tx).PlaceholderFormat(sq.Dollar).ExecContext(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
// delete values
|
||||
if ids := append(updateIDs, deleteIDs...); len(ids) > 0 {
|
||||
_, err = sq.Delete("mercury_values").Where(sq.Eq{"id": ids}).RunWith(tx).PlaceholderFormat(sq.Dollar).ExecContext(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
var newValues []*Value
|
||||
|
||||
// update spaces
|
||||
for i, u := range updateSpaces {
|
||||
_, err := sq.Update("mercury_spaces").
|
||||
Where(sq.Eq{"id": updateIDs[i]}).
|
||||
Set("tags", listString(u.Tags)).
|
||||
Set("notes", listString(u.Notes)).
|
||||
PlaceholderFormat(sq.Dollar).
|
||||
RunWith(tx).ExecContext(ctx)
|
||||
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// log.Debugf("UPDATED %d SPACES", len(updateSpaces))
|
||||
for _, v := range u.List {
|
||||
newValues = append(newValues, &Value{Value: v, ID: updateIDs[i]})
|
||||
}
|
||||
}
|
||||
|
||||
// insert spaces
|
||||
for _, s := range insertSpaces {
|
||||
var id uint64
|
||||
query := sq.Insert("mercury_spaces").
|
||||
PlaceholderFormat(sq.Dollar).
|
||||
Columns("space", "tags", "notes").
|
||||
Values(s.Space, listString(s.Tags), listString(s.Notes)).
|
||||
Suffix("RETURNING \"id\"")
|
||||
err := query.
|
||||
RunWith(tx).
|
||||
QueryRowContext(ctx).
|
||||
Scan(&id)
|
||||
if err != nil {
|
||||
s, v, _ := query.ToSql()
|
||||
log.Println(s, v, err)
|
||||
return err
|
||||
}
|
||||
for _, v := range s.List {
|
||||
newValues = append(newValues, &Value{Value: v, ID: id})
|
||||
}
|
||||
}
|
||||
|
||||
// write all values to db.
|
||||
err = p.writeValues(ctx, tx, newValues)
|
||||
// log.Debugf("WROTE %d ATTRS", len(attrs))
|
||||
|
||||
tx.Commit()
|
||||
tx = nil
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// writeValues writes the values to db
|
||||
func (p *postgresHandler) writeValues(ctx context.Context, tx sq.BaseRunner, lis []*Value) (err error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
if len(lis) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
newInsert := func() sq.InsertBuilder {
|
||||
return sq.Insert("mercury_values").
|
||||
RunWith(tx).
|
||||
PlaceholderFormat(sq.Dollar).
|
||||
Columns(
|
||||
"id",
|
||||
"seq",
|
||||
"name",
|
||||
"values",
|
||||
"notes",
|
||||
"tags",
|
||||
)
|
||||
}
|
||||
chunk := int(65000 / 3)
|
||||
insert := newInsert()
|
||||
for i, s := range lis {
|
||||
insert = insert.Values(
|
||||
s.ID,
|
||||
s.Seq,
|
||||
s.Name,
|
||||
listString(s.Values),
|
||||
listString(s.Notes),
|
||||
listString(s.Tags),
|
||||
)
|
||||
// log.Debug(s.Name)
|
||||
|
||||
if i > 0 && i%chunk == 0 {
|
||||
// log.Debugf("inserting %v rows into %v", i%chunk, d.Table)
|
||||
// log.Debug(insert.ToSql())
|
||||
|
||||
_, err = insert.ExecContext(ctx)
|
||||
if err != nil {
|
||||
// log.Error(err)
|
||||
return
|
||||
}
|
||||
|
||||
insert = newInsert()
|
||||
}
|
||||
}
|
||||
if len(lis)%chunk > 0 {
|
||||
// log.Debugf("inserting %v rows into %v", len(lis)%chunk, d.Table)
|
||||
// log.Debug(insert.ToSql())
|
||||
|
||||
_, err = insert.ExecContext(ctx)
|
||||
if err != nil {
|
||||
// log.Error(err)
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func getWhere(search mercury.NamespaceSearch, d *rsql.DbColumns) (sq.Sqlizer, error) {
|
||||
var where sq.Or
|
||||
space, err := d.Col("space")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, m := range search {
|
||||
switch m.(type) {
|
||||
case mercury.NamespaceNode:
|
||||
where = append(where, sq.Eq{space: m.Value()})
|
||||
case mercury.NamespaceStar:
|
||||
where = append(where, sq.Like{space: m.Value()})
|
||||
case mercury.NamespaceTrace:
|
||||
e := sq.Expr(`? LIKE concat(`+space+`, '%')`, m.Value())
|
||||
where = append(where, e)
|
||||
}
|
||||
}
|
||||
return where, nil
|
||||
}
|
||||
92
mercury/pg/rules.go
Normal file
92
mercury/pg/rules.go
Normal file
|
|
@ -0,0 +1,92 @@
|
|||
package pg
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"github.com/Masterminds/squirrel"
|
||||
"go.sour.is/pkg/lg"
|
||||
"go.sour.is/pkg/mercury"
|
||||
)
|
||||
|
||||
type grouper interface {
|
||||
GetGroups() []string
|
||||
}
|
||||
|
||||
// GetRules get list of rules
|
||||
func (p *postgresHandler) GetRules(ctx context.Context, user mercury.Ident) (lis mercury.Rules, err error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
var ids []string
|
||||
ids = append(ids, "U-"+user.GetIdentity())
|
||||
switch u := user.(type) {
|
||||
case grouper:
|
||||
for _, g := range u.GetGroups() {
|
||||
ids = append(ids, "G-"+g)
|
||||
}
|
||||
}
|
||||
if groups, err := p.getGroups(ctx, user.GetIdentity()); err != nil {
|
||||
for _, g := range groups {
|
||||
ids = append(ids, "G-"+g)
|
||||
}
|
||||
}
|
||||
|
||||
query := squirrel.Select("role", "type", "match").
|
||||
From("mercury_rules_vw").
|
||||
Where(squirrel.Eq{"id": ids}).
|
||||
PlaceholderFormat(squirrel.Dollar)
|
||||
rows, err := query.
|
||||
RunWith(p.db).
|
||||
QueryContext(ctx)
|
||||
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
defer rows.Close()
|
||||
for rows.Next() {
|
||||
var s mercury.Rule
|
||||
err = rows.Scan(&s.Role, &s.Type, &s.Match)
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
return nil, err
|
||||
}
|
||||
lis = append(lis, s)
|
||||
}
|
||||
err = rows.Err()
|
||||
span.RecordError(err)
|
||||
|
||||
span.AddEvent(fmt.Sprint("read rules ", len(lis)))
|
||||
return lis, err
|
||||
}
|
||||
|
||||
// getGroups get list of groups
|
||||
func (pgm *postgresHandler) getGroups(ctx context.Context, user string) (lis []string, err error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
rows, err := squirrel.Select("group_id").
|
||||
From("mercury_groups_vw").
|
||||
Where(squirrel.Eq{"user_id": user}).
|
||||
PlaceholderFormat(squirrel.Dollar).
|
||||
RunWith(pgm.db).
|
||||
QueryContext(ctx)
|
||||
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
defer rows.Close()
|
||||
for rows.Next() {
|
||||
var s string
|
||||
err = rows.Scan(&s)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
lis = append(lis, s)
|
||||
}
|
||||
|
||||
return lis, rows.Err()
|
||||
}
|
||||
43
mercury/public/index.html
Normal file
43
mercury/public/index.html
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<script src="https://unpkg.com/htmx.org@1.9.10" integrity="sha384-D1Kt99CQMDuVetoL1lrYwg5t+9QdHe7NLX/SoJYkXDFfX37iInKRy5xLSi8nO7UC" crossorigin="anonymous"></script>
|
||||
<title>Mercury</title>
|
||||
</head>
|
||||
<body>
|
||||
Mercury
|
||||
|
||||
<form
|
||||
hx-get="/v1/mercury-index"
|
||||
hx-target="#index-results">
|
||||
@ <input
|
||||
id="search-index"
|
||||
name="space"
|
||||
type="text"
|
||||
placeholder="Search...">
|
||||
<button type="submit">Search</button>
|
||||
</form>
|
||||
<pre id="index-results"></pre>
|
||||
|
||||
<form
|
||||
hx-get="/v1/mercury-config"
|
||||
hx-target="#config-results">
|
||||
@ <input
|
||||
id="space-config"
|
||||
name="space"
|
||||
type="text"
|
||||
placeholder="Space...">
|
||||
<button type="submit">Load</button>
|
||||
</form>
|
||||
<pre id="config-results"></pre>
|
||||
|
||||
<form
|
||||
hx-post="/v1/mercury-config"
|
||||
hx-target="#space-saved">
|
||||
<textarea name="content"></textarea>
|
||||
<button type="submit">Save</button>
|
||||
</form>
|
||||
<pre id="space-saved"></pre>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
382
mercury/registry.go
Normal file
382
mercury/registry.go
Normal file
|
|
@ -0,0 +1,382 @@
|
|||
package mercury
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"go.sour.is/pkg/lg"
|
||||
"go.sour.is/pkg/rsql"
|
||||
"go.sour.is/pkg/set"
|
||||
)
|
||||
|
||||
// Ident interface for a logged in user
|
||||
type Ident interface {
|
||||
GetIdentity() string
|
||||
IsActive() bool
|
||||
}
|
||||
type GetIndex interface {
|
||||
GetIndex(context.Context, NamespaceSearch, *rsql.Program) (Config, error)
|
||||
}
|
||||
type GetConfig interface {
|
||||
GetConfig(context.Context, NamespaceSearch, *rsql.Program, []string) (Config, error)
|
||||
}
|
||||
type WriteConfig interface {
|
||||
WriteConfig(context.Context, Config) error
|
||||
}
|
||||
type GetRules interface {
|
||||
GetRules(context.Context, Ident) (Rules, error)
|
||||
}
|
||||
type GetNotify interface {
|
||||
GetNotify(context.Context, string) (ListNotify, error)
|
||||
}
|
||||
type SendNotify interface {
|
||||
SendNotify(context.Context, Notify) error
|
||||
}
|
||||
|
||||
type nobody struct{}
|
||||
|
||||
func (nobody) IsActive() bool { return true }
|
||||
func (nobody) GetIdentity() string { return "xuu" }
|
||||
func (nobody) HasRole(r ...string) bool { return true }
|
||||
|
||||
func (reg *registry) accessFilter(rules Rules, lis Config) (out Config, err error) {
|
||||
accessList := make(map[string]struct{})
|
||||
for _, o := range lis {
|
||||
if _, ok := accessList[o.Space]; ok {
|
||||
out = append(out, o)
|
||||
continue
|
||||
}
|
||||
|
||||
if role := rules.GetRoles("NS", o.Space); role.HasRole("read", "write") && !role.HasRole("deny") {
|
||||
accessList[o.Space] = struct{}{}
|
||||
out = append(out, o)
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// HandlerItem a single handler matching
|
||||
type matcher[T any] struct {
|
||||
Name string
|
||||
Match NamespaceSearch
|
||||
Priority int
|
||||
Handler T
|
||||
}
|
||||
type matchers struct {
|
||||
getIndex []matcher[GetIndex]
|
||||
getConfig []matcher[GetConfig]
|
||||
writeConfig []matcher[WriteConfig]
|
||||
getRules []matcher[GetRules]
|
||||
getNotify []matcher[GetNotify]
|
||||
sendNotify []matcher[SendNotify]
|
||||
}
|
||||
|
||||
// registry a list of handlers
|
||||
type registry struct {
|
||||
handlers map[string]func(*Space) any
|
||||
matchers matchers
|
||||
}
|
||||
|
||||
func (m matcher[T]) String() string {
|
||||
return fmt.Sprintf("%d: %s", m.Priority, m.Match)
|
||||
}
|
||||
|
||||
// Registry handler
|
||||
var Registry registry
|
||||
|
||||
func (r registry) String() string {
|
||||
var buf strings.Builder
|
||||
for h := range r.handlers {
|
||||
buf.WriteString(h)
|
||||
buf.WriteRune('\n')
|
||||
}
|
||||
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func (r *registry) resetMatchers() {
|
||||
r.matchers.getIndex = r.matchers.getIndex[:0]
|
||||
r.matchers.getConfig = r.matchers.getConfig[:0]
|
||||
r.matchers.writeConfig = r.matchers.writeConfig[:0]
|
||||
r.matchers.getRules = r.matchers.getRules[:0]
|
||||
r.matchers.getNotify = r.matchers.getNotify[:0]
|
||||
r.matchers.sendNotify = r.matchers.sendNotify[:0]
|
||||
}
|
||||
func (r *registry) sortMatchers() {
|
||||
sort.Slice(r.matchers.getConfig, func(i, j int) bool { return r.matchers.getConfig[i].Priority < r.matchers.getConfig[j].Priority })
|
||||
sort.Slice(r.matchers.getIndex, func(i, j int) bool { return r.matchers.getIndex[i].Priority < r.matchers.getIndex[j].Priority })
|
||||
sort.Slice(r.matchers.writeConfig, func(i, j int) bool { return r.matchers.writeConfig[i].Priority < r.matchers.writeConfig[j].Priority })
|
||||
sort.Slice(r.matchers.getRules, func(i, j int) bool { return r.matchers.getRules[i].Priority < r.matchers.getRules[j].Priority })
|
||||
sort.Slice(r.matchers.getNotify, func(i, j int) bool { return r.matchers.getNotify[i].Priority < r.matchers.getNotify[j].Priority })
|
||||
sort.Slice(r.matchers.sendNotify, func(i, j int) bool { return r.matchers.sendNotify[i].Priority < r.matchers.sendNotify[j].Priority })
|
||||
}
|
||||
func (r *registry) Register(name string, h func(*Space) any) {
|
||||
if r.handlers == nil {
|
||||
r.handlers = make(map[string]func(*Space) any)
|
||||
}
|
||||
r.handlers[name] = h
|
||||
}
|
||||
|
||||
func (r *registry) Configure(m SpaceMap) error {
|
||||
r.resetMatchers()
|
||||
for space, c := range m {
|
||||
space = strings.TrimPrefix(space, "mercury.source.")
|
||||
handler, name, _ := strings.Cut(space, ".")
|
||||
matches := c.FirstValue("match")
|
||||
for _, match := range matches.Values {
|
||||
ps := strings.Fields(match)
|
||||
priority, err := strconv.Atoi(ps[0])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
r.add(name, handler, ps[1], priority, c)
|
||||
}
|
||||
}
|
||||
|
||||
r.sortMatchers()
|
||||
return nil
|
||||
}
|
||||
|
||||
// Register add a handler to registry
|
||||
func (r *registry) add(name, handler, match string, priority int, cfg *Space) error {
|
||||
// log.Infos("mercury regster", "match", match, "pri", priority)
|
||||
mkHandler, ok := r.handlers[handler]
|
||||
if !ok {
|
||||
return fmt.Errorf("handler not registered: %s", handler)
|
||||
}
|
||||
hdlr := mkHandler(cfg)
|
||||
if err, ok := hdlr.(error); ok {
|
||||
return fmt.Errorf("%w: failed to config %s as handler: %s", err, name, handler)
|
||||
}
|
||||
if hdlr == nil {
|
||||
return fmt.Errorf("failed to config %s as handler: %s", name, handler)
|
||||
}
|
||||
|
||||
if hdlr, ok := hdlr.(GetIndex); ok {
|
||||
r.matchers.getIndex = append(
|
||||
r.matchers.getIndex,
|
||||
matcher[GetIndex]{Name: name, Match: ParseNamespace(match), Priority: priority, Handler: hdlr},
|
||||
)
|
||||
}
|
||||
if hdlr, ok := hdlr.(GetConfig); ok {
|
||||
r.matchers.getConfig = append(
|
||||
r.matchers.getConfig,
|
||||
matcher[GetConfig]{Name: name, Match: ParseNamespace(match), Priority: priority, Handler: hdlr},
|
||||
)
|
||||
}
|
||||
|
||||
if hdlr, ok := hdlr.(WriteConfig); ok {
|
||||
|
||||
r.matchers.writeConfig = append(
|
||||
r.matchers.writeConfig,
|
||||
matcher[WriteConfig]{Name: name, Match: ParseNamespace(match), Priority: priority, Handler: hdlr},
|
||||
)
|
||||
}
|
||||
if hdlr, ok := hdlr.(GetRules); ok {
|
||||
r.matchers.getRules = append(
|
||||
r.matchers.getRules,
|
||||
matcher[GetRules]{Name: name, Match: ParseNamespace(match), Priority: priority, Handler: hdlr},
|
||||
)
|
||||
}
|
||||
if hdlr, ok := hdlr.(GetNotify); ok {
|
||||
r.matchers.getNotify = append(
|
||||
r.matchers.getNotify,
|
||||
matcher[GetNotify]{Name: name, Match: ParseNamespace(match), Priority: priority, Handler: hdlr},
|
||||
)
|
||||
}
|
||||
if hdlr, ok := hdlr.(SendNotify); ok {
|
||||
r.matchers.sendNotify = append(
|
||||
r.matchers.sendNotify,
|
||||
matcher[SendNotify]{Name: name, Match: ParseNamespace(match), Priority: priority, Handler: hdlr},
|
||||
)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetIndex query each handler that match namespace.
|
||||
func (r registry) GetIndex(ctx context.Context, match, search string) (c Config, err error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
spec := ParseNamespace(match)
|
||||
pgm := rsql.DefaultParse(search)
|
||||
matches := make([]NamespaceSearch, len(r.matchers.getIndex))
|
||||
|
||||
for _, n := range spec {
|
||||
for i, hdlr := range r.matchers.getIndex {
|
||||
if hdlr.Match.Match(n.Raw()) {
|
||||
matches[i] = append(matches[i], n)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for i, hdlr := range r.matchers.getIndex {
|
||||
span.AddEvent(fmt.Sprint("INDEX ", hdlr.Name, hdlr.Match))
|
||||
lis, err := hdlr.Handler.GetIndex(ctx, matches[i], pgm)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
c = append(c, lis...)
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// Search query each handler with a key=value search
|
||||
|
||||
// GetConfig query each handler that match for fully qualified namespaces.
|
||||
func (r registry) GetConfig(ctx context.Context, match, search, fields string) (Config, error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
spec := ParseNamespace(match)
|
||||
pgm := rsql.DefaultParse(search)
|
||||
flds := strings.Split(fields, ",")
|
||||
|
||||
matches := make([]NamespaceSearch, len(r.matchers.getConfig))
|
||||
|
||||
for _, n := range spec {
|
||||
for i, hdlr := range r.matchers.getConfig {
|
||||
if hdlr.Match.Match(n.Raw()) {
|
||||
matches[i] = append(matches[i], n)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
m := make(SpaceMap)
|
||||
for i, hdlr := range r.matchers.getConfig {
|
||||
if len(matches[i]) == 0 {
|
||||
continue
|
||||
}
|
||||
span.AddEvent(fmt.Sprint("QUERY", hdlr.Name, hdlr.Match))
|
||||
lis, err := hdlr.Handler.GetConfig(ctx, matches[i], pgm, flds)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
m.Merge(lis...)
|
||||
}
|
||||
|
||||
return m.ToArray(), nil
|
||||
}
|
||||
|
||||
// WriteConfig write objects to backends
|
||||
func (r registry) WriteConfig(ctx context.Context, spaces Config) error {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
matches := make([]Config, len(r.matchers.writeConfig))
|
||||
|
||||
for _, s := range spaces {
|
||||
for i, hdlr := range r.matchers.writeConfig {
|
||||
if hdlr.Match.Match(s.Space) {
|
||||
matches[i] = append(matches[i], s)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for i, hdlr := range r.matchers.writeConfig {
|
||||
if len(matches[i]) == 0 {
|
||||
continue
|
||||
}
|
||||
span.AddEvent(fmt.Sprint("WRITE MATCH", hdlr.Name, hdlr.Match))
|
||||
err := hdlr.Handler.WriteConfig(ctx, matches[i])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetRules query each of the handlers for rules.
|
||||
func (r registry) GetRules(ctx context.Context, user Ident) (Rules, error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
s := set.New[Rule]()
|
||||
for _, hdlr := range r.matchers.getRules {
|
||||
span.AddEvent(fmt.Sprint("RULES", hdlr.Name, hdlr.Match))
|
||||
lis, err := hdlr.Handler.GetRules(ctx, user)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
s.Add(lis...)
|
||||
}
|
||||
var rules Rules = s.Values()
|
||||
sort.Sort(rules)
|
||||
return rules, nil
|
||||
}
|
||||
|
||||
// GetNotify query each of the handlers for rules.
|
||||
func (r registry) GetNotify(ctx context.Context, event string) (ListNotify, error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
s := set.New[Notify]()
|
||||
for _, hdlr := range r.matchers.getNotify {
|
||||
span.AddEvent(fmt.Sprint("GET NOTIFY", hdlr.Name, hdlr.Match))
|
||||
|
||||
lis, err := hdlr.Handler.GetNotify(ctx, event)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
s.Add(lis...)
|
||||
}
|
||||
|
||||
return s.Values(), nil
|
||||
}
|
||||
|
||||
func (r registry) SendNotify(ctx context.Context, n Notify) (err error) {
|
||||
ctx, span := lg.Span(ctx)
|
||||
defer span.End()
|
||||
|
||||
for _, hdlr := range r.matchers.sendNotify {
|
||||
span.AddEvent(fmt.Sprint("SEND NOTIFY", hdlr.Name, hdlr.Match))
|
||||
|
||||
err := hdlr.Handler.SendNotify(ctx, n)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// Check if name matches notify
|
||||
func (n Notify) Check(name string) bool {
|
||||
ok, err := filepath.Match(n.Match, name)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
return ok
|
||||
}
|
||||
|
||||
// Notify stores the attributes for a registry space
|
||||
type Notify struct {
|
||||
Name string
|
||||
Match string
|
||||
Event string
|
||||
Method string
|
||||
URL string
|
||||
}
|
||||
|
||||
// ListNotify array of notify
|
||||
type ListNotify []Notify
|
||||
|
||||
// Find returns list of notify that match name.
|
||||
func (ln ListNotify) Find(name string) (lis ListNotify) {
|
||||
lis = make(ListNotify, 0, len(ln))
|
||||
for _, o := range ln {
|
||||
if o.Check(name) {
|
||||
lis = append(lis, o)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
252
mercury/route.go
Normal file
252
mercury/route.go
Normal file
|
|
@ -0,0 +1,252 @@
|
|||
package mercury
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/BurntSushi/toml"
|
||||
"github.com/golang/gddo/httputil"
|
||||
"go.sour.is/pkg/lg"
|
||||
)
|
||||
|
||||
type root struct{}
|
||||
|
||||
func NewHTTP() *root {
|
||||
return &root{}
|
||||
}
|
||||
|
||||
func (s *root) RegisterHTTP(mux *http.ServeMux) {
|
||||
mux.HandleFunc("/v1/mercury-index", s.getIndex)
|
||||
mux.HandleFunc("/v1/mercury-config", s.getConfig)
|
||||
// mux.HandleFunc("POST /v1/mercury-config", s.postConfig)
|
||||
mux.Handle("/", http.FileServer(http.Dir("./mercury/public")))
|
||||
}
|
||||
|
||||
func (s *root) getConfig(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Method == http.MethodPost {
|
||||
s.postConfig(w, r)
|
||||
return
|
||||
}
|
||||
|
||||
ctx, span := lg.Span(r.Context())
|
||||
defer span.End()
|
||||
|
||||
var id Ident = nobody{}
|
||||
|
||||
if !id.IsActive() {
|
||||
span.RecordError(fmt.Errorf("NO_AUTH"))
|
||||
http.Error(w, "NO_AUTH", http.StatusUnauthorized)
|
||||
return
|
||||
}
|
||||
|
||||
rules, err := Registry.GetRules(ctx, id)
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
http.Error(w, "ERR: "+err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
space := r.URL.Query().Get("space")
|
||||
if space == "" {
|
||||
space = "*"
|
||||
}
|
||||
|
||||
ns := ParseNamespace(space)
|
||||
ns = rules.ReduceSearch(ns)
|
||||
|
||||
lis, err := Registry.GetConfig(ctx, ns.String(), "", "")
|
||||
if err != nil {
|
||||
http.Error(w, "ERR: "+err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
lis, err = Registry.accessFilter(rules, lis)
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
http.Error(w, "ERR: "+err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
sort.Sort(lis)
|
||||
var content string
|
||||
|
||||
switch httputil.NegotiateContentType(r, []string{
|
||||
"text/plain",
|
||||
"application/environ",
|
||||
"application/ini",
|
||||
"application/json",
|
||||
"application/toml",
|
||||
}, "text/plain") {
|
||||
case "text/plain":
|
||||
content = lis.String()
|
||||
case "application/environ":
|
||||
content = lis.EnvString()
|
||||
case "application/ini":
|
||||
content = lis.IniString()
|
||||
case "application/json":
|
||||
json.NewEncoder(w).Encode(lis)
|
||||
case "application/toml":
|
||||
w.WriteHeader(200)
|
||||
m := make(map[string]map[string][]string)
|
||||
for _, o := range lis {
|
||||
if _, ok := m[o.Space]; !ok {
|
||||
m[o.Space] = make(map[string][]string)
|
||||
}
|
||||
for _, v := range o.List {
|
||||
m[o.Space][v.Name] = append(m[o.Space][v.Name], v.Values...)
|
||||
}
|
||||
}
|
||||
err := toml.NewEncoder(w).Encode(m)
|
||||
if err != nil {
|
||||
// log.Error(err)
|
||||
http.Error(w, "ERR", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
fmt.Fprint(w, content)
|
||||
}
|
||||
|
||||
func (s *root) postConfig(w http.ResponseWriter, r *http.Request) {
|
||||
ctx, span := lg.Span(r.Context())
|
||||
defer span.End()
|
||||
|
||||
var id Ident = nobody{}
|
||||
|
||||
if !id.IsActive() {
|
||||
span.RecordError(fmt.Errorf("NO_AUTH"))
|
||||
http.Error(w, "NO_AUTH", http.StatusUnauthorized)
|
||||
return
|
||||
}
|
||||
|
||||
var config SpaceMap
|
||||
var err error
|
||||
switch r.Header.Get("Content-Type") {
|
||||
case "text/plain":
|
||||
config, err = ParseText(r.Body)
|
||||
r.Body.Close()
|
||||
case "application/x-www-form-urlencoded":
|
||||
r.ParseForm()
|
||||
config, err = ParseText(strings.NewReader(r.Form.Get("content")))
|
||||
case "multipart/form-data":
|
||||
r.ParseMultipartForm(1 << 20)
|
||||
config, err = ParseText(strings.NewReader(r.Form.Get("content")))
|
||||
}
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
http.Error(w, "PARSE_ERR", 400)
|
||||
return
|
||||
}
|
||||
|
||||
{
|
||||
rules, err := Registry.GetRules(ctx, id)
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
http.Error(w, "ERR: "+err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
notify, err := Registry.GetNotify(ctx, "updated")
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
http.Error(w, "ERR", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
_ = rules
|
||||
var notifyActive = make(map[string]struct{})
|
||||
var filteredConfigs Config
|
||||
for ns, c := range config {
|
||||
if !rules.GetRoles("NS", ns).HasRole("write") {
|
||||
span.AddEvent(fmt.Sprint("SKIP", ns))
|
||||
continue
|
||||
}
|
||||
|
||||
span.AddEvent(fmt.Sprint("SAVE", ns))
|
||||
for _, n := range notify.Find(ns) {
|
||||
notifyActive[n.Name] = struct{}{}
|
||||
}
|
||||
filteredConfigs = append(filteredConfigs, c)
|
||||
}
|
||||
|
||||
err = Registry.WriteConfig(ctx, filteredConfigs)
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
http.Error(w, "ERR", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
span.AddEvent(fmt.Sprint("SEND NOTIFYS ", notifyActive))
|
||||
for _, n := range notify {
|
||||
if _, ok := notifyActive[n.Name]; ok {
|
||||
err = Registry.SendNotify(ctx, n)
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
http.Error(w, "ERR", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
span.AddEvent("DONE!")
|
||||
}
|
||||
|
||||
w.WriteHeader(202)
|
||||
fmt.Fprint(w, "OK")
|
||||
}
|
||||
|
||||
func (s *root) getIndex(w http.ResponseWriter, r *http.Request) {
|
||||
ctx, span := lg.Span(r.Context())
|
||||
defer span.End()
|
||||
|
||||
var id Ident = nobody{}
|
||||
|
||||
timer := time.Now()
|
||||
defer func() { fmt.Println(time.Since(timer)) }()
|
||||
|
||||
if !id.IsActive() {
|
||||
span.RecordError(fmt.Errorf("NO_AUTH"))
|
||||
http.Error(w, "NO_AUTH", http.StatusUnauthorized)
|
||||
return
|
||||
}
|
||||
|
||||
rules, err := Registry.GetRules(ctx, id)
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
http.Error(w, "ERR: "+err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
span.AddEvent(fmt.Sprint(rules))
|
||||
|
||||
space := r.URL.Query().Get("space")
|
||||
if space == "" {
|
||||
space = "*"
|
||||
}
|
||||
|
||||
ns := ParseNamespace(space)
|
||||
ns = rules.ReduceSearch(ns)
|
||||
span.AddEvent(ns.String())
|
||||
|
||||
lis, err := Registry.GetIndex(ctx, ns.String(), "")
|
||||
if err != nil {
|
||||
span.RecordError(err)
|
||||
http.Error(w, "ERR: "+err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
sort.Sort(lis)
|
||||
|
||||
switch httputil.NegotiateContentType(r, []string{
|
||||
"text/plain",
|
||||
"application/json",
|
||||
}, "text/plain") {
|
||||
case "text/plain":
|
||||
_, err = fmt.Fprint(w, lis.StringList())
|
||||
span.RecordError(err)
|
||||
case "application/json":
|
||||
err = json.NewEncoder(w).Encode(lis)
|
||||
span.RecordError(err)
|
||||
}
|
||||
}
|
||||
255
rsql/ast.go
Normal file
255
rsql/ast.go
Normal file
|
|
@ -0,0 +1,255 @@
|
|||
package rsql
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Node is the smallest unit of ast
|
||||
type Node interface {
|
||||
TokenLiteral() string
|
||||
String() string
|
||||
}
|
||||
|
||||
// Statement is a executable tree
|
||||
type Statement interface {
|
||||
Node
|
||||
statementNode()
|
||||
}
|
||||
|
||||
// Expression is a portion of tree
|
||||
type Expression interface {
|
||||
Node
|
||||
expressionNode()
|
||||
}
|
||||
|
||||
// Identifier is a variable name
|
||||
type Identifier struct {
|
||||
Token Token
|
||||
Value string
|
||||
}
|
||||
|
||||
func (i *Identifier) expressionNode() {}
|
||||
|
||||
// TokenLiteral returns the literal value of a token
|
||||
func (i *Identifier) TokenLiteral() string { return i.Token.Literal }
|
||||
|
||||
// String returns a string representation of value
|
||||
func (i *Identifier) String() string { return i.Value }
|
||||
|
||||
// Integer is a numeric value
|
||||
type Integer struct {
|
||||
Token Token
|
||||
Value int64
|
||||
}
|
||||
|
||||
func (i *Integer) expressionNode() {}
|
||||
|
||||
// TokenLiteral returns the literal value of a token
|
||||
func (i *Integer) TokenLiteral() string { return i.Token.Literal }
|
||||
|
||||
// String returns a string representation of value
|
||||
func (i *Integer) String() string { return i.Token.Literal }
|
||||
|
||||
// Float is a floating point value
|
||||
type Float struct {
|
||||
Token Token
|
||||
Value float64
|
||||
}
|
||||
|
||||
func (i *Float) expressionNode() {}
|
||||
|
||||
// TokenLiteral returns the literal value of a token
|
||||
func (i *Float) TokenLiteral() string { return i.Token.Literal }
|
||||
|
||||
// String returns a string representation of value
|
||||
func (i *Float) String() string { return i.Token.Literal }
|
||||
|
||||
// Bool is a boolean value
|
||||
type Bool struct {
|
||||
Token Token
|
||||
Value bool
|
||||
}
|
||||
|
||||
func (i *Bool) expressionNode() {}
|
||||
|
||||
// TokenLiteral returns the literal value of a token
|
||||
func (i *Bool) TokenLiteral() string { return i.Token.Literal }
|
||||
|
||||
// String returns a string representation of value
|
||||
func (i *Bool) String() string { return i.Token.Literal }
|
||||
|
||||
// Null is an empty value
|
||||
type Null struct {
|
||||
Token Token
|
||||
}
|
||||
|
||||
func (i *Null) expressionNode() {}
|
||||
|
||||
// TokenLiteral returns the literal value of a token
|
||||
func (i *Null) TokenLiteral() string { return i.Token.Literal }
|
||||
|
||||
// String returns a string representation of value
|
||||
func (i *Null) String() string { return i.Token.Literal }
|
||||
|
||||
// String is an array of codepoints
|
||||
type String struct {
|
||||
Token Token
|
||||
Value string
|
||||
}
|
||||
|
||||
func (i *String) expressionNode() {}
|
||||
|
||||
// TokenLiteral returns the literal value of a token
|
||||
func (i *String) TokenLiteral() string { return i.Token.Literal }
|
||||
|
||||
// String returns a string representation of value
|
||||
func (i *String) String() string {
|
||||
var out bytes.Buffer
|
||||
|
||||
out.WriteRune('"')
|
||||
out.WriteString(i.Value)
|
||||
out.WriteRune('"')
|
||||
|
||||
return out.String()
|
||||
}
|
||||
|
||||
// Array is an array of tokens
|
||||
type Array struct {
|
||||
Token Token
|
||||
Elements []Expression
|
||||
}
|
||||
|
||||
func (a *Array) expressionNode() {}
|
||||
|
||||
// TokenLiteral returns the literal value of a token
|
||||
func (a *Array) TokenLiteral() string { return a.Token.Literal }
|
||||
|
||||
// String returns a string representation of value
|
||||
func (a *Array) String() string {
|
||||
var out bytes.Buffer
|
||||
|
||||
var elements []string
|
||||
for _, el := range a.Elements {
|
||||
elements = append(elements, el.String())
|
||||
}
|
||||
|
||||
out.WriteRune('(')
|
||||
out.WriteString(strings.Join(elements, ","))
|
||||
out.WriteRune(')')
|
||||
|
||||
return out.String()
|
||||
}
|
||||
|
||||
// Program is a collection of statements
|
||||
type Program struct {
|
||||
Statements []Statement
|
||||
Args map[string]string
|
||||
}
|
||||
|
||||
func (p *Program) expressionNode() {}
|
||||
|
||||
// TokenLiteral returns the literal value of a token
|
||||
func (p *Program) TokenLiteral() string {
|
||||
if len(p.Statements) > 0 {
|
||||
return p.Statements[0].TokenLiteral()
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// String returns a string representation of value
|
||||
func (p *Program) String() string {
|
||||
var out bytes.Buffer
|
||||
|
||||
for _, s := range p.Statements {
|
||||
out.WriteString(s.String())
|
||||
}
|
||||
if len(p.Args) > 0 {
|
||||
out.WriteRune('|')
|
||||
for a, b := range p.Args {
|
||||
out.WriteRune(' ')
|
||||
out.WriteString(a)
|
||||
out.WriteRune(':')
|
||||
out.WriteString(b)
|
||||
}
|
||||
}
|
||||
return out.String()
|
||||
}
|
||||
|
||||
// ExpressionStatement is a collection of expressions
|
||||
type ExpressionStatement struct {
|
||||
Token Token
|
||||
Expression Expression
|
||||
}
|
||||
|
||||
func (ExpressionStatement) statementNode() {}
|
||||
|
||||
// TokenLiteral returns the literal value of a token
|
||||
func (e ExpressionStatement) TokenLiteral() string { return e.Token.Literal }
|
||||
|
||||
// String returns a string representation of value
|
||||
func (e ExpressionStatement) String() string {
|
||||
if e.Expression != nil {
|
||||
return e.Expression.String()
|
||||
}
|
||||
|
||||
return ""
|
||||
}
|
||||
|
||||
// PrefixExpression is an expression with a preceeding operator
|
||||
type PrefixExpression struct {
|
||||
Token Token
|
||||
Operator string
|
||||
Right Expression
|
||||
}
|
||||
|
||||
func (p *PrefixExpression) expressionNode() {}
|
||||
|
||||
// TokenLiteral returns the literal value of a token
|
||||
func (p *PrefixExpression) TokenLiteral() string { return p.Token.Literal }
|
||||
|
||||
// String returns a string representation of value
|
||||
func (p *PrefixExpression) String() string {
|
||||
var out bytes.Buffer
|
||||
|
||||
out.WriteRune('(')
|
||||
out.WriteString(p.Operator)
|
||||
out.WriteString(p.Right.String())
|
||||
out.WriteRune(')')
|
||||
|
||||
return out.String()
|
||||
}
|
||||
|
||||
// InfixExpression is two expressions with a infix operator
|
||||
type InfixExpression struct {
|
||||
Token Token
|
||||
Left Expression
|
||||
Operator string
|
||||
Right Expression
|
||||
}
|
||||
|
||||
func (i *InfixExpression) expressionNode() {}
|
||||
|
||||
// TokenLiteral returns the literal value of a token
|
||||
func (i *InfixExpression) TokenLiteral() string { return i.Token.Literal }
|
||||
|
||||
// String returns a string representation of value
|
||||
func (i *InfixExpression) String() string {
|
||||
var out bytes.Buffer
|
||||
|
||||
out.WriteRune('(')
|
||||
if i.Left != nil {
|
||||
out.WriteString(i.Left.String())
|
||||
} else {
|
||||
out.WriteString("nil")
|
||||
}
|
||||
out.WriteString(i.Operator)
|
||||
if i.Right != nil {
|
||||
out.WriteString(i.Right.String())
|
||||
} else {
|
||||
out.WriteString("nil")
|
||||
}
|
||||
out.WriteRune(')')
|
||||
|
||||
return out.String()
|
||||
}
|
||||
21
rsql/ast_test.go
Normal file
21
rsql/ast_test.go
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
package rsql
|
||||
|
||||
import "testing"
|
||||
|
||||
func TestString(t *testing.T) {
|
||||
program := &Program{
|
||||
Statements: []Statement {
|
||||
ExpressionStatement{
|
||||
Token: Token{TokEQ, "=="},
|
||||
Expression: &InfixExpression{
|
||||
Token: Token{TokEQ, "=="},
|
||||
Left: &Identifier{Token{TokIdent,"foo"}, "foo"},
|
||||
Operator: "==",
|
||||
Right: &Integer{Token{TokInteger, "5"}, 5},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
t.Log(program.String())
|
||||
}
|
||||
90
rsql/dbcolumns.go
Normal file
90
rsql/dbcolumns.go
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
package rsql
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strings"
|
||||
"unicode"
|
||||
)
|
||||
|
||||
// DbColumns database model metadata
|
||||
type DbColumns struct {
|
||||
Cols []string
|
||||
index map[string]int
|
||||
Table string
|
||||
View string
|
||||
}
|
||||
|
||||
// Col returns the mapped column names
|
||||
func (d *DbColumns) Col(column string) (s string, err error) {
|
||||
idx, ok := d.Index(column)
|
||||
if !ok {
|
||||
err = fmt.Errorf("column not found on table: %v", column)
|
||||
return
|
||||
}
|
||||
return d.Cols[idx], err
|
||||
}
|
||||
|
||||
// Index returns the column number
|
||||
func (d *DbColumns) Index(column string) (idx int, ok bool) {
|
||||
idx, ok = d.index[column]
|
||||
return
|
||||
}
|
||||
|
||||
// GetDbColumns builds a metadata struct
|
||||
func GetDbColumns(o interface{}) *DbColumns {
|
||||
d := DbColumns{}
|
||||
t := reflect.TypeOf(o)
|
||||
|
||||
d.index = make(map[string]int)
|
||||
for i := 0; i < t.NumField(); i++ {
|
||||
field := t.Field(i)
|
||||
|
||||
sp := append(strings.Split(field.Tag.Get("db"), ","), "")
|
||||
|
||||
tag := sp[0]
|
||||
|
||||
json := field.Tag.Get("json")
|
||||
if tag == "" {
|
||||
tag = json
|
||||
}
|
||||
|
||||
graphql := field.Tag.Get("graphql")
|
||||
if tag == "" {
|
||||
tag = graphql
|
||||
}
|
||||
|
||||
if tag == "-" {
|
||||
continue
|
||||
}
|
||||
|
||||
if tag == "" {
|
||||
tag = field.Name
|
||||
}
|
||||
|
||||
d.index[field.Name] = len(d.Cols)
|
||||
|
||||
if _, ok := d.index[tag]; !ok && tag != "" {
|
||||
d.index[tag] = len(d.Cols)
|
||||
}
|
||||
if _, ok := d.index[json]; !ok && json != "" {
|
||||
d.index[json] = len(d.Cols)
|
||||
}
|
||||
if _, ok := d.index[graphql]; !ok && graphql != "" {
|
||||
d.index[graphql] = len(d.Cols)
|
||||
} else if !ok && graphql == "" {
|
||||
a := []rune(field.Name)
|
||||
for i := 0; i < len(a); i++ {
|
||||
if unicode.IsLower(a[i]) {
|
||||
break
|
||||
}
|
||||
a[i] = unicode.ToLower(a[i])
|
||||
}
|
||||
graphql = string(a)
|
||||
d.index[graphql] = len(d.Cols)
|
||||
}
|
||||
|
||||
d.Cols = append(d.Cols, tag)
|
||||
}
|
||||
return &d
|
||||
}
|
||||
258
rsql/lexer.go
Normal file
258
rsql/lexer.go
Normal file
|
|
@ -0,0 +1,258 @@
|
|||
package rsql
|
||||
|
||||
import (
|
||||
"unicode"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
type Lexer struct {
|
||||
input string
|
||||
position int
|
||||
readPosition int
|
||||
rune rune
|
||||
}
|
||||
|
||||
// NewLexer returns a new lexing generator
|
||||
func NewLexer(in string) *Lexer {
|
||||
l := &Lexer{input: in}
|
||||
l.readRune()
|
||||
return l
|
||||
}
|
||||
|
||||
// NextToken returns the next token from lexer
|
||||
func (l *Lexer) NextToken() Token {
|
||||
var tok Token
|
||||
|
||||
l.skipSpace()
|
||||
|
||||
switch l.rune {
|
||||
case '-':
|
||||
l.readRune()
|
||||
if isNumber(l.rune) {
|
||||
var isFloat bool
|
||||
tok.Literal, isFloat = l.readNumber()
|
||||
if isFloat {
|
||||
tok.Type = TokFloat
|
||||
} else {
|
||||
tok.Type = TokInteger
|
||||
}
|
||||
|
||||
} else if isLetter(l.rune) {
|
||||
tok.Literal = l.readIdentifier()
|
||||
tok.Type = lookupIdent(tok.Literal)
|
||||
|
||||
} else {
|
||||
tok = newToken(TokIllegal, l.rune)
|
||||
return tok
|
||||
}
|
||||
|
||||
tok.Literal = "-" + tok.Literal
|
||||
return tok
|
||||
case '=':
|
||||
r := l.peekRune()
|
||||
if r == '=' {
|
||||
r := l.rune
|
||||
l.readRune()
|
||||
tok.Type, tok.Literal = TokEQ, string(r)+string(l.rune)
|
||||
} else if isLetter(r) {
|
||||
tok = l.readFIQL()
|
||||
|
||||
return tok
|
||||
} else {
|
||||
tok = newToken(TokIllegal, l.rune)
|
||||
}
|
||||
case ';':
|
||||
tok = newToken(TokAND, l.rune)
|
||||
case ',':
|
||||
tok = newToken(TokOR, l.rune)
|
||||
case ')':
|
||||
tok = newToken(TokRParen, l.rune)
|
||||
case '(':
|
||||
tok = newToken(TokLParen, l.rune)
|
||||
case ']':
|
||||
tok = newToken(TokRBracket, l.rune)
|
||||
case '[':
|
||||
tok = newToken(TokLBracket, l.rune)
|
||||
case '~':
|
||||
tok = newToken(TokLIKE, l.rune)
|
||||
case '!':
|
||||
if l.peekRune() == '=' {
|
||||
r := l.rune
|
||||
l.readRune()
|
||||
tok.Type, tok.Literal = TokNEQ, string(r)+string(l.rune)
|
||||
} else if l.peekRune() == '~' {
|
||||
r := l.rune
|
||||
l.readRune()
|
||||
tok.Type, tok.Literal = TokNLIKE, string(r)+string(l.rune)
|
||||
} else {
|
||||
tok = newToken(TokIllegal, l.rune)
|
||||
return tok
|
||||
}
|
||||
case '<':
|
||||
if l.peekRune() == '=' {
|
||||
r := l.rune
|
||||
l.readRune()
|
||||
tok.Type, tok.Literal = TokLE, string(r)+string(l.rune)
|
||||
} else {
|
||||
tok = newToken(TokLT, l.rune)
|
||||
}
|
||||
case '>':
|
||||
if l.peekRune() == '=' {
|
||||
r := l.rune
|
||||
l.readRune()
|
||||
tok.Type, tok.Literal = TokGE, string(r)+string(l.rune)
|
||||
} else {
|
||||
tok = newToken(TokGT, l.rune)
|
||||
}
|
||||
case '"', '\'':
|
||||
tok.Type = TokString
|
||||
tok.Literal = l.readString(l.rune)
|
||||
case 0:
|
||||
tok.Type, tok.Literal = TokEOF, ""
|
||||
default:
|
||||
if isNumber(l.rune) {
|
||||
var isFloat bool
|
||||
tok.Literal, isFloat = l.readNumber()
|
||||
if isFloat {
|
||||
tok.Type = TokFloat
|
||||
} else {
|
||||
tok.Type = TokInteger
|
||||
}
|
||||
|
||||
} else if isLetter(l.rune) {
|
||||
tok.Literal = l.readIdentifier()
|
||||
tok.Type = lookupIdent(tok.Literal)
|
||||
|
||||
} else {
|
||||
tok = newToken(TokIllegal, l.rune)
|
||||
return tok
|
||||
}
|
||||
|
||||
return tok
|
||||
}
|
||||
|
||||
l.readRune()
|
||||
return tok
|
||||
}
|
||||
|
||||
func (l *Lexer) readRune() {
|
||||
var size int
|
||||
if l.readPosition >= len(l.input) {
|
||||
l.rune = 0
|
||||
} else {
|
||||
l.rune, size = utf8.DecodeRuneInString(l.input[l.readPosition:])
|
||||
}
|
||||
|
||||
l.position = l.readPosition
|
||||
l.readPosition += size
|
||||
}
|
||||
func (l *Lexer) peekRune() rune {
|
||||
if l.readPosition >= len(l.input) {
|
||||
return 0
|
||||
}
|
||||
r, _ := utf8.DecodeRuneInString(l.input[l.readPosition:])
|
||||
return r
|
||||
}
|
||||
|
||||
func (l *Lexer) skipSpace() {
|
||||
for unicode.IsSpace(l.rune) {
|
||||
l.readRune()
|
||||
}
|
||||
}
|
||||
|
||||
func (l *Lexer) readIdentifier() string {
|
||||
position := l.position
|
||||
if isLetter(l.rune) {
|
||||
l.readRune()
|
||||
}
|
||||
|
||||
for isLetter(l.rune) || isNumber(l.rune) {
|
||||
l.readRune()
|
||||
}
|
||||
|
||||
return l.input[position:l.position]
|
||||
}
|
||||
|
||||
func (l *Lexer) readNumber() (string, bool) {
|
||||
isFloat := false
|
||||
|
||||
position := l.position
|
||||
for isNumber(l.rune) {
|
||||
if l.rune == '.' {
|
||||
isFloat = true
|
||||
}
|
||||
|
||||
l.readRune()
|
||||
}
|
||||
|
||||
return l.input[position:l.position], isFloat
|
||||
}
|
||||
func (l *Lexer) readString(st rune) string {
|
||||
position := l.position + 1
|
||||
escape := false
|
||||
for {
|
||||
l.readRune()
|
||||
|
||||
if l.rune == '\\' {
|
||||
escape = true
|
||||
|
||||
continue
|
||||
}
|
||||
if escape {
|
||||
escape = false
|
||||
continue
|
||||
}
|
||||
if l.rune == st || l.rune == 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
return l.input[position:l.position]
|
||||
|
||||
}
|
||||
func (l *Lexer) readFIQL() Token {
|
||||
l.readRune()
|
||||
s := l.readIdentifier()
|
||||
if l.rune != '=' {
|
||||
return Token{TokIllegal, "=" + s}
|
||||
}
|
||||
l.readRune()
|
||||
|
||||
switch s {
|
||||
case "eq":
|
||||
return Token{TokEQ, "=" + s + "="}
|
||||
case "neq":
|
||||
return Token{TokNEQ, "=" + s + "="}
|
||||
case "gt":
|
||||
return Token{TokGT, "=" + s + "="}
|
||||
case "ge":
|
||||
return Token{TokGE, "=" + s + "="}
|
||||
case "lt":
|
||||
return Token{TokLT, "=" + s + "="}
|
||||
case "le":
|
||||
return Token{TokLE, "=" + s + "="}
|
||||
default:
|
||||
return Token{TokExtend, "=" + s + "="}
|
||||
}
|
||||
}
|
||||
|
||||
func isLetter(r rune) bool {
|
||||
if unicode.IsSpace(r) {
|
||||
return false
|
||||
}
|
||||
switch r {
|
||||
case '"', '\'', '(', ')', ';', ',', '=', '!', '~', '<', '>', '[', ']':
|
||||
return false
|
||||
}
|
||||
if '0' < r && r < '9' || r == '.' {
|
||||
return false
|
||||
}
|
||||
|
||||
return unicode.IsPrint(r)
|
||||
}
|
||||
func isNumber(r rune) bool {
|
||||
if '0' <= r && r <= '9' || r == '.' {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
105
rsql/lexer_test.go
Normal file
105
rsql/lexer_test.go
Normal file
|
|
@ -0,0 +1,105 @@
|
|||
package rsql
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/matryer/is"
|
||||
)
|
||||
|
||||
func TestReservedToken(t *testing.T) {
|
||||
input := `( ) ; , == != ~ < > <= >= [ ]`
|
||||
tests := []struct {
|
||||
expectedType TokenType
|
||||
expectedLiteral string
|
||||
}{
|
||||
{TokLParen, "("},
|
||||
{TokRParen, ")"},
|
||||
{TokAND, ";"},
|
||||
{TokOR, ","},
|
||||
{TokEQ, "=="},
|
||||
{TokNEQ, "!="},
|
||||
{TokLIKE, "~"},
|
||||
{TokLT, "<"},
|
||||
{TokGT, ">"},
|
||||
{TokLE, "<="},
|
||||
{TokGE, ">="},
|
||||
{TokLBracket, "["},
|
||||
{TokRBracket, "]"},
|
||||
}
|
||||
|
||||
t.Run("Reserved Tokens", func(t *testing.T) {
|
||||
is := is.New(t)
|
||||
|
||||
l := NewLexer(input)
|
||||
|
||||
for _, tt := range tests {
|
||||
tok := l.NextToken()
|
||||
is.Equal(tt.expectedType, tok.Type)
|
||||
is.Equal(tt.expectedLiteral, tok.Literal)
|
||||
}
|
||||
})
|
||||
}
|
||||
func TestNextToken(t *testing.T) {
|
||||
input := `director=='name\'s';actor=eq="name's";Year=le=2000,Year>=2010;(one <= -1.0, two != true),three=in=(1,2,3);c4==5`
|
||||
tests := []struct {
|
||||
expectedType TokenType
|
||||
expectedLiteral string
|
||||
}{
|
||||
{TokIdent, `director`},
|
||||
{TokEQ, `==`},
|
||||
{TokString, `name\'s`},
|
||||
{TokAND, `;`},
|
||||
{TokIdent, `actor`},
|
||||
{TokEQ, `=eq=`},
|
||||
{TokString, `name's`},
|
||||
{TokAND, `;`},
|
||||
{TokIdent, "Year"},
|
||||
{TokLE, "=le="},
|
||||
{TokInteger, "2000"},
|
||||
{TokOR, ","},
|
||||
{TokIdent, "Year"},
|
||||
{TokGE, ">="},
|
||||
{TokInteger, "2010"},
|
||||
{TokAND, ";"},
|
||||
{TokLParen, "("},
|
||||
{TokIdent, "one"},
|
||||
{TokLE, "<="},
|
||||
{TokFloat, "-1.0"},
|
||||
{TokOR, ","},
|
||||
{TokIdent, "two"},
|
||||
{TokNEQ, "!="},
|
||||
{TokTRUE, "true"},
|
||||
{TokRParen, ")"},
|
||||
{TokOR, ","},
|
||||
{TokIdent, "three"},
|
||||
{TokExtend, "=in="},
|
||||
{TokLParen, "("},
|
||||
{TokInteger, "1"},
|
||||
{TokOR, ","},
|
||||
{TokInteger, "2"},
|
||||
{TokOR, ","},
|
||||
{TokInteger, "3"},
|
||||
{TokRParen, ")"},
|
||||
{TokAND, ";"},
|
||||
{TokIdent, "c4"},
|
||||
{TokEQ, "=="},
|
||||
{TokInteger, "5"},
|
||||
}
|
||||
|
||||
t.Run("Next Token Parsing", func(t *testing.T) {
|
||||
is := is.New(t)
|
||||
|
||||
l := NewLexer(input)
|
||||
|
||||
c := 0
|
||||
for _, tt := range tests {
|
||||
c++
|
||||
tok := l.NextToken()
|
||||
|
||||
is.Equal(tt.expectedType, tok.Type)
|
||||
is.Equal(tt.expectedLiteral, tok.Literal)
|
||||
|
||||
}
|
||||
is.Equal(c, len(tests))
|
||||
})
|
||||
}
|
||||
285
rsql/parser.go
Normal file
285
rsql/parser.go
Normal file
|
|
@ -0,0 +1,285 @@
|
|||
package rsql
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Precidence enumerations
|
||||
const (
|
||||
_ = iota
|
||||
PrecedenceLowest
|
||||
PrecedenceAND
|
||||
PrecedenceOR
|
||||
PrecedenceCompare
|
||||
PrecedenceHighest
|
||||
)
|
||||
|
||||
var precidences = map[TokenType]int{
|
||||
TokEQ: PrecedenceCompare,
|
||||
TokNEQ: PrecedenceCompare,
|
||||
TokLT: PrecedenceCompare,
|
||||
TokLE: PrecedenceCompare,
|
||||
TokGT: PrecedenceCompare,
|
||||
TokGE: PrecedenceCompare,
|
||||
TokLIKE: PrecedenceCompare,
|
||||
TokOR: PrecedenceOR,
|
||||
TokAND: PrecedenceAND,
|
||||
}
|
||||
|
||||
type (
|
||||
prefixParseFn func() Expression
|
||||
infixParseFn func(expression Expression) Expression
|
||||
)
|
||||
|
||||
// Parser reads lexed values and builds an AST
|
||||
type Parser struct {
|
||||
l *Lexer
|
||||
errors []string
|
||||
|
||||
curToken Token
|
||||
peekToken Token
|
||||
|
||||
prefixParseFns map[TokenType]prefixParseFn
|
||||
infixParseFns map[TokenType]infixParseFn
|
||||
}
|
||||
|
||||
// NewParser returns a parser for a given lexer
|
||||
func NewParser(l *Lexer) *Parser {
|
||||
p := &Parser{l: l}
|
||||
|
||||
p.prefixParseFns = make(map[TokenType]prefixParseFn)
|
||||
p.registerPrefix(TokIdent, p.parseIdentifier)
|
||||
p.registerPrefix(TokInteger, p.parseInteger)
|
||||
p.registerPrefix(TokFloat, p.parseFloat)
|
||||
p.registerPrefix(TokTRUE, p.parseBool)
|
||||
p.registerPrefix(TokFALSE, p.parseBool)
|
||||
p.registerPrefix(TokNULL, p.parseNull)
|
||||
p.registerPrefix(TokString, p.parseString)
|
||||
p.registerPrefix(TokLParen, p.parseGroupedExpression)
|
||||
p.registerPrefix(TokLBracket, p.parseArray)
|
||||
|
||||
p.infixParseFns = make(map[TokenType]infixParseFn)
|
||||
p.registerInfix(TokEQ, p.parseInfixExpression)
|
||||
p.registerInfix(TokNEQ, p.parseInfixExpression)
|
||||
p.registerInfix(TokLT, p.parseInfixExpression)
|
||||
p.registerInfix(TokLE, p.parseInfixExpression)
|
||||
p.registerInfix(TokGT, p.parseInfixExpression)
|
||||
p.registerInfix(TokGE, p.parseInfixExpression)
|
||||
p.registerInfix(TokLIKE, p.parseInfixExpression)
|
||||
p.registerInfix(TokAND, p.parseInfixExpression)
|
||||
p.registerInfix(TokOR, p.parseInfixExpression)
|
||||
|
||||
p.nextToken()
|
||||
p.nextToken()
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
// DefaultParse sets up a default lex/parse and returns the program
|
||||
func DefaultParse(in string) *Program {
|
||||
args := make(map[string]string)
|
||||
in, argstr, ok := strings.Cut(in, "|")
|
||||
if ok {
|
||||
for _, fd := range strings.Fields(argstr) {
|
||||
a, b, _ := strings.Cut(fd, ":")
|
||||
args[a] = b
|
||||
}
|
||||
}
|
||||
|
||||
l := NewLexer(in)
|
||||
p := NewParser(l)
|
||||
return p.ParseProgram(args)
|
||||
}
|
||||
|
||||
func (p *Parser) registerPrefix(tokenType TokenType, fn prefixParseFn) {
|
||||
p.prefixParseFns[tokenType] = fn
|
||||
}
|
||||
func (p *Parser) registerInfix(tokenType TokenType, fn infixParseFn) {
|
||||
p.infixParseFns[tokenType] = fn
|
||||
}
|
||||
|
||||
// Errors returns a list of errors while parsing
|
||||
func (p *Parser) Errors() []string {
|
||||
return p.errors
|
||||
}
|
||||
func (p *Parser) peekError(t TokenType) {
|
||||
msg := fmt.Sprintf("expected next token to be %s, got %s instad",
|
||||
t, p.peekToken.Type)
|
||||
p.errors = append(p.errors, msg)
|
||||
}
|
||||
|
||||
func (p *Parser) nextToken() {
|
||||
p.curToken = p.peekToken
|
||||
p.peekToken = p.l.NextToken()
|
||||
}
|
||||
func (p *Parser) curTokenIs(t TokenType) bool {
|
||||
return p.curToken.Type == t
|
||||
}
|
||||
func (p *Parser) peekTokenIs(t TokenType) bool {
|
||||
return p.peekToken.Type == t
|
||||
}
|
||||
func (p *Parser) expectPeek(t TokenType) bool {
|
||||
if p.peekTokenIs(t) {
|
||||
p.nextToken()
|
||||
return true
|
||||
}
|
||||
p.peekError(t)
|
||||
return false
|
||||
}
|
||||
func (p *Parser) peekPrecedence() int {
|
||||
if p, ok := precidences[p.peekToken.Type]; ok {
|
||||
return p
|
||||
}
|
||||
return PrecedenceLowest
|
||||
}
|
||||
func (p *Parser) curPrecedence() int {
|
||||
if p, ok := precidences[p.curToken.Type]; ok {
|
||||
return p
|
||||
}
|
||||
return PrecedenceLowest
|
||||
}
|
||||
|
||||
// ParseProgram builds a program AST from lexer
|
||||
func (p *Parser) ParseProgram(args map[string]string) *Program {
|
||||
program := &Program{Args: args}
|
||||
program.Statements = []Statement{}
|
||||
|
||||
for p.curToken.Type != TokEOF {
|
||||
stmt := p.parseStatement()
|
||||
if stmt != nil {
|
||||
program.Statements = append(program.Statements, stmt)
|
||||
}
|
||||
p.nextToken()
|
||||
}
|
||||
|
||||
return program
|
||||
}
|
||||
func (p *Parser) parseStatement() Statement {
|
||||
switch p.curToken.Type {
|
||||
default:
|
||||
return p.parseExpressionStatement()
|
||||
}
|
||||
}
|
||||
func (p *Parser) parseExpressionStatement() *ExpressionStatement {
|
||||
stmt := &ExpressionStatement{Token: p.curToken}
|
||||
stmt.Expression = p.parseExpression(PrecedenceLowest)
|
||||
|
||||
return stmt
|
||||
}
|
||||
func (p *Parser) parseExpression(precedence int) Expression {
|
||||
prefix := p.prefixParseFns[p.curToken.Type]
|
||||
if prefix == nil {
|
||||
msg := fmt.Sprintf("no prefix parse function for %s found", p.curToken.Type)
|
||||
p.errors = append(p.errors, msg)
|
||||
return nil
|
||||
}
|
||||
leftExp := prefix()
|
||||
|
||||
for !p.peekTokenIs(TokEOF) && precedence < p.peekPrecedence() {
|
||||
infix := p.infixParseFns[p.peekToken.Type]
|
||||
if infix == nil {
|
||||
return leftExp
|
||||
}
|
||||
|
||||
p.nextToken()
|
||||
|
||||
leftExp = infix(leftExp)
|
||||
}
|
||||
|
||||
return leftExp
|
||||
}
|
||||
func (p *Parser) parseIdentifier() Expression {
|
||||
return &Identifier{Token: p.curToken, Value: p.curToken.Literal}
|
||||
}
|
||||
func (p *Parser) parseInteger() Expression {
|
||||
lit := &Integer{Token: p.curToken}
|
||||
|
||||
value, err := strconv.ParseInt(p.curToken.Literal, 0, 64)
|
||||
if err != nil {
|
||||
msg := fmt.Sprintf("could not parse %q as integer", p.curToken.Literal)
|
||||
p.errors = append(p.errors, msg)
|
||||
return nil
|
||||
}
|
||||
|
||||
lit.Value = value
|
||||
return lit
|
||||
}
|
||||
func (p *Parser) parseFloat() Expression {
|
||||
lit := &Float{Token: p.curToken}
|
||||
|
||||
value, err := strconv.ParseFloat(p.curToken.Literal, 64)
|
||||
if err != nil {
|
||||
msg := fmt.Sprintf("could not parse %q as float", p.curToken.Literal)
|
||||
p.errors = append(p.errors, msg)
|
||||
return nil
|
||||
}
|
||||
|
||||
lit.Value = value
|
||||
return lit
|
||||
}
|
||||
func (p *Parser) parseBool() Expression {
|
||||
return &Bool{Token: p.curToken, Value: p.curTokenIs(TokTRUE)}
|
||||
}
|
||||
func (p *Parser) parseString() Expression {
|
||||
s := p.curToken.Literal
|
||||
s = strings.Replace(s, `\'`, `'`, -1)
|
||||
s = strings.Replace(s, `\"`, `"`, -1)
|
||||
|
||||
return &String{Token: p.curToken, Value: s}
|
||||
}
|
||||
func (p *Parser) parseNull() Expression {
|
||||
return &Null{Token: p.curToken}
|
||||
}
|
||||
func (p *Parser) parseArray() Expression {
|
||||
array := &Array{Token: p.curToken}
|
||||
array.Elements = p.parseExpressionList(TokRBracket)
|
||||
return array
|
||||
}
|
||||
func (p *Parser) parseExpressionList(end TokenType) []Expression {
|
||||
var list []Expression
|
||||
|
||||
if p.peekTokenIs(end) {
|
||||
p.nextToken()
|
||||
return list
|
||||
}
|
||||
|
||||
p.nextToken()
|
||||
list = append(list, p.parseExpression(PrecedenceHighest))
|
||||
for p.peekTokenIs(TokOR) {
|
||||
p.nextToken()
|
||||
p.nextToken()
|
||||
list = append(list, p.parseExpression(PrecedenceHighest))
|
||||
}
|
||||
|
||||
if !p.expectPeek(end) {
|
||||
return nil
|
||||
}
|
||||
|
||||
return list
|
||||
}
|
||||
func (p *Parser) parseInfixExpression(left Expression) Expression {
|
||||
expression := &InfixExpression{
|
||||
Token: p.curToken,
|
||||
Left: left,
|
||||
Operator: p.curToken.Literal,
|
||||
}
|
||||
|
||||
precidence := p.curPrecedence()
|
||||
p.nextToken()
|
||||
expression.Right = p.parseExpression(precidence)
|
||||
|
||||
return expression
|
||||
}
|
||||
func (p *Parser) parseGroupedExpression() Expression {
|
||||
p.nextToken()
|
||||
|
||||
exp := p.parseExpression(PrecedenceLowest)
|
||||
|
||||
if !p.expectPeek(TokRParen) {
|
||||
return nil
|
||||
}
|
||||
|
||||
return exp
|
||||
}
|
||||
309
rsql/parser_test.go
Normal file
309
rsql/parser_test.go
Normal file
|
|
@ -0,0 +1,309 @@
|
|||
package rsql
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/matryer/is"
|
||||
)
|
||||
|
||||
func typeOf(t any) string { return fmt.Sprintf("%T", t) }
|
||||
|
||||
func TestIdentifierExpression(t *testing.T) {
|
||||
input := `foobar`
|
||||
|
||||
t.Run("Identifier Expressions", func(t *testing.T) {
|
||||
is := is.New(t)
|
||||
|
||||
l := NewLexer(input)
|
||||
p := NewParser(l)
|
||||
|
||||
program := p.ParseProgram(nil)
|
||||
checkParserErrors(t, p)
|
||||
|
||||
is.Equal(len(program.Statements), 1)
|
||||
// if len(program.Statements) != 1 {
|
||||
// t.Fatalf("program has not envough statements. got=%d", len(program.Statements))
|
||||
// }
|
||||
})
|
||||
}
|
||||
|
||||
func TestIntegerExpression(t *testing.T) {
|
||||
input := `5`
|
||||
|
||||
t.Run("IntegerExpression", func(t *testing.T) {
|
||||
is := is.New(t)
|
||||
|
||||
l := NewLexer(input)
|
||||
p := NewParser(l)
|
||||
|
||||
program := p.ParseProgram(nil)
|
||||
checkParserErrors(t, p)
|
||||
|
||||
is.Equal(len(program.Statements), 1)
|
||||
// if len(program.Statements) != 1 {
|
||||
// t.Fatalf("program has not enough statements. got=%d", len(program.Statements))
|
||||
// }
|
||||
|
||||
stmt, ok := program.Statements[0].(*ExpressionStatement)
|
||||
is.Equal(typeOf(program.Statements[0]), typeOf(&ExpressionStatement{}))
|
||||
is.True(ok)
|
||||
// if !ok {
|
||||
// t.Fatalf("program.Statements[0] is not ExpressionStatement got=%T",
|
||||
// program.Statements[0])
|
||||
// }
|
||||
|
||||
literal, ok := stmt.Expression.(*Integer)
|
||||
is.Equal(typeOf(literal), typeOf(&Integer{}))
|
||||
is.True(ok)
|
||||
// if !ok {
|
||||
// t.Fatalf("stmt.Expression is not Integer got=%T",
|
||||
// stmt.Expression)
|
||||
// }
|
||||
|
||||
is.Equal(literal.Value, int64(5))
|
||||
// if literal.Value != 5 {
|
||||
// t.Errorf("literal.Value not %d. got=%d", 5, literal.Value)
|
||||
// }
|
||||
|
||||
is.Equal(literal.TokenLiteral(), "5")
|
||||
// if literal.TokenLiteral() != "5" {
|
||||
// t.Errorf("literal.TokenLiteral not %v. got=%v", "5", literal.TokenLiteral())
|
||||
// }
|
||||
})
|
||||
}
|
||||
|
||||
func TestInfixExpression(t *testing.T) {
|
||||
tests := []struct {
|
||||
input string
|
||||
left string
|
||||
operator string
|
||||
right int64
|
||||
}{
|
||||
{"foo == 1", "foo", "==", 1},
|
||||
{"bar > 2", "bar", ">", 2},
|
||||
{"bin < 3", "bin", "<", 3},
|
||||
{"baz != 4", "baz", "!=", 4},
|
||||
{"buf >= 5", "buf", ">=", 5},
|
||||
{"goz <= 6", "goz", "<=", 6},
|
||||
}
|
||||
t.Run("Infix Expressions", func(t *testing.T) {
|
||||
is := is.New(t)
|
||||
|
||||
for _, tt := range tests {
|
||||
l := NewLexer(tt.input)
|
||||
p := NewParser(l)
|
||||
program := p.ParseProgram(nil)
|
||||
checkParserErrors(t, p)
|
||||
|
||||
is.Equal(len(program.Statements), 1)
|
||||
// if len(program.Statements) != 1 {
|
||||
// t.Fatalf("program has not envough statements. got=%d", len(program.Statements))
|
||||
// }
|
||||
|
||||
stmt, ok := program.Statements[0].(*ExpressionStatement)
|
||||
is.Equal(typeOf(stmt), typeOf(&ExpressionStatement{}))
|
||||
is.True(ok)
|
||||
// if !ok {
|
||||
// t.Fatalf("program.Statements[0] is not ExpressionStatement got=%T",
|
||||
// program.Statements[0])
|
||||
// }
|
||||
|
||||
exp, ok := stmt.Expression.(*InfixExpression)
|
||||
is.Equal(typeOf(exp), typeOf(&InfixExpression{}))
|
||||
is.True(ok)
|
||||
// if !ok {
|
||||
// t.Fatalf("stmt.Expression is not InfixExpression got=%T",
|
||||
// stmt.Expression)
|
||||
// }
|
||||
|
||||
if !testIdentifier(t, exp.Left, tt.left) {
|
||||
return
|
||||
}
|
||||
|
||||
is.Equal(exp.Operator, tt.operator)
|
||||
// if exp.Operator != tt.operator {
|
||||
// t.Fatalf("exp.Operator is not '%v'. got '%v'", tt.operator, exp.Operator)
|
||||
// }
|
||||
|
||||
if testInteger(t, exp.Right, tt.right) {
|
||||
return
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestOperatorPrecedenceParsing(t *testing.T) {
|
||||
tests := []struct {
|
||||
input string
|
||||
expect string
|
||||
}{
|
||||
{
|
||||
"foo == 1; bar == 2.0",
|
||||
"((foo==1);(bar==2.0))",
|
||||
},
|
||||
{
|
||||
`director=='name\'s';actor=eq="name\'s";Year=le=2000,Year>=2010;one <= -1.0, two != true`,
|
||||
`((((director=="name's");(actor=eq="name's"));((Year=le=2000),(Year>=2010)));((one<=-1.0),(two!=true)))`,
|
||||
},
|
||||
}
|
||||
t.Run("Operator Precidence Parsing", func(t *testing.T) {
|
||||
is := is.New(t)
|
||||
|
||||
for _, tt := range tests {
|
||||
l := NewLexer(tt.input)
|
||||
p := NewParser(l)
|
||||
program := p.ParseProgram(nil)
|
||||
checkParserErrors(t, p)
|
||||
|
||||
actual := program.String()
|
||||
is.Equal(actual, tt.expect)
|
||||
// if actual != tt.expect {
|
||||
// t.Errorf("expcected=%q, got=%q", tt.expect, actual)
|
||||
// }
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestParsingArray(t *testing.T) {
|
||||
input := "[1, 2.1, true, null]"
|
||||
|
||||
l := NewLexer(input)
|
||||
p := NewParser(l)
|
||||
program := p.ParseProgram(nil)
|
||||
checkParserErrors(t, p)
|
||||
|
||||
if len(program.Statements) != 1 {
|
||||
t.Fatalf("program has not enough statements. got=%d", len(program.Statements))
|
||||
}
|
||||
|
||||
stmt, ok := program.Statements[0].(*ExpressionStatement)
|
||||
if !ok {
|
||||
t.Fatalf("program.Statements[0] is not ExpressionStatement got=%T",
|
||||
program.Statements[0])
|
||||
}
|
||||
|
||||
array, ok := stmt.Expression.(*Array)
|
||||
if !ok {
|
||||
t.Fatalf("stmt.Expression is not Array got=%T",
|
||||
stmt.Expression)
|
||||
}
|
||||
|
||||
if len(array.Elements) != 4 {
|
||||
t.Fatalf("len(array.Elements) not 4. got=%v", len(array.Elements))
|
||||
}
|
||||
|
||||
testInteger(t, array.Elements[0], 1)
|
||||
testFloat(t, array.Elements[1], 2.1)
|
||||
testBool(t, array.Elements[2], true)
|
||||
testNull(t, array.Elements[3])
|
||||
}
|
||||
|
||||
func checkParserErrors(t *testing.T, p *Parser) {
|
||||
errors := p.Errors()
|
||||
if len(errors) == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
t.Errorf("parser has %d errors", len(errors))
|
||||
for _, msg := range errors {
|
||||
t.Errorf("parser error: %q", msg)
|
||||
}
|
||||
t.FailNow()
|
||||
}
|
||||
|
||||
func testInteger(t *testing.T, e Expression, value int64) bool {
|
||||
literal, ok := e.(*Integer)
|
||||
if !ok {
|
||||
t.Errorf("stmt.Expression is not Integer got=%T", e)
|
||||
return false
|
||||
}
|
||||
|
||||
if literal.Value != value {
|
||||
t.Errorf("literal.Value not %d. got=%d", value, literal.Value)
|
||||
return false
|
||||
}
|
||||
|
||||
if literal.TokenLiteral() != fmt.Sprintf("%v", value) {
|
||||
t.Errorf("literal.TokenLiteral not %v. got=%v", value, literal.TokenLiteral())
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
func testFloat(t *testing.T, e Expression, value float64) bool {
|
||||
literal, ok := e.(*Float)
|
||||
if !ok {
|
||||
t.Errorf("stmt.Expression is not Float got=%T", e)
|
||||
return false
|
||||
}
|
||||
|
||||
if literal.Value != value {
|
||||
t.Errorf("literal.Value not %f. got=%f", value, literal.Value)
|
||||
return false
|
||||
}
|
||||
|
||||
if literal.TokenLiteral() != fmt.Sprintf("%v", value) {
|
||||
t.Errorf("literal.TokenLiteral not %q. got=%q", fmt.Sprintf("%v", value), literal.TokenLiteral())
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
func testBool(t *testing.T, e Expression, value bool) bool {
|
||||
literal, ok := e.(*Bool)
|
||||
if !ok {
|
||||
t.Errorf("stmt.Expression is not Float got=%T", e)
|
||||
return false
|
||||
}
|
||||
|
||||
if literal.Value != value {
|
||||
t.Errorf("literal.Value not %t. got=%t", value, literal.Value)
|
||||
return false
|
||||
}
|
||||
|
||||
if literal.TokenLiteral() != fmt.Sprintf("%v", value) {
|
||||
t.Errorf("literal.TokenLiteral not %v. got=%v", value, literal.TokenLiteral())
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
func testNull(t *testing.T, e Expression) bool {
|
||||
literal, ok := e.(*Null)
|
||||
if !ok {
|
||||
t.Errorf("stmt.Expression is not Null got=%T", e)
|
||||
return false
|
||||
}
|
||||
if literal.Token.Type != TokNULL {
|
||||
t.Errorf("liternal.Token is not TokNULL got=%T", e)
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
func testIdentifier(t *testing.T, e Expression, value string) bool {
|
||||
literal, ok := e.(*Identifier)
|
||||
if !ok {
|
||||
t.Errorf("stmt.Expression is not Integer got=%T", e)
|
||||
return false
|
||||
}
|
||||
|
||||
if literal.Value != value {
|
||||
t.Errorf("literal.Value not %s. got=%s", value, literal.Value)
|
||||
return false
|
||||
}
|
||||
|
||||
if literal.TokenLiteral() != value {
|
||||
t.Errorf("literal.TokenLiteral not %v. got=%v", value, literal.TokenLiteral())
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
func TestReplace(t *testing.T) {
|
||||
is := is.New(t)
|
||||
is.Equal(strings.Replace(`name\'s`, `\'`, `'`, -1), `name's`)
|
||||
}
|
||||
300
rsql/squirrel/sqlizer.go
Normal file
300
rsql/squirrel/sqlizer.go
Normal file
|
|
@ -0,0 +1,300 @@
|
|||
package squirrel
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"github.com/Masterminds/squirrel"
|
||||
"go.sour.is/pkg/rsql"
|
||||
)
|
||||
|
||||
type dbInfo interface {
|
||||
Col(string) (string, error)
|
||||
}
|
||||
|
||||
type args map[string]string
|
||||
|
||||
func (d *decoder) mkArgs(a args) args {
|
||||
m := make(args, len(a))
|
||||
for k, v := range a {
|
||||
if k == "limit" || k == "offset" {
|
||||
m[k] = v
|
||||
continue
|
||||
}
|
||||
|
||||
var err error
|
||||
if k, err = d.dbInfo.Col(k); err == nil {
|
||||
m[k] = v
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return m
|
||||
}
|
||||
|
||||
func (a args) Limit() (uint64, bool) {
|
||||
if a == nil {
|
||||
return 0, false
|
||||
}
|
||||
if v, ok := a["limit"]; ok {
|
||||
i, err := strconv.ParseUint(v, 10, 64)
|
||||
return i, err == nil
|
||||
}
|
||||
|
||||
return 0, false
|
||||
}
|
||||
func (a args) Offset() (uint64, bool) {
|
||||
if a == nil {
|
||||
return 0, false
|
||||
}
|
||||
if v, ok := a["offset"]; ok {
|
||||
i, err := strconv.ParseUint(v, 10, 64)
|
||||
return i, err == nil
|
||||
}
|
||||
|
||||
return 0, false
|
||||
}
|
||||
func (a args) Order() []string {
|
||||
var lis []string
|
||||
|
||||
for k, v := range a {
|
||||
if k == "limit" || k == "offset" {
|
||||
continue
|
||||
}
|
||||
lis = append(lis, k+" "+v)
|
||||
}
|
||||
|
||||
return lis
|
||||
}
|
||||
|
||||
func Query(in string, db dbInfo) (squirrel.Sqlizer, args, error) {
|
||||
d := decoder{dbInfo: db}
|
||||
program := rsql.DefaultParse(in)
|
||||
sql, err := d.decode(program)
|
||||
return sql, d.mkArgs(program.Args), err
|
||||
}
|
||||
|
||||
type decoder struct {
|
||||
dbInfo dbInfo
|
||||
}
|
||||
|
||||
func (db *decoder) decode(in *rsql.Program) (squirrel.Sqlizer, error) {
|
||||
switch len(in.Statements) {
|
||||
case 0:
|
||||
return nil, nil
|
||||
case 1:
|
||||
return db.decodeStatement(in.Statements[0])
|
||||
default:
|
||||
a := squirrel.And{}
|
||||
for _, stmt := range in.Statements {
|
||||
d, err := db.decodeStatement(stmt)
|
||||
if d == nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
a = append(a, d)
|
||||
}
|
||||
return a, nil
|
||||
}
|
||||
}
|
||||
func (db *decoder) decodeStatement(in rsql.Statement) (squirrel.Sqlizer, error) {
|
||||
switch s := in.(type) {
|
||||
case *rsql.ExpressionStatement:
|
||||
return db.decodeExpression(s.Expression)
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
func (db *decoder) decodeExpression(in rsql.Expression) (squirrel.Sqlizer, error) {
|
||||
switch e := in.(type) {
|
||||
case *rsql.InfixExpression:
|
||||
return db.decodeInfix(e)
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
func (db *decoder) decodeInfix(in *rsql.InfixExpression) (squirrel.Sqlizer, error) {
|
||||
|
||||
switch in.Token.Type {
|
||||
case rsql.TokAND:
|
||||
a := squirrel.And{}
|
||||
left, err := db.decodeExpression(in.Left)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
switch v := left.(type) {
|
||||
case squirrel.And:
|
||||
for _, el := range v {
|
||||
if el != nil {
|
||||
a = append(a, el)
|
||||
}
|
||||
}
|
||||
|
||||
default:
|
||||
if v != nil {
|
||||
a = append(a, v)
|
||||
}
|
||||
}
|
||||
|
||||
right, err := db.decodeExpression(in.Right)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
switch v := right.(type) {
|
||||
case squirrel.And:
|
||||
for _, el := range v {
|
||||
if el != nil {
|
||||
a = append(a, el)
|
||||
}
|
||||
}
|
||||
|
||||
default:
|
||||
if v != nil {
|
||||
a = append(a, v)
|
||||
}
|
||||
}
|
||||
|
||||
return a, nil
|
||||
case rsql.TokOR:
|
||||
left, err := db.decodeExpression(in.Left)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
right, err := db.decodeExpression(in.Right)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return squirrel.Or{left, right}, nil
|
||||
case rsql.TokEQ:
|
||||
col, err := db.dbInfo.Col(in.Left.String())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
v, err := db.decodeValue(in.Right)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return squirrel.Eq{col: v}, nil
|
||||
case rsql.TokLIKE:
|
||||
col, err := db.dbInfo.Col(in.Left.String())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
v, err := db.decodeValue(in.Right)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
switch value := v.(type) {
|
||||
case string:
|
||||
return Like{col, strings.Replace(value, "*", "%", -1)}, nil
|
||||
default:
|
||||
return nil, fmt.Errorf("LIKE requires a string value")
|
||||
}
|
||||
|
||||
case rsql.TokNEQ:
|
||||
col, err := db.dbInfo.Col(in.Left.String())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
v, err := db.decodeValue(in.Right)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return squirrel.NotEq{col: v}, nil
|
||||
case rsql.TokGT:
|
||||
col, err := db.dbInfo.Col(in.Left.String())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
v, err := db.decodeValue(in.Right)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return squirrel.Gt{col: v}, nil
|
||||
case rsql.TokGE:
|
||||
col, err := db.dbInfo.Col(in.Left.String())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
v, err := db.decodeValue(in.Right)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return squirrel.GtOrEq{col: v}, nil
|
||||
case rsql.TokLT:
|
||||
col, err := db.dbInfo.Col(in.Left.String())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
v, err := db.decodeValue(in.Right)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return squirrel.Lt{col: v}, nil
|
||||
case rsql.TokLE:
|
||||
col, err := db.dbInfo.Col(in.Left.String())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
v, err := db.decodeValue(in.Right)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return squirrel.LtOrEq{col: v}, nil
|
||||
default:
|
||||
return nil, nil
|
||||
}
|
||||
}
|
||||
func (db *decoder) decodeValue(in rsql.Expression) (interface{}, error) {
|
||||
switch v := in.(type) {
|
||||
case *rsql.Array:
|
||||
var values []interface{}
|
||||
for _, el := range v.Elements {
|
||||
v, err := db.decodeValue(el)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
values = append(values, v)
|
||||
}
|
||||
|
||||
return values, nil
|
||||
case *rsql.InfixExpression:
|
||||
return db.decodeInfix(v)
|
||||
case *rsql.Identifier:
|
||||
return v.Value, nil
|
||||
case *rsql.Integer:
|
||||
return v.Value, nil
|
||||
case *rsql.Float:
|
||||
return v.Value, nil
|
||||
case *rsql.String:
|
||||
return v.Value, nil
|
||||
case *rsql.Bool:
|
||||
return v.Value, nil
|
||||
case *rsql.Null:
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
type Like struct {
|
||||
column string
|
||||
value string
|
||||
}
|
||||
|
||||
func (l Like) ToSql() (sql string, args []interface{}, err error) {
|
||||
sql = fmt.Sprintf("%s LIKE(?)", l.column)
|
||||
args = append(args, l.value)
|
||||
return
|
||||
}
|
||||
141
rsql/squirrel/sqlizer_test.go
Normal file
141
rsql/squirrel/sqlizer_test.go
Normal file
|
|
@ -0,0 +1,141 @@
|
|||
package squirrel
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"testing"
|
||||
|
||||
"github.com/Masterminds/squirrel"
|
||||
"github.com/matryer/is"
|
||||
"go.sour.is/pkg/rsql"
|
||||
)
|
||||
|
||||
type testTable struct {
|
||||
Foo string `json:"foo"`
|
||||
Bar string `json:"bar"`
|
||||
Baz string `json:"baz"`
|
||||
Director string `json:"director"`
|
||||
Actor string `json:"actor"`
|
||||
Year string `json:"year"`
|
||||
Genres string `json:"genres"`
|
||||
One string `json:"one"`
|
||||
Two string `json:"two"`
|
||||
Family string `json:"family_name"`
|
||||
}
|
||||
|
||||
func TestQuery(t *testing.T) {
|
||||
d := rsql.GetDbColumns(testTable{})
|
||||
is := is.New(t)
|
||||
|
||||
tests := []struct {
|
||||
input string
|
||||
expect squirrel.Sqlizer
|
||||
expectLimit *uint64
|
||||
expectOffset *uint64
|
||||
expectOrder []string
|
||||
fail bool
|
||||
}{
|
||||
{input: "foo==[1, 2, 3]", expect: squirrel.Eq{"foo": []interface{}{1, 2, 3}}},
|
||||
{input: "foo==1,(bar==2;baz==3)", expect: squirrel.Or{squirrel.Eq{"foo": 1}, squirrel.And{squirrel.Eq{"bar": 2}, squirrel.Eq{"baz": 3}}}},
|
||||
|
||||
{input: "foo==1", expect: squirrel.Eq{"foo": 1}},
|
||||
{input: "foo!=1.1", expect: squirrel.NotEq{"foo": 1.1}},
|
||||
{input: "foo==true", expect: squirrel.Eq{"foo": true}},
|
||||
{input: "foo==null", expect: squirrel.Eq{"foo": nil}},
|
||||
{input: "foo>2", expect: squirrel.Gt{"foo": 2}},
|
||||
{input: "foo>=2.1", expect: squirrel.GtOrEq{"foo": 2.1}},
|
||||
{input: "foo<3", expect: squirrel.Lt{"foo": 3}},
|
||||
{input: "foo<=3.1", expect: squirrel.LtOrEq{"foo": 3.1}},
|
||||
|
||||
{input: "foo=eq=1", expect: squirrel.Eq{"foo": 1}},
|
||||
{input: "foo=neq=1.1", expect: squirrel.NotEq{"foo": 1.1}},
|
||||
{input: "foo=gt=2", expect: squirrel.Gt{"foo": 2}},
|
||||
{input: "foo=ge=2.1", expect: squirrel.GtOrEq{"foo": 2.1}},
|
||||
{input: "foo=lt=3", expect: squirrel.Lt{"foo": 3}},
|
||||
{input: "foo=le=3.1", expect: squirrel.LtOrEq{"foo": 3.1}},
|
||||
|
||||
{input: "foo==1;bar==2", expect: squirrel.And{squirrel.Eq{"foo": 1}, squirrel.Eq{"bar": 2}}},
|
||||
{input: "foo==1,bar==2", expect: squirrel.Or{squirrel.Eq{"foo": 1}, squirrel.Eq{"bar": 2}}},
|
||||
{input: "foo==1,bar==2;baz=3", expect: nil},
|
||||
{
|
||||
input: `director=='name\'s';actor=eq="name\'s";Year=le=2000,Year>=2010;one <= -1.0, two != true`,
|
||||
expect: squirrel.And{
|
||||
squirrel.Eq{"director": "name's"},
|
||||
squirrel.Eq{"actor": "name's"},
|
||||
squirrel.Or{
|
||||
squirrel.LtOrEq{"year": 2000},
|
||||
squirrel.GtOrEq{"year": 2010},
|
||||
},
|
||||
squirrel.Or{
|
||||
squirrel.LtOrEq{"one": -1.0},
|
||||
squirrel.NotEq{"two": true},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
input: `genres==[sci-fi,action] ; genres==[romance,animated,horror] , director~Que*Tarantino`,
|
||||
expect: squirrel.And{
|
||||
squirrel.Eq{"genres": []interface{}{"sci-fi", "action"}},
|
||||
squirrel.Or{
|
||||
squirrel.Eq{"genres": []interface{}{"romance", "animated", "horror"}},
|
||||
Like{"director", "Que%Tarantino"},
|
||||
},
|
||||
},
|
||||
},
|
||||
{input: "", expect: nil},
|
||||
{input: "family_name==LUNDY", expect: squirrel.Eq{"family_name": "LUNDY"}},
|
||||
{input: "family_name==[1,2,null]", expect: squirrel.Eq{"family_name": []interface{}{1, 2, nil}}},
|
||||
{input: "family_name=LUNDY", expect: nil},
|
||||
{input: "family_name==LUNDY and family_name==SMITH", expect: squirrel.And{squirrel.Eq{"family_name": "LUNDY"}, squirrel.Eq{"family_name": "SMITH"}}},
|
||||
{input: "family_name==LUNDY or family_name==SMITH", expect: squirrel.Or{squirrel.Eq{"family_name": "LUNDY"}, squirrel.Eq{"family_name": "SMITH"}}},
|
||||
{input: "foo==1,family_name=LUNDY;baz==2", expect: nil},
|
||||
{input: "foo ~ bar*", expect: Like{"foo", "bar%"}},
|
||||
{input: "foo ~ [bar*,bin*]", expect: nil, fail: true},
|
||||
{input: "foo==1|limit:10", expect: squirrel.Eq{"foo": 1}, expectLimit: ptr(uint64(10))},
|
||||
{input: "foo==1|offset:2", expect: squirrel.Eq{"foo": 1}, expectOffset: ptr(uint64(2))},
|
||||
{
|
||||
input: "foo>=1|limit:10 offset:2 foo:desc",
|
||||
expect: squirrel.GtOrEq{"foo": 1},
|
||||
expectLimit: ptr(uint64(10)),
|
||||
expectOffset: ptr(uint64(2)),
|
||||
expectOrder: []string{"foo desc"},
|
||||
},
|
||||
}
|
||||
|
||||
for i, tt := range tests {
|
||||
q, a, err := Query(tt.input, d)
|
||||
if !tt.fail && err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
if q != nil {
|
||||
t.Log(q.ToSql())
|
||||
}
|
||||
|
||||
actual := fmt.Sprintf("%#v", q)
|
||||
expect := fmt.Sprintf("%#v", tt.expect)
|
||||
if expect != actual {
|
||||
t.Errorf("test[%d]: %v\n\tinput and expected are not the same. wanted=%s got=%s", i, tt.input, expect, actual)
|
||||
}
|
||||
|
||||
if limit, ok := a.Limit(); tt.expectLimit != nil {
|
||||
is.True(ok)
|
||||
is.Equal(limit, *tt.expectLimit)
|
||||
} else {
|
||||
is.True(!ok)
|
||||
}
|
||||
|
||||
if offset, ok := a.Offset(); tt.expectOffset != nil {
|
||||
is.True(ok)
|
||||
is.Equal(offset, *tt.expectOffset)
|
||||
} else {
|
||||
is.True(!ok)
|
||||
}
|
||||
|
||||
if order := a.Order(); tt.expectOrder != nil {
|
||||
is.Equal(order, tt.expectOrder)
|
||||
} else {
|
||||
is.Equal(len(order), 0)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func ptr[T any](t T) *T { return &t }
|
||||
62
rsql/token.go
Normal file
62
rsql/token.go
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
package rsql
|
||||
|
||||
// Tokens for RSQL FIQL
|
||||
const (
|
||||
TokIllegal = "TokIllegal"
|
||||
TokEOF = "TokEOF"
|
||||
|
||||
TokIdent = "TokIdent"
|
||||
TokInteger = "TokInteger"
|
||||
TokString = "TokString"
|
||||
TokFloat = "TokFloat"
|
||||
TokExtend = "TokExtend"
|
||||
|
||||
TokLParen = "("
|
||||
TokRParen = ")"
|
||||
|
||||
TokLBracket = "["
|
||||
TokRBracket = "]"
|
||||
|
||||
TokLIKE = "~"
|
||||
TokNLIKE= "!~"
|
||||
TokNOT = "!"
|
||||
TokLT = "<"
|
||||
TokGT = ">"
|
||||
TokLE = "<="
|
||||
TokGE = ">="
|
||||
TokEQ = "=="
|
||||
TokNEQ = "!="
|
||||
TokAND = ";"
|
||||
TokOR = ","
|
||||
|
||||
TokTRUE = "true"
|
||||
TokFALSE = "false"
|
||||
TokNULL = "null"
|
||||
)
|
||||
|
||||
var keywords = map[string]TokenType {
|
||||
"true": TokTRUE,
|
||||
"false": TokFALSE,
|
||||
"null": TokNULL,
|
||||
"and": TokAND,
|
||||
"or": TokOR,
|
||||
}
|
||||
|
||||
// TokenType is a token enumeration
|
||||
type TokenType string
|
||||
// Token is a type and literal pair
|
||||
type Token struct {
|
||||
Type TokenType
|
||||
Literal string
|
||||
}
|
||||
|
||||
func newToken(tokenType TokenType, ch rune) Token {
|
||||
return Token{Type: tokenType, Literal: string(ch)}
|
||||
}
|
||||
|
||||
func lookupIdent(ident string) TokenType {
|
||||
if tok, ok := keywords[ident]; ok {
|
||||
return tok
|
||||
}
|
||||
return TokIdent
|
||||
}
|
||||
|
|
@ -6,6 +6,7 @@ import (
|
|||
"strings"
|
||||
|
||||
"go.sour.is/pkg/math"
|
||||
"golang.org/x/exp/maps"
|
||||
)
|
||||
|
||||
type Set[T comparable] map[T]struct{}
|
||||
|
|
@ -33,6 +34,9 @@ func (s Set[T]) Delete(items ...T) Set[T] {
|
|||
}
|
||||
return s
|
||||
}
|
||||
func (s Set[T]) Values() []T {
|
||||
return maps.Keys(s)
|
||||
}
|
||||
|
||||
func (s Set[T]) Equal(e Set[T]) bool {
|
||||
for k := range s {
|
||||
|
|
|
|||
BIN
sour.is-mercury
Executable file
BIN
sour.is-mercury
Executable file
Binary file not shown.
30
xdg/xdg.go
30
xdg/xdg.go
|
|
@ -4,6 +4,7 @@
|
|||
package xdg
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
|
@ -36,6 +37,9 @@ func setENV(name, value string) string {
|
|||
return literal(name)
|
||||
}
|
||||
func Get(base, suffix string) string {
|
||||
return strings.Join(paths(base, suffix), string(os.PathListSeparator))
|
||||
}
|
||||
func paths(base, suffix string) []string {
|
||||
paths := strings.Split(os.ExpandEnv(base), string(os.PathListSeparator))
|
||||
for i, path := range paths {
|
||||
if strings.HasPrefix(path, "~") {
|
||||
|
|
@ -43,7 +47,17 @@ func Get(base, suffix string) string {
|
|||
}
|
||||
paths[i] = os.ExpandEnv(filepath.Join(path, suffix))
|
||||
}
|
||||
return strings.Join(paths, string(os.PathListSeparator))
|
||||
return paths
|
||||
}
|
||||
func Find(base, filename string) []string {
|
||||
var files []string
|
||||
for _, f := range paths(base, filename) {
|
||||
if ok, _ := exists(f); !ok {
|
||||
continue
|
||||
}
|
||||
files = append(files, f)
|
||||
}
|
||||
return files
|
||||
}
|
||||
|
||||
func getHome() string {
|
||||
|
|
@ -53,3 +67,17 @@ func getHome() string {
|
|||
}
|
||||
return home
|
||||
}
|
||||
|
||||
func exists(name string) (bool, error) {
|
||||
s, err := os.Stat(name)
|
||||
if err == nil {
|
||||
return true, nil
|
||||
}
|
||||
if errors.Is(err, os.ErrNotExist) {
|
||||
return false, nil
|
||||
}
|
||||
if s.IsDir() {
|
||||
return false, nil
|
||||
}
|
||||
return false, err
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user