joao/pkg/config/output.go

163 lines
4.1 KiB
Go
Raw Normal View History

2022-12-20 05:49:37 +00:00
// Copyright © 2022 Roberto Hidalgo <joao@un.rob.mx>
2022-12-31 06:14:08 +00:00
// SPDX-License-Identifier: Apache-2.0
2022-12-20 05:49:37 +00:00
package config
import (
"bytes"
"encoding/json"
"fmt"
"io/fs"
"os"
2022-12-20 05:49:37 +00:00
op "github.com/1Password/connect-sdk-go/onepassword"
"github.com/sirupsen/logrus"
"gopkg.in/yaml.v3"
)
const YAMLTypeSecret string = "!!secret"
const YAMLTypeMetaConfig string = "!!joao"
type outputOptions struct {
mode OutputMode
}
func (flag *outputOptions) Set(modes ...OutputMode) {
for _, mode := range modes {
flag.mode = mode | flag.mode
}
}
func (flag *outputOptions) Clear(mode OutputMode) { flag.mode = mode &^ flag.mode }
func (flag *outputOptions) Toggle(mode OutputMode) { flag.mode = mode ^ flag.mode }
func (flag *outputOptions) Has(mode OutputMode) bool { return mode&flag.mode != 0 }
type OutputMode uint8
const (
// OutputModeRoundTrip outputs the input as-is.
OutputModeRoundTrip OutputMode = iota
// OutputModeRedacted prints empty secret values.
OutputModeRedacted
// OutputModeNoComments does not output comments.
OutputModeNoComments OutputMode = 2
// OutputModeSorted outputs map keys in alphabetical order.
OutputModeSorted OutputMode = 4
// OutputModeNoConfig does not output the _config key if any.
OutputModeNoConfig OutputMode = 8
)
var defaultYamlOutput = &outputOptions{OutputModeRoundTrip}
var yamlOutput = defaultYamlOutput
2022-12-23 05:38:37 +00:00
func setOutputMode(modes []OutputMode) func() {
if len(modes) > 0 {
yamlOutput = &outputOptions{}
yamlOutput.Set(modes...)
}
return func() { yamlOutput = defaultYamlOutput }
}
2022-12-20 05:49:37 +00:00
// ToMap turns a config into a dictionary of strings to values.
2022-12-23 05:38:37 +00:00
func (cfg *Config) ToMap(modes ...OutputMode) map[string]any {
defer setOutputMode(modes)()
2022-12-20 05:49:37 +00:00
ret := map[string]any{}
for _, child := range cfg.Tree.Content {
2022-12-23 05:38:37 +00:00
if child.Name() == "" || (yamlOutput.Has(OutputModeNoConfig) && child.Name() == "_config") {
2022-12-20 05:49:37 +00:00
continue
}
ret[child.Name()] = child.AsMap()
}
return ret
}
// ToOp turns a config into an 1Password Item.
func (cfg *Config) ToOP() *op.Item {
sections := []*op.ItemSection{annotationsSection}
fields := append([]*op.ItemField{}, defaultItemFields...)
datafields := cfg.Tree.ToOP()
cs := checksum(datafields)
fields[0].Value = cs
fields = append(fields, datafields...)
for i := 0; i < len(cfg.Tree.Content); i += 2 {
value := cfg.Tree.Content[i+1]
if value.Type == YAMLTypeMetaConfig {
continue
}
2023-01-11 04:50:06 +00:00
if value.Kind == yaml.MappingNode || value.Kind == yaml.SequenceNode {
2022-12-20 05:49:37 +00:00
sections = append(sections, &op.ItemSection{
ID: value.Name(),
Label: value.Name(),
})
}
}
return &op.Item{
Title: cfg.Name,
Sections: sections,
Vault: op.ItemVault{ID: cfg.Vault},
Category: op.Password,
Fields: fields,
}
}
// MarshalYAML implements `yaml.Marshal``.
func (cfg *Config) MarshalYAML() (any, error) {
return cfg.Tree.MarshalYAML()
}
// AsYAML returns the config encoded as YAML.
func (cfg *Config) AsYAML(modes ...OutputMode) ([]byte, error) {
2022-12-23 05:38:37 +00:00
defer setOutputMode(modes)()
logrus.Debugf("Printing as yaml with modes %v", yamlOutput)
2022-12-20 05:49:37 +00:00
var out bytes.Buffer
enc := yaml.NewEncoder(&out)
enc.SetIndent(2)
if err := enc.Encode(cfg); err != nil {
return nil, fmt.Errorf("could not serialize config as yaml: %w", err)
}
return out.Bytes(), nil
}
// AsJSON returns the config enconded as JSON, optionally encoding as a 1Password item.
func (cfg *Config) AsJSON(redacted bool, item bool) ([]byte, error) {
var repr any
if item {
repr = cfg.ToOP()
} else {
2022-12-23 05:38:37 +00:00
modes := []OutputMode{OutputModeNoConfig}
if redacted {
modes = append(modes, OutputModeRedacted)
}
repr = cfg.ToMap(modes...)
2022-12-20 05:49:37 +00:00
}
bytes, err := json.Marshal(repr)
if err != nil {
return nil, fmt.Errorf("could not serialize config as json: %w", err)
}
return bytes, nil
}
func (cfg *Config) AsFile(path string, modes ...OutputMode) error {
b, err := cfg.AsYAML(modes...)
if err != nil {
return err
}
var mode fs.FileMode = 0644
if info, err := os.Stat(path); err == nil {
mode = info.Mode().Perm()
}
if err := os.WriteFile(path, b, mode); err != nil {
return fmt.Errorf("could not save config to file %s: %w", path, err)
}
return nil
}