krakend-ce

1
package krakend
2

3
import (
4
	"context"
5
	"fmt"
6

7
	otellura "github.com/krakend/krakend-otel/lura"
8
	amqp "github.com/krakendio/krakend-amqp/v2"
9
	cel "github.com/krakendio/krakend-cel/v2"
10
	cb "github.com/krakendio/krakend-circuitbreaker/v2/gobreaker/proxy"
11
	httpcache "github.com/krakendio/krakend-httpcache/v2"
12
	lambda "github.com/krakendio/krakend-lambda/v2"
13
	lua "github.com/krakendio/krakend-lua/v2/proxy"
14
	martian "github.com/krakendio/krakend-martian/v2"
15
	metrics "github.com/krakendio/krakend-metrics/v2/gin"
16
	oauth2client "github.com/krakendio/krakend-oauth2-clientcredentials/v2"
17
	opencensus "github.com/krakendio/krakend-opencensus/v2"
18
	pubsub "github.com/krakendio/krakend-pubsub/v2"
19
	ratelimit "github.com/krakendio/krakend-ratelimit/v3/proxy"
20
	"github.com/luraproject/lura/v2/config"
21
	"github.com/luraproject/lura/v2/logging"
22
	"github.com/luraproject/lura/v2/proxy"
23
	"github.com/luraproject/lura/v2/transport/http/client"
24
	httprequestexecutor "github.com/luraproject/lura/v2/transport/http/client/plugin"
25
)
26

27
// NewBackendFactory creates a BackendFactory by stacking all the available middlewares:
28
// - oauth2 client credentials
29
// - http cache
30
// - martian
31
// - pubsub
32
// - amqp
33
// - cel
34
// - lua
35
// - rate-limit
36
// - circuit breaker
37
// - metrics collector
38
// - opencensus collector
39
func NewBackendFactory(logger logging.Logger, metricCollector *metrics.Metrics) proxy.BackendFactory {
40
	return NewBackendFactoryWithContext(context.Background(), logger, metricCollector)
41
}
42

43
func newRequestExecutorFactory(logger logging.Logger) func(*config.Backend) client.HTTPRequestExecutor {
44
	requestExecutorFactory := func(cfg *config.Backend) client.HTTPRequestExecutor {
45
		clientFactory := client.NewHTTPClient
46
		if _, ok := cfg.ExtraConfig[oauth2client.Namespace]; ok {
47
			clientFactory = oauth2client.NewHTTPClient(cfg)
48
		}
49

50
		clientFactory = httpcache.NewHTTPClient(cfg, clientFactory)
51
		clientFactory = otellura.InstrumentedHTTPClientFactory(clientFactory, cfg)
52
		// TODO: check what happens if we have both, opencensus and otel enabled ?
53
		return opencensus.HTTPRequestExecutorFromConfig(clientFactory, cfg)
54
	}
55
	return httprequestexecutor.HTTPRequestExecutor(logger, requestExecutorFactory)
56
}
57

58
func internalNewBackendFactory(ctx context.Context, requestExecutorFactory func(*config.Backend) client.HTTPRequestExecutor,
59
	logger logging.Logger, metricCollector *metrics.Metrics) proxy.BackendFactory {
60

61
	backendFactory := martian.NewConfiguredBackendFactory(logger, requestExecutorFactory)
62
	bf := pubsub.NewBackendFactory(ctx, logger, backendFactory)
63
	backendFactory = bf.New
64
	backendFactory = amqp.NewBackendFactory(ctx, logger, backendFactory)
65
	backendFactory = lambda.BackendFactory(logger, backendFactory)
66
	backendFactory = cel.BackendFactory(logger, backendFactory)
67
	backendFactory = lua.BackendFactory(logger, backendFactory)
68
	backendFactory = ratelimit.BackendFactory(logger, backendFactory)
69
	backendFactory = cb.BackendFactory(backendFactory, logger)
70
	backendFactory = metricCollector.BackendFactory("backend", backendFactory)
71
	backendFactory = opencensus.BackendFactory(backendFactory)
72
	backendFactory = otellura.BackendFactory(backendFactory)
73
	return func(remote *config.Backend) proxy.Proxy {
74
		logger.Debug(fmt.Sprintf("[BACKEND: %s] Building the backend pipe", remote.URLPattern))
75
		return backendFactory(remote)
76
	}
77
}
78

79
// NewBackendFactoryWithContext creates a BackendFactory by stacking all the available middlewares and injecting the received context
80
func NewBackendFactoryWithContext(ctx context.Context, logger logging.Logger, metricCollector *metrics.Metrics) proxy.BackendFactory {
81
	requestExecutorFactory := newRequestExecutorFactory(logger)
82
	return internalNewBackendFactory(ctx, requestExecutorFactory, logger, metricCollector)
83
}
84

85
type backendFactory struct{}
86

87
func (backendFactory) NewBackendFactory(ctx context.Context, l logging.Logger, m *metrics.Metrics) proxy.BackendFactory {
88
	return NewBackendFactoryWithContext(ctx, l, m)
89
}
90