5a505c5b3a
* auth providers * binding rules * auth provider for kubernetes * login/logout
213 lines
4.9 KiB
Go
213 lines
4.9 KiB
Go
package bindingruleupdate
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
|
|
"github.com/hashicorp/consul/api"
|
|
"github.com/hashicorp/consul/command/acl"
|
|
"github.com/hashicorp/consul/command/flags"
|
|
"github.com/mitchellh/cli"
|
|
)
|
|
|
|
func New(ui cli.Ui) *cmd {
|
|
c := &cmd{UI: ui}
|
|
c.init()
|
|
return c
|
|
}
|
|
|
|
type cmd struct {
|
|
UI cli.Ui
|
|
flags *flag.FlagSet
|
|
http *flags.HTTPFlags
|
|
help string
|
|
|
|
ruleID string
|
|
|
|
description string
|
|
selector string
|
|
bindType string
|
|
bindName string
|
|
|
|
noMerge bool
|
|
showMeta bool
|
|
}
|
|
|
|
func (c *cmd) init() {
|
|
c.flags = flag.NewFlagSet("", flag.ContinueOnError)
|
|
c.flags.BoolVar(
|
|
&c.showMeta,
|
|
"meta",
|
|
false,
|
|
"Indicates that binding rule metadata such "+
|
|
"as the content hash and raft indices should be shown for each entry.",
|
|
)
|
|
|
|
c.flags.StringVar(
|
|
&c.ruleID,
|
|
"id",
|
|
"",
|
|
"The ID of the binding rule to update. "+
|
|
"It may be specified as a unique ID prefix but will error if the prefix "+
|
|
"matches multiple binding rule IDs",
|
|
)
|
|
|
|
c.flags.StringVar(
|
|
&c.description,
|
|
"description",
|
|
"",
|
|
"A description of the binding rule.",
|
|
)
|
|
c.flags.StringVar(
|
|
&c.selector,
|
|
"selector",
|
|
"",
|
|
"Selector is an expression that matches against verified identity "+
|
|
"attributes returned from the auth method during login.",
|
|
)
|
|
c.flags.StringVar(
|
|
&c.bindType,
|
|
"bind-type",
|
|
string(api.BindingRuleBindTypeService),
|
|
"Type of binding to perform (\"service\" or \"role\").",
|
|
)
|
|
c.flags.StringVar(
|
|
&c.bindName,
|
|
"bind-name",
|
|
"",
|
|
"Name to bind on match. Can use ${var} interpolation. "+
|
|
"This flag is required.",
|
|
)
|
|
|
|
c.flags.BoolVar(
|
|
&c.noMerge,
|
|
"no-merge",
|
|
false,
|
|
"Do not merge the current binding rule "+
|
|
"information with what is provided to the command. Instead overwrite all fields "+
|
|
"with the exception of the binding rule ID which is immutable.",
|
|
)
|
|
|
|
c.http = &flags.HTTPFlags{}
|
|
flags.Merge(c.flags, c.http.ClientFlags())
|
|
flags.Merge(c.flags, c.http.ServerFlags())
|
|
c.help = flags.Usage(help, c.flags)
|
|
}
|
|
|
|
func (c *cmd) Run(args []string) int {
|
|
if err := c.flags.Parse(args); err != nil {
|
|
return 1
|
|
}
|
|
|
|
if c.ruleID == "" {
|
|
c.UI.Error(fmt.Sprintf("Cannot update a binding rule without specifying the -id parameter"))
|
|
return 1
|
|
}
|
|
|
|
client, err := c.http.APIClient()
|
|
if err != nil {
|
|
c.UI.Error(fmt.Sprintf("Error connecting to Consul agent: %s", err))
|
|
return 1
|
|
}
|
|
|
|
ruleID, err := acl.GetBindingRuleIDFromPartial(client, c.ruleID)
|
|
if err != nil {
|
|
c.UI.Error(fmt.Sprintf("Error determining binding rule ID: %v", err))
|
|
return 1
|
|
}
|
|
|
|
// Read the current binding rule in both cases so we can fail better if not found.
|
|
currentRule, _, err := client.ACL().BindingRuleRead(ruleID, nil)
|
|
if err != nil {
|
|
c.UI.Error(fmt.Sprintf("Error when retrieving current binding rule: %v", err))
|
|
return 1
|
|
} else if currentRule == nil {
|
|
c.UI.Error(fmt.Sprintf("Binding rule not found with ID %q", ruleID))
|
|
return 1
|
|
}
|
|
|
|
var rule *api.ACLBindingRule
|
|
if c.noMerge {
|
|
if c.bindType == "" {
|
|
c.UI.Error(fmt.Sprintf("Missing required '-bind-type' flag"))
|
|
c.UI.Error(c.Help())
|
|
return 1
|
|
} else if c.bindName == "" {
|
|
c.UI.Error(fmt.Sprintf("Missing required '-bind-name' flag"))
|
|
c.UI.Error(c.Help())
|
|
return 1
|
|
}
|
|
|
|
rule = &api.ACLBindingRule{
|
|
ID: ruleID,
|
|
AuthMethod: currentRule.AuthMethod, // immutable
|
|
Description: c.description,
|
|
BindType: api.BindingRuleBindType(c.bindType),
|
|
BindName: c.bindName,
|
|
Selector: c.selector,
|
|
}
|
|
|
|
} else {
|
|
rule = currentRule
|
|
|
|
if c.description != "" {
|
|
rule.Description = c.description
|
|
}
|
|
if c.bindType != "" {
|
|
rule.BindType = api.BindingRuleBindType(c.bindType)
|
|
}
|
|
if c.bindName != "" {
|
|
rule.BindName = c.bindName
|
|
}
|
|
if isFlagSet(c.flags, "selector") {
|
|
rule.Selector = c.selector // empty is valid
|
|
}
|
|
}
|
|
|
|
rule, _, err = client.ACL().BindingRuleUpdate(rule, nil)
|
|
if err != nil {
|
|
c.UI.Error(fmt.Sprintf("Error updating binding rule %q: %v", ruleID, err))
|
|
return 1
|
|
}
|
|
|
|
c.UI.Info(fmt.Sprintf("Binding rule updated successfully"))
|
|
acl.PrintBindingRule(rule, c.UI, c.showMeta)
|
|
return 0
|
|
}
|
|
|
|
func (c *cmd) Synopsis() string {
|
|
return synopsis
|
|
}
|
|
|
|
func (c *cmd) Help() string {
|
|
return flags.Usage(c.help, nil)
|
|
}
|
|
|
|
func isFlagSet(flags *flag.FlagSet, name string) bool {
|
|
found := false
|
|
flags.Visit(func(f *flag.Flag) {
|
|
if f.Name == name {
|
|
found = true
|
|
}
|
|
})
|
|
return found
|
|
}
|
|
|
|
const synopsis = "Update an ACL Binding Rule"
|
|
const help = `
|
|
Usage: consul acl binding-rule update -id ID [options]
|
|
|
|
Updates a binding rule. By default it will merge the binding rule
|
|
information with its current state so that you do not have to provide all
|
|
parameters. This behavior can be disabled by passing -no-merge.
|
|
|
|
Update all editable fields of the binding rule:
|
|
|
|
$ consul acl binding-rule update \
|
|
-id=43cb72df-9c6f-4315-ac8a-01a9d98155ef \
|
|
-description="new description" \
|
|
-bind-type=role \
|
|
-bind-name='k8s-${serviceaccount.name}' \
|
|
-selector='serviceaccount.namespace==default and serviceaccount.name==web'
|
|
`
|