policy-engine/pkg/engine/inmemory/morph_storage.go

package inmemory

import (
	"git.frostfs.info/TrueCloudLab/policy-engine/pkg/chain"
	"git.frostfs.info/TrueCloudLab/policy-engine/pkg/engine"
	"github.com/google/uuid"
	"github.com/nspcc-dev/neo-go/pkg/neorpc/result"
	"github.com/nspcc-dev/neo-go/pkg/util"
	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
)

type inmemoryMorphRuleChainStorage struct {
	storage engine.LocalOverrideStorage
}

func NewInmemoryMorphRuleChainStorage() engine.MorphRuleChainStorage {
	return &inmemoryMorphRuleChainStorage{
		storage: NewInmemoryLocalStorage(),
	}
}

func (s *inmemoryMorphRuleChainStorage) AddMorphRuleChain(name chain.Name, target engine.Target, c *chain.Chain) (_ util.Uint256, _ uint32, err error) {
	switch target.Type {
	case engine.Namespace, engine.Container:
		_, err = s.storage.AddOverride(name, target, c)
	default:
		err = engine.ErrUnknownTarget
	}
	return
}

func (s *inmemoryMorphRuleChainStorage) RemoveMorphRuleChain(name chain.Name, target engine.Target, chainID chain.ID) (_ util.Uint256, _ uint32, err error) {
	switch target.Type {
	case engine.Namespace, engine.Container:
		err = s.storage.RemoveOverride(name, target, chainID)
	default:
		err = engine.ErrUnknownTarget
	}
	return
}

func (s *inmemoryMorphRuleChainStorage) RemoveMorphRuleChainsByTarget(name chain.Name, target engine.Target) (_ util.Uint256, _ uint32, err error) {
	switch target.Type {
	case engine.Namespace, engine.Container:
		err = s.storage.RemoveOverridesByTarget(name, target)
	default:
		err = engine.ErrUnknownTarget
	}
	return
}

func (s *inmemoryMorphRuleChainStorage) ListMorphRuleChains(name chain.Name, target engine.Target) ([]*chain.Chain, error) {
	switch target.Type {
	case engine.Namespace, engine.Container:
		return s.storage.ListOverrides(name, target)
	default:
	}
	return nil, engine.ErrUnknownTarget
}

func (s *inmemoryMorphRuleChainStorage) GetAdmin() (util.Uint160, error) {
	panic("not implemented")
}

func (s *inmemoryMorphRuleChainStorage) SetAdmin(_ util.Uint160) (util.Uint256, uint32, error) {
	panic("not implemented")
}

func (s *inmemoryMorphRuleChainStorage) ListTargetsIterator(targetType engine.TargetType) (uuid uuid.UUID, it result.Iterator, err error) {
	it.Values = make([]stackitem.Item, 0)

	switch targetType {
	case engine.Namespace:
		// Listing targets may look bizarre, because inmemory rule chain storage use inmemory local overrides where
		// targets are listed by chain names.
		var targets []engine.Target
		targets, err = s.storage.ListOverrideDefinedTargets(chain.Ingress)
		if err != nil {
			return
		}
		for _, t := range targets {
			it.Values = append(it.Values, stackitem.NewByteArray([]byte(t.Name)))
		}

		targets, err = s.storage.ListOverrideDefinedTargets(chain.S3)
		if err != nil {
			return
		}
		for _, t := range targets {
			it.Values = append(it.Values, stackitem.NewByteArray([]byte(t.Name)))
		}
	case engine.Container:
		var targets []engine.Target
		targets, err = s.storage.ListOverrideDefinedTargets(chain.Ingress)
		if err != nil {
			return
		}
		for _, t := range targets {
			it.Values = append(it.Values, stackitem.NewByteArray([]byte(t.Name)))
		}

		targets, err = s.storage.ListOverrideDefinedTargets(chain.S3)
		if err != nil {
			return
		}
		for _, t := range targets {
			it.Values = append(it.Values, stackitem.NewByteArray([]byte(t.Name)))
		}
	default:
	}
	return
}