lotus/cmd/lotus-storage-miner/init.go

270 lines
6.0 KiB
Go
Raw Normal View History

2019-07-19 09:24:11 +00:00
package main
import (
"context"
"github.com/ipfs/go-datastore"
2019-07-25 12:50:34 +00:00
"github.com/libp2p/go-libp2p-core/peer"
2019-07-19 09:24:11 +00:00
"golang.org/x/xerrors"
"gopkg.in/urfave/cli.v2"
"github.com/filecoin-project/go-lotus/api"
"github.com/filecoin-project/go-lotus/build"
2019-07-25 12:50:34 +00:00
"github.com/filecoin-project/go-lotus/chain/actors"
"github.com/filecoin-project/go-lotus/chain/address"
2019-07-25 12:50:34 +00:00
"github.com/filecoin-project/go-lotus/chain/types"
2019-07-19 09:24:11 +00:00
lcli "github.com/filecoin-project/go-lotus/cli"
"github.com/filecoin-project/go-lotus/node/repo"
)
var initCmd = &cli.Command{
Name: "init",
Usage: "Initialize a lotus storage miner repo",
Flags: []cli.Flag{
&cli.StringFlag{
Name: "actor",
Usage: "specify the address of an already created miner actor",
},
},
2019-07-19 09:24:11 +00:00
Action: func(cctx *cli.Context) error {
log.Info("Initializing lotus storage miner")
log.Info("Checking if repo exists")
2019-07-23 21:50:52 +00:00
r, err := repo.NewFS(cctx.String(FlagStorageRepo))
2019-07-19 09:24:11 +00:00
if err != nil {
return err
}
2019-07-23 21:54:54 +00:00
ok, err := r.Exists()
if err != nil {
return err
}
if ok {
2019-07-23 21:50:52 +00:00
return xerrors.Errorf("repo at '%s' is already initialized", cctx.String(FlagStorageRepo))
2019-07-19 09:24:11 +00:00
}
log.Info("Trying to connect to full node RPC")
2019-08-02 16:18:44 +00:00
api, err := lcli.GetFullNodeAPI(cctx) // TODO: consider storing full node address in config
2019-07-19 09:24:11 +00:00
if err != nil {
return err
}
ctx := lcli.ReqContext(cctx)
log.Info("Checking full node version")
v, err := api.Version(ctx)
if err != nil {
return err
}
2019-07-23 21:55:19 +00:00
if v.APIVersion&build.MinorMask != build.APIVersion&build.MinorMask {
return xerrors.Errorf("Remote API version didn't match (local %x, remote %x)", build.APIVersion, v.APIVersion)
}
log.Info("Initializing repo")
2019-07-19 09:24:11 +00:00
if err := r.Init(); err != nil {
return err
}
2019-07-25 12:50:34 +00:00
lr, err := r.Lock()
if err != nil {
return err
}
defer lr.Close()
log.Info("Initializing libp2p identity")
p2pSk, err := lr.Libp2pIdentity()
if err != nil {
return err
}
peerid, err := peer.IDFromPrivateKey(p2pSk)
if err != nil {
return err
}
var addr address.Address
if act := cctx.String("actor"); act != "" {
a, err := address.NewFromString(act)
if err != nil {
return err
}
if err := configureStorageMiner(ctx, api, a, peerid); err != nil {
return xerrors.Errorf("failed to configure storage miner: %w", err)
}
addr = a
} else {
a, err := createStorageMiner(ctx, api, peerid)
if err != nil {
return err
}
addr = a
2019-07-25 12:50:34 +00:00
}
ds, err := lr.Datastore("/metadata")
2019-07-25 12:50:34 +00:00
if err != nil {
return err
}
if err := ds.Put(datastore.NewKey("miner-address"), addr.Bytes()); err != nil {
2019-07-25 12:50:34 +00:00
return err
}
// TODO: Point to setting storage price, maybe do it interactively or something
log.Info("Storage miner successfully created, you can now start it with 'lotus-storage-miner run'")
2019-07-25 12:50:34 +00:00
return nil
},
}
2019-07-25 12:50:34 +00:00
func configureStorageMiner(ctx context.Context, api api.FullNode, addr address.Address, peerid peer.ID) error {
// This really just needs to be an api call at this point...
recp, err := api.ChainCall(ctx, &types.Message{
To: addr,
From: addr,
Method: actors.MAMethods.GetWorkerAddr,
}, nil)
if err != nil {
return xerrors.Errorf("failed to get worker address: %w", err)
}
if recp.ExitCode != 0 {
return xerrors.Errorf("getWorkerAddr returned exit code %d", recp.ExitCode)
}
waddr, err := address.NewFromBytes(recp.Return)
if err != nil {
return xerrors.Errorf("getWorkerAddr returned bad address: %w", err)
}
enc, err := actors.SerializeParams(&actors.UpdatePeerIDParams{PeerID: peerid})
if err != nil {
return err
}
nonce, err := api.MpoolGetNonce(ctx, waddr)
if err != nil {
return err
}
msg := &types.Message{
To: addr,
From: waddr,
Method: actors.MAMethods.UpdatePeerID,
Params: enc,
Nonce: nonce,
2019-08-16 22:10:34 +00:00
Value: types.NewInt(0),
GasPrice: types.NewInt(0),
GasLimit: types.NewInt(1000),
}
smsg, err := api.WalletSignMessage(ctx, waddr, msg)
if err != nil {
return err
}
if err := api.MpoolPush(ctx, smsg); err != nil {
return err
}
2019-08-16 22:10:34 +00:00
log.Info("Waiting for message: ", smsg.Cid())
ret, err := api.ChainWaitMsg(ctx, smsg.Cid())
if err != nil {
return err
}
if ret.Receipt.ExitCode != 0 {
return xerrors.Errorf("update peer id message failed with exit code %d", ret.Receipt.ExitCode)
}
return nil
}
2019-07-25 12:50:34 +00:00
func createStorageMiner(ctx context.Context, api api.FullNode, peerid peer.ID) (address.Address, error) {
log.Info("Creating StorageMarket.CreateStorageMiner message")
2019-07-25 12:50:34 +00:00
defOwner, err := api.WalletDefaultAddress(ctx)
if err != nil {
return address.Undef, err
}
2019-07-25 12:50:34 +00:00
nonce, err := api.MpoolGetNonce(ctx, defOwner)
if err != nil {
return address.Undef, err
}
2019-07-25 12:50:34 +00:00
k, err := api.WalletNew(ctx, types.KTSecp256k1)
if err != nil {
return address.Undef, err
}
2019-07-25 12:50:34 +00:00
collateral := types.NewInt(1000) // TODO: Get this from params
2019-07-25 12:50:34 +00:00
params, err := actors.SerializeParams(actors.CreateStorageMinerParams{
Owner: defOwner,
Worker: k,
SectorSize: types.NewInt(actors.SectorSize),
PeerID: peerid,
})
if err != nil {
return address.Undef, err
}
2019-07-25 12:50:34 +00:00
createStorageMinerMsg := types.Message{
To: actors.StorageMarketAddress,
From: defOwner,
Nonce: nonce,
Value: collateral,
2019-07-25 12:50:34 +00:00
Method: actors.SMAMethods.CreateStorageMiner,
Params: params,
GasLimit: types.NewInt(10000),
GasPrice: types.NewInt(0),
}
2019-07-25 12:50:34 +00:00
unsigned, err := createStorageMinerMsg.Serialize()
if err != nil {
return address.Undef, err
}
log.Info("Signing StorageMarket.CreateStorageMiner")
2019-07-25 12:50:34 +00:00
sig, err := api.WalletSign(ctx, defOwner, unsigned)
if err != nil {
return address.Undef, err
}
signed := &types.SignedMessage{
Message: createStorageMinerMsg,
Signature: *sig,
}
log.Infof("Pushing %s to Mpool", signed.Cid())
err = api.MpoolPush(ctx, signed)
if err != nil {
return address.Undef, err
}
log.Infof("Waiting for confirmation")
mw, err := api.ChainWaitMsg(ctx, signed.Cid())
if err != nil {
return address.Undef, err
}
addr, err := address.NewFromBytes(mw.Receipt.Return)
if err != nil {
return address.Undef, err
}
log.Infof("New storage miners address is: %s", addr)
return addr, nil
2019-07-19 09:24:11 +00:00
}