frostfs-node/modules/node/objectmanager.go
alexvanin dadfd90dcd Initial commit
Initial public review release v0.10.0
2020-07-10 17:45:00 +03:00

219 lines
6 KiB
Go

package node
import (
"crypto/ecdsa"
"github.com/nspcc-dev/neofs-api-go/bootstrap"
"github.com/nspcc-dev/neofs-api-go/hash"
apiobj "github.com/nspcc-dev/neofs-api-go/object"
"github.com/nspcc-dev/neofs-api-go/session"
libacl "github.com/nspcc-dev/neofs-node/lib/acl"
"github.com/nspcc-dev/neofs-node/lib/container"
"github.com/nspcc-dev/neofs-node/lib/core"
"github.com/nspcc-dev/neofs-node/lib/implementations"
"github.com/nspcc-dev/neofs-node/lib/ir"
"github.com/nspcc-dev/neofs-node/lib/localstore"
"github.com/nspcc-dev/neofs-node/lib/peers"
"github.com/nspcc-dev/neofs-node/lib/placement"
"github.com/nspcc-dev/neofs-node/lib/transformer"
"github.com/nspcc-dev/neofs-node/services/public/object"
"github.com/spf13/viper"
"go.uber.org/dig"
"go.uber.org/zap"
)
type (
objectManagerParams struct {
dig.In
Logger *zap.Logger
Viper *viper.Viper
LocalStore localstore.Localstore
PeersInterface peers.Interface
Peers peers.Store
Placement placement.Component
TokenStore session.PrivateTokenStore
Options []string `name:"node_options"`
Key *ecdsa.PrivateKey
IRStorage ir.Storage
EpochReceiver implementations.EpochReceiver
Placer implementations.ObjectPlacer
ExtendedACLStore libacl.ExtendedACLSource
ContainerStorage container.Storage
}
)
const (
transformersSectionPath = "object.transformers."
aclMandatorySetBits = 0x04040444
)
const xorSalitor = "xor"
func newObjectManager(p objectManagerParams) (object.Service, error) {
var sltr object.Salitor
if p.Viper.GetString("object.salitor") == xorSalitor {
sltr = hash.SaltXOR
}
as, err := implementations.NewAddressStore(p.Peers, p.Logger)
if err != nil {
return nil, err
}
rs := object.NewRemoteService(p.PeersInterface)
pto := p.Viper.GetDuration("object.put.timeout")
gto := p.Viper.GetDuration("object.get.timeout")
hto := p.Viper.GetDuration("object.head.timeout")
sto := p.Viper.GetDuration("object.search.timeout")
rhto := p.Viper.GetDuration("object.range_hash.timeout")
dto := p.Viper.GetDuration("object.dial_timeout")
tr, err := object.NewMultiTransport(object.MultiTransportParams{
AddressStore: as,
EpochReceiver: p.EpochReceiver,
RemoteService: rs,
Logger: p.Logger,
Key: p.Key,
PutTimeout: pto,
GetTimeout: gto,
HeadTimeout: hto,
SearchTimeout: sto,
RangeHashTimeout: rhto,
DialTimeout: dto,
PrivateTokenStore: p.TokenStore,
})
if err != nil {
return nil, err
}
exec, err := implementations.NewContainerTraverseExecutor(tr)
if err != nil {
return nil, err
}
selectiveExec, err := implementations.NewObjectContainerHandler(implementations.ObjectContainerHandlerParams{
NodeLister: p.Placer,
Executor: exec,
Logger: p.Logger,
})
if err != nil {
return nil, err
}
sgInfoRecv, err := implementations.NewStorageGroupInfoReceiver(implementations.StorageGroupInfoReceiverParams{
SelectiveContainerExecutor: selectiveExec,
Logger: p.Logger,
})
if err != nil {
return nil, err
}
verifier, err := implementations.NewLocalIntegrityVerifier(
core.NewNeoKeyVerifier(),
)
if err != nil {
return nil, err
}
trans, err := transformer.NewTransformer(transformer.Params{
SGInfoReceiver: sgInfoRecv,
EpochReceiver: p.EpochReceiver,
SizeLimit: uint64(p.Viper.GetInt64(transformersSectionPath+"payload_limiter.max_payload_size") * apiobj.UnitsKB),
Verifier: verifier,
})
if err != nil {
return nil, err
}
aclChecker := libacl.NewMaskedBasicACLChecker(aclMandatorySetBits, libacl.DefaultAndFilter)
aclHelper, err := implementations.NewACLHelper(p.ContainerStorage)
if err != nil {
return nil, err
}
verifier, err = implementations.NewLocalHeadIntegrityVerifier(
core.NewNeoKeyVerifier(),
)
if err != nil {
return nil, err
}
return object.New(&object.Params{
Verifier: verifier,
Salitor: sltr,
LocalStore: p.LocalStore,
MaxProcessingSize: p.Viper.GetUint64("object.max_processing_size") * uint64(apiobj.UnitsMB),
StorageCapacity: bootstrap.NodeInfo{Options: p.Options}.Capacity() * uint64(apiobj.UnitsGB),
PoolSize: p.Viper.GetInt("object.workers_count"),
Placer: p.Placer,
Transformer: trans,
ObjectRestorer: transformer.NewRestorePipeline(
transformer.SplitRestorer(),
),
RemoteService: rs,
AddressStore: as,
Logger: p.Logger,
TokenStore: p.TokenStore,
EpochReceiver: p.EpochReceiver,
ContainerNodesLister: p.Placer,
Key: p.Key,
CheckACL: p.Viper.GetBool("object.check_acl"),
DialTimeout: p.Viper.GetDuration("object.dial_timeout"),
MaxPayloadSize: p.Viper.GetUint64("object.transformers.payload_limiter.max_payload_size") * uint64(apiobj.UnitsKB),
PutParams: object.OperationParams{
Timeout: pto,
LogErrors: p.Viper.GetBool("object.put.log_errs"),
},
GetParams: object.OperationParams{
Timeout: gto,
LogErrors: p.Viper.GetBool("object.get.log_errs"),
},
HeadParams: object.OperationParams{
Timeout: hto,
LogErrors: p.Viper.GetBool("object.head.log_errs"),
},
DeleteParams: object.OperationParams{
Timeout: p.Viper.GetDuration("object.delete.timeout"),
LogErrors: p.Viper.GetBool("object.get.log_errs"),
},
SearchParams: object.OperationParams{
Timeout: sto,
LogErrors: p.Viper.GetBool("object.search.log_errs"),
},
RangeParams: object.OperationParams{
Timeout: p.Viper.GetDuration("object.range.timeout"),
LogErrors: p.Viper.GetBool("object.range.log_errs"),
},
RangeHashParams: object.OperationParams{
Timeout: rhto,
LogErrors: p.Viper.GetBool("object.range_hash.log_errs"),
},
Assembly: p.Viper.GetBool("object.assembly"),
WindowSize: p.Viper.GetInt("object.window_size"),
ACLHelper: aclHelper,
BasicACLChecker: aclChecker,
IRStorage: p.IRStorage,
ContainerLister: p.Placer,
SGInfoReceiver: sgInfoRecv,
OwnerKeyVerifier: core.NewNeoKeyVerifier(),
ExtendedACLSource: p.ExtendedACLStore,
})
}