table: filter

enabled: [mon,osd]
disabled: []

ipv4:
  mon:
    priority: 100
    tcp:
    - "-p tcp -m multiport --dport 6789,3300 -m state --state NEW -j ACCEPT"
    - "-p tcp -m multiport --dport 6789,3300 -m state --state ESTABLISHED -j ACCEPT"
  osd:
    priority: 200
    tcp:
    - "-p tcp -m multiport --dport 6800:7300 -m state --state NEW -j ACCEPT"
    - "-p tcp -m multiport --dport 6800:7300 -m state --state ESTABLISHED -j ACCEPT"

type Config struct {
	Table *string `yaml:"table,omitempty"`

	Enabled  []string `yaml:"enabled,flow,omitempty"`
	Disabled []string `yaml:"disabled,flow,omitempty"`

	RulesV4 map[string]Rule `yaml:"ipv4,omitempty"`
	RulesV6 map[string]Rule `yaml:"ipv6,omitempty"`
}

type Rule struct {
	Priority *int         `yaml:"priority,omitempty"`
	TCP      []string     `yaml:"tcp,omitempty"`
	UDP      []string     `yaml:"udp,omitempty"`
}

// UnmarshalYAML implements the yaml.Unmarshaler interface.
func (raw *Config) UnmarshalYAML(node *yaml.Node) error {
	defaultTable := "filter"
	*raw = Config{
		Table: &defaultTable,
	}
	type plain Config
	if err := node.Decode((*plain)(raw)); err != nil {
		return errors.Wrapf(err, "yaml: failed to decode document: %s", err)
	}
	return nil
}

// Parse parses a config fragment in YAML format.
func Parse(data []byte) (raw Config, err error) {
	decoder := yaml.NewDecoder(bytes.NewBuffer(data))
	decoder.KnownFields(true)

	if err = decoder.Decode(&raw); err != nil {
		return Config{}, errors.Wrap(err, "config: failed to parse config file")
	}
	return
}

// The Unmarshaler interface may be implemented by types to customize their
// behavior when being unmarshaled from a YAML document.
type Unmarshaler interface {
	UnmarshalYAML(value *Node) error
}

//
// write to stdout
//
// https://github.com/go-yaml/yaml/issues/166
// https://github.com/go-yaml/yaml/pull/455
var buffer bytes.Buffer
encoder := yaml.NewEncoder(&buffer)
encoder.SetIndent(2)
err = encoder.Encode(raw)
if err != nil {
  return errors.Wrapf(err, "failed to encode config: %s", err)
}

_, err = os.Stdout.Write(buffer.Bytes())

// The Marshaler interface may be implemented by types to customize their
// behavior when being marshaled into a YAML document. The returned value
// is marshaled in place of the original value implementing Marshaler.
//
// If an error is returned by MarshalYAML, the marshaling procedure stops
// and returns with the provided error.
type Marshaler interface {
	MarshalYAML() (interface{}, error)
}