mirror of
https://github.com/hanzoai/gateway.git
synced 2026-10-30 15:04:44 +00:00
zeekayandHanzo Dev
53350699b6
Every import in this module now resolves to github.com/hanzoai/gateway/v2.
The 34 github.com/krakend/* + github.com/luraproject/lura modules that
supplied the engine and its components are vendored under internal/ and
their 91 packages rewritten onto our own path.
Why fold rather than mirror into 34 hanzoai/* repos:
- It removes the exposure outright. 34 rows leave 34 rows of go.sum to
reason about; zero modules leave nothing. `go list -m all` and go.sum
now contain no krakend/lura entry at all.
- Cross-references cannot go wrong. 28 of the 34 import lura (97 files
inside lura self-reference it). Mirroring means rewriting every one of
those to our lura, and a single miss silently links a SECOND copy of
lura into the binary. With one module that is structurally impossible.
- It creates no duplicates. These are lura-coupled gateway glue with no
consumer outside this binary; publishing 34 repos would be 34 new
things to maintain for zero second caller. internal/ makes that
guarantee mechanical — Go forbids importing it from outside this
module, so none of it can become a competing public package. Verified
no repo outside gateway imports any hanzoai/gateway/v2 subpackage.
Layout mirrors provenance so an upstream re-sync stays a diff:
luraproject/lura/v2 -> internal/lura (the engine, 20 pkgs)
krakend/krakend-<x> -> internal/plugin/<x> (28 components)
krakend/<x> -> internal/pkg/<x> (6 standalone libs)
This commit is PURELY MECHANICAL: 196 of the 197 vendored files are
byte-identical to their upstream original once the import rewrite is
applied. The single exception is bloomfilter's subpackage, which upstream
names `krakend` — the one package name that could not survive as-is; it
becomes internal/pkg/bloomfilter/register. Hand edits land separately in
the next commit so they are readable on their own.
Per `go mod vendor` semantics, dependencies' _test.go files are not
vendored. They test upstream code at a pinned version that we do not
modify, several cannot run at all from a module distribution (they need
TLS certs and compiled .so plugins upstream generates but never ships),
and one is a 100k-request stress test that exhausts the ephemeral port
range and fails every package running beside it. Fold integrity is proven
by the byte-diff above instead, which is the stronger check.
Preserved deliberately — each of these is behaviour, not branding:
- the `github.com/devopsfaith/krakend*` extra_config namespace strings
(35 of them). These are config-surface keys, not import paths;
renaming one silently stops that component finding its config. The
jose validator namespace backs `auth/validator` on 212 endpoints.
- core.KrakendVersion / KrakendUserAgent / the X-KRAKEND consts, whose
VALUES rebrand.go overwrites — that seam is unchanged.
- the KRAKEND_ koanf env prefix (a hardcoded upstream const).
- every vendored module's LICENSE (34 files, Apache-2.0/MIT).
The Makefile/CI -X paths move with the engine. An -X naming a symbol that
does not exist is silently ignored by the linker, so a stale path here
would have shipped an "undefined" version in the backend User-Agent and
X-Api-Version with a perfectly green build. Verified live:
`gateway version` reports 2.13.0, not undefined.
Verification (GOWORK=off CGO_ENABLED=0, both tag modes):
go build ./... OK go build -tags legacy ./... OK
go vet ./... clean go vet -tags legacy ./... clean
go test ./... 6/6 ok go test -tags legacy 5/5 ok
tests/ integration harness 47 fixtures pass
gateway check -c configs/{hanzo,lux}/gateway.json -> Syntax OK!
go list -m all | grep -iE 'krakend|lura' -> empty
go mod verify -> all modules verified
Co-authored-by: Hanzo Dev <[email protected]>
100 lines
4.6 KiB
Go
100 lines
4.6 KiB
Go
//go:build legacy
|
|
// +build legacy
|
|
|
|
package gateway
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
amqp "github.com/hanzoai/gateway/v2/internal/plugin/amqp"
|
|
cel "github.com/hanzoai/gateway/v2/internal/plugin/cel"
|
|
cb "github.com/hanzoai/gateway/v2/internal/plugin/circuitbreaker/gobreaker/proxy"
|
|
httpcache "github.com/hanzoai/gateway/v2/internal/plugin/httpcache"
|
|
lambda "github.com/hanzoai/gateway/v2/internal/plugin/lambda"
|
|
lua "github.com/hanzoai/gateway/v2/internal/plugin/lua/proxy"
|
|
martian "github.com/hanzoai/gateway/v2/internal/plugin/martian"
|
|
metrics "github.com/hanzoai/gateway/v2/internal/plugin/metrics/gin"
|
|
oauth2client "github.com/hanzoai/gateway/v2/internal/plugin/oauth2-clientcredentials"
|
|
opencensus "github.com/hanzoai/gateway/v2/internal/plugin/opencensus"
|
|
pubsub "github.com/hanzoai/gateway/v2/internal/plugin/pubsub"
|
|
ratelimit "github.com/hanzoai/gateway/v2/internal/plugin/ratelimit/proxy"
|
|
"github.com/hanzoai/gateway/v2/internal/lura/config"
|
|
"github.com/hanzoai/gateway/v2/internal/lura/logging"
|
|
"github.com/hanzoai/gateway/v2/internal/lura/proxy"
|
|
"github.com/hanzoai/gateway/v2/internal/lura/transport/http/client"
|
|
httprequestexecutor "github.com/hanzoai/gateway/v2/internal/lura/transport/http/client/plugin"
|
|
)
|
|
|
|
// NewBackendFactory creates a BackendFactory by stacking all the available middlewares:
|
|
// - oauth2 client credentials
|
|
// - http cache
|
|
// - martian
|
|
// - pubsub
|
|
// - amqp
|
|
// - cel
|
|
// - lua
|
|
// - rate-limit
|
|
// - circuit breaker
|
|
// - metrics collector
|
|
// - opencensus collector
|
|
func NewBackendFactory(logger logging.Logger, metricCollector *metrics.Metrics) proxy.BackendFactory {
|
|
return NewBackendFactoryWithContext(context.Background(), logger, metricCollector)
|
|
}
|
|
|
|
func newRequestExecutorFactory(ctx context.Context, logger logging.Logger) func(*config.Backend) client.HTTPRequestExecutor {
|
|
requestExecutorFactory := func(cfg *config.Backend) client.HTTPRequestExecutor {
|
|
clientFactory := client.NewHTTPClient
|
|
if _, ok := cfg.ExtraConfig[oauth2client.Namespace]; ok {
|
|
clientFactory = oauth2client.NewHTTPClient(cfg)
|
|
}
|
|
|
|
clientFactory = httpcache.NewHTTPClient(cfg, clientFactory)
|
|
return opencensus.HTTPRequestExecutorFromConfig(clientFactory, cfg)
|
|
}
|
|
// WithContext propagates the application context into client plugins so
|
|
// they observe cancellation and can drain on shutdown (upstream upstream
|
|
// 16a23d2 "Application context is not propagated to client plugins").
|
|
return httprequestexecutor.HTTPRequestExecutorWithContext(ctx, logger, requestExecutorFactory)
|
|
}
|
|
|
|
func internalNewBackendFactory(ctx context.Context, requestExecutorFactory func(*config.Backend) client.HTTPRequestExecutor,
|
|
logger logging.Logger, metricCollector *metrics.Metrics) proxy.BackendFactory {
|
|
|
|
backendFactory := martian.NewConfiguredBackendFactory(logger, requestExecutorFactory)
|
|
bf := pubsub.NewBackendFactory(ctx, logger, backendFactory)
|
|
backendFactory = bf.New
|
|
backendFactory = amqp.NewBackendFactory(ctx, logger, backendFactory)
|
|
backendFactory = lambda.BackendFactory(logger, backendFactory)
|
|
backendFactory = cel.BackendFactory(logger, backendFactory)
|
|
backendFactory = lua.BackendFactory(logger, backendFactory)
|
|
backendFactory = ratelimit.BackendFactory(logger, backendFactory)
|
|
backendFactory = cb.BackendFactory(backendFactory, logger)
|
|
backendFactory = metricCollector.BackendFactory("backend", backendFactory)
|
|
backendFactory = opencensus.BackendFactory(backendFactory)
|
|
// ZAP transport: zero-copy binary protocol for internal services
|
|
backendFactory = ZapBackendFactory(logger, backendFactory)
|
|
// base-network: shard-aware routing over base/network-enabled services
|
|
// (ATS, BD, TA, IAM, KMS, AML). See base_network_backend.go.
|
|
backendFactory = BaseNetworkBackendFactory(logger, backendFactory)
|
|
// base_ha: leader-pin + round-robin routing over hanzoai/base-ha
|
|
// clusters (BaseApp CRD). See base_ha_backend.go.
|
|
backendFactory = BaseHABackendFactory(logger, backendFactory)
|
|
return func(remote *config.Backend) proxy.Proxy {
|
|
logger.Debug(fmt.Sprintf("[BACKEND: %s] Building the backend pipe", remote.URLPattern))
|
|
return backendFactory(remote)
|
|
}
|
|
}
|
|
|
|
// NewBackendFactoryWithContext creates a BackendFactory by stacking all the available middlewares and injecting the received context
|
|
func NewBackendFactoryWithContext(ctx context.Context, logger logging.Logger, metricCollector *metrics.Metrics) proxy.BackendFactory {
|
|
requestExecutorFactory := newRequestExecutorFactory(ctx, logger)
|
|
return internalNewBackendFactory(ctx, requestExecutorFactory, logger, metricCollector)
|
|
}
|
|
|
|
type backendFactory struct{}
|
|
|
|
func (backendFactory) NewBackendFactory(ctx context.Context, l logging.Logger, m *metrics.Metrics) proxy.BackendFactory {
|
|
return NewBackendFactoryWithContext(ctx, l, m)
|
|
}
|