Example #1
0
File: cli.go Project: Byron/godi
// return subcommands for our particular area of algorithms
func SubCommands() []gcli.Command {
	out := make([]gcli.Command, 1)
	cmd := verify.Command{}

	verify := gcli.Command{
		Name:      verify.Name,
		ShortName: "",
		Usage:     verifyDescription,
		Action:    func(c *gcli.Context) { cli.RunAction(&cmd, c) },
		Before:    func(c *gcli.Context) error { return cli.CheckCommonFlagsAndInit(&cmd, c) },
	}

	out[0] = verify
	return out
}
Example #2
0
File: cli.go Project: Byron/godi
func startSealedCopy(cmd *seal.Command, c *gcli.Context) {

	// Yes, currently the post-verification is only implemented in the CLI ...
	// Testing needs to do similar things to set it up ...
	if cmd.Verify {
		// Setup a aggregation result handler which tracks produced indices
		var indices []string
		cmdDone := make(chan bool)

		handler := cli.MakeLogHandler(cmd.LogLevel())
		aggHandler := api.IndexTrackingResultHandlerAdapter(&indices, handler)

		// and run ourselves
		err := api.StartEngine(cmd, aggHandler)
		// Make sure we don't keep logging while verification is going with its own handler
		close(cmdDone)

		if err == nil && len(indices) == 0 {
			panic("Unexpectedly I didn't see a single seal index without error")
		} else if len(indices) > 0 {
			// no matter whether we have an error, try to verify what's there
			select {
			case <-cmd.Done:
				// this does nothing, most importantly, it doesn't run verify, as we don't run it
				// after cancellation. It's arguable whether we migth want to do that anyway
				// as the index is valid !
			default:
				{
					// prepare and run a verify command
					verifycmd, err := verify.NewCommand(indices, c.GlobalInt(cli.StreamsPerInputDeviceFlagName))
					if err == nil {
						err = api.StartEngine(verifycmd, handler)
					}
				}
			}
		}

		// Finally, exit with appropriate error code
		if err != nil {
			os.Exit(1)
		}
	} else {
		// copy without verify
		cli.RunAction(cmd, c)
	}
}
Example #3
0
File: cli.go Project: Byron/godi
// return subcommands for our particular area of algorithms
func SubCommands() []gcli.Command {
	cmdseal := seal.Command{Mode: seal.ModeSeal}
	cmdcopy := seal.Command{Mode: seal.ModeCopy}

	fmt := gcli.StringFlag{
		Name:  formatFlag,
		Value: codec.GobName,
		Usage: formatDescription,
	}

	return []gcli.Command{
		gcli.Command{
			Name:      seal.ModeSeal,
			ShortName: "",
			Usage:     sealDescription,
			Action:    func(c *gcli.Context) { cli.RunAction(&cmdseal, c) },
			Before:    func(c *gcli.Context) error { return checkSeal(&cmdseal, c) },
			Flags:     []gcli.Flag{fmt},
		},
		gcli.Command{
			Name:      seal.ModeCopy,
			ShortName: "",
			Usage:     sealedCopyDescription,
			Action:    func(c *gcli.Context) { startSealedCopy(&cmdcopy, c) },
			Before:    func(c *gcli.Context) error { return checkSealedCopy(&cmdcopy, c) },
			Flags: []gcli.Flag{
				gcli.BoolFlag{
					Name:  verifyAfterCopy,
					Usage: "Run `godi verify` on all produced seals when copy is finished"},
				gcli.IntFlag{
					Name:  streamsPerOutputDevice + ", spod",
					Value: 1,
					Usage: "Amount of parallel streams per output device"},
				fmt,
			},
		},
	}
}