mirror of
https://github.com/ipfs/kubo.git
synced 2026-02-21 18:37:45 +08:00
119 lines
3.3 KiB
Go
119 lines
3.3 KiB
Go
package node
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
|
|
"go.uber.org/fx"
|
|
|
|
"github.com/ipfs/go-ipfs/core/node/helpers"
|
|
"github.com/ipfs/go-ipfs/provider"
|
|
q "github.com/ipfs/go-ipfs/provider/queue"
|
|
"github.com/ipfs/go-ipfs/provider/simple"
|
|
"github.com/ipfs/go-ipfs/repo"
|
|
"github.com/libp2p/go-libp2p-routing"
|
|
)
|
|
|
|
const kReprovideFrequency = time.Hour * 12
|
|
|
|
// SIMPLE
|
|
|
|
// ProviderQueue creates new datastore backed provider queue
|
|
func ProviderQueue(mctx helpers.MetricsCtx, lc fx.Lifecycle, repo repo.Repo) (*q.Queue, error) {
|
|
return q.NewQueue(helpers.LifecycleCtx(mctx, lc), "provider-v1", repo.Datastore())
|
|
}
|
|
|
|
// SimpleProvider creates new record provider
|
|
func SimpleProvider(mctx helpers.MetricsCtx, lc fx.Lifecycle, queue *q.Queue, rt routing.IpfsRouting) provider.Provider {
|
|
return simple.NewProvider(helpers.LifecycleCtx(mctx, lc), queue, rt)
|
|
}
|
|
|
|
// SimpleReprovider creates new reprovider
|
|
func SimpleReprovider(reproviderInterval time.Duration) interface{} {
|
|
return func(mctx helpers.MetricsCtx, lc fx.Lifecycle, rt routing.IpfsRouting, keyProvider simple.KeyChanFunc) (provider.Reprovider, error) {
|
|
return simple.NewReprovider(helpers.LifecycleCtx(mctx, lc), reproviderInterval, rt, keyProvider), nil
|
|
}
|
|
}
|
|
|
|
// SimpleProviderSys creates new provider system
|
|
func SimpleProviderSys(isOnline bool) interface{} {
|
|
return func(lc fx.Lifecycle, p provider.Provider, r provider.Reprovider) provider.System {
|
|
sys := provider.NewSystem(p, r)
|
|
|
|
if isOnline {
|
|
lc.Append(fx.Hook{
|
|
OnStart: func(ctx context.Context) error {
|
|
sys.Run()
|
|
return nil
|
|
},
|
|
OnStop: func(ctx context.Context) error {
|
|
return sys.Close()
|
|
},
|
|
})
|
|
}
|
|
|
|
return sys
|
|
}
|
|
}
|
|
|
|
// ONLINE/OFFLINE
|
|
|
|
// OnlineProviders groups units managing provider routing records online
|
|
func OnlineProviders(useStrategicProviding bool, reprovideStrategy string, reprovideInterval string) fx.Option {
|
|
if useStrategicProviding {
|
|
return fx.Provide(provider.NewOfflineProvider)
|
|
}
|
|
|
|
return fx.Options(
|
|
SimpleProviders(reprovideStrategy, reprovideInterval),
|
|
fx.Provide(SimpleProviderSys(true)),
|
|
)
|
|
}
|
|
|
|
// OfflineProviders groups units managing provider routing records offline
|
|
func OfflineProviders(useStrategicProviding bool, reprovideStrategy string, reprovideInterval string) fx.Option {
|
|
if useStrategicProviding {
|
|
return fx.Provide(provider.NewOfflineProvider)
|
|
}
|
|
|
|
return fx.Options(
|
|
SimpleProviders(reprovideStrategy, reprovideInterval),
|
|
fx.Provide(SimpleProviderSys(false)),
|
|
)
|
|
}
|
|
|
|
// SimpleProviders creates the simple provider/reprovider dependencies
|
|
func SimpleProviders(reprovideStrategy string, reprovideInterval string) fx.Option {
|
|
reproviderInterval := kReprovideFrequency
|
|
if reprovideInterval != "" {
|
|
dur, err := time.ParseDuration(reprovideInterval)
|
|
if err != nil {
|
|
return fx.Error(err)
|
|
}
|
|
|
|
reproviderInterval = dur
|
|
}
|
|
|
|
var keyProvider fx.Option
|
|
switch reprovideStrategy {
|
|
case "all":
|
|
fallthrough
|
|
case "":
|
|
keyProvider = fx.Provide(simple.NewBlockstoreProvider)
|
|
case "roots":
|
|
keyProvider = fx.Provide(simple.NewPinnedProvider(true))
|
|
case "pinned":
|
|
keyProvider = fx.Provide(simple.NewPinnedProvider(false))
|
|
default:
|
|
return fx.Error(fmt.Errorf("unknown reprovider strategy '%s'", reprovideStrategy))
|
|
}
|
|
|
|
return fx.Options(
|
|
fx.Provide(ProviderQueue),
|
|
fx.Provide(SimpleProvider),
|
|
keyProvider,
|
|
fx.Provide(SimpleReprovider(reproviderInterval)),
|
|
)
|
|
}
|