lotus-provider-in-progress

.vscode/launch.json

@@ -0,0 +1,23 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch Package",
+            "type": "go",
+            "request": "launch",
+            "mode": "exec",
+            "program": "lotus-provider",
+            "args": ["--db-host=localhost","run"],
+            "env": {
+                "LOTUS_PATH":"~/.lotus-local-net",                                     
+                "LOTUS_MINER_PATH":"~/.lotus-miner-local-net",
+                "LOTUS_SKIP_GENESIS_CHECK":"_yes_",
+                "CGO_CFLAGS_ALLOW":"-D__BLST_PORTABLE__",
+                "CGO_CFLAGS":"-D__BLST_PORTABLE__",
+            }       
+        }
+    ]
+}

Makefile

@@ -101,6 +101,9 @@ lotus-provider: $(BUILD_DEPS)
 	rm -f lotus-provider
 	$(GOCC) build $(GOFLAGS) -o lotus-provider ./cmd/lotus-provider
 
+lp2k: GOFLAGS+=-tags=2k
+lp2k: lotus-provider
+
 lotus-worker: $(BUILD_DEPS)
 	rm -f lotus-worker
 	$(GOCC) build $(GOFLAGS) -o lotus-worker ./cmd/lotus-worker

cli/util/api.go

@@ -164,6 +164,28 @@ func GetRawAPIMulti(ctx *cli.Context, t repo.RepoType, version string) ([]HttpHe
 	return httpHeads, nil
 }
 
+func GetRawAPIMultiV2(ctx *cli.Context, ainfoCfg []string, version string) ([]HttpHead, error) {
+	var httpHeads []HttpHead
+
+	if len(ainfoCfg) == 0 {
+		return httpHeads, xerrors.Errorf("could not get API info: none configured")
+	}
+	for _, i := range ainfoCfg {
+		ainfo := ParseApiInfo(i)
+		addr, err := ainfo.DialArgs(version)
+		if err != nil {
+			return httpHeads, xerrors.Errorf("could not get DialArgs: %w", err)
+		}
+		httpHeads = append(httpHeads, HttpHead{addr: addr, header: ainfo.AuthHeader()})
+	}
+
+	if IsVeryVerbose {
+		_, _ = fmt.Fprintf(ctx.App.Writer, "using raw API %s endpoint: %s\n", version, httpHeads[0].addr)
+	}
+
+	return httpHeads, nil
+}
+
 func GetRawAPI(ctx *cli.Context, t repo.RepoType, version string) (string, http.Header, error) {
 	heads, err := GetRawAPIMulti(ctx, t, version)
 	if err != nil {
@@ -393,6 +415,68 @@ func GetFullNodeAPIV1(ctx *cli.Context, opts ...GetFullNodeOption) (v1api.FullNo
 	return &v1API, finalCloser, nil
 }
 
+func GetFullNodeAPIV1LotusProvider(ctx *cli.Context, ainfoCfg []string, opts ...GetFullNodeOption) (v1api.FullNode, jsonrpc.ClientCloser, error) {
+	if tn, ok := ctx.App.Metadata["testnode-full"]; ok {
+		return tn.(v1api.FullNode), func() {}, nil
+	}
+
+	var options GetFullNodeOptions
+	for _, opt := range opts {
+		opt(&options)
+	}
+
+	var rpcOpts []jsonrpc.Option
+	if options.ethSubHandler != nil {
+		rpcOpts = append(rpcOpts, jsonrpc.WithClientHandler("Filecoin", options.ethSubHandler), jsonrpc.WithClientHandlerAlias("eth_subscription", "Filecoin.EthSubscription"))
+	}
+
+	heads, err := GetRawAPIMultiV2(ctx, ainfoCfg, "v1")
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if IsVeryVerbose {
+		_, _ = fmt.Fprintln(ctx.App.Writer, "using full node API v1 endpoint:", heads[0].addr)
+	}
+
+	var fullNodes []api.FullNode
+	var closers []jsonrpc.ClientCloser
+
+	for _, head := range heads {
+		v1api, closer, err := client.NewFullNodeRPCV1(ctx.Context, head.addr, head.header, rpcOpts...)
+		if err != nil {
+			log.Warnf("Not able to establish connection to node with addr: ", head.addr)
+			continue
+		}
+		fullNodes = append(fullNodes, v1api)
+		closers = append(closers, closer)
+	}
+
+	// When running in cluster mode and trying to establish connections to multiple nodes, fail
+	// if less than 2 lotus nodes are actually running
+	if len(heads) > 1 && len(fullNodes) < 2 {
+		return nil, nil, xerrors.Errorf("Not able to establish connection to more than a single node")
+	}
+
+	finalCloser := func() {
+		for _, c := range closers {
+			c()
+		}
+	}
+
+	var v1API api.FullNodeStruct
+	FullNodeProxy(fullNodes, &v1API)
+
+	v, err := v1API.Version(ctx.Context)
+	if err != nil {
+		return nil, nil, err
+	}
+	if !v.APIVersion.EqMajorMinor(api.FullAPIVersion1) {
+		return nil, nil, xerrors.Errorf("Remote API version didn't match (expected %s, remote %s)", api.FullAPIVersion1, v.APIVersion)
+	}
+	return &v1API, finalCloser, nil
+}
+
 type GetStorageMinerOptions struct {
 	PreferHttp bool
 }

cmd/lotus-provider/main.go

@@ -2,6 +2,11 @@ package main
 
 import (
 	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"runtime/debug"
+	"syscall"
 
 	"github.com/fatih/color"
 	logging "github.com/ipfs/go-log/v2"
@@ -17,7 +22,19 @@ import (
 
 var log = logging.Logger("main")
 
+func SetupCloseHandler() {
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+	go func() {
+		<-c
+		fmt.Println("\r- Ctrl+C pressed in Terminal")
+		debug.PrintStack()
+		os.Exit(1)
+	}()
+}
+
 func main() {
+	SetupCloseHandler()
 
 	lotuslog.SetupLogLevels()
 

cmd/lotus-provider/run.go

@@ -12,6 +12,7 @@ import (
 	"github.com/gin-contrib/pprof"
 	"github.com/gin-gonic/gin"
 	"github.com/ipfs/go-datastore/namespace"
+	"github.com/pkg/errors"
 	"github.com/urfave/cli/v2"
 	"go.opencensus.io/stats"
 	"go.opencensus.io/tag"
@@ -39,6 +40,10 @@ import (
 	"github.com/filecoin-project/lotus/storage/sealer/storiface"
 )
 
+type stackTracer interface {
+	StackTrace() errors.StackTrace
+}
+
 var runCmd = &cli.Command{
 	Name:  "run",
 	Usage: "Start a lotus provider process",
@@ -64,7 +69,16 @@ var runCmd = &cli.Command{
 			Value: true,
 		},
 	},
-	Action: func(cctx *cli.Context) error {
+	Action: func(cctx *cli.Context) (err error) {
+		defer func() {
+			if err != nil {
+				if err, ok := err.(stackTracer); ok {
+					for _, f := range err.StackTrace() {
+						fmt.Printf("%+s:%d\n", f, f)
+					}
+				}
+			}
+		}()
 		if !cctx.Bool("enable-gpu-proving") {
 			err := os.Setenv("BELLMAN_NO_GPU", "true")
 			if err != nil {
@@ -179,7 +193,7 @@ var runCmd = &cli.Command{
 		if err != nil {
 			return err
 		}
-		lp, err := getConfig(cctx, db)
+		cfg, err := getConfig(cctx, db)
 		if err != nil {
 			return err
 		}
@@ -187,37 +201,34 @@ var runCmd = &cli.Command{
 
 		var activeTasks []harmonytask.TaskInterface
 
-		ds, dsCloser, err := modules.DatastoreV2(ctx, false, lr)
-		if err != nil {
-			return err
-		}
-		defer dsCloser()
-		maddr, err := modules.MinerAddress(ds)
-		if err != nil {
-			return err
-		}
 		var verif storiface.Verifier = ffiwrapper.ProofVerifier
 
-		as, err := modules.AddressSelector(&lp.Addresses)()
+		as, err := modules.AddressSelector(&cfg.Addresses)()
+		if err != nil {
+			return err
+		}
 
-		j, err := fsjournal.OpenFSJournal(lr, journal.EnvDisabledEvents()) // TODO switch this into DB entries.
+		de, err := journal.ParseDisabledEvents(cfg.Journal.DisabledEvents)
+		if err != nil {
+			return err
+		}
+		j, err := fsjournal.OpenFSJournal(lr, de)
 		if err != nil {
 			return err
 		}
 		defer j.Close()
 
-		full, fullCloser, err := cliutil.GetFullNodeAPIV1(cctx) // TODO switch this into DB entries.
-		if err != nil {
-			return err
-		}
-		defer fullCloser()
-
 		si := paths.NewIndexProxy( /*TODO Alerting*/ nil, db, true)
 
 		lstor, err := paths.NewLocal(ctx, lr, si, nil /*TODO URLs*/)
 		if err != nil {
 			return err
 		}
+		full, fullCloser, err := cliutil.GetFullNodeAPIV1LotusProvider(cctx, cfg.Apis.Daemon) // TODO switch this into DB entries.
+		if err != nil {
+			return err
+		}
+		defer fullCloser()
 		sa, err := modules.StorageAuth(ctx, full)
 		if err != nil {
 			return err
@@ -231,14 +242,24 @@ var runCmd = &cli.Command{
 
 		wsts := statestore.New(namespace.Wrap(mds, modules.WorkerCallsPrefix))
 		smsts := statestore.New(namespace.Wrap(mds, modules.ManagerWorkPrefix))
-		sealer, err := sealer.New(ctx, lstor, stor, lr, si, lp.SealerConfig, config.ProvingConfig{}, wsts, smsts)
+		sealer, err := sealer.New(ctx, lstor, stor, lr, si, cfg.SealerConfig, config.ProvingConfig{}, wsts, smsts)
 		if err != nil {
 			return err
 		}
 
-		if lp.Subsystems.EnableWindowPost {
+		ds, dsCloser, err := modules.DatastoreV2(ctx, false, lr)
-			wdPostTask, err := modules.WindowPostSchedulerV2(ctx, lp.Fees, lp.Proving, full, sealer, verif, j,
+		if err != nil {
-				as, maddr, db, lp.Subsystems.WindowPostMaxTasks)
+			return err
+		}
+		defer dsCloser()
+		maddr, err := modules.MinerAddress(ds)
+		if err != nil {
+			return err
+		}
+
+		if cfg.Subsystems.EnableWindowPost {
+			wdPostTask, err := modules.WindowPostSchedulerV2(ctx, cfg.Fees, cfg.Proving, full, sealer, verif, j,
+				as, maddr, db, cfg.Subsystems.WindowPostMaxTasks)
 			if err != nil {
 				return err
 			}

journal/types.go

@@ -26,6 +26,9 @@ func ParseDisabledEvents(s string) (DisabledEvents, error) {
 	s = strings.TrimSpace(s) // sanitize
 	evts := strings.Split(s, ",")
 	ret := make(DisabledEvents, 0, len(evts))
+	if len(s) == 0 {
+		return ret, nil
+	}
 	for _, evt := range evts {
 		evt = strings.TrimSpace(evt) // sanitize
 		s := strings.Split(evt, ":")

lib/harmony/harmonydb/harmonydb.go

@@ -201,9 +201,11 @@ var schemaRE = regexp.MustCompile(schemaREString)
 
 func ensureSchemaExists(connString, schema string) error {
 	// FUTURE allow using fallback DBs for start-up.
-	p, err := pgx.Connect(context.Background(), connString)
+	ctx, cncl := context.WithDeadline(context.Background(), time.Now().Add(3*time.Second))
+	p, err := pgx.Connect(ctx, connString)
+	defer cncl()
 	if err != nil {
-		return err
+		return fmt.Errorf("unable to connect to db: %s, err: %v", connString, err)
 	}
 	defer func() { _ = p.Close(context.Background()) }()
 

node/config/types.go

@@ -74,6 +74,18 @@ type LotusProviderConfig struct {
 	Proving       ProvingConfig
 	SealingParams SealingConfig // TODO defaults
 	SealerConfig                // TODO defaults
+	Journal       JournalConfig
+	Apis          ApisConfig
+}
+
+type ApisConfig struct {
+	// Daemon is the API endpoint for the Lotus daemon.
+	Daemon []string
+}
+
+type JournalConfig struct {
+	//Events of the form: "system1:event1,system1:event2[,...]"
+	DisabledEvents string
 }
 
 type ProviderSubsystemsConfig struct {