Merge pull request #2154 from laser/feat/1920-selection-commands

implement toggling of online/offline storage/retrieval deals

api/api_storage.go

@@ -56,10 +56,16 @@ type StorageMiner interface {
 
 	DealsImportData(ctx context.Context, dealPropCid cid.Cid, file string) error
 	DealsList(ctx context.Context) ([]storagemarket.StorageDeal, error)
-	DealsSetAcceptingStorageDeals(context.Context, bool) error
+	DealsConsiderOnlineStorageDeals(context.Context) (bool, error)
-	DealsSetAcceptingRetrievalDeals(context.Context, bool) error
+	DealsSetConsiderOnlineStorageDeals(context.Context, bool) error
+	DealsConsiderOnlineRetrievalDeals(context.Context) (bool, error)
+	DealsSetConsiderOnlineRetrievalDeals(context.Context, bool) error
 	DealsPieceCidBlocklist(context.Context) ([]cid.Cid, error)
 	DealsSetPieceCidBlocklist(context.Context, []cid.Cid) error
+	DealsConsiderOfflineStorageDeals(context.Context) (bool, error)
+	DealsSetConsiderOfflineStorageDeals(context.Context, bool) error
+	DealsConsiderOfflineRetrievalDeals(context.Context) (bool, error)
+	DealsSetConsiderOfflineRetrievalDeals(context.Context, bool) error
 
 	StorageAddLocal(ctx context.Context, path string) error
 }

api/apistruct/struct.go

@@ -224,12 +224,18 @@ type StorageMinerStruct struct {
 		StorageLock          func(ctx context.Context, sector abi.SectorID, read stores.SectorFileType, write stores.SectorFileType) error                                 `perm:"admin"`
 		StorageTryLock       func(ctx context.Context, sector abi.SectorID, read stores.SectorFileType, write stores.SectorFileType) (bool, error)                         `perm:"admin"`
 
-		DealsImportData                 func(ctx context.Context, dealPropCid cid.Cid, file string) error `perm:"write"`
+		DealsImportData                       func(ctx context.Context, dealPropCid cid.Cid, file string) error `perm:"write"`
-		DealsList                       func(ctx context.Context) ([]storagemarket.StorageDeal, error)    `perm:"read"`
+		DealsList                             func(ctx context.Context) ([]storagemarket.StorageDeal, error)    `perm:"read"`
-		DealsSetAcceptingStorageDeals   func(context.Context, bool) error                                 `perm:"admin"`
+		DealsConsiderOnlineStorageDeals       func(context.Context) (bool, error)                               `perm:"read"`
-		DealsSetAcceptingRetrievalDeals func(context.Context, bool) error                                 `perm:"admin"`
+		DealsSetConsiderOnlineStorageDeals    func(context.Context, bool) error                                 `perm:"admin"`
-		DealsPieceCidBlocklist          func(context.Context) ([]cid.Cid, error)                          `perm:"admin"`
+		DealsConsiderOnlineRetrievalDeals     func(context.Context) (bool, error)                               `perm:"read"`
-		DealsSetPieceCidBlocklist       func(context.Context, []cid.Cid) error                            `perm:"read"`
+		DealsSetConsiderOnlineRetrievalDeals  func(context.Context, bool) error                                 `perm:"admin"`
+		DealsConsiderOfflineStorageDeals      func(context.Context) (bool, error)                               `perm:"read"`
+		DealsSetConsiderOfflineStorageDeals   func(context.Context, bool) error                                 `perm:"admin"`
+		DealsConsiderOfflineRetrievalDeals    func(context.Context) (bool, error)                               `perm:"read"`
+		DealsSetConsiderOfflineRetrievalDeals func(context.Context, bool) error                                 `perm:"admin"`
+		DealsPieceCidBlocklist                func(context.Context) ([]cid.Cid, error)                          `perm:"read"`
+		DealsSetPieceCidBlocklist             func(context.Context, []cid.Cid) error                            `perm:"admin"`
 
 		StorageAddLocal func(ctx context.Context, path string) error `perm:"admin"`
 	}
@@ -878,12 +884,20 @@ func (c *StorageMinerStruct) DealsList(ctx context.Context) ([]storagemarket.Sto
 	return c.Internal.DealsList(ctx)
 }
 
-func (c *StorageMinerStruct) DealsSetAcceptingStorageDeals(ctx context.Context, b bool) error {
+func (c *StorageMinerStruct) DealsConsiderOnlineStorageDeals(ctx context.Context) (bool, error) {
-	return c.Internal.DealsSetAcceptingStorageDeals(ctx, b)
+	return c.Internal.DealsConsiderOnlineStorageDeals(ctx)
 }
 
-func (c *StorageMinerStruct) DealsSetAcceptingRetrievalDeals(ctx context.Context, b bool) error {
+func (c *StorageMinerStruct) DealsSetConsiderOnlineStorageDeals(ctx context.Context, b bool) error {
-	return c.Internal.DealsSetAcceptingRetrievalDeals(ctx, b)
+	return c.Internal.DealsSetConsiderOnlineStorageDeals(ctx, b)
+}
+
+func (c *StorageMinerStruct) DealsConsiderOnlineRetrievalDeals(ctx context.Context) (bool, error) {
+	return c.Internal.DealsConsiderOnlineRetrievalDeals(ctx)
+}
+
+func (c *StorageMinerStruct) DealsSetConsiderOnlineRetrievalDeals(ctx context.Context, b bool) error {
+	return c.Internal.DealsSetConsiderOnlineRetrievalDeals(ctx, b)
 }
 
 func (c *StorageMinerStruct) DealsPieceCidBlocklist(ctx context.Context) ([]cid.Cid, error) {
@@ -894,6 +908,22 @@ func (c *StorageMinerStruct) DealsSetPieceCidBlocklist(ctx context.Context, cids
 	return c.Internal.DealsSetPieceCidBlocklist(ctx, cids)
 }
 
+func (c *StorageMinerStruct) DealsConsiderOfflineStorageDeals(ctx context.Context) (bool, error) {
+	return c.Internal.DealsConsiderOfflineStorageDeals(ctx)
+}
+
+func (c *StorageMinerStruct) DealsSetConsiderOfflineStorageDeals(ctx context.Context, b bool) error {
+	return c.Internal.DealsSetConsiderOfflineStorageDeals(ctx, b)
+}
+
+func (c *StorageMinerStruct) DealsConsiderOfflineRetrievalDeals(ctx context.Context) (bool, error) {
+	return c.Internal.DealsConsiderOfflineRetrievalDeals(ctx)
+}
+
+func (c *StorageMinerStruct) DealsSetConsiderOfflineRetrievalDeals(ctx context.Context, b bool) error {
+	return c.Internal.DealsSetConsiderOfflineRetrievalDeals(ctx, b)
+}
+
 func (c *StorageMinerStruct) StorageAddLocal(ctx context.Context, path string) error {
 	return c.Internal.StorageAddLocal(ctx, path)
 }

cmd/lotus-storage-miner/market.go

@@ -50,33 +50,100 @@ func GetCidEncoder(cctx *cli.Context) (cidenc.Encoder, error) {
 	return e, nil
 }
 
-var enableCmd = &cli.Command{
+var storageDealSelectionCmd = &cli.Command{
-	Name:  "enable",
+	Name:  "selection",
-	Usage: "Configure the miner to consider storage deal proposals",
+	Usage: "Configure acceptance criteria for storage deal proposals",
-	Flags: []cli.Flag{},
+	Subcommands: []*cli.Command{
-	Action: func(cctx *cli.Context) error {
+		storageDealSelectionShowCmd,
-		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		storageDealSelectionResetCmd,
-		if err != nil {
+		storageDealSelectionRejectCmd,
-			return err
-		}
-		defer closer()
-
-		return api.DealsSetAcceptingStorageDeals(lcli.DaemonContext(cctx), true)
 	},
 }
 
-var disableCmd = &cli.Command{
+var storageDealSelectionShowCmd = &cli.Command{
-	Name:  "disable",
+	Name:  "list",
-	Usage: "Configure the miner to reject all storage deal proposals",
+	Usage: "List storage deal proposal selection criteria",
-	Flags: []cli.Flag{},
 	Action: func(cctx *cli.Context) error {
-		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		smapi, closer, err := lcli.GetStorageMinerAPI(cctx)
 		if err != nil {
 			return err
 		}
 		defer closer()
 
-		return api.DealsSetAcceptingStorageDeals(lcli.DaemonContext(cctx), false)
+		onlineOk, err := smapi.DealsConsiderOnlineStorageDeals(lcli.DaemonContext(cctx))
+		if err != nil {
+			return err
+		}
+
+		offlineOk, err := smapi.DealsConsiderOfflineStorageDeals(lcli.DaemonContext(cctx))
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("considering online storage deals: %t\n", onlineOk)
+		fmt.Printf("considering offline storage deals: %t\n", offlineOk)
+
+		return nil
+	},
+}
+
+var storageDealSelectionResetCmd = &cli.Command{
+	Name:  "reset",
+	Usage: "Reset storage deal proposal selection criteria to default values",
+	Action: func(cctx *cli.Context) error {
+		smapi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		err = smapi.DealsSetConsiderOnlineStorageDeals(lcli.DaemonContext(cctx), true)
+		if err != nil {
+			return err
+		}
+
+		err = smapi.DealsSetConsiderOfflineStorageDeals(lcli.DaemonContext(cctx), true)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
+
+var storageDealSelectionRejectCmd = &cli.Command{
+	Name:  "reject",
+	Usage: "Configure criteria which necessitate automatic rejection",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name: "online",
+		},
+		&cli.BoolFlag{
+			Name: "offline",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		smapi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		if cctx.Bool("online") {
+			err = smapi.DealsSetConsiderOnlineStorageDeals(lcli.DaemonContext(cctx), false)
+			if err != nil {
+				return err
+			}
+		}
+
+		if cctx.Bool("offline") {
+			err = smapi.DealsSetConsiderOfflineStorageDeals(lcli.DaemonContext(cctx), false)
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
 	},
 }
 
@@ -223,8 +290,7 @@ var storageDealsCmd = &cli.Command{
 	Subcommands: []*cli.Command{
 		dealsImportDataCmd,
 		dealsListCmd,
-		enableCmd,
+		storageDealSelectionCmd,
-		disableCmd,
 		setAskCmd,
 		getAskCmd,
 		setBlocklistCmd,

cmd/lotus-storage-miner/retrieval-deals.go

@@ -1,6 +1,8 @@
 package main
 
 import (
+	"fmt"
+
 	lcli "github.com/filecoin-project/lotus/cli"
 	"github.com/urfave/cli/v2"
 )
@@ -9,37 +11,103 @@ var retrievalDealsCmd = &cli.Command{
 	Name:  "retrieval-deals",
 	Usage: "Manage retrieval deals and related configuration",
 	Subcommands: []*cli.Command{
-		enableRetrievalCmd,
+		retrievalDealSelectionCmd,
-		disableRetrievalCmd,
 	},
 }
 
-var enableRetrievalCmd = &cli.Command{
+var retrievalDealSelectionCmd = &cli.Command{
-	Name:  "enable",
+	Name:  "selection",
-	Usage: "Configure the miner to consider retrieval deal proposals",
+	Usage: "Configure acceptance criteria for retrieval deal proposals",
-	Flags: []cli.Flag{},
+	Subcommands: []*cli.Command{
+		retrievalDealSelectionShowCmd,
+		retrievalDealSelectionResetCmd,
+		retrievalDealSelectionRejectCmd,
+	},
+}
+
+var retrievalDealSelectionShowCmd = &cli.Command{
+	Name:  "list",
+	Usage: "List retrieval deal proposal selection criteria",
 	Action: func(cctx *cli.Context) error {
-		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		smapi, closer, err := lcli.GetStorageMinerAPI(cctx)
 		if err != nil {
 			return err
 		}
 		defer closer()
 
-		return api.DealsSetAcceptingRetrievalDeals(lcli.DaemonContext(cctx), true)
+		onlineOk, err := smapi.DealsConsiderOnlineRetrievalDeals(lcli.DaemonContext(cctx))
+		if err != nil {
+			return err
+		}
+
+		offlineOk, err := smapi.DealsConsiderOfflineRetrievalDeals(lcli.DaemonContext(cctx))
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("considering online retrieval deals: %t\n", onlineOk)
+		fmt.Printf("considering offline retrieval deals: %t\n", offlineOk)
+
+		return nil
 	},
 }
 
-var disableRetrievalCmd = &cli.Command{
+var retrievalDealSelectionResetCmd = &cli.Command{
-	Name:  "disable",
+	Name:  "reset",
-	Usage: "Configure the miner to reject all retrieval deal proposals",
+	Usage: "Reset retrieval deal proposal selection criteria to default values",
-	Flags: []cli.Flag{},
 	Action: func(cctx *cli.Context) error {
-		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		smapi, closer, err := lcli.GetStorageMinerAPI(cctx)
 		if err != nil {
 			return err
 		}
 		defer closer()
 
-		return api.DealsSetAcceptingRetrievalDeals(lcli.DaemonContext(cctx), false)
+		err = smapi.DealsSetConsiderOnlineRetrievalDeals(lcli.DaemonContext(cctx), true)
+		if err != nil {
+			return err
+		}
+
+		err = smapi.DealsSetConsiderOfflineRetrievalDeals(lcli.DaemonContext(cctx), true)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
+
+var retrievalDealSelectionRejectCmd = &cli.Command{
+	Name:  "reject",
+	Usage: "Configure criteria which necessitate automatic rejection",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name: "online",
+		},
+		&cli.BoolFlag{
+			Name: "offline",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		smapi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		if cctx.Bool("online") {
+			err = smapi.DealsSetConsiderOnlineRetrievalDeals(lcli.DaemonContext(cctx), false)
+			if err != nil {
+				return err
+			}
+		}
+
+		if cctx.Bool("offline") {
+			err = smapi.DealsSetConsiderOfflineRetrievalDeals(lcli.DaemonContext(cctx), false)
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
 	},
 }

node/builder.go

@@ -313,12 +313,16 @@ func Online() Option {
 			Override(new(gen.WinningPoStProver), storage.NewWinningPoStProver),
 			Override(new(*miner.Miner), modules.SetupBlockProducer),
 
-			Override(new(dtypes.AcceptingRetrievalDealsConfigFunc), modules.NewAcceptingRetrievalDealsConfigFunc),
+			Override(new(dtypes.ConsiderOnlineStorageDealsConfigFunc), modules.NewConsiderOnlineStorageDealsConfigFunc),
-			Override(new(dtypes.SetAcceptingRetrievalDealsConfigFunc), modules.NewSetAcceptingRetrievalDealsConfigFunc),
+			Override(new(dtypes.SetConsiderOnlineStorageDealsConfigFunc), modules.NewSetConsideringOnlineStorageDealsFunc),
-			Override(new(dtypes.AcceptingStorageDealsConfigFunc), modules.NewAcceptingStorageDealsConfigFunc),
+			Override(new(dtypes.ConsiderOnlineRetrievalDealsConfigFunc), modules.NewConsiderOnlineRetrievalDealsConfigFunc),
-			Override(new(dtypes.SetAcceptingStorageDealsConfigFunc), modules.NewSetAcceptingStorageDealsConfigFunc),
+			Override(new(dtypes.SetConsiderOnlineRetrievalDealsConfigFunc), modules.NewSetConsiderOnlineRetrievalDealsConfigFunc),
 			Override(new(dtypes.StorageDealPieceCidBlocklistConfigFunc), modules.NewStorageDealPieceCidBlocklistConfigFunc),
 			Override(new(dtypes.SetStorageDealPieceCidBlocklistConfigFunc), modules.NewSetStorageDealPieceCidBlocklistConfigFunc),
+			Override(new(dtypes.ConsiderOfflineStorageDealsConfigFunc), modules.NewConsiderOfflineStorageDealsConfigFunc),
+			Override(new(dtypes.SetConsiderOfflineStorageDealsConfigFunc), modules.NewSetConsideringOfflineStorageDealsFunc),
+			Override(new(dtypes.ConsiderOfflineRetrievalDealsConfigFunc), modules.NewConsiderOfflineRetrievalDealsConfigFunc),
+			Override(new(dtypes.SetConsiderOfflineRetrievalDealsConfigFunc), modules.NewSetConsiderOfflineRetrievalDealsConfigFunc),
 		),
 	)
 }

node/config/def.go

@@ -34,9 +34,11 @@ type StorageMiner struct {
 }
 
 type DealmakingConfig struct {
-	AcceptingStorageDeals   bool
+	ConsiderOnlineStorageDeals    bool
-	AcceptingRetrievalDeals bool
+	ConsiderOfflineStorageDeals   bool
-	PieceCidBlocklist       []cid.Cid
+	ConsiderOnlineRetrievalDeals  bool
+	ConsiderOfflineRetrievalDeals bool
+	PieceCidBlocklist             []cid.Cid
 }
 
 // API contains configs for API endpoint
@@ -124,9 +126,11 @@ func DefaultStorageMiner() *StorageMiner {
 		},
 
 		Dealmaking: DealmakingConfig{
-			AcceptingStorageDeals:   true,
+			ConsiderOnlineStorageDeals:    true,
-			AcceptingRetrievalDeals: true,
+			ConsiderOfflineStorageDeals:   true,
-			PieceCidBlocklist:       []cid.Cid{},
+			ConsiderOnlineRetrievalDeals:  true,
+			ConsiderOfflineRetrievalDeals: true,
+			PieceCidBlocklist:             []cid.Cid{},
 		},
 	}
 	cfg.Common.API.ListenAddress = "/ip4/127.0.0.1/tcp/2345/http"

node/impl/storminer.go

@@ -43,10 +43,16 @@ type StorageMinerAPI struct {
 	StorageMgr      *sectorstorage.Manager `optional:"true"`
 	*stores.Index
 
-	SetAcceptingStorageDealsConfigFunc        dtypes.SetAcceptingStorageDealsConfigFunc
+	ConsiderOnlineStorageDealsConfigFunc       dtypes.ConsiderOnlineStorageDealsConfigFunc
-	SetAcceptingRetrievalDealsConfigFunc      dtypes.SetAcceptingRetrievalDealsConfigFunc
+	SetConsiderOnlineStorageDealsConfigFunc    dtypes.SetConsiderOnlineStorageDealsConfigFunc
-	StorageDealPieceCidBlocklistConfigFunc    dtypes.StorageDealPieceCidBlocklistConfigFunc
+	ConsiderOnlineRetrievalDealsConfigFunc     dtypes.ConsiderOnlineRetrievalDealsConfigFunc
-	SetStorageDealPieceCidBlocklistConfigFunc dtypes.SetStorageDealPieceCidBlocklistConfigFunc
+	SetConsiderOnlineRetrievalDealsConfigFunc  dtypes.SetConsiderOnlineRetrievalDealsConfigFunc
+	StorageDealPieceCidBlocklistConfigFunc     dtypes.StorageDealPieceCidBlocklistConfigFunc
+	SetStorageDealPieceCidBlocklistConfigFunc  dtypes.SetStorageDealPieceCidBlocklistConfigFunc
+	ConsiderOfflineStorageDealsConfigFunc      dtypes.ConsiderOfflineStorageDealsConfigFunc
+	SetConsiderOfflineStorageDealsConfigFunc   dtypes.SetConsiderOfflineStorageDealsConfigFunc
+	ConsiderOfflineRetrievalDealsConfigFunc    dtypes.ConsiderOfflineRetrievalDealsConfigFunc
+	SetConsiderOfflineRetrievalDealsConfigFunc dtypes.SetConsiderOfflineRetrievalDealsConfigFunc
 }
 
 func (sm *StorageMinerAPI) ServeRemote(w http.ResponseWriter, r *http.Request) {
@@ -225,12 +231,36 @@ func (sm *StorageMinerAPI) DealsList(ctx context.Context) ([]storagemarket.Stora
 	return sm.StorageProvider.ListDeals(ctx)
 }
 
-func (sm *StorageMinerAPI) DealsSetAcceptingStorageDeals(ctx context.Context, b bool) error {
+func (sm *StorageMinerAPI) DealsConsiderOnlineStorageDeals(ctx context.Context) (bool, error) {
-	return sm.SetAcceptingStorageDealsConfigFunc(b)
+	return sm.ConsiderOnlineStorageDealsConfigFunc()
 }
 
-func (sm *StorageMinerAPI) DealsSetAcceptingRetrievalDeals(ctx context.Context, b bool) error {
+func (sm *StorageMinerAPI) DealsSetConsiderOnlineStorageDeals(ctx context.Context, b bool) error {
-	return sm.SetAcceptingRetrievalDealsConfigFunc(b)
+	return sm.SetConsiderOnlineStorageDealsConfigFunc(b)
+}
+
+func (sm *StorageMinerAPI) DealsConsiderOnlineRetrievalDeals(ctx context.Context) (bool, error) {
+	return sm.ConsiderOnlineRetrievalDealsConfigFunc()
+}
+
+func (sm *StorageMinerAPI) DealsSetConsiderOnlineRetrievalDeals(ctx context.Context, b bool) error {
+	return sm.SetConsiderOnlineRetrievalDealsConfigFunc(b)
+}
+
+func (sm *StorageMinerAPI) DealsConsiderOfflineStorageDeals(ctx context.Context) (bool, error) {
+	return sm.ConsiderOfflineStorageDealsConfigFunc()
+}
+
+func (sm *StorageMinerAPI) DealsSetConsiderOfflineStorageDeals(ctx context.Context, b bool) error {
+	return sm.SetConsiderOfflineStorageDealsConfigFunc(b)
+}
+
+func (sm *StorageMinerAPI) DealsConsiderOfflineRetrievalDeals(ctx context.Context) (bool, error) {
+	return sm.ConsiderOfflineRetrievalDealsConfigFunc()
+}
+
+func (sm *StorageMinerAPI) DealsSetConsiderOfflineRetrievalDeals(ctx context.Context, b bool) error {
+	return sm.SetConsiderOfflineRetrievalDealsConfigFunc(b)
 }
 
 func (sm *StorageMinerAPI) DealsImportData(ctx context.Context, deal cid.Cid, fname string) error {

node/modules/dtypes/miner.go

@@ -10,27 +10,43 @@ import (
 type MinerAddress address.Address
 type MinerID abi.ActorID
 
-// AcceptingStorageDealsConfigFunc is a function which reads from miner config
+// ConsiderOnlineStorageDealsConfigFunc is a function which reads from miner
-// to determine if the user has disabled storage deals (or not).
+// config to determine if the user has disabled storage deals (or not).
-type AcceptingStorageDealsConfigFunc func() (bool, error)
+type ConsiderOnlineStorageDealsConfigFunc func() (bool, error)
 
-// SetAcceptingStorageDealsConfigFunc is a function which is used to disable or
+// SetConsiderOnlineStorageDealsConfigFunc is a function which is used to
-// enable storage deal acceptance.
+// disable or enable storage deal acceptance.
-type SetAcceptingStorageDealsConfigFunc func(bool) error
+type SetConsiderOnlineStorageDealsConfigFunc func(bool) error
 
-// AcceptingRetrievalDealsConfigFunc is a function which reads from miner config
+// ConsiderOnlineRetrievalDealsConfigFunc is a function which reads from miner
-// to determine if the user has disabled retrieval acceptance (or not).
+// config to determine if the user has disabled retrieval acceptance (or not).
-type AcceptingRetrievalDealsConfigFunc func() (bool, error)
+type ConsiderOnlineRetrievalDealsConfigFunc func() (bool, error)
 
-// SetAcceptingRetrievalDealsConfigFunc is a function which is used to disable
+// SetConsiderOnlineRetrievalDealsConfigFunc is a function which is used to
-// or enable retrieval deal acceptance.
+// disable or enable retrieval deal acceptance.
-type SetAcceptingRetrievalDealsConfigFunc func(bool) error
+type SetConsiderOnlineRetrievalDealsConfigFunc func(bool) error
 
-// StorageDealPieceCidBlocklistConfigFunc is a function which reads from miner config
+// StorageDealPieceCidBlocklistConfigFunc is a function which reads from miner
-// to obtain a list of CIDs for which the storage miner will not accept storage
+// config to obtain a list of CIDs for which the storage miner will not accept
-// proposals.
+// storage proposals.
 type StorageDealPieceCidBlocklistConfigFunc func() ([]cid.Cid, error)
 
 // SetStorageDealPieceCidBlocklistConfigFunc is a function which is used to set a
 // list of CIDs for which the storage miner will reject deal proposals.
 type SetStorageDealPieceCidBlocklistConfigFunc func([]cid.Cid) error
+
+// ConsiderOfflineStorageDealsConfigFunc is a function which reads from miner
+// config to determine if the user has disabled storage deals (or not).
+type ConsiderOfflineStorageDealsConfigFunc func() (bool, error)
+
+// SetConsiderOfflineStorageDealsConfigFunc is a function which is used to
+// disable or enable storage deal acceptance.
+type SetConsiderOfflineStorageDealsConfigFunc func(bool) error
+
+// ConsiderOfflineRetrievalDealsConfigFunc is a function which reads from miner
+// config to determine if the user has disabled retrieval acceptance (or not).
+type ConsiderOfflineRetrievalDealsConfigFunc func() (bool, error)
+
+// SetConsiderOfflineRetrievalDealsConfigFunc is a function which is used to
+// disable or enable retrieval deal acceptance.
+type SetConsiderOfflineRetrievalDealsConfigFunc func(bool) error

node/modules/storageminer.go

@@ -315,7 +315,7 @@ func NewStorageAsk(ctx helpers.MetricsCtx, fapi lapi.FullNode, ds dtypes.Metadat
 	return storedAsk, nil
 }
 
-func StorageProvider(minerAddress dtypes.MinerAddress, ffiConfig *ffiwrapper.Config, storedAsk *storedask.StoredAsk, h host.Host, ds dtypes.MetadataDS, ibs dtypes.StagingBlockstore, r repo.LockedRepo, pieceStore dtypes.ProviderPieceStore, dataTransfer dtypes.ProviderDataTransfer, spn storagemarket.StorageProviderNode, isAcceptingFunc dtypes.AcceptingStorageDealsConfigFunc, blocklistFunc dtypes.StorageDealPieceCidBlocklistConfigFunc) (storagemarket.StorageProvider, error) {
+func StorageProvider(minerAddress dtypes.MinerAddress, ffiConfig *ffiwrapper.Config, storedAsk *storedask.StoredAsk, h host.Host, ds dtypes.MetadataDS, ibs dtypes.StagingBlockstore, r repo.LockedRepo, pieceStore dtypes.ProviderPieceStore, dataTransfer dtypes.ProviderDataTransfer, spn storagemarket.StorageProviderNode, onlineOk dtypes.ConsiderOnlineStorageDealsConfigFunc, offlineOk dtypes.ConsiderOfflineStorageDealsConfigFunc, blocklistFunc dtypes.StorageDealPieceCidBlocklistConfigFunc) (storagemarket.StorageProvider, error) {
 	net := smnet.NewFromLibp2pHost(h)
 	store, err := piecefilestore.NewLocalFileStore(piecefilestore.OsPath(r.Path()))
 	if err != nil {
@@ -323,14 +323,24 @@ func StorageProvider(minerAddress dtypes.MinerAddress, ffiConfig *ffiwrapper.Con
 	}
 
 	opt := storageimpl.CustomDealDecisionLogic(func(ctx context.Context, deal storagemarket.MinerDeal) (bool, string, error) {
-		b, err := isAcceptingFunc()
+		b, err := onlineOk()
 		if err != nil {
 			return false, "miner error", err
 		}
 
-		if !b {
+		if deal.Ref != nil && deal.Ref.TransferType != storagemarket.TTManual && !b {
-			log.Warnf("storage deal acceptance disabled; rejecting storage deal proposal from client: %s", deal.Client.String())
+			log.Warnf("online storage deal consideration disabled; rejecting storage deal proposal from client: %s", deal.Client.String())
-			return false, "miner is not accepting storage deals", nil
+			return false, "miner is not considering online storage deals", nil
+		}
+
+		b, err = offlineOk()
+		if err != nil {
+			return false, "miner error", err
+		}
+
+		if deal.Ref != nil && deal.Ref.TransferType == storagemarket.TTManual && !b {
+			log.Warnf("offline storage deal consideration disabled; rejecting storage deal proposal from client: %s", deal.Client.String())
+			return false, "miner is not accepting offline storage deals", nil
 		}
 
 		blocklist, err := blocklistFunc()
@@ -357,7 +367,7 @@ func StorageProvider(minerAddress dtypes.MinerAddress, ffiConfig *ffiwrapper.Con
 }
 
 // RetrievalProvider creates a new retrieval provider attached to the provider blockstore
-func RetrievalProvider(h host.Host, miner *storage.Miner, sealer sectorstorage.SectorManager, full lapi.FullNode, ds dtypes.MetadataDS, pieceStore dtypes.ProviderPieceStore, ibs dtypes.StagingBlockstore, isAcceptingFunc dtypes.AcceptingRetrievalDealsConfigFunc) (retrievalmarket.RetrievalProvider, error) {
+func RetrievalProvider(h host.Host, miner *storage.Miner, sealer sectorstorage.SectorManager, full lapi.FullNode, ds dtypes.MetadataDS, pieceStore dtypes.ProviderPieceStore, ibs dtypes.StagingBlockstore, onlineOk dtypes.ConsiderOnlineRetrievalDealsConfigFunc, offlineOk dtypes.ConsiderOfflineRetrievalDealsConfigFunc) (retrievalmarket.RetrievalProvider, error) {
 	adapter := retrievaladapter.NewRetrievalProviderNode(miner, sealer, full)
 
 	maddr, err := minerAddrFromDS(ds)
@@ -368,14 +378,23 @@ func RetrievalProvider(h host.Host, miner *storage.Miner, sealer sectorstorage.S
 	netwk := rmnet.NewFromLibp2pHost(h)
 
 	opt := retrievalimpl.DealDeciderOpt(func(ctx context.Context, state retrievalmarket.ProviderDealState) (bool, string, error) {
-		b, err := isAcceptingFunc()
+		b, err := onlineOk()
 		if err != nil {
 			return false, "miner error", err
 		}
 
 		if !b {
-			log.Warn("retrieval deal acceptance disabled; rejecting retrieval deal proposal from client")
+			log.Warn("online retrieval deal consideration disabled; rejecting retrieval deal proposal from client")
-			return false, "miner is not accepting retrieval deals", nil
+			return false, "miner is not accepting online retrieval deals", nil
+		}
+
+		b, err = offlineOk()
+		if err != nil {
+			return false, "miner error", err
+		}
+
+		if !b {
+			log.Info("offline retrieval has not been implemented yet")
 		}
 
 		return true, "", nil
@@ -416,37 +435,37 @@ func StorageAuth(ctx helpers.MetricsCtx, ca lapi.Common) (sectorstorage.StorageA
 	return sectorstorage.StorageAuth(headers), nil
 }
 
-func NewAcceptingRetrievalDealsConfigFunc(r repo.LockedRepo) (dtypes.AcceptingRetrievalDealsConfigFunc, error) {
+func NewConsiderOnlineStorageDealsConfigFunc(r repo.LockedRepo) (dtypes.ConsiderOnlineStorageDealsConfigFunc, error) {
 	return func() (out bool, err error) {
 		err = readCfg(r, func(cfg *config.StorageMiner) {
-			out = cfg.Dealmaking.AcceptingRetrievalDeals
+			out = cfg.Dealmaking.ConsiderOnlineStorageDeals
 		})
 		return
 	}, nil
 }
 
-func NewSetAcceptingRetrievalDealsConfigFunc(r repo.LockedRepo) (dtypes.SetAcceptingRetrievalDealsConfigFunc, error) {
+func NewSetConsideringOnlineStorageDealsFunc(r repo.LockedRepo) (dtypes.SetConsiderOnlineStorageDealsConfigFunc, error) {
 	return func(b bool) (err error) {
 		err = mutateCfg(r, func(cfg *config.StorageMiner) {
-			cfg.Dealmaking.AcceptingRetrievalDeals = b
+			cfg.Dealmaking.ConsiderOnlineStorageDeals = b
 		})
 		return
 	}, nil
 }
 
-func NewAcceptingStorageDealsConfigFunc(r repo.LockedRepo) (dtypes.AcceptingStorageDealsConfigFunc, error) {
+func NewConsiderOnlineRetrievalDealsConfigFunc(r repo.LockedRepo) (dtypes.ConsiderOnlineRetrievalDealsConfigFunc, error) {
 	return func() (out bool, err error) {
 		err = readCfg(r, func(cfg *config.StorageMiner) {
-			out = cfg.Dealmaking.AcceptingStorageDeals
+			out = cfg.Dealmaking.ConsiderOnlineRetrievalDeals
 		})
 		return
 	}, nil
 }
 
-func NewSetAcceptingStorageDealsConfigFunc(r repo.LockedRepo) (dtypes.SetAcceptingStorageDealsConfigFunc, error) {
+func NewSetConsiderOnlineRetrievalDealsConfigFunc(r repo.LockedRepo) (dtypes.SetConsiderOnlineRetrievalDealsConfigFunc, error) {
 	return func(b bool) (err error) {
 		err = mutateCfg(r, func(cfg *config.StorageMiner) {
-			cfg.Dealmaking.AcceptingStorageDeals = b
+			cfg.Dealmaking.ConsiderOnlineRetrievalDeals = b
 		})
 		return
 	}, nil
@@ -470,6 +489,42 @@ func NewSetStorageDealPieceCidBlocklistConfigFunc(r repo.LockedRepo) (dtypes.Set
 	}, nil
 }
 
+func NewConsiderOfflineStorageDealsConfigFunc(r repo.LockedRepo) (dtypes.ConsiderOfflineStorageDealsConfigFunc, error) {
+	return func() (out bool, err error) {
+		err = readCfg(r, func(cfg *config.StorageMiner) {
+			out = cfg.Dealmaking.ConsiderOfflineStorageDeals
+		})
+		return
+	}, nil
+}
+
+func NewSetConsideringOfflineStorageDealsFunc(r repo.LockedRepo) (dtypes.SetConsiderOfflineStorageDealsConfigFunc, error) {
+	return func(b bool) (err error) {
+		err = mutateCfg(r, func(cfg *config.StorageMiner) {
+			cfg.Dealmaking.ConsiderOfflineStorageDeals = b
+		})
+		return
+	}, nil
+}
+
+func NewConsiderOfflineRetrievalDealsConfigFunc(r repo.LockedRepo) (dtypes.ConsiderOfflineRetrievalDealsConfigFunc, error) {
+	return func() (out bool, err error) {
+		err = readCfg(r, func(cfg *config.StorageMiner) {
+			out = cfg.Dealmaking.ConsiderOfflineRetrievalDeals
+		})
+		return
+	}, nil
+}
+
+func NewSetConsiderOfflineRetrievalDealsConfigFunc(r repo.LockedRepo) (dtypes.SetConsiderOfflineRetrievalDealsConfigFunc, error) {
+	return func(b bool) (err error) {
+		err = mutateCfg(r, func(cfg *config.StorageMiner) {
+			cfg.Dealmaking.ConsiderOfflineRetrievalDeals = b
+		})
+		return
+	}, nil
+}
+
 func readCfg(r repo.LockedRepo, accessor func(*config.StorageMiner)) error {
 	raw, err := r.Config()
 	if err != nil {