forked from TrueCloudLab/frostfs-s3-gw
112 lines
3.1 KiB
Go
112 lines
3.1 KiB
Go
package contract
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"math/big"
|
|
|
|
policycontract "git.frostfs.info/TrueCloudLab/frostfs-contract/policy"
|
|
policyclient "git.frostfs.info/TrueCloudLab/frostfs-contract/rpcclient/policy"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/internal/frostfs/util"
|
|
"git.frostfs.info/TrueCloudLab/policy-engine/pkg/chain"
|
|
"git.frostfs.info/TrueCloudLab/policy-engine/pkg/engine"
|
|
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
|
|
"github.com/nspcc-dev/neo-go/pkg/rpcclient"
|
|
"github.com/nspcc-dev/neo-go/pkg/rpcclient/actor"
|
|
"github.com/nspcc-dev/neo-go/pkg/wallet"
|
|
)
|
|
|
|
type Client struct {
|
|
actor *actor.Actor
|
|
policyContract *policyclient.Contract
|
|
}
|
|
|
|
type Config struct {
|
|
// RPCAddress is an endpoint to connect to neo rpc.
|
|
RPCAddress string
|
|
|
|
// Contract is hash of contract or its name in NNS.
|
|
Contract string
|
|
|
|
// Key is used to interact with policy contract.
|
|
// If this is nil than random key will be generated.
|
|
Key *keys.PrivateKey
|
|
}
|
|
|
|
var _ engine.MorphRuleChainStorage = (*Client)(nil)
|
|
|
|
// New creates new Policy contract wrapper.
|
|
func New(ctx context.Context, cfg Config) (*Client, error) {
|
|
contractHash, err := util.ResolveContractHash(cfg.Contract, cfg.RPCAddress)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("resolve frostfs contract hash: %w", err)
|
|
}
|
|
|
|
key := cfg.Key
|
|
if key == nil {
|
|
if key, err = keys.NewPrivateKey(); err != nil {
|
|
return nil, fmt.Errorf("generate anon private key for policy: %w", err)
|
|
}
|
|
}
|
|
|
|
rpcCli, err := rpcclient.New(ctx, cfg.RPCAddress, rpcclient.Options{})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("create policy rpc client: %w", err)
|
|
}
|
|
|
|
acc := wallet.NewAccountFromPrivateKey(key)
|
|
act, err := actor.NewSimple(rpcCli, acc)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("create new actor: %w", err)
|
|
}
|
|
|
|
return &Client{
|
|
actor: act,
|
|
policyContract: policyclient.New(act, contractHash),
|
|
}, nil
|
|
}
|
|
|
|
func (c *Client) AddMorphRuleChain(name chain.Name, target engine.Target, policyChain *chain.Chain) error {
|
|
chainName := append([]byte(name), []byte(policyChain.ID)...)
|
|
_, err := c.actor.Wait(c.policyContract.AddChain(getKind(target), target.Name, chainName, policyChain.Bytes()))
|
|
return err
|
|
}
|
|
|
|
func (c *Client) RemoveMorphRuleChain(name chain.Name, target engine.Target, chainID chain.ID) error {
|
|
chainName := append([]byte(name), []byte(chainID)...)
|
|
_, err := c.actor.Wait(c.policyContract.RemoveChain(getKind(target), target.Name, chainName))
|
|
return err
|
|
}
|
|
|
|
func (c *Client) ListMorphRuleChains(name chain.Name, target engine.Target) ([]*chain.Chain, error) {
|
|
items, err := c.policyContract.ListChainsByPrefix(getKind(target), target.Name, []byte(name))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res := make([]*chain.Chain, len(items))
|
|
for i, item := range items {
|
|
data, err := item.TryBytes()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var policyChain chain.Chain
|
|
if err = policyChain.DecodeBytes(data); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res[i] = &policyChain
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func getKind(target engine.Target) *big.Int {
|
|
var kind int64 = policycontract.Container
|
|
if target.Type != engine.Container {
|
|
kind = policycontract.Namespace
|
|
}
|
|
|
|
return big.NewInt(kind)
|
|
}
|