snapshot of https://github.com/cortezaproject/corteza.git (2024.9.x, 2026-09-18; blobs > 131072B omitted)

server/pkg/apigw/pipeline/chain/default.go

@@ -0,0 +1,38 @@
+package chain
+
+import (
+	"net/http"
+
+	"github.com/go-chi/chi/v5"
+)
+
+type (
+	middleware []func(http.Handler) http.Handler
+
+	ChainHandler interface {
+		Handler() http.Handler
+		Chain(middleware)
+	}
+
+	chiHandlerChainDefault struct {
+		chain middleware
+	}
+)
+
+func NewDefault() *chiHandlerChainDefault {
+	return &chiHandlerChainDefault{}
+}
+
+func (cc *chiHandlerChainDefault) Chain(m middleware) {
+	cc.chain = m
+}
+
+func (cc *chiHandlerChainDefault) Handler() http.Handler {
+	return chiHandler(cc.chain)
+}
+
+func chiHandler(cc middleware) http.Handler {
+	return chi.
+		Chain(cc...).
+		HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {})
+}

server/pkg/apigw/pipeline/chain/profiler.go

@@ -0,0 +1,29 @@
+package chain
+
+import (
+	"net/http"
+
+	"github.com/cortezaproject/corteza/server/pkg/apigw/profiler"
+)
+
+type (
+	chiHandlerChainProfiler struct {
+		chain middleware
+	}
+)
+
+func NewProfiler() *chiHandlerChainProfiler {
+	return &chiHandlerChainProfiler{}
+}
+
+func (cc *chiHandlerChainProfiler) Chain(m middleware) {
+	cc.chain = m
+}
+
+func (cc *chiHandlerChainProfiler) Handler() http.Handler {
+	// wrap handlers around the chain so we get some profiling info
+	cc.chain = append([]func(http.Handler) http.Handler{profiler.StartHandler}, cc.chain...)
+	cc.chain = append(cc.chain, profiler.FinishHandler)
+
+	return chiHandler(cc.chain)
+}

server/pkg/apigw/pipeline/pipeline.go

@@ -0,0 +1,157 @@
+package pipeline
+
+import (
+	"context"
+	"net/http"
+	"sort"
+	"time"
+
+	actx "github.com/cortezaproject/corteza/server/pkg/apigw/ctx"
+	"github.com/cortezaproject/corteza/server/pkg/apigw/pipeline/chain"
+	"github.com/cortezaproject/corteza/server/pkg/apigw/types"
+	"github.com/cortezaproject/corteza/server/pkg/auth"
+	"go.uber.org/zap"
+)
+
+type (
+	Worker struct {
+		Weight  int
+		Async   bool
+		Name    string
+		Type    types.FilterKind
+		Handler func(rw http.ResponseWriter, r *http.Request) error
+	}
+
+	workerSet []*Worker
+
+	Pl struct {
+		workers workerSet
+		ch      chain.ChainHandler
+		err     types.ErrorHandlerFunc
+		log     *zap.Logger
+		async   bool
+	}
+)
+
+func NewPipeline(log *zap.Logger, ch chain.ChainHandler) *Pl {
+	var (
+		defaultErrorHandler = types.NewDefaultErrorHandler(log)
+	)
+
+	return &Pl{
+		ch:  ch,
+		log: log,
+		err: defaultErrorHandler.Handler(),
+	}
+}
+
+func (pp *Pl) Async(a bool) {
+	pp.async = a
+}
+
+func (pp *Pl) Error() types.ErrorHandlerFunc {
+	return pp.err
+}
+
+// ErrorHandler adds error handler
+func (pp *Pl) ErrorHandler(ff types.ErrorHandlerFunc) {
+	pp.err = ff
+}
+
+// Add filter
+func (pp *Pl) Add(w *Worker) {
+	pp.workers = append(pp.workers, w)
+	sort.Sort(pp.workers)
+}
+
+// Handler is the main operating entry point for requests
+// that handles filter groups
+func (pp *Pl) Handler() http.Handler {
+	// use the chi implementation of chains
+	pp.ch.Chain(pp.makeMiddleware(pp.workers...))
+	return pp.ch.Handler()
+}
+
+// makeMiddleware creates a list of handlers from workers
+// it is used in chaining
+func (pp *Pl) makeMiddleware(hh ...*Worker) (middleware []func(http.Handler) http.Handler) {
+	for _, wrker := range hh {
+		middleware = append(middleware, pp.makeHandler(*wrker))
+	}
+
+	return middleware
+}
+
+// makeHandler creates a handler from worker, it also
+// wraps the error handling
+func (pp *Pl) makeHandler(hh Worker) func(next http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
+			var (
+				err   error
+				start = time.Now()
+				log   = pp.log.With(zap.String("filter", hh.Name))
+			)
+
+			log.Debug("started processing", zap.Bool("async", hh.Async))
+
+			fn := func() (err error) {
+				err = hh.Handler(rw, r)
+				log.Debug("finished processing", zap.Duration("duration", time.Since(start)))
+				return
+			}
+
+			if hh.Async {
+				go func() {
+					var (
+						newCtx = context.Background()
+
+						ident = auth.GetIdentityFromContext(r.Context())
+						scope = actx.ScopeFromContext(r.Context())
+					)
+
+					newCtx = actx.ScopeToContext(context.Background(), scope)
+					newCtx = auth.SetIdentityToContext(newCtx, ident)
+
+					r = r.WithContext(newCtx)
+
+					// only log error, do not call error handler,
+					// since we do not reply back the response (it was already sent)
+					if err = fn(); err != nil {
+						log.Error(err.Error())
+					}
+				}()
+			} else {
+				err = fn()
+			}
+
+			if err != nil {
+				pp.err(rw, r, err)
+				return
+			} else {
+				next.ServeHTTP(rw, r)
+			}
+		})
+	}
+}
+
+func (a workerSet) Len() int { return len(a) }
+func (a workerSet) Less(i, j int) bool {
+	return a[i].Weight < a[j].Weight
+}
+func (a workerSet) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+
+func (a workerSet) Filter(f func(*Worker) (bool, error)) (out workerSet, err error) {
+	var ok bool
+	out = workerSet{}
+
+	for i := range a {
+		if ok, err = f(a[i]); err != nil {
+			return
+		} else if ok {
+			out = append(out, a[i])
+		}
+	}
+
+	return
+}

server/pkg/apigw/pipeline/pipeline_test.go

@@ -0,0 +1,126 @@
+package pipeline
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/cortezaproject/corteza/server/pkg/apigw/pipeline/chain"
+	"github.com/cortezaproject/corteza/server/pkg/apigw/types"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+)
+
+var (
+	mockEmptyHandler = func(rw http.ResponseWriter, r *http.Request) (err error) { return }
+)
+
+func NewPl() *Pl {
+	return NewPipeline(zap.NewNop(), chain.NewDefault())
+}
+
+func Test_pipelineAdd(t *testing.T) {
+	var (
+		req = require.New(t)
+	)
+
+	p := NewPl()
+	p.Add(&Worker{
+		Handler: mockEmptyHandler,
+		Weight:  0,
+		Name:    "mockWorker",
+	})
+
+	req.Len(p.workers, 1)
+}
+
+func Test_pipelineHandleMultiple(t *testing.T) {
+	var (
+		req = require.New(t)
+		rr  = httptest.NewRecorder()
+		p   = NewPl()
+
+		first = types.MockHandler{
+			Handler_: func(rw http.ResponseWriter, r *http.Request) error {
+				rw.Write([]byte(`first`))
+				return nil
+			},
+		}
+
+		second = types.MockHandler{
+			Handler_: func(rw http.ResponseWriter, r *http.Request) error {
+				rw.Write([]byte(`second`))
+				return nil
+			},
+		}
+	)
+
+	p.Add(&Worker{
+		Handler: first.Handler(),
+		Weight:  5,
+		Name:    "mockHandler",
+	})
+
+	p.Add(&Worker{
+		Handler: second.Handler(),
+		Weight:  0,
+		Name:    "mockHandler",
+	})
+
+	p.Handler().ServeHTTP(rr, &http.Request{})
+
+	req.Equal(`secondfirst`, rr.Body.String())
+}
+
+func Test_pipelineExecErr(t *testing.T) {
+	type (
+		tf struct {
+			name string
+			mh   types.MockHandler
+			w    *Worker
+			wgt  int
+			exp  string
+		}
+	)
+
+	var (
+		tcc = []tf{
+			{
+				name: "matching simple",
+				mh: types.MockHandler{
+					Handler_: func(rw http.ResponseWriter, r *http.Request) error {
+						return fmt.Errorf("triggered")
+					}},
+				w:   &Worker{},
+				exp: `{"error":{"message":"triggered"}}` + "\n",
+			},
+			{
+				name: "matching simple",
+				mh: types.MockHandler{
+					Handler_: func(rw http.ResponseWriter, r *http.Request) error {
+						rw.Write([]byte(`foobar`))
+						return nil
+					}},
+				w:   &Worker{},
+				exp: `foobar`,
+			},
+		}
+	)
+
+	for _, tc := range tcc {
+		var (
+			p   = NewPl()
+			rr  = httptest.NewRecorder()
+			req = require.New(t)
+		)
+
+		tc.w.Handler = tc.mh.Handler()
+
+		p.Add(tc.w)
+		p.Handler().ServeHTTP(rr, &http.Request{})
+
+		req.Equal(tc.exp, rr.Body.String())
+	}
+
+}