feat: log more info

cmd/kubevpn/cmds/serve.go

@@ -43,6 +43,7 @@ func CmdServe(_ cmdutil.Factory) *cobra.Command {
 			}()
 			servers, err := handler.Parse(*route)
 			if err != nil {
+				log.Errorf("parse server failed: %v", err)
 				return err
 			}
 			ctx := cmd.Context()

pkg/core/gvisorstack.go

@@ -2,7 +2,6 @@ package core
 
 import (
 	"context"
-	"fmt"
 
 	log "github.com/sirupsen/logrus"
 	"gvisor.dev/gvisor/pkg/tcpip"
@@ -69,7 +68,7 @@ func NewStack(ctx context.Context, tun stack.LinkEndpoint) *stack.Stack {
 	{
 		opt := tcpip.TCPSACKEnabled(true)
 		if err := s.SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
-			log.Fatal(fmt.Errorf("SetTransportProtocolOption(%d, &%T(%t)): %s", tcp.ProtocolNumber, opt, opt, err))
+			log.Fatalf("SetTransportProtocolOption(%d, &%T(%t)): %v", tcp.ProtocolNumber, opt, opt, err)
 		}
 	}
 
@@ -77,10 +76,10 @@ func NewStack(ctx context.Context, tun stack.LinkEndpoint) *stack.Stack {
 	{
 		opt := tcpip.DefaultTTLOption(64)
 		if err := s.SetNetworkProtocolOption(ipv4.ProtocolNumber, &opt); err != nil {
-			log.Fatal(fmt.Errorf("SetNetworkProtocolOption(%d, &%T(%d)): %s", ipv4.ProtocolNumber, opt, opt, err))
+			log.Fatalf("SetNetworkProtocolOption(%d, &%T(%d)): %v", ipv4.ProtocolNumber, opt, opt, err)
 		}
 		if err := s.SetNetworkProtocolOption(ipv6.ProtocolNumber, &opt); err != nil {
-			log.Fatal(fmt.Errorf("SetNetworkProtocolOption(%d, &%T(%d)): %s", ipv6.ProtocolNumber, opt, opt, err))
+			log.Fatalf("SetNetworkProtocolOption(%d, &%T(%d)): %v", ipv6.ProtocolNumber, opt, opt, err)
 		}
 	}
 
@@ -88,23 +87,23 @@ func NewStack(ctx context.Context, tun stack.LinkEndpoint) *stack.Stack {
 	{
 		opt := tcpip.TCPModerateReceiveBufferOption(true)
 		if err := s.SetTransportProtocolOption(tcp.ProtocolNumber, &opt); err != nil {
-			log.Fatal(fmt.Errorf("SetTransportProtocolOption(%d, &%T(%t)): %s", tcp.ProtocolNumber, opt, opt, err))
+			log.Fatalf("SetTransportProtocolOption(%d, &%T(%t)): %v", tcp.ProtocolNumber, opt, opt, err)
 		}
 	}
 
 	{
 		if err := s.SetForwardingDefaultAndAllNICs(ipv4.ProtocolNumber, true); err != nil {
-			log.Fatal(fmt.Errorf("set ipv4 forwarding: %s", err))
+			log.Fatalf("set ipv4 forwarding: %v", err)
 		}
 		if err := s.SetForwardingDefaultAndAllNICs(ipv6.ProtocolNumber, true); err != nil {
-			log.Fatal(fmt.Errorf("set ipv6 forwarding: %s", err))
+			log.Fatalf("set ipv6 forwarding: %v", err)
 		}
 	}
 
 	{
 		option := tcpip.TCPModerateReceiveBufferOption(true)
 		if err := s.SetTransportProtocolOption(tcp.ProtocolNumber, &option); err != nil {
-			log.Fatal(fmt.Errorf("set TCP moderate receive buffer: %s", err))
+			log.Fatalf("set TCP moderate receive buffer: %v", err)
 		}
 	}
 	return s

pkg/core/route.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/types"
 	"github.com/pkg/errors"
+	log "github.com/sirupsen/logrus"
 
 	"github.com/wencaiwulue/kubevpn/pkg/config"
 	"github.com/wencaiwulue/kubevpn/pkg/tun"
@@ -49,6 +50,7 @@ func (r *Route) parseChain() (*Chain, error) {
 func parseChainNode(ns string) (*Node, error) {
 	node, err := ParseNode(ns)
 	if err != nil {
+		log.Errorf("parse node error: %v", err)
 		return nil, err
 	}
 	node.Client = &Client{
@@ -61,6 +63,7 @@ func parseChainNode(ns string) (*Node, error) {
 func (r *Route) GenerateServers() ([]Server, error) {
 	chain, err := r.parseChain()
 	if err != nil && !errors.Is(err, ErrorInvalidNode) {
+		log.Errorf("parse chain error: %v", err)
 		return nil, err
 	}
 
@@ -69,6 +72,7 @@ func (r *Route) GenerateServers() ([]Server, error) {
 		var node *Node
 		node, err = ParseNode(serveNode)
 		if err != nil {
+			log.Errorf("parse node %s error: %v", serveNode, err)
 			return nil, err
 		}
 
@@ -87,27 +91,32 @@ func (r *Route) GenerateServers() ([]Server, error) {
 				Gateway: node.Get("gw"),
 			})
 			if err != nil {
+				log.Errorf("create tun listener error: %v", err)
 				return nil, err
 			}
 		case "tcp":
 			handler = TCPHandler()
 			ln, err = TCPListener(node.Addr)
 			if err != nil {
+				log.Errorf("create tcp listener error: %v", err)
 				return nil, err
 			}
 		case "gtcp":
 			handler = GvisorTCPHandler()
 			ln, err = GvisorTCPListener(node.Addr)
 			if err != nil {
+				log.Errorf("create gvisor tcp listener error: %v", err)
 				return nil, err
 			}
 		case "gudp":
 			handler = GvisorUDPHandler()
 			ln, err = GvisorUDPListener(node.Addr)
 			if err != nil {
+				log.Errorf("create gvisor udp listener error: %v", err)
 				return nil, err
 			}
 		default:
+			log.Errorf("not support protocol %s", node.Protocol)
 			return nil, fmt.Errorf("not support protocol %s", node.Protocol)
 		}
 		servers = append(servers, Server{Listener: ln, Handler: handler})

pkg/core/tunendpoint.go

@@ -106,7 +106,7 @@ func (e *tunEndpoint) Attach(dispatcher stack.NetworkDispatcher) {
 				if err != nil {
 					// if context is still going
 					if e.ctx.Err() == nil {
-						log.Errorf("[TUN]: read from tun failed: %s", err.Error())
+						log.Fatalf("[TUN]: read from tun failed: %v", err)
 					} else {
 						log.Info("tun device closed")
 					}

pkg/daemon/action/proxy.go

@@ -122,6 +122,12 @@ func (svr *Server) Proxy(req *rpc.ConnectRequest, resp rpc.Daemon_ProxyServer) e
 		log.SetOutput(out)
 	}
 
+	// todo optimize here
+	{
+		svr.connect.Workloads = append(svr.connect.Workloads, req.Workloads...)
+		svr.connect.Headers = req.Headers
+	}
+
 	err = svr.connect.CreateRemoteInboundPod(ctx)
 	if err != nil {
 		log.Errorf("create remote inbound pod failed: %s", err.Error())

pkg/dev/main.go

@@ -119,22 +119,26 @@ func (d *Options) Main(ctx context.Context, tempContainerConfig *containerConfig
 
 	env, err := util.GetEnv(ctx, d.Factory, d.Namespace, pod)
 	if err != nil {
+		log.Errorf("get env from k8s: %v", err)
 		return err
 	}
 	volume, err := GetVolume(ctx, d.Factory, d.Namespace, pod)
 	if err != nil {
+		log.Errorf("get volume from k8s: %v", err)
 		return err
 	}
 	dns, err := GetDNS(ctx, d.Factory, d.Namespace, pod)
 	if err != nil {
-		return fmt.Errorf("can not get dns conf from pod: %s, err: %v", pod, err)
+		log.Errorf("get dns from k8s: %v", err)
+		return err
 	}
 
 	mesh.RemoveContainers(templateSpec)
 	runConfigList := ConvertKubeResourceToContainer(d.Namespace, *templateSpec, env, volume, dns)
 	err = mergeDockerOptions(runConfigList, d, tempContainerConfig)
 	if err != nil {
-		return fmt.Errorf("can not fill docker options, err: %v", err)
+		log.Errorf("can not fill docker options, err: %v", err)
+		return err
 	}
 	// check resource
 	var outOfMemory bool
@@ -164,6 +168,7 @@ func (d *Options) Main(ctx context.Context, tempContainerConfig *containerConfig
 		var networkID string
 		networkID, err = createKubevpnNetwork(ctx, d.Cli)
 		if err != nil {
+			log.Errorf("create network for %s: %v", d.Workload, err)
 			return err
 		}
 
@@ -245,6 +250,7 @@ func (l ConfigList) Run(ctx context.Context, volume map[string][]mount.Mount, cl
 		if index == 0 {
 			_, err := runFirst(ctx, runConfig, cli, dockerCli)
 			if err != nil {
+				log.Errorf("run main container container failed: %v", err)
 				return err
 			}
 		} else {
@@ -272,20 +278,23 @@ func (l ConfigList) copyToContainer(ctx context.Context, volume []mount.Mount, c
 	for _, v := range volume {
 		target, err := createFolder(ctx, cli, id, v.Source, v.Target)
 		if err != nil {
-			log.Debugf("create folder %s previoully faied, err: %v", target, err)
+			log.Debugf("create folder %s previoully failed, err: %v", target, err)
 		}
 		log.Debugf("from %s to %s", v.Source, v.Target)
 		srcInfo, err := archive.CopyInfoSourcePath(v.Source, true)
 		if err != nil {
-			return fmt.Errorf("copy info source path, err: %v", err)
+			log.Errorf("copy info source path, err: %v", err)
+			return err
 		}
 		srcArchive, err := archive.TarResource(srcInfo)
 		if err != nil {
-			return fmt.Errorf("tar resource failed, err: %v", err)
+			log.Errorf("tar resource failed, err: %v", err)
+			return err
 		}
 		dstDir, preparedArchive, err := archive.PrepareArchiveCopy(srcArchive, srcInfo, archive.CopyInfo{Path: v.Target})
 		if err != nil {
-			return fmt.Errorf("can not prepare archive copy, err: %v", err)
+			log.Errorf("can not prepare archive copy, err: %v", err)
+			return err
 		}
 
 		err = cli.CopyToContainer(ctx, id, dstDir, preparedArchive, types.CopyToContainerOptions{
@@ -293,7 +302,7 @@ func (l ConfigList) copyToContainer(ctx context.Context, volume []mount.Mount, c
 			CopyUIDGID:                true,
 		})
 		if err != nil {
-			log.Info(fmt.Errorf("can not copy %s to container %s:%s, err: %v", v.Source, id, v.Target, err))
+			log.Infof("can not copy %s to container %s:%s, err: %v", v.Source, id, v.Target, err)
 		}
 	}
 	return nil
@@ -315,16 +324,20 @@ func createFolder(ctx context.Context, cli *client.Client, id string, src string
 		Cmd:          []string{"mkdir", "-p", target},
 	})
 	if err != nil {
+		log.Errorf("create folder %s previoully failed, err: %v", target, err)
 		return "", err
 	}
 	err = cli.ContainerExecStart(ctx, create.ID, types.ExecStartCheck{})
 	if err != nil {
+		log.Errorf("create folder %s previoully failed, err: %v", target, err)
 		return "", err
 	}
+	log.Infof("wait create folder %s in container %s to be done...", target, id)
 	chanStop := make(chan struct{})
 	wait.Until(func() {
 		inspect, err := cli.ContainerExecInspect(ctx, create.ID)
 		if err != nil {
+			log.Warningf("can not inspect container %s, err: %v", id, err)
 			return
 		}
 		if !inspect.Running {

pkg/dev/run.go

@@ -49,6 +49,7 @@ func run(ctx context.Context, runConfig *RunConfig, cli *client.Client, c *comma
 	if needPull {
 		err = util.PullImage(ctx, runConfig.platform, cli, c, config.Image, nil)
 		if err != nil {
+			log.Errorf("Failed to pull image: %s, err: %s", config.Image, err)
 			return
 		}
 	}
@@ -56,7 +57,7 @@ func run(ctx context.Context, runConfig *RunConfig, cli *client.Client, c *comma
 	var create typescommand.CreateResponse
 	create, err = cli.ContainerCreate(ctx, config, hostConfig, networkConfig, platform, name)
 	if err != nil {
-		err = fmt.Errorf("failed to create container %s, err: %s", name, err)
+		log.Errorf("Failed to create container: %s, err: %s", name, err)
 		return
 	}
 	id = create.ID
@@ -69,7 +70,7 @@ func run(ctx context.Context, runConfig *RunConfig, cli *client.Client, c *comma
 
 	err = cli.ContainerStart(ctx, create.ID, types.ContainerStartOptions{})
 	if err != nil {
-		err = fmt.Errorf("failed to startup container %s: %v", name, err)
+		log.Errorf("failed to startup container %s: %v", name, err)
 		return
 	}
 	log.Infof("Wait container %s to be running...", name)
@@ -96,7 +97,7 @@ func run(ctx context.Context, runConfig *RunConfig, cli *client.Client, c *comma
 		}
 	}, time.Second, chanStop)
 	if err != nil {
-		err = fmt.Errorf("failed to wait container to be ready: %v", err)
+		log.Errorf("failed to wait container to be ready: %v", err)
 		return
 	}
 
@@ -167,6 +168,7 @@ func runFirst(ctx context.Context, runConfig *RunConfig, cli *apiclient.Client,
 		NetworkingConfig: runConfig.networkingConfig,
 	}, &runConfig.Options.createOptions)
 	if err != nil {
+		log.Errorf("Failed to create container: %s", err)
 		return "", err
 	}
 	log.Infof("Created container: %s", runConfig.containerName)
@@ -251,6 +253,7 @@ func runFirst(ctx context.Context, runConfig *RunConfig, cli *apiclient.Client,
 			return
 		}
 		if err != nil {
+			log.Errorf("Error inspect container: %s", err)
 			return
 		}
 		if inspect.State != nil && (inspect.State.Status == "exited" || inspect.State.Status == "dead" || inspect.State.Dead) {
@@ -264,6 +267,7 @@ func runFirst(ctx context.Context, runConfig *RunConfig, cli *apiclient.Client,
 		}
 	}, time.Second, chanStop)
 	if err != nil {
+		log.Errorf("wait container to be ready: %v", err)
 		err = fmt.Errorf("failed to wait container to be ready: %v", err)
 		return
 	}

pkg/dns/dns_unix.go

@@ -255,7 +255,7 @@ func networkCancel() {
 					args := []string{"-setdnsservers", s}
 					combinedOutput, err := exec.Command("networksetup", append(args, dnsServers...)...).Output()
 					if err != nil {
-						log.Warnf("error while remove dnsserver for %s, err: %v, output: %s\n", s, err, string(combinedOutput))
+						log.Warnf("error while remove dnsserver for %s, err: %v, output: %s", s, err, string(combinedOutput))
 					}
 				}
 			}

pkg/dns/dns_windows.go

@@ -22,7 +22,7 @@ func SetupDNS(clientConfig *miekgdns.ClientConfig, _ []string, _ bool) error {
 	env := os.Getenv(config.EnvTunNameOrLUID)
 	parseUint, err := strconv.ParseUint(env, 10, 64)
 	if err != nil {
-		log.Warningln(err)
+		log.Errorf("parse %s failed: %s", env, err)
 		return err
 	}
 	luid := winipcfg.LUID(parseUint)
@@ -31,18 +31,14 @@ func SetupDNS(clientConfig *miekgdns.ClientConfig, _ []string, _ bool) error {
 		var addr netip.Addr
 		addr, err = netip.ParseAddr(s)
 		if err != nil {
-			log.Warningln(err)
+			log.Errorf("parse %s failed: %s", s, err)
 			return err
 		}
 		servers = append(servers, addr)
 	}
 	err = luid.SetDNS(windows.AF_INET, servers, clientConfig.Search)
 	if err != nil {
-		log.Warningln(err)
+		log.Errorf("set DNS failed: %s", err)
-		return err
-	}
-	if err != nil {
-		log.Warningln(err)
 		return err
 	}
 	//_ = updateNicMetric(tunName)
@@ -53,9 +49,12 @@ func SetupDNS(clientConfig *miekgdns.ClientConfig, _ []string, _ bool) error {
 func CancelDNS() {
 	updateHosts("")
 	getenv := os.Getenv(config.EnvTunNameOrLUID)
+	if getenv == "" {
+		return
+	}
 	parseUint, err := strconv.ParseUint(getenv, 10, 64)
 	if err != nil {
-		log.Warningln(err)
+		log.Errorf("parse %s failed: %s", getenv, err)
 		return
 	}
 	luid := winipcfg.LUID(parseUint)

pkg/handler/cleaner.go

@@ -128,6 +128,7 @@ func updateRefCount(ctx context.Context, configMapInterface v12.ConfigMapInterfa
 			return
 		})
 	if err != nil {
+		log.Errorf("update ref count error, increment: %d, error: %v", increment, err)
 		return
 	}
 	log.Info("update ref count successfully")

pkg/handler/connect.go

@@ -240,20 +240,20 @@ func (c *ConnectOptions) DoConnect(ctx context.Context) (err error) {
 	core.GvisorTCPForwardAddr = fmt.Sprintf("tcp://127.0.0.1:%d", gvisorTCPForwardPort)
 	core.GvisorUDPForwardAddr = fmt.Sprintf("tcp://127.0.0.1:%d", gvisorUDPForwardPort)
 	if err = c.startLocalTunServe(c.ctx, forward); err != nil {
-		log.Errorf("start local tun service failed: %s", err.Error())
+		log.Errorf("start local tun service failed: %v", err)
 		return
 	}
 	if err = c.addRouteDynamic(c.ctx); err != nil {
-		log.Errorf("add route dynamic failed: %s", err.Error())
+		log.Errorf("add route dynamic failed: %v", err)
 		return
 	}
 	c.deleteFirewallRule(c.ctx)
 	if err = c.addExtraRoute(c.ctx); err != nil {
-		log.Errorf("add extra route failed: %s", err.Error())
+		log.Errorf("add extra route failed: %v", err)
 		return
 	}
 	if err = c.setupDNS(c.ctx); err != nil {
-		log.Errorf("set up dns failed: %s", err.Error())
+		log.Errorf("set up dns failed: %v", err)
 		return
 	}
 	go c.heartbeats(c.ctx)
@@ -389,7 +389,8 @@ func (c *ConnectOptions) startLocalTunServe(ctx context.Context, forwardAddress
 	log.Debugf("ipv4: %s, ipv6: %s", c.localTunIPv4.IP.String(), c.localTunIPv6.IP.String())
 	servers, err := Parse(r)
 	if err != nil {
-		return errors.Wrap(err, "error while create tunnel")
+		log.Errorf("parse route error: %v", err)
+		return err
 	}
 	go func() {
 		log.Error(Run(ctx, servers))
@@ -410,6 +411,7 @@ func (c *ConnectOptions) addRouteDynamic(ctx context.Context) (err error) {
 	var tunIface *net.Interface
 	tunIface, err = tun.GetInterface()
 	if err != nil {
+		log.Warningf("get tun interface error: %v", err)
 		return
 	}
 
@@ -672,7 +674,7 @@ func Run(ctx context.Context, servers []core.Server) error {
 func Parse(r core.Route) ([]core.Server, error) {
 	servers, err := r.GenerateServers()
 	if err != nil {
-		return nil, errors.WithStack(err)
+		return nil, err
 	}
 	if len(servers) == 0 {
 		return nil, fmt.Errorf("server is empty, server config: %s", strings.Join(r.ServeNodes, ","))
@@ -1053,6 +1055,7 @@ func (c *ConnectOptions) addExtraRoute(ctx context.Context) error {
 	var tunIface *net.Interface
 	tunIface, err = tun.GetInterface()
 	if err != nil {
+		log.Errorf("get tun interface failed: %s", err.Error())
 		return err
 	}
 
@@ -1379,7 +1382,8 @@ func (c *ConnectOptions) setImage(ctx context.Context) error {
 			DryRun(false).
 			Patch(p.Info.Namespace, p.Info.Name, pkgtypes.StrategicMergePatchType, p.Patch, nil)
 		if err != nil {
-			return fmt.Errorf("failed to patch image update to pod template: %v", err)
+			log.Errorf("failed to patch image update to pod template: %v", err)
+			return err
 		}
 		err = util.RolloutStatus(ctx, c.factory, c.Namespace, fmt.Sprintf("%s/%s", p.Info.Mapping.Resource.GroupResource().String(), p.Info.Name), time.Minute*60)
 		if err != nil {

pkg/handler/envoy.go

@@ -176,10 +176,12 @@ func UnPatchContainer(factory cmdutil.Factory, mapInterface v12.ConfigMapInterfa
 			},
 		})
 		if err != nil {
+			log.Errorf("error while generating json patch: %v", err)
 			return err
 		}
 		_, err = helper.Patch(object.Namespace, object.Name, types.JSONPatchType, bytes, &metav1.PatchOptions{})
 		if err != nil {
+			log.Errorf("error while patching resource: %s %s, err: %v", object.Mapping.GroupVersionKind.GroupKind().String(), object.Name, err)
 			return err
 		}
 	}

pkg/handler/remote.go

@@ -580,12 +580,13 @@ func InjectVPNSidecar(ctx1 context.Context, factory cmdutil.Factory, namespace,
 }
 
 func CreateAfterDeletePod(factory cmdutil.Factory, p *v1.Pod, helper *pkgresource.Helper) error {
-	if _, err := helper.DeleteWithOptions(p.Namespace, p.Name, &metav1.DeleteOptions{
+	_, err := helper.DeleteWithOptions(p.Namespace, p.Name, &metav1.DeleteOptions{
 		GracePeriodSeconds: pointer.Int64(0),
-	}); err != nil {
+	})
+	if err != nil {
 		log.Errorf("error while delete resource: %s %s, ignore, err: %v", p.Namespace, p.Name, err)
 	}
-	if err := retry.OnError(wait.Backoff{
+	err = retry.OnError(wait.Backoff{
 		Steps:    10,
 		Duration: 50 * time.Millisecond,
 		Factor:   5.0,
@@ -605,10 +606,12 @@ func CreateAfterDeletePod(factory cmdutil.Factory, p *v1.Pod, helper *pkgresourc
 			return err
 		}
 		return errors.New("")
-	}); err != nil {
+	})
+	if err != nil {
 		if k8serrors.IsAlreadyExists(err) {
 			return nil
 		}
+		log.Errorf("error while create resource: %s %s, err: %v", p.Namespace, p.Name, err)
 		return err
 	}
 	return nil

pkg/tun/tun.go

@@ -41,6 +41,7 @@ func Listener(config Config) (net.Listener, error) {
 
 	conn, ifce, err := createTun(config)
 	if err != nil {
+		log.Errorf("create tun device error: %v", err)
 		return nil, err
 	}
 	addrs, _ := ifce.Addrs()

pkg/tun/tun_darwin.go

@@ -67,6 +67,7 @@ func createTun(cfg Config) (conn net.Conn, itf *net.Interface, err error) {
 	}
 
 	if err = addTunRoutes(name, cfg.Routes...); err != nil {
+		log.Errorf("add tun routes failed: %v", err)
 		return
 	}
 
@@ -98,7 +99,7 @@ func addTunRoutes(ifName string, routes ...types.Route) error {
 		args := strings.Split(cmd, " ")
 		err := exec.Command(args[0], args[1:]...).Run()
 		if err != nil {
-			return fmt.Errorf("%s: %v", cmd, err)
+			return fmt.Errorf("run cmd %s: %v", cmd, err)
 		}
 	}
 	return nil

pkg/util/cidr.go

@@ -133,6 +133,7 @@ func GetCIDRFromResourceUgly(clientset *kubernetes.Clientset, namespace string)
 func GetLocalTunIP() (net.IP, net.IP, error) {
 	tunIface, err := tun.GetInterface()
 	if err != nil {
+		log.Errorf("get tun interface failed: %v", err)
 		return nil, nil, err
 	}
 	addrs, err := tunIface.Addrs()

pkg/util/image.go

@@ -19,6 +19,7 @@ import (
 	"github.com/moby/term"
 	"github.com/opencontainers/image-spec/specs-go/v1"
 	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
 )
 
 func GetClient() (*client.Client, *command.DockerCli, error) {
@@ -47,18 +48,21 @@ func GetClient() (*client.Client, *command.DockerCli, error) {
 func TransferImage(ctx context.Context, conf *SshConfig, from, to string, out io.Writer) error {
 	cli, c, err := GetClient()
 	if err != nil {
-		return fmt.Errorf("failed to get docker client: %v", err)
+		log.Errorf("failed to get docker client: %v", err)
+		return err
 	}
 	// todo add flags? or detect k8s node runtime ?
 	platform := &v1.Platform{Architecture: "amd64", OS: "linux"}
 	err = PullImage(ctx, platform, cli, c, from, out)
 	if err != nil {
-		return fmt.Errorf("failed to pull image: %v", err)
+		log.Errorf("failed to pull image: %v", err)
+		return err
 	}
 
 	err = cli.ImageTag(ctx, from, to)
 	if err != nil {
-		return fmt.Errorf("failed to tag image %s to %s: %v", from, to, err)
+		log.Errorf("failed to tag image %s to %s: %v", from, to, err)
+		return err
 	}
 
 	// use it if sshConfig is not empty
@@ -66,17 +70,20 @@ func TransferImage(ctx context.Context, conf *SshConfig, from, to string, out io
 		var distributionRef reference.Named
 		distributionRef, err = reference.ParseNormalizedNamed(to)
 		if err != nil {
-			return fmt.Errorf("can not parse image name %s: %v", to, err)
+			log.Errorf("can not parse image name %s: %v", to, err)
+			return err
 		}
 		var imgRefAndAuth trust.ImageRefAndAuth
 		imgRefAndAuth, err = trust.GetImageReferencesAndAuth(ctx, nil, image.AuthResolver(c), distributionRef.String())
 		if err != nil {
-			return fmt.Errorf("can not get image auth: %v", err)
+			log.Errorf("can not get image auth: %v", err)
+			return err
 		}
 		var encodedAuth string
 		encodedAuth, err = command.EncodeAuthToBase64(*imgRefAndAuth.AuthConfig())
 		if err != nil {
-			return fmt.Errorf("can not encode auth config to base64: %v", err)
+			log.Errorf("can not encode auth config to base64: %v", err)
+			return err
 		}
 		requestPrivilege := command.RegistryAuthenticationPrivilegedFunc(c, imgRefAndAuth.RepoInfo().Index, "push")
 		var readCloser io.ReadCloser
@@ -85,7 +92,7 @@ func TransferImage(ctx context.Context, conf *SshConfig, from, to string, out io
 			PrivilegeFunc: requestPrivilege,
 		})
 		if err != nil {
-			err = fmt.Errorf("can not push image %s, err: %v", to, err)
+			log.Errorf("can not push image %s, err: %v", to, err)
 			return err
 		}
 		defer readCloser.Close()
@@ -95,7 +102,7 @@ func TransferImage(ctx context.Context, conf *SshConfig, from, to string, out io
 		outWarp := streams.NewOut(out)
 		err = jsonmessage.DisplayJSONMessagesToStream(readCloser, outWarp, nil)
 		if err != nil {
-			err = fmt.Errorf("can not display message, err: %v", err)
+			log.Errorf("can not display message, err: %v", err)
 			return err
 		}
 		return nil
@@ -105,6 +112,7 @@ func TransferImage(ctx context.Context, conf *SshConfig, from, to string, out io
 	var responseReader io.ReadCloser
 	responseReader, err = cli.ImageSave(ctx, []string{to})
 	if err != nil {
+		log.Errorf("can not save image %s: %v", to, err)
 		return err
 	}
 	defer responseReader.Close()
@@ -143,17 +151,20 @@ func PullImage(ctx context.Context, platform *v1.Platform, cli *client.Client, c
 	}
 	distributionRef, err := reference.ParseNormalizedNamed(img)
 	if err != nil {
-		return fmt.Errorf("can not parse image name %s: %v", img, err)
+		log.Errorf("can not parse image name %s: %v", img, err)
+		return err
 	}
 	var imgRefAndAuth trust.ImageRefAndAuth
 	imgRefAndAuth, err = trust.GetImageReferencesAndAuth(ctx, nil, image.AuthResolver(c), distributionRef.String())
 	if err != nil {
-		return fmt.Errorf("can not get image auth: %v", err)
+		log.Errorf("can not get image auth: %v", err)
+		return err
 	}
 	var encodedAuth string
 	encodedAuth, err = command.EncodeAuthToBase64(*imgRefAndAuth.AuthConfig())
 	if err != nil {
-		return fmt.Errorf("can not encode auth config to base64:%v", err)
+		log.Errorf("can not encode auth config to base64: %v", err)
+		return err
 	}
 	requestPrivilege := command.RegistryAuthenticationPrivilegedFunc(c, imgRefAndAuth.RepoInfo().Index, "pull")
 	readCloser, err = cli.ImagePull(ctx, img, types.ImagePullOptions{
@@ -163,7 +174,7 @@ func PullImage(ctx context.Context, platform *v1.Platform, cli *client.Client, c
 		Platform:      plat,
 	})
 	if err != nil {
-		err = fmt.Errorf("can not pull image %s, err: %s, please make sure image is exist and can be pulled from local", img, err)
+		log.Errorf("can not pull image %s, err: %s, please make sure image is exist and can be pulled from local", img, err)
 		return err
 	}
 	defer readCloser.Close()
@@ -173,7 +184,7 @@ func PullImage(ctx context.Context, platform *v1.Platform, cli *client.Client, c
 	outWarp := streams.NewOut(out)
 	err = jsonmessage.DisplayJSONMessagesToStream(readCloser, outWarp, nil)
 	if err != nil {
-		err = fmt.Errorf("can not display message, err: %v", err)
+		log.Errorf("can not display message, err: %v", err)
 		return err
 	}
 	return nil

pkg/util/scp.go

@@ -50,6 +50,7 @@ func SCP(conf *SshConfig, filename string, commands ...string) error {
 	}
 	err = main(sess, filename)
 	if err != nil {
+		log.Errorf("Copy file to remote error: %s", err)
 		return err
 	}
 	sess, err = remote.NewSession()
@@ -119,10 +120,11 @@ func sCopy(dst io.Writer, src io.Reader, size int64) error {
 	buf := make([]byte, 10<<(10*2)) // 10M
 	written, err := io.CopyBuffer(io.MultiWriter(dst, bar), src, buf)
 	if err != nil {
+		log.Errorf("failed to transfer file to remote: %v", err)
 		return err
 	}
 	if written != size {
-		err = fmt.Errorf("failed to transfer file to remote: written size %d but actuall is %d", written, size)
+		log.Errorf("failed to transfer file to remote: written size %d but actuall is %d", written, size)
 		return err
 	}
 	return nil