apps/kubevpn
1
0
Fork 0
mirror of https://github.com/kubenetworks/kubevpn.git synced 2025-10-05 23:36:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: log more info

Browse Source
This commit is contained in:
fengcaiwen
2023-09-22 22:20:24 +08:00
committed by naison
parent 76f1b74076
commit ab6b9ae2a2
18 changed files with 111 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
cmd/kubevpn/cmds/serve.go
View File

@@ -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()

15
pkg/core/gvisorstack.go
View File

@@ -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

9
pkg/core/route.go
View File

@@ -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})

2
pkg/core/tunendpoint.go
View File

@@ -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")
}

6
pkg/daemon/action/proxy.go
View File

@@ -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())

27
pkg/dev/main.go
View File

@@ -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 {

10
pkg/dev/run.go
View File

@@ -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
}

2
pkg/dns/dns_unix.go
View File

@@ -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))
}
}
}

15
pkg/dns/dns_windows.go
View File

@@ -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)
return err
}
if err != nil {
log.Warningln(err)
log.Errorf("set DNS failed: %s", 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)

1
pkg/handler/cleaner.go
View File

@@ -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")

18
pkg/handler/connect.go
View File

@@ -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 {

2
pkg/handler/envoy.go
View File

@@ -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
}
}

11
pkg/handler/remote.go
View File

@@ -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

1
pkg/tun/tun.go
View File

@@ -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()

3
pkg/tun/tun_darwin.go
View File

@@ -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

1
pkg/util/cidr.go
View File

@@ -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()

37
pkg/util/image.go
View File

@@ -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

4
pkg/util/scp.go
View File

@@ -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