Copies Docker repo from one to another

docker_copy.go

package main

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"crypto/sha256"
	"encoding/hex"
    "github.com/heroku/docker-registry-client/registry"
    "github.com/docker/distribution/digest"
    "github.com/docker/distribution/manifest"
    "github.com/docker/libtrust"
)

func copy_repo() (error, error) {
	url      := "https://registry-1.docker.io/"
	username := "****" // anonymous
	password := "****" // anonymous
	hub, err := registry.New(url, username, password)

	if err != nil {
		fmt.Printf("Error in connecting %s\n", err)
		return nil, err
	}

	tags, err := hub.Tags("codervinod/foo")

	if err != nil {
		return nil, err
	}

	tag := tags[0]

	signedManifest, err := hub.Manifest("codervinod/foo", tag)

	if err != nil {
		return nil, err
	}

	fmt.Printf("Recieved signedManifest\n")
	newManifest := signedManifest.Manifest
	fmt.Printf("Tag recieved %s\n", newManifest.Tag)
	newManifest.Tag = "latest" 


	for _,FSLayer := range signedManifest.FSLayers {

		fmt.Printf("%+v\n", FSLayer.BlobSum)
		digest_curr := FSLayer.BlobSum

		exists, err := hub.HasLayer("codervinod/bar", digest_curr)

		if err != nil {
			return nil, err
		}

		if exists {
			fmt.Printf("layer exists\n")
			continue
		}
		
		reader, err := hub.DownloadLayer("codervinod/foo", digest_curr)
		if err != nil {
			fmt.Printf(" Error downloading layer %s\n", err)	
			return nil, err
		}

		if reader != nil {	
				buf, _ := ioutil.ReadAll(reader)
				sha256_digest := sha256.Sum256(buf)
				sha256_str := hex.EncodeToString(sha256_digest[:])
				
				
				new_digest  := digest.NewDigestFromHex(
				    "sha256",
				    sha256_str,
				)
				fmt.Printf("sha256 string of downloaded layer:%+v\n", digest_curr)
				fmt.Printf("sha256 string of uploading layer:%+v\n", new_digest)	
				
				new_buf := bytes.NewReader(buf[:])
				
				err = hub.UploadLayer("codervinod/bar", new_digest, new_buf)
				if err != nil {
					fmt.Printf(" Error uploading image %s\n", err)	
					defer reader.Close()
					return nil, err
				}
				
		    defer reader.Close()
		}

		fmt.Printf("Uploaded layer\n")

	}


	key, err := libtrust.GenerateECP256PrivateKey()
	if err != nil {
	    fmt.Printf("Unable to create key")
	    return nil, err
	}

	newSignedManifest, err := manifest.Sign(&newManifest, key)

	if err != nil {
	    fmt.Printf("Unable to sign manifest")
	    return nil, err
	}

	err = hub.PutManifest("codervinod/bar", "latest", newSignedManifest)
	
	fmt.Printf("Uploaded signedManifest %s\n", err)

	return nil, nil
}

func main() {
  fmt.Printf("hello, docker\n")
  copy_repo()
}