Cadoles/bouncer
10
0
Fork 0
Code Issues 1 Pull Requests Projects Releases 5 Wiki Activity

feat: command flags cleanup
All checks were successful
Cadoles/bouncer/pipeline/head This commit looks good
Details

Browse Source
This commit is contained in:
wpetit
2023-06-23 11:08:35 -06:00
parent 8d21e9083c
commit e32c72e030
12 changed files with 292 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
internal/command/admin/layer/flag/flag.go
View File

@ -2,27 +2,22 @@ package flag
import (
"encoding/json"
"fmt"
proxyFlag "forge.cadoles.com/cadoles/bouncer/internal/command/admin/proxy/flag"
"forge.cadoles.com/cadoles/bouncer/internal/setup"
"forge.cadoles.com/cadoles/bouncer/internal/store"
"github.com/pkg/errors"
"github.com/urfave/cli/v2"
)
const (
FlagLayerName = "layer-name"
FlagLayerType = "layer-type"
FlagLayerOptions = "layer-options"
FlagKeyLayerType = "layer-type"
)
func WithLayerFlags(flags ...cli.Flag) []cli.Flag {
baseFlags := proxyFlag.WithProxyFlags(
&cli.StringFlag{
Name: FlagLayerName,
Usage: "use `LAYER_NAME` as targeted layer",
Value: "",
Required: true,
},
LayerName(),
)
flags = append(flags, baseFlags...)
@ -32,22 +27,63 @@ func WithLayerFlags(flags ...cli.Flag) []cli.Flag {
func WithLayerCreateFlags(flags ...cli.Flag) []cli.Flag {
return WithLayerFlags(
&cli.StringFlag{
Name: FlagLayerType,
Usage: "Set `LAYER_TYPE` as layer's type",
Value: "",
Required: true,
},
&cli.StringFlag{
Name: FlagLayerOptions,
Usage: "Set `LAYER_OPTIONS` as layer's options",
Value: "{}",
},
LayerType(),
LayerOptions(),
)
}
const KeyLayerName = "layer-name"
func LayerName() cli.Flag {
return &cli.StringFlag{
Name: KeyLayerName,
Usage: "use `LAYER_NAME` as targeted layer",
Value: "",
Required: true,
}
}
const KeyLayerType = "layer-type"
func LayerType() cli.Flag {
return &cli.StringFlag{
Name: KeyLayerType,
Usage: fmt.Sprintf("Set `LAYER_TYPE` as layer's type (available: %v)", setup.GetLayerTypes()),
Value: "",
Required: true,
}
}
const KeyLayerOptions = "layer-options"
func LayerOptions() cli.Flag {
return &cli.StringFlag{
Name: KeyLayerOptions,
Usage: "Set `LAYER_OPTIONS` as layer's options",
Value: "{}",
}
}
const KeyLayerWeight = "layer-weight"
func LayerWeight() cli.Flag {
return &cli.IntFlag{
Name: KeyLayerWeight,
Usage: "Set `LAYER_WEIGHT` as layer's weight",
}
}
const KeyLayerEnabled = "layer-enabled"
func LayerEnabled() cli.Flag {
return &cli.BoolFlag{
Name: KeyLayerEnabled,
Usage: "Enable or disable layer",
}
}
func AssertLayerName(ctx *cli.Context) (store.LayerName, error) {
rawLayerName := ctx.String(FlagLayerName)
rawLayerName := ctx.String(KeyLayerName)
name, err := store.ValidateName(rawLayerName)
if err != nil {
@ -58,13 +94,18 @@ func AssertLayerName(ctx *cli.Context) (store.LayerName, error) {
}
func AssertLayerType(ctx *cli.Context) (store.LayerType, error) {
rawLayerType := ctx.String(FlagLayerType)
rawLayerType := ctx.String(FlagKeyLayerType)
return store.LayerType(rawLayerType), nil
layerType := store.LayerType(rawLayerType)
if !setup.LayerTypeExists(layerType) {
return "", errors.Errorf("unknown layer type '%s'", layerType)
}
return layerType, nil
}
func AssertLayerOptions(ctx *cli.Context) (store.LayerOptions, error) {
rawLayerOptions := ctx.String(FlagLayerOptions)
rawLayerOptions := ctx.String(KeyLayerOptions)
layerOptions := store.LayerOptions{}

30
internal/command/admin/layer/update.go
View File

@ -7,6 +7,7 @@ import (
"forge.cadoles.com/cadoles/bouncer/internal/client"
"forge.cadoles.com/cadoles/bouncer/internal/command/admin/apierr"
clientFlag "forge.cadoles.com/cadoles/bouncer/internal/command/admin/flag"
"forge.cadoles.com/cadoles/bouncer/internal/command/admin/layer/flag"
layerFlag "forge.cadoles.com/cadoles/bouncer/internal/command/admin/layer/flag"
proxyFlag "forge.cadoles.com/cadoles/bouncer/internal/command/admin/proxy/flag"
"forge.cadoles.com/cadoles/bouncer/internal/format"
@ -20,18 +21,9 @@ func UpdateCommand() *cli.Command {
Name: "update",
Usage: "Update layer",
Flags: layerFlag.WithLayerFlags(
&cli.BoolFlag{
Name: "enabled",
Usage: "Enable or disable proxy",
},
&cli.IntFlag{
Name: "weight",
Usage: "Set `WEIGHT` as proxy's weight",
},
&cli.StringFlag{
Name: "options",
Usage: "Set `OPTIONS` as proxy's options",
},
flag.LayerEnabled(),
flag.LayerWeight(),
flag.LayerOptions(),
),
Action: func(ctx *cli.Context) error {
baseFlags := clientFlag.GetBaseFlags(ctx)
@ -53,22 +45,22 @@ func UpdateCommand() *cli.Command {
opts := &client.UpdateLayerOptions{}
if ctx.IsSet("options") {
if ctx.IsSet(flag.KeyLayerOptions) {
var options store.LayerOptions
if err := json.Unmarshal([]byte(ctx.String("options")), &options); err != nil {
return errors.Wrap(err, "could not parse options")
if err := json.Unmarshal([]byte(ctx.String(flag.KeyLayerOptions)), &options); err != nil {
return errors.Wrap(err, "could not parse layer's options")
}
opts.Options = &options
}
if ctx.IsSet("weight") {
weight := ctx.Int("weight")
if ctx.IsSet(flag.KeyLayerWeight) {
weight := ctx.Int(flag.KeyLayerWeight)
opts.Weight = &weight
}
if ctx.IsSet("enabled") {
enabled := ctx.Bool("enabled")
if ctx.IsSet(flag.KeyLayerEnabled) {
enabled := ctx.Bool(flag.KeyLayerEnabled)
opts.Enabled = &enabled
}

18
internal/command/admin/proxy/create.go
View File

@ -7,6 +7,7 @@ import (
"forge.cadoles.com/cadoles/bouncer/internal/client"
"forge.cadoles.com/cadoles/bouncer/internal/command/admin/apierr"
clientFlag "forge.cadoles.com/cadoles/bouncer/internal/command/admin/flag"
"forge.cadoles.com/cadoles/bouncer/internal/command/admin/proxy/flag"
proxyFlag "forge.cadoles.com/cadoles/bouncer/internal/command/admin/proxy/flag"
"forge.cadoles.com/cadoles/bouncer/internal/format"
"github.com/pkg/errors"
@ -18,17 +19,8 @@ func CreateCommand() *cli.Command {
Name: "create",
Usage: "Create proxy",
Flags: proxyFlag.WithProxyFlags(
&cli.StringFlag{
Name: "to",
Usage: "Set `TO` as proxy's destination url",
Value: "",
Required: true,
},
&cli.StringSliceFlag{
Name: "from",
Usage: "Set `FROM` as proxy's patterns to match incoming requests",
Value: cli.NewStringSlice("*"),
},
flag.ProxyTo(),
flag.ProxyFrom(),
),
Action: func(ctx *cli.Context) error {
baseFlags := clientFlag.GetBaseFlags(ctx)
@ -43,12 +35,12 @@ func CreateCommand() *cli.Command {
return errors.Wrap(err, "'to' parameter should be a valid url")
}
to, err := url.Parse(ctx.String("to"))
to, err := url.Parse(ctx.String(flag.KeyProxyTo))
if err != nil {
return errors.Wrap(err, "'to' parameter should be a valid url")
}
from := ctx.StringSlice("from")
from := ctx.StringSlice(flag.KeyProxyFrom)
client := client.New(baseFlags.ServerURL, client.WithToken(token))

61
internal/command/admin/proxy/flag/flag.go
View File

@ -7,16 +7,9 @@ import (
"github.com/urfave/cli/v2"
)
const FlagProxyName = "proxy-name"
func WithProxyFlags(flags ...cli.Flag) []cli.Flag {
baseFlags := clientFlag.ComposeFlags(
&cli.StringFlag{
Name: FlagProxyName,
Usage: "use `PROXY_NAME` as targeted proxy",
Value: "",
Required: true,
},
ProxyName(),
)
flags = append(flags, baseFlags...)
@ -24,8 +17,58 @@ func WithProxyFlags(flags ...cli.Flag) []cli.Flag {
return flags
}
const KeyProxyName = "proxy-name"
func ProxyName() cli.Flag {
return &cli.StringFlag{
Name: KeyProxyName,
Usage: "use `PROXY_NAME` as targeted proxy",
Value: "",
Required: true,
}
}
const KeyProxyTo = "proxy-to"
func ProxyTo() cli.Flag {
return &cli.StringFlag{
Name: KeyProxyTo,
Usage: "Set `PROXY_TO` as proxy's destination url",
Value: "",
Required: true,
}
}
const KeyProxyFrom = "proxy-from"
func ProxyFrom() cli.Flag {
return &cli.StringSliceFlag{
Name: KeyProxyFrom,
Usage: "Set `PROXY_FROM` as proxy's patterns to match incoming requests",
Value: cli.NewStringSlice("*"),
}
}
const KeyProxyWeight = "proxy-weight"
func ProxyWeight() cli.Flag {
return &cli.IntFlag{
Name: KeyProxyWeight,
Usage: "Set `PROXY_WEIGHT` as proxy's weight",
}
}
const KeyProxyEnabled = "proxy-enabled"
func ProxyEnabled() cli.Flag {
return &cli.BoolFlag{
Name: KeyProxyEnabled,
Usage: "Enable or disable proxy",
}
}
func AssertProxyName(ctx *cli.Context) (store.ProxyName, error) {
rawProxyName := ctx.String(FlagProxyName)
rawProxyName := ctx.String(KeyProxyName)
name, err := store.ValidateName(rawProxyName)
if err != nil {

43
internal/command/admin/proxy/update.go
View File

@ -7,6 +7,7 @@ import (
"forge.cadoles.com/cadoles/bouncer/internal/client"
"forge.cadoles.com/cadoles/bouncer/internal/command/admin/apierr"
clientFlag "forge.cadoles.com/cadoles/bouncer/internal/command/admin/flag"
"forge.cadoles.com/cadoles/bouncer/internal/command/admin/proxy/flag"
proxyFlag "forge.cadoles.com/cadoles/bouncer/internal/command/admin/proxy/flag"
"forge.cadoles.com/cadoles/bouncer/internal/format"
"github.com/pkg/errors"
@ -18,22 +19,10 @@ func UpdateCommand() *cli.Command {
Name: "update",
Usage: "Update proxy",
Flags: proxyFlag.WithProxyFlags(
&cli.StringFlag{
Name: "to",
Usage: "Set `TO` as proxy's destination url",
},
&cli.StringSliceFlag{
Name: "from",
Usage: "Set `FROM` as proxy's patterns to match incoming requests",
},
&cli.BoolFlag{
Name: "enabled",
Usage: "Enable or disable proxy",
},
&cli.IntFlag{
Name: "weight",
Usage: "Set `WEIGHT` as proxy's weight",
},
flag.ProxyTo(),
flag.ProxyFrom(),
flag.ProxyEnabled(),
flag.ProxyWeight(),
),
Action: func(ctx *cli.Context) error {
baseFlags := clientFlag.GetBaseFlags(ctx)
@ -50,27 +39,29 @@ func UpdateCommand() *cli.Command {
opts := &client.UpdateProxyOptions{}
if ctx.IsSet("to") {
to := ctx.String("to")
if ctx.IsSet(flag.KeyProxyTo) {
to := ctx.String(flag.KeyProxyTo)
if _, err := url.Parse(to); err != nil {
return errors.Wrap(err, "'to' parameter should be a valid url")
return errors.Wrapf(err, "'%s' parameter should be a valid url", flag.KeyProxyTo)
}
opts.To = &to
}
from := ctx.StringSlice("from")
if from != nil {
opts.From = from
if ctx.IsSet(flag.KeyProxyFrom) {
from := ctx.StringSlice(flag.KeyProxyFrom)
if from != nil {
opts.From = from
}
}
if ctx.IsSet("weight") {
weight := ctx.Int("weight")
if ctx.IsSet(flag.KeyProxyWeight) {
weight := ctx.Int(flag.KeyProxyWeight)
opts.Weight = &weight
}
if ctx.IsSet("enabled") {
enabled := ctx.Bool("enabled")
if ctx.IsSet(flag.KeyProxyEnabled) {
enabled := ctx.Bool(flag.KeyProxyEnabled)
opts.Enabled = &enabled
}

40
internal/command/server/proxy/run.go
View File

@ -1,16 +1,11 @@
package proxy
import (
"context"
"fmt"
"strings"
"time"
"forge.cadoles.com/cadoles/bouncer/internal/command/common"
"forge.cadoles.com/cadoles/bouncer/internal/config"
"forge.cadoles.com/cadoles/bouncer/internal/proxy"
"forge.cadoles.com/cadoles/bouncer/internal/proxy/director"
"forge.cadoles.com/cadoles/bouncer/internal/queue"
"forge.cadoles.com/cadoles/bouncer/internal/setup"
"github.com/pkg/errors"
"github.com/urfave/cli/v2"
@ -33,7 +28,7 @@ func RunCommand() *cli.Command {
logger.SetFormat(logger.Format(conf.Logger.Format))
logger.SetLevel(logger.Level(conf.Logger.Level))
layers, err := initDirectorLayers(ctx.Context, conf)
layers, err := setup.CreateLayers(ctx.Context, conf)
if err != nil {
return errors.Wrap(err, "could not initialize director layers")
}
@ -64,36 +59,3 @@ func RunCommand() *cli.Command {
},
}
}
func initDirectorLayers(ctx context.Context, conf *config.Config) ([]director.Layer, error) {
layers := make([]director.Layer, 0)
queue, err := initQueueLayer(ctx, conf)
if err != nil {
return nil, errors.Wrap(err, "could not initialize queue layer")
}
layers = append(layers, queue)
return layers, nil
}
func initQueueLayer(ctx context.Context, conf *config.Config) (*queue.Queue, error) {
adapter, err := setup.NewQueueAdapter(ctx, conf.Redis)
if err != nil {
return nil, errors.WithStack(err)
}
options := []queue.OptionFunc{
queue.WithTemplateDir(string(conf.Layers.Queue.TemplateDir)),
}
if conf.Layers.Queue.DefaultKeepAlive != nil {
options = append(options, queue.WithDefaultKeepAlive(time.Duration(*conf.Layers.Queue.DefaultKeepAlive)))
}
return queue.New(
adapter,
options...,
), nil
}