Example #1
0
// RunCommandAndWait executes a single command on a given vtworker and blocks until the command did return or timed out.
// Output from vtworker is streamed as logutil.Event messages which
// have to be consumed by the caller who has to specify a "recv" function.
func RunCommandAndWait(ctx context.Context, server string, args []string, recv func(*logutilpb.Event)) error {
	if recv == nil {
		panic("no function closure for Event stream specified")
	}
	// create the client
	// TODO(mberlin): vtctlclient exposes dialTimeout as flag. If there are no use cases, remove it there as well to be consistent?
	client, err := New(server, 30*time.Second /* dialTimeout */)
	if err != nil {
		return vterrors.WithPrefix("cannot dial to server "+server+": ", err)
	}
	defer client.Close()

	// run the command
	stream, err := client.ExecuteVtworkerCommand(ctx, args)
	if err != nil {
		return vterrors.WithPrefix("cannot execute remote command: ", err)
	}

	for {
		e, err := stream.Recv()
		switch err {
		case nil:
			recv(e)
		case io.EOF:
			return nil
		default:
			return vterrors.WithPrefix("stream error: ", err)
		}
	}
}
Example #2
0
// RunCommand executes the vtworker command specified by "args". Use WaitForCommand() to block on the returned done channel.
// If wr is nil, the default wrangler will be used.
// If you pass a wr wrangler, note that a MemoryLogger will be added to its current logger.
// The returned worker and done channel may be nil if no worker was started e.g. in case of a "Reset".
func (wi *Instance) RunCommand(args []string, wr *wrangler.Wrangler, runFromCli bool) (Worker, chan struct{}, error) {
	if len(args) >= 1 {
		switch args[0] {
		case "Reset":
			err := wi.Reset()
			return nil, nil, err
		case "Cancel":
			wi.Cancel()
			return nil, nil, nil
		}
	}

	if wr == nil {
		wr = wi.wr
	}
	wrk, err := commandWorker(wi, wr, args, wi.cell, runFromCli)
	if err != nil {
		return nil, nil, err
	}
	done, err := wi.setAndStartWorker(wrk, wr)
	if err != nil {
		return nil, nil, vterrors.WithPrefix("cannot set worker: ", err)
	}
	return wrk, done, nil
}
Example #3
0
func runVtworkerCommand(client vtworkerclient.Client, args []string) error {
	stream, err := client.ExecuteVtworkerCommand(context.Background(), args)
	if err != nil {
		return fmt.Errorf("cannot execute remote command: %v", err)
	}

	for {
		_, err := stream.Recv()
		switch err {
		case nil:
			// Consume next response.
		case io.EOF:
			return nil
		default:
			return vterrors.WithPrefix("unexpected error when reading the stream: ", err)
		}
	}
}