frostfs-sdk-go/policy/json.go

package policy

import (
	"encoding/json"
	"fmt"
	"strings"

	"github.com/nspcc-dev/neofs-api-go/pkg/netmap"
)

type (
	filter struct {
		Name    string   `json:"name,omitempty"`
		Key     string   `json:"key,omitempty"`
		Op      string   `json:"op,omitempty"`
		Value   string   `json:"value,omitempty"`
		Filters []filter `json:"filters,omitempty"`
	}
	replica struct {
		Count    uint32 `json:"count"`
		Selector string `json:"selector,omitempty"`
	}
	selector struct {
		Count     uint32 `json:"count"`
		Attribute string `json:"attribute"`
		Filter    string `json:"filter,omitempty"`
		Name      string `json:"name,omitempty"`
		Clause    string `json:"clause,omitempty"`
	}
	placement struct {
		Replicas  []replica  `json:"replicas"`
		CBF       uint32     `json:"container_backup_factor,omitempty"`
		Selectors []selector `json:"selectors,omitempty"`
		Filters   []filter   `json:"filters,omitempty"`
	}
)

// ToJSON converts placement policy to JSON.
func ToJSON(np *netmap.PlacementPolicy) ([]byte, error) {
	p := new(placement)
	p.CBF = np.ContainerBackupFactor()
	p.Filters = make([]filter, len(np.Filters()))
	for i, f := range np.Filters() {
		p.Filters[i].fromNetmap(f)
	}
	p.Selectors = make([]selector, len(np.Selectors()))
	for i, s := range np.Selectors() {
		p.Selectors[i].fromNetmap(s)
	}
	p.Replicas = make([]replica, len(np.Replicas()))
	for i, r := range np.Replicas() {
		p.Replicas[i].fromNetmap(r)
	}
	return json.Marshal(p)
}

// FromJSON creates placement policy from JSON.
func FromJSON(data []byte) (*netmap.PlacementPolicy, error) {
	p := new(placement)
	if err := json.Unmarshal(data, p); err != nil {
		return nil, err
	}

	rs := make([]*netmap.Replica, len(p.Replicas))
	for i := range p.Replicas {
		rs[i] = p.Replicas[i].toNetmap()
	}

	var fs []*netmap.Filter
	if len(p.Filters) != 0 {
		fs = make([]*netmap.Filter, len(p.Filters))
		for i := range p.Filters {
			f, err := p.Filters[i].toNetmap()
			if err != nil {
				return nil, err
			}
			fs[i] = f
		}
	}

	var ss []*netmap.Selector
	if len(p.Selectors) != 0 {
		ss = make([]*netmap.Selector, len(p.Selectors))
		for i := range p.Selectors {
			s, err := p.Selectors[i].toNetmap()
			if err != nil {
				return nil, err
			}
			ss[i] = s
		}
	}

	pp := new(netmap.PlacementPolicy)
	pp.SetReplicas(rs...)
	pp.SetContainerBackupFactor(p.CBF)
	pp.SetFilters(fs...)
	pp.SetSelectors(ss...)
	return pp, nil
}

func (r *replica) toNetmap() *netmap.Replica {
	nr := new(netmap.Replica)
	nr.SetCount(r.Count)
	nr.SetSelector(r.Selector)
	return nr
}

func (r *replica) fromNetmap(nr *netmap.Replica) {
	r.Count = nr.Count()
	r.Selector = nr.Selector()
}

func (f *filter) toNetmap() (*netmap.Filter, error) {
	var op netmap.Operation
	switch strings.ToUpper(f.Op) {
	case "EQ":
		op = netmap.OpEQ
	case "NE":
		op = netmap.OpNE
	case "GT":
		op = netmap.OpGT
	case "GE":
		op = netmap.OpGE
	case "LT":
		op = netmap.OpLT
	case "LE":
		op = netmap.OpLE
	case "AND":
		op = netmap.OpAND
	case "OR":
		op = netmap.OpOR
	case "":
	default:
		return nil, fmt.Errorf("%w: '%s'", ErrUnknownOp, f.Op)
	}

	var fs []*netmap.Filter
	if len(f.Filters) != 0 {
		fs = make([]*netmap.Filter, len(f.Filters))
		for i := range f.Filters {
			var err error
			fs[i], err = f.Filters[i].toNetmap()
			if err != nil {
				return nil, err
			}
		}
	}

	nf := new(netmap.Filter)
	nf.SetInnerFilters(fs...)
	nf.SetOperation(op)
	nf.SetName(f.Name)
	nf.SetValue(f.Value)
	nf.SetKey(f.Key)
	return nf, nil
}

func (f *filter) fromNetmap(nf *netmap.Filter) {
	f.Name = nf.Name()
	f.Key = nf.Key()
	f.Value = nf.Value()
	switch nf.Operation() {
	case netmap.OpEQ:
		f.Op = "EQ"
	case netmap.OpNE:
		f.Op = "NE"
	case netmap.OpGT:
		f.Op = "GT"
	case netmap.OpGE:
		f.Op = "GE"
	case netmap.OpLT:
		f.Op = "LT"
	case netmap.OpLE:
		f.Op = "LE"
	case netmap.OpAND:
		f.Op = "AND"
	case netmap.OpOR:
		f.Op = "OR"
	default:
		// do nothing
	}
	if nf.InnerFilters() != nil {
		f.Filters = make([]filter, len(nf.InnerFilters()))
		for i, sf := range nf.InnerFilters() {
			f.Filters[i].fromNetmap(sf)
		}
	}
}

func (s *selector) toNetmap() (*netmap.Selector, error) {
	var c netmap.Clause
	switch strings.ToUpper(s.Clause) {
	case "SAME":
		c = netmap.ClauseSame
	case "DISTINCT":
		c = netmap.ClauseDistinct
	case "":
	default:
		return nil, fmt.Errorf("%w: '%s'", ErrUnknownClause, s.Clause)
	}
	ns := new(netmap.Selector)
	ns.SetName(s.Name)
	ns.SetAttribute(s.Attribute)
	ns.SetCount(s.Count)
	ns.SetClause(c)
	ns.SetFilter(s.Filter)
	return ns, nil
}

func (s *selector) fromNetmap(ns *netmap.Selector) {
	s.Name = ns.Name()
	s.Filter = ns.Filter()
	s.Count = ns.Count()
	s.Attribute = ns.Attribute()
	switch ns.Clause() {
	case netmap.ClauseSame:
		s.Clause = "same"
	case netmap.ClauseDistinct:
		s.Clause = "distinct"
	default:
		// do nothing
	}
	s.Name = ns.Name()
}