mirror of
https://github.com/hanzoai/gateway.git
synced 2026-11-02 23:52:23 +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]>
99 lines
2.3 KiB
Go
99 lines
2.3 KiB
Go
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
package proxy
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"net/url"
|
|
)
|
|
|
|
// Request contains the data to send to the backend
|
|
type Request struct {
|
|
Method string
|
|
URL *url.URL
|
|
Query url.Values
|
|
Path string
|
|
Body io.ReadCloser
|
|
Params map[string]string
|
|
Headers map[string][]string
|
|
}
|
|
|
|
// GeneratePath takes a pattern and updates the path of the request
|
|
func (r *Request) GeneratePath(URLPattern string) {
|
|
if len(r.Params) == 0 {
|
|
r.Path = URLPattern
|
|
return
|
|
}
|
|
buff := []byte(URLPattern)
|
|
for k, v := range r.Params {
|
|
var key []byte
|
|
|
|
key = append(key, "{{."...)
|
|
key = append(key, k...)
|
|
key = append(key, "}}"...)
|
|
buff = bytes.ReplaceAll(buff, key, []byte(v))
|
|
}
|
|
r.Path = string(buff)
|
|
}
|
|
|
|
// Clone clones itself into a new request. The returned cloned request is not
|
|
// thread-safe, so changes on request.Params and request.Headers could generate
|
|
// race-conditions depending on the part of the pipe they are being executed.
|
|
// For thread-safe request headers and/or params manipulation, use the proxy.CloneRequest
|
|
// function.
|
|
func (r *Request) Clone() Request {
|
|
var clonedURL *url.URL
|
|
if r.URL != nil {
|
|
clonedURL, _ = url.Parse(r.URL.String())
|
|
}
|
|
return Request{
|
|
Method: r.Method,
|
|
URL: clonedURL,
|
|
Query: r.Query,
|
|
Path: r.Path,
|
|
Body: r.Body,
|
|
Params: r.Params,
|
|
Headers: r.Headers,
|
|
}
|
|
}
|
|
|
|
// CloneRequest returns a deep copy of the received request, so the received and the
|
|
// returned proxy.Request do not share a pointer
|
|
func CloneRequest(r *Request) *Request {
|
|
clone := r.Clone()
|
|
clone.Headers = CloneRequestHeaders(r.Headers)
|
|
clone.Params = CloneRequestParams(r.Params)
|
|
if r.Body == nil {
|
|
return &clone
|
|
}
|
|
buf := new(bytes.Buffer)
|
|
buf.ReadFrom(r.Body)
|
|
r.Body.Close()
|
|
|
|
r.Body = io.NopCloser(bytes.NewReader(buf.Bytes()))
|
|
clone.Body = io.NopCloser(buf)
|
|
|
|
return &clone
|
|
}
|
|
|
|
// CloneRequestHeaders returns a copy of the received request headers
|
|
func CloneRequestHeaders(headers map[string][]string) map[string][]string {
|
|
m := make(map[string][]string, len(headers))
|
|
for k, vs := range headers {
|
|
tmp := make([]string, len(vs))
|
|
copy(tmp, vs)
|
|
m[k] = tmp
|
|
}
|
|
return m
|
|
}
|
|
|
|
// CloneRequestParams returns a copy of the received request params
|
|
func CloneRequestParams(params map[string]string) map[string]string {
|
|
m := make(map[string]string, len(params))
|
|
for k, v := range params {
|
|
m[k] = v
|
|
}
|
|
return m
|
|
}
|