How to wait for the command to finish/ till some seconds in golang?

I am running command exec.Command("cf api https://something.com/") and the response takes sometimes. But when executing this command, there is no wait happens but executed and goes further immediately. I need to wait for some seconds or until output has been received. How to achieve this?

func TestCMDExex(t *testing.T) {
	expectedText := "Success"
	cmd := exec.Command("cf api https://something.com/")
	cmd.Dir = "/root//"
	out, err := cmd.Output()
	if err != nil {
		t.Fail()
	}
	assert.Contains(t, string(out), expectedText)

}

First: the correct way to create the cmd is:

 cmd := exec.Command("cf", "api", "https://something.com/")

Every argument to the child program must be a separate string. This way you can also pass arguments that contain spaces in them. For instance, executing the program with:

cmd := exec.Command("cf", "api https://something.com/")

will pass one command line argument to cf, which is "api https://something.com/", whereas passing two strings will pass two arguments "api" and "https://something.com/".

In your original code, you are trying to execute a program whose name is "cf api https://something.com/".

Then you can run it and get the output:

out, err:=cmd.Output()

This can be solved with a goroutine, a channel and the select statement. The sample code below also does error handling:

func main() {
	type output struct {
		out []byte
		err error
	}

	ch := make(chan output)

	go func() {
		// cmd := exec.Command("sleep", "1")
		// cmd := exec.Command("sleep", "5")
		cmd := exec.Command("false")
		out, err := cmd.CombinedOutput()
		ch <- output{out, err}
	}()

	select {
	case <-time.After(2 * time.Second):
		fmt.Println("timed out")
	case x := <-ch:
		fmt.Printf("program done; out: %q\n", string(x.out))
		if x.err != nil {
			fmt.Printf("program errored: %s\n", x.err)
		}
	}
}

By choosing one of the 3 options in exec.Command(), you can see the code behaving in the 3 possible ways: timed out, normal subprocess termination, errored subprocess termination.

As usual when using goroutines, care must be taken to ensure they terminate, to avoid resource leaks.

Note also that if the executed subprocess is interactive or if it prints its progression to stdout and it is important to see the output while it is happening, then it is better to use cmd.Run(), remove the struct and report only the error in the channel.

You can use a go waitGroup. This is the function we’ll run in every goroutine. Note that a WaitGroup must be passed to functions by pointer. On return, notify the WaitGroup that we’re done. Sleep to simulate an expensive task. (remove it in your case) This WaitGroup is used to wait for all the goroutines launched here to finish. Block until the WaitGroup counter goes back to 0; all the workers notified they’re done.

  package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, wg *sync.WaitGroup) {

    defer wg.Done()

    fmt.Printf("Worker %d starting\n", id)

    time.Sleep(time.Second)
    fmt.Printf("Worker %d done\n", id)
}

func main() {

    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }

    wg.Wait()
}