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]>
167 lines
3.7 KiB
Go
167 lines
3.7 KiB
Go
package audit
|
|
|
|
// Service represents a KrakenD configuration as a tree of bitsets representing
|
|
// which components and flags are enabled at the KrakenD configuration
|
|
type Service struct {
|
|
Details []int `json:"d"`
|
|
Agents []Agent `json:"a"`
|
|
Endpoints []Endpoint `json:"e"`
|
|
Components Component `json:"c"`
|
|
}
|
|
|
|
// Clone returns a deep copy of the service
|
|
func (s Service) Clone() Service {
|
|
res := Service{
|
|
Details: make([]int, len(s.Details)),
|
|
Agents: make([]Agent, len(s.Agents)),
|
|
Endpoints: make([]Endpoint, len(s.Endpoints)),
|
|
Components: s.Components.Clone(),
|
|
}
|
|
copy(res.Details, s.Details)
|
|
for i, a := range s.Agents {
|
|
res.Agents[i] = a.Clone()
|
|
}
|
|
for i, e := range s.Endpoints {
|
|
res.Endpoints[i] = e.Clone()
|
|
}
|
|
return res
|
|
}
|
|
|
|
// Agent captures details of the AsyncAgents present at the configuration
|
|
type Agent struct {
|
|
Details []int `json:"d"`
|
|
Backends []Backend `json:"b"`
|
|
Components Component `json:"c"`
|
|
}
|
|
|
|
// Clone returns a deep copy of the agent
|
|
func (a Agent) Clone() Agent {
|
|
res := Agent{
|
|
Details: make([]int, len(a.Details)),
|
|
Backends: make([]Backend, len(a.Backends)),
|
|
Components: a.Components.Clone(),
|
|
}
|
|
copy(res.Details, a.Details)
|
|
for i, b := range a.Backends {
|
|
res.Backends[i] = b.Clone()
|
|
}
|
|
return res
|
|
}
|
|
|
|
// Endpoint captures details of the endpoints present at the configuration
|
|
type Endpoint struct {
|
|
Details []int `json:"d"`
|
|
Backends []Backend `json:"b"`
|
|
Components Component `json:"c"`
|
|
}
|
|
|
|
// Clone returns a deep copy of the endpoint
|
|
func (e Endpoint) Clone() Endpoint {
|
|
res := Endpoint{
|
|
Details: make([]int, len(e.Details)),
|
|
Backends: make([]Backend, len(e.Backends)),
|
|
Components: e.Components.Clone(),
|
|
}
|
|
copy(res.Details, e.Details)
|
|
for i, b := range e.Backends {
|
|
res.Backends[i] = b.Clone()
|
|
}
|
|
return res
|
|
}
|
|
|
|
// Backend captures details of the backends present at the configuration
|
|
type Backend struct {
|
|
Details []int `json:"d"`
|
|
Components Component `json:"c"`
|
|
}
|
|
|
|
// Clone returns a deep copy of the backend
|
|
func (b Backend) Clone() Backend {
|
|
res := Backend{
|
|
Details: make([]int, len(b.Details)),
|
|
Components: b.Components.Clone(),
|
|
}
|
|
copy(res.Details, b.Details)
|
|
return res
|
|
}
|
|
|
|
// Component captures details of the extra configuration sections
|
|
type Component map[string][]int
|
|
|
|
// Clone returns a deep copy of the set of components
|
|
func (c Component) Clone() Component {
|
|
res := Component{}
|
|
for i, vs := range c {
|
|
res[i] = make([]int, len(vs))
|
|
copy(res[i], vs)
|
|
}
|
|
return res
|
|
}
|
|
|
|
var AiProviders = [][]string{{"gemini", "v1beta"}, {"openai", "v1"}, {"mistral", "v1"}, {"anthropic", "v1"}}
|
|
|
|
const (
|
|
ServicePlugin = iota
|
|
ServiceSequentialStart
|
|
ServiceDebug
|
|
ServiceAllowInsecureConnections
|
|
ServiceDisableStrictREST
|
|
ServiceHasTLS
|
|
ServiceTLSEnabled
|
|
ServiceTLSEnableMTLS
|
|
ServiceTLSDisableSystemCaPool
|
|
ServiceTLSCaCerts
|
|
ServiceEcho
|
|
ServiceUseH2C
|
|
ServiceTLSPrivPubKey
|
|
)
|
|
|
|
const (
|
|
EncodingNOOP = iota
|
|
EncodingJSON
|
|
EncodingSAFEJSON
|
|
EncodingSTRING
|
|
EncodingRSS
|
|
EncodingXML
|
|
EncodingOther
|
|
)
|
|
|
|
const (
|
|
BackendAllow = iota + EncodingOther + 1
|
|
BackendDeny
|
|
BackendMapping
|
|
BackendGroup
|
|
BackendTarget
|
|
BackendIsCollection
|
|
BackendHeadersToPass
|
|
BackendQuery
|
|
)
|
|
|
|
const (
|
|
RouterErrorBody = iota
|
|
RouterDisableHealth
|
|
RouterDisableAccessLog
|
|
RouterHealthPath
|
|
RouterErrorMsg
|
|
RouterDisableRedirectTrailingSlash
|
|
RouterDisableRedirectFixedPath
|
|
RouterExtraSlash
|
|
RouterHandleMethodNotAllowed
|
|
RouterPathDecoding
|
|
RouterAutoOptions
|
|
RouterForwardedByClientIp
|
|
RouterRemoteIpHeaders
|
|
RouterTrustedProxies
|
|
RouterAppEngine
|
|
RouterMaxMultipartMemory
|
|
RouterLoggerSkipPaths
|
|
RouterHideVersionHeader
|
|
RouterUseH2C
|
|
)
|
|
|
|
const (
|
|
BackendComponentHTTPClient = iota
|
|
BackendComponentHTTPClientAllowInsecureConnections
|
|
BackendComponentHTTPClientCerts
|
|
)
|