cmd

Documentation

Index

• Variables
• func Execute()
• type DAG
  • func (d *DAG) Close()
• type Datastore
  • func (d *Datastore) Close()
• type SealedSectorMetadataOrder
  • func (o SealedSectorMetadataOrder) Compare(a, b query.Entry) int
• type SectorBuilder
  • func (sb *SectorBuilder) Close()
  • func (sb *SectorBuilder) HandleSectorSealResult(r *sectorbuilder.SectorSealResult, startAt time.Time)
  • func (sb *SectorBuilder) SealAllStagedUnsealedSectors()

Variables

var InitCmd = &cobra.Command{
	Use:   "init",
	Short: "Initialize a filbench directory",
	Long:  "",
	Run: func(cmd *cobra.Command, args []string) {
		var err error
		defer func() {
			if err != nil {
				fmt.Println(err)
				os.Exit(1)
			}
		}()

		filbenchDir := getFilbenchDir()

		err = repo.EnsureWritableDirectory(filbenchDir)
		if err != nil {
			return
		}
		empty, err := repo.IsEmptyDir(filbenchDir)
		if err != nil {
			err = errors.Wrapf(err, "failed to list filbench directory %s", filbenchDir)
			return
		}
		if !empty {
			err = fmt.Errorf("refusing to initialize filbench in non-empty directory %s", filbenchDir)
			return
		}

		dag := openSectorBuilderPiecesDAG()
		defer dag.Close()
		datastore := openMetaDatastore()
		defer datastore.Close()
	},
}

var SectorBuilderAddPieceCmd = &cobra.Command{
	Use:   "add-piece <file>",
	Short: "Add piece",
	Args:  cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		filename := args[0]
		file, err := os.Open(filename)
		if err != nil {
			panic(err)
		}
		defer file.Close()

		dag := openSectorBuilderPiecesDAG()
		defer dag.Close()
		ds := openMetaDatastore()

		nd, err := dag.dag.ImportData(context.Background(), file)
		if err != nil {
			panic(err)
		}
		err = ds.Put(makeKey(metaSectorBuilderPiecePrefix, nd.Cid().String()), nil)
		if err != nil {
			return
		}

		ds.Close()

		sb := openSectorBuilder()
		defer sb.Close()

		r, err := dag.dag.Cat(context.Background(), nd.Cid())
		if err != nil {
			return
		}
		t := time.Now()
		sectorID, err := sb.AddPiece(context.Background(), nd.Cid(), r.Size(), r)
		if err != nil {
			panic(err)
		}
		fmt.Printf("Added piece %s into staging sector %d, took %v\n", nd.Cid(), sectorID, time.Since(t))

		sb.SealAllStagedUnsealedSectors()
	},
}

var SectorBuilderCmd = &cobra.Command{
	Use:   "sector-builder",
	Short: "Commands for filecoin sector builder",
}

var SectorBuilderGenPieceCmd = &cobra.Command{
	Use:   "generate-piece <file>",
	Short: "Generate piece",
	Run: func(cmd *cobra.Command, args []string) {
		sb := openSectorBuilder()
		defer sb.Close()

		for i := 0; i < pieceNum; i++ {
			pieceData := make([]byte, sb.MaxBytesPerSector.Uint64())
			_, err := io.ReadFull(rand.Reader, pieceData)
			if err != nil {
				panic(err)
			}

			data := merkledag.NewRawNode(pieceData)

			t := time.Now()
			sectorID, err := sb.AddPiece(context.Background(), data.Cid(), uint64(len(pieceData)), bytes.NewReader(pieceData))
			if err != nil {
				panic(err)
			}
			fmt.Printf("Generate and add piece %s with size %d into staging sector %d, took %v\n", data.Cid(), len(pieceData), sectorID, time.Since(t))
		}

		sb.SealAllStagedUnsealedSectors()
	},
}

var SectorBuilderGetPiecesCmd = &cobra.Command{
	Use:   "get-piece <cid> <file>",
	Short: "Get piece and save into file",
	Args:  cobra.RangeArgs(1, 2),
	Run: func(cmd *cobra.Command, args []string) {
		var err error
		defer func() {
			if err != nil {
				fmt.Println(err)
				os.Exit(1)
			}
		}()

		dag := openSectorBuilderPiecesDAG()
		defer dag.Close()

		c, err := cid.Parse(args[0])
		if err != nil {
			return
		}

		r, err := dag.dag.Cat(context.Background(), c)
		if err != nil {
			return
		}
		filename := args[0]
		if len(args) == 2 {
			filename = args[1]
		}
		f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
		if err != nil {
			return
		}
		n, err := io.Copy(f, r)
		if err == nil && uint64(n) < r.Size() {
			err = io.ErrShortWrite
		}
		if err1 := f.Close(); err == nil {
			err = err1
		}
	},
}

var SectorBuilderLsPiecesCmd = &cobra.Command{
	Use:   "ls-pieces",
	Short: "List all pieces",
	Run: func(cmd *cobra.Command, args []string) {
		var err error
		defer func() {
			if err != nil {
				fmt.Println(err)
				os.Exit(1)
			}
		}()

		ds := openMetaDatastore()
		defer ds.Close()
		dag := openSectorBuilderPiecesDAG()
		defer dag.Close()

		result, err := ds.Query(query.Query{
			Prefix:   metaSectorBuilderPiecePrefix,
			KeysOnly: true,
		})
		if err != nil {
			return
		}

		for entry := range result.Next() {
			err = entry.Error
			if err != nil {
				return
			}
			var c cid.Cid
			c, err = cid.Parse(strings.TrimLeft(entry.Key, metaSectorBuilderPiecePrefix+"/"))

			r, err := dag.dag.Cat(context.Background(), c)
			if err != nil {
				return
			}

			var node format.Node
			node, err = dag.dagService.Get(context.Background(), c)
			if err != nil {
				return
			}
			err = traverseNode(dag.dagService, node, 0, func(node format.Node, depth int) error {
				stat, err := node.Stat()
				if err != nil {
					return err
				}
				s := fmt.Sprintf("data size: %d, links: %d, cumulative size: %d", stat.DataSize, stat.NumLinks, stat.CumulativeSize)
				if depth == 0 {
					fmt.Printf("Piece: %s, %s, original data size: %d\n", blue(node.Cid().String()), s, r.Size())
				} else {
					fmt.Printf("%s%s, %s\n", strings.Repeat("  ", depth), red(node.Cid().String()), s)
				}
				return nil
			})
			if err != nil {
				return
			}
		}

		fmt.Println("Note: data size is node contained bytes (greater than the original data size), cumulative size is node size plus its all children size.")
	},
}

var SectorBuilderLsSectorsCmd = &cobra.Command{
	Use:   "ls-sectors",
	Short: "List all sectors",
	Run: func(cmd *cobra.Command, args []string) {
		sb := openSectorBuilder()
		defer sb.Close()

		fmt.Println(green("Staged sectors:"))
		allStaged, err := sb.GetAllStagedSectors()
		if err != nil {
			panic(err)
		}
		for _, s := range allStaged {
			fmt.Printf("  Sector %d\n", s.SectorID)
		}

		fmt.Println(green("Sealed sectors:"))
		allSealed := getSealedSectorMetadataList(sb.MetaStore)
		for _, s := range allSealed {
			fmt.Printf("  Sector %d\n", s.SectorID)
			for _, p := range s.Pieces {
				fmt.Printf("    Piece %s, size %d\n", cyan(p.Ref), p.Size)
			}
		}
	},
}

var SectorBuilderSealSectorsCmd = &cobra.Command{
	Use:   "seal-sectors",
	Short: "Seal all staged sectors",
	Run: func(cmd *cobra.Command, args []string) {
		sb := openSectorBuilder()
		defer sb.Close()

		sb.SealAllStagedUnsealedSectors()
	},
}

var SectorBuilderVerifySectorsPorepCmd = &cobra.Command{
	Use:   "verify-sectors-porep",
	Short: "Verify PoRep (Proof-of-Replication) of all sealed sectors",
	Run: func(cmd *cobra.Command, args []string) {
		sb := openSectorBuilder()
		defer sb.Close()

		allSealed := getSealedSectorMetadataList(sb.MetaStore)
		var sectorIDs []string
		for _, s := range allSealed {
			sectorIDs = append(sectorIDs, fmt.Sprint(s.SectorID))
		}
		fmt.Printf("All sealed sectors: [%s]\n", blue(strings.Join(sectorIDs, ", ")))
		for _, s := range allSealed {
			fmt.Printf("Verify sector %d: ", s.SectorID)
			t := time.Now()
			res, err := (&verification.RustVerifier{}).VerifySeal(verification.VerifySealRequest{
				CommD:      s.CommD,
				CommR:      s.CommR,
				CommRStar:  s.CommRStar,
				Proof:      s.Proof,
				ProverID:   sectorbuilder.AddressToProverID(minerAddr),
				SectorID:   s.SectorID,
				SectorSize: types.TwoHundredFiftySixMiBSectorSize,
			})
			if err != nil {
				fmt.Printf("error %s", red(err))
			} else if !res.IsValid {
				fmt.Print(red("invalid"))
			} else {
				fmt.Print("valid")
			}
			fmt.Printf(", took %v\n", time.Since(t))
		}
	},
}

var SectorBuilderVerifySectorsPostCmd = &cobra.Command{
	Use:   "verify-sectors-post",
	Short: "Challenge and verify PoSt (Proof-of-Spacetime) of all sealed sectors",
	Run: func(cmd *cobra.Command, args []string) {
		var challengeSeed types.PoStChallengeSeed
		_, err := io.ReadFull(rand.Reader, challengeSeed[:])
		if err != nil {
			panic(err)
		}
		fmt.Printf("Use challenge seed: %s\n", hex.EncodeToString(challengeSeed[:]))

		sb := openSectorBuilder()
		defer sb.Close()

		allSealed := getSealedSectorMetadataList(sb.MetaStore)
		var sectorInfos []go_sectorbuilder.SectorInfo
		var sectorIDs []string
		for _, s := range allSealed {
			sectorInfos = append(sectorInfos, go_sectorbuilder.SectorInfo{
				SectorID: s.SectorID,
				CommR:    s.CommR,
			})
			sectorIDs = append(sectorIDs, fmt.Sprint(s.SectorID))
		}
		sortedSectorInfo := go_sectorbuilder.NewSortedSectorInfo(sectorInfos...)

		fmt.Println("Generate PoSt ...")
		t := time.Now()
		gres, err := sb.GeneratePoSt(sectorbuilder.GeneratePoStRequest{
			SortedSectorInfo: sortedSectorInfo,
			ChallengeSeed:    challengeSeed,
		})
		if err != nil {
			panic(err)
		}
		fmt.Printf("  sectors: [%s]\n", blue(strings.Join(sectorIDs, ", ")))
		fmt.Printf("  proof %s, took %v\n", hex.EncodeToString(gres.Proof), time.Since(t))

		fmt.Println("Verify PoSt ...")
		t = time.Now()
		vres, err := (&verification.RustVerifier{}).VerifyPoSt(verification.VerifyPoStRequest{
			ChallengeSeed:    challengeSeed,
			SortedSectorInfo: sortedSectorInfo,
			Faults:           []uint64{},
			Proof:            gres.Proof,
			SectorSize:       types.TwoHundredFiftySixMiBSectorSize,
		})
		if err != nil {
			panic(err)
		}
		if !vres.IsValid {
			fmt.Print(red("  invalid"))
		} else {
			fmt.Print("  valid")
		}
		fmt.Printf(", took %v\n", time.Since(t))
	},
}

Functions

func Execute

func Execute()

Types

type DAG

type DAG struct {
	// contains filtered or unexported fields
}

func (*DAG) Close

func (d *DAG) Close()

type Datastore

type Datastore struct {
	repo.Datastore
}

func (*Datastore) Close

func (d *Datastore) Close()

type SealedSectorMetadataOrder

type SealedSectorMetadataOrder struct {
}

func (SealedSectorMetadataOrder) Compare

func (o SealedSectorMetadataOrder) Compare(a, b query.Entry) int

type SectorBuilder

type SectorBuilder struct {
	sectorbuilder.SectorBuilder
	MetaStore         *Datastore
	MaxBytesPerSector *types.BytesAmount
}

func (*SectorBuilder) Close

func (sb *SectorBuilder) Close()

func (*SectorBuilder) HandleSectorSealResult

func (sb *SectorBuilder) HandleSectorSealResult(r *sectorbuilder.SectorSealResult, startAt time.Time)

func (*SectorBuilder) SealAllStagedUnsealedSectors

func (sb *SectorBuilder) SealAllStagedUnsealedSectors()