package mercury import ( "context" "fmt" "path/filepath" "sort" "strconv" "strings" "go.sour.is/pkg/lg" "go.sour.is/pkg/ident" "go.sour.is/pkg/rsql" "go.sour.is/pkg/set" "golang.org/x/sync/errgroup" ) 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.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) Identity() 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 = ®istry{} 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) } } } wg, ctx := errgroup.WithContext(ctx) slots := make(chan Config, len(r.matchers.getConfig)) wg.Go(func() error { i := 0 for lis := range slots { c = append(c, lis...) i++ if i > len(slots) { break } } return nil }) for i, hdlr := range r.matchers.getIndex { i, hdlr := i, hdlr wg.Go(func() error { span.AddEvent(fmt.Sprintf("INDEX %s %s", hdlr.Name, hdlr.Match)) lis, err := hdlr.Handler.GetIndex(ctx, matches[i], pgm) slots <- lis return err }) } err = wg.Wait() if err != nil { return nil, err } 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.Sprintf("QUERY %s %s", 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.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 }