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]>
166 lines
3.9 KiB
Go
166 lines
3.9 KiB
Go
// Package cmd defines the cobra command structs and an execution method for adding an improved CLI to
|
|
// KrakenD based api gateways
|
|
package cmd
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/hanzoai/gateway/v2/internal/lura/config"
|
|
"github.com/spf13/cobra"
|
|
)
|
|
|
|
// Executor defines the function that requires a service description
|
|
type Executor func(config.ServiceConfig)
|
|
|
|
// Execute sets up the cmd package with the received configuration parser and executor and delegates
|
|
// the CLI execution to the cobra lib
|
|
func Execute(configParser config.Parser, f Executor) {
|
|
ExecuteRoot(configParser, f, DefaultRoot)
|
|
}
|
|
|
|
func ExecuteRoot(configParser config.Parser, f Executor, root Root) {
|
|
root.Build()
|
|
root.Execute(configParser, f)
|
|
}
|
|
|
|
func GetConfigFlag() string {
|
|
return cfgFile
|
|
}
|
|
|
|
func GetDebugFlag() bool {
|
|
return debug > 0
|
|
}
|
|
|
|
func GetConfigParser() config.Parser {
|
|
return parser
|
|
}
|
|
|
|
type FlagBuilder func(*cobra.Command)
|
|
|
|
func StringFlagBuilder(dst *string, long, short, defaultValue, help string) FlagBuilder {
|
|
return func(cmd *cobra.Command) {
|
|
cmd.PersistentFlags().StringVarP(dst, long, short, defaultValue, help)
|
|
}
|
|
}
|
|
|
|
func BoolFlagBuilder(dst *bool, long, short string, defaultValue bool, help string) FlagBuilder {
|
|
return func(cmd *cobra.Command) {
|
|
cmd.PersistentFlags().BoolVarP(dst, long, short, defaultValue, help)
|
|
}
|
|
}
|
|
|
|
func DurationFlagBuilder(dst *time.Duration, long, short string, defaultValue time.Duration, help string) FlagBuilder {
|
|
return func(cmd *cobra.Command) {
|
|
cmd.PersistentFlags().DurationVarP(dst, long, short, defaultValue, help)
|
|
}
|
|
}
|
|
|
|
func Float64FlagBuilder(dst *float64, long, short string, defaultValue float64, help string) FlagBuilder {
|
|
return func(cmd *cobra.Command) {
|
|
cmd.PersistentFlags().Float64VarP(dst, long, short, defaultValue, help)
|
|
}
|
|
}
|
|
|
|
func IntFlagBuilder(dst *int, long, short string, defaultValue int, help string) FlagBuilder {
|
|
return func(cmd *cobra.Command) {
|
|
cmd.PersistentFlags().IntVarP(dst, long, short, defaultValue, help)
|
|
}
|
|
}
|
|
|
|
func CountFlagBuilder(dst *int, long, short, help string) FlagBuilder {
|
|
return func(cmd *cobra.Command) {
|
|
cmd.PersistentFlags().CountVarP(dst, long, short, help)
|
|
}
|
|
}
|
|
|
|
type ConstraintBuilder func(*cobra.Command)
|
|
|
|
func OneRequired(flags ...string) ConstraintBuilder {
|
|
return func(cmd *cobra.Command) {
|
|
cmd.MarkFlagsOneRequired(flags...)
|
|
}
|
|
}
|
|
|
|
func RequiredTogether(flags ...string) ConstraintBuilder {
|
|
return func(cmd *cobra.Command) {
|
|
cmd.MarkFlagsRequiredTogether(flags...)
|
|
}
|
|
}
|
|
|
|
func MutuallyExclusive(flags ...string) ConstraintBuilder {
|
|
return func(cmd *cobra.Command) {
|
|
cmd.MarkFlagsMutuallyExclusive(flags...)
|
|
}
|
|
}
|
|
|
|
type Command struct {
|
|
Cmd *cobra.Command
|
|
Flags []FlagBuilder
|
|
once *sync.Once
|
|
Constraints []ConstraintBuilder
|
|
}
|
|
|
|
func NewCommand(command *cobra.Command, flags ...FlagBuilder) Command {
|
|
return Command{Cmd: command, Flags: flags, once: new(sync.Once)}
|
|
}
|
|
|
|
func (c *Command) AddConstraint(r ConstraintBuilder) {
|
|
c.Constraints = append(c.Constraints, r)
|
|
}
|
|
|
|
func (c *Command) AddFlag(f FlagBuilder) {
|
|
c.Flags = append(c.Flags, f)
|
|
}
|
|
|
|
func (c *Command) BuildFlags() {
|
|
c.once.Do(func() {
|
|
for i := range c.Flags {
|
|
c.Flags[i](c.Cmd)
|
|
}
|
|
})
|
|
}
|
|
|
|
func (c *Command) AddSubCommand(cmd *cobra.Command) {
|
|
c.Cmd.AddCommand(cmd)
|
|
}
|
|
|
|
func NewRoot(root Command, subCommands ...Command) Root {
|
|
r := Root{Command: root, SubCommands: subCommands, once: new(sync.Once)}
|
|
return r
|
|
}
|
|
|
|
type Root struct {
|
|
Command
|
|
SubCommands []Command
|
|
once *sync.Once
|
|
}
|
|
|
|
func (r *Root) Build() {
|
|
r.once.Do(func() {
|
|
r.BuildFlags()
|
|
for i := range r.Constraints {
|
|
r.Constraints[i](r.Cmd)
|
|
}
|
|
for i := range r.SubCommands {
|
|
s := r.SubCommands[i]
|
|
s.BuildFlags()
|
|
for j := range s.Constraints {
|
|
s.Constraints[j](s.Cmd)
|
|
}
|
|
r.Cmd.AddCommand(s.Cmd)
|
|
}
|
|
})
|
|
}
|
|
|
|
func (r Root) Execute(configParser config.Parser, f Executor) {
|
|
parser = configParser
|
|
run = f
|
|
if err := r.Cmd.Execute(); err != nil {
|
|
fmt.Println(err)
|
|
os.Exit(-1)
|
|
}
|
|
}
|