Pull a docker image to local registry using golang

I'm trying to build an automation tool to pull docker images using golang.

Here is the simplified version of the script:

package dockermgr

import (
	"context"


	"github.com/docker/docker/api/types"
	"github.com/docker/docker/client"
)


func getClient() (*client.Client, error) {

	return client.NewClientWithOpts(client.FromEnv)
}

func ImagePull(image models.DockerImage) error {
	// TODO: Is docker daemon running?
	cli, err := getClient()

	if err != nil {
		panic(err)
	}

	defer cli.Close()

	reader, err := cli.ImagePull(
		context.Background(),
		image.GetNameAndTag(),
		types.ImagePullOptions{})

	if err != nil {
		panic(err)
	}

	defer reader.Close()

	return err

}

It apparently pulls the image, but when I turn back to terminal and execute a docker image list, I can't see the specified image pulled & saved into the local registry.

I wondered if it invokes it's own docker daemon instead of using the local one. But it does not seem to be the case. If I try to pause the local docker daemon, it wakes back up when I execute this.

So what am I missing?

I initially suggested printing the events returned by PullImage to see the error causing the issue. Later @SercioSoydanov mentioned in one of the comments:
> if you don't consume the reader until it's depleted, the Image Pull operation gets interrupted before it can finish

So I edited my answer so it makes more sense. When the ImagePull is returned it doesn't mean the image is pulled (which is not great since at least the function name and the doc doesn't show that). So the issue with the original implementation in the question is that the program exists too soon. One obvious solution is to stick around enough to read all events as mentioned by @SercioSoydanov in comments. But since achieving the expected behaviour has nothing to do with consuming those events I added another implementation which is more complicated but makes more sense logically (just for the sake of being an answer).

The program sticks around till the image is actually pulled.

func getClient() (*client.Client, error) {
	return client.NewClientWithOpts(client.FromEnv)
}

func main() {
	ImagePull()
}

func ImagePull() error {
	cli, err := getClient()

	if err != nil {
		panic(err)
	}

	defer cli.Close()

	events, err := cli.ImagePull(
		context.Background(),
		"busybox:1.35",
		types.ImagePullOptions{},
	)

	if err != nil {
		panic(err)
	}
	defer events.Close()

	wg := sync.WaitGroup{}
	wg.Add(1)
	go func(wg *sync.WaitGroup) {
		time.Sleep(1 * time.Second)
		list, err := cli.ImageList(context.Background(), types.ImageListOptions{})
		if err != nil {
			panic(err)
		}
		for _, ims := range list {
			for _, tag := range ims.RepoTags {
				if strings.HasPrefix(tag, "busybox:1.35") {
					wg.Done()
				}
			}
		}
	}(&wg)
	wg.Wait()
	return nil
}