Concurrent commands for the same app could each read a setting, change it, and write it back, so all of them exited successfully while silently dropping changes made by the others. Updates to app settings are now serialized so every change is kept, and readers never see a partially written value.
208 lines
6.0 KiB
Go
208 lines
6.0 KiB
Go
package storage
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
|
|
"github.com/dokku/dokku/plugins/common"
|
|
)
|
|
|
|
// entryMapField selects which of an Entry's string maps a metadata command
|
|
// operates on, so the annotations and labels commands can share one
|
|
// implementation the way scheduler-k3s does.
|
|
type entryMapField struct {
|
|
Name string
|
|
Singular string
|
|
ReportType string
|
|
RowLabel string
|
|
Get func(*Entry) map[string]string
|
|
Set func(*Entry, map[string]string)
|
|
}
|
|
|
|
var annotationsField = entryMapField{
|
|
Name: "annotations",
|
|
Singular: "annotation",
|
|
ReportType: "storage-annotations",
|
|
RowLabel: "Annotation",
|
|
Get: func(e *Entry) map[string]string { return e.Annotations },
|
|
Set: func(e *Entry, m map[string]string) { e.Annotations = m },
|
|
}
|
|
|
|
var labelsField = entryMapField{
|
|
Name: "labels",
|
|
Singular: "label",
|
|
ReportType: "storage-labels",
|
|
RowLabel: "Label",
|
|
Get: func(e *Entry) map[string]string { return e.Labels },
|
|
Set: func(e *Entry, m map[string]string) { e.Labels = m },
|
|
}
|
|
|
|
// CommandAnnotationsSet sets or clears a single annotation on an entry.
|
|
func CommandAnnotationsSet(name string, key string, value string) error {
|
|
return setEntryMapKey(annotationsField, name, key, value)
|
|
}
|
|
|
|
// CommandLabelsSet sets or clears a single label on an entry.
|
|
func CommandLabelsSet(name string, key string, value string) error {
|
|
return setEntryMapKey(labelsField, name, key, value)
|
|
}
|
|
|
|
// CommandAnnotationsReport displays the annotations on one entry, or on
|
|
// every entry when no name is given.
|
|
func CommandAnnotationsReport(name string, format string, infoFlag string) error {
|
|
return reportEntryMap(annotationsField, name, format, infoFlag)
|
|
}
|
|
|
|
// CommandLabelsReport displays the labels on one entry, or on every entry
|
|
// when no name is given.
|
|
func CommandLabelsReport(name string, format string, infoFlag string) error {
|
|
return reportEntryMap(labelsField, name, format, infoFlag)
|
|
}
|
|
|
|
// setEntryMapKey writes a single key on one of an entry's metadata maps.
|
|
// An empty value deletes just that key, leaving its siblings in place -
|
|
// the behavior the wholesale --annotation flag could never express.
|
|
func setEntryMapKey(field entryMapField, name string, key string, value string) error {
|
|
if name == "" {
|
|
return errors.New("storage entry name is required")
|
|
}
|
|
if key == "" {
|
|
return fmt.Errorf("No %s key specified", field.Singular)
|
|
}
|
|
if !EntryExists(name) {
|
|
return fmt.Errorf("storage entry %q does not exist", name)
|
|
}
|
|
|
|
entry, err := UpdateEntry(name, func(entry *Entry) error {
|
|
values := field.Get(entry)
|
|
if value == "" {
|
|
delete(values, key)
|
|
common.LogInfo2Quiet(fmt.Sprintf("Unsetting %s %s", field.Singular, key))
|
|
} else {
|
|
if values == nil {
|
|
values = map[string]string{}
|
|
}
|
|
values[key] = value
|
|
common.LogInfo2Quiet(fmt.Sprintf("Setting %s %s to %s", field.Singular, key, value))
|
|
}
|
|
if len(values) == 0 {
|
|
// Drop the empty map so the omitempty tag keeps it out of the JSON.
|
|
values = nil
|
|
}
|
|
field.Set(entry, values)
|
|
|
|
return entry.Validate()
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// k3s renders annotations and labels onto the PVC and PV through the
|
|
// entry's helm release, so the cluster only sees this once the chart
|
|
// is re-applied.
|
|
if entry.Scheduler == SchedulerK3s {
|
|
if err := callSchedulerCreateTrigger(entry); err != nil {
|
|
return fmt.Errorf("scheduler refused %s change for %q: %w", field.Name, name, err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// reportEntryMap renders one entry's metadata map, or every entry's when
|
|
// no name is given.
|
|
func reportEntryMap(field entryMapField, name string, format string, infoFlag string) error {
|
|
if format != "stdout" && format != "text" && format != "json" {
|
|
return fmt.Errorf("Invalid format: %s", format)
|
|
}
|
|
if format == "json" && infoFlag != "" {
|
|
return errors.New("--format flag cannot be specified when specifying an info flag")
|
|
}
|
|
|
|
if name != "" {
|
|
if !EntryExists(name) {
|
|
return fmt.Errorf("storage entry %q does not exist", name)
|
|
}
|
|
entry, err := LoadEntry(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return renderEntryMap(field, entry, format, infoFlag)
|
|
}
|
|
|
|
if infoFlag != "" {
|
|
return fmt.Errorf("storage:%s:report requires a storage entry name when an info flag is specified", field.Name)
|
|
}
|
|
|
|
entries, err := ListEntries()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(entries) == 0 {
|
|
common.LogInfo1Quiet("No storage entries registered")
|
|
return nil
|
|
}
|
|
for _, entry := range entries {
|
|
if err := renderEntryMap(field, entry, format, ""); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// renderEntryMap prints one entry's metadata map. Keys are emitted
|
|
// verbatim rather than through common.ReportSingleApp, which rewrites
|
|
// dots and dashes into spaces and would mangle keys like
|
|
// app.kubernetes.io/part-of.
|
|
func renderEntryMap(field entryMapField, entry *Entry, format string, infoFlag string) error {
|
|
values := field.Get(entry)
|
|
|
|
keys := []string{}
|
|
for key := range values {
|
|
keys = append(keys, key)
|
|
}
|
|
sort.Strings(keys)
|
|
|
|
if infoFlag != "" {
|
|
flagPrefix := "--" + field.ReportType + "."
|
|
validFlags := []string{}
|
|
for _, key := range keys {
|
|
flag := flagPrefix + key
|
|
if flag == infoFlag {
|
|
fmt.Println(values[key])
|
|
return nil
|
|
}
|
|
validFlags = append(validFlags, flag)
|
|
}
|
|
return fmt.Errorf("Invalid flag passed, valid flags: %s", strings.Join(validFlags, ", "))
|
|
}
|
|
|
|
if format == "json" {
|
|
flat := map[string]string{}
|
|
for _, key := range keys {
|
|
flat[key] = values[key]
|
|
}
|
|
data, err := json.Marshal(flat)
|
|
if err != nil {
|
|
return fmt.Errorf("Unable to marshal json: %w", err)
|
|
}
|
|
fmt.Println(string(data))
|
|
return nil
|
|
}
|
|
|
|
common.LogInfo2Quiet(fmt.Sprintf("%s %s information", entry.Name, field.Name))
|
|
length := 31
|
|
for _, key := range keys {
|
|
if label := fmt.Sprintf("%s %s:", field.RowLabel, key); len(label) > length {
|
|
length = len(label)
|
|
}
|
|
}
|
|
for _, key := range keys {
|
|
label := fmt.Sprintf("%s %s:", field.RowLabel, key)
|
|
common.LogVerbose(fmt.Sprintf("%s%s", common.RightPad(label, length, " "), values[key]))
|
|
}
|
|
return nil
|
|
}
|