feat: support shell resize (#4287)

internal/support/container/agent_service.go

@@ -2,6 +2,7 @@ package container_support
 
 import (
 	"context"
+	"encoding/json"
 	"io"
 	"sync"
 
@@ -77,9 +78,9 @@ func (a *agentService) Attach(ctx context.Context, container container.Container
 	panic("not implemented")
 }
 
-func (a *agentService) Exec(ctx context.Context, container container.Container, cmd []string, stdin io.Reader, stdout io.Writer) error {
+func (a *agentService) Exec(ctx context.Context, c container.Container, cmd []string, stdin io.Reader, stdout io.Writer) error {
 	cancelCtx, cancel := context.WithCancel(ctx)
-	containerWriter, containerReader, err := a.client.ContainerExec(cancelCtx, container.ID, cmd)
+	session, err := a.client.ContainerExec(cancelCtx, c.ID, cmd)
 
 	if err != nil {
 		cancel()
@@ -89,15 +90,35 @@ func (a *agentService) Exec(ctx context.Context, container container.Container,
 	var wg sync.WaitGroup
 
 	wg.Go(func() {
-		if _, err := io.Copy(containerWriter, stdin); err != nil {
-			log.Error().Err(err).Msg("error while reading from ws using agent")
+		decoder := json.NewDecoder(stdin)
+	loop:
+		for {
+			var event container.ExecEvent
+			if err := decoder.Decode(&event); err != nil {
+				if err != io.EOF {
+					log.Error().Err(err).Msg("error decoding event from ws using agent")
+				}
+				break
+			}
+
+			switch event.Type {
+			case "userinput":
+				if _, err := session.Writer.Write([]byte(event.Data)); err != nil {
+					log.Error().Err(err).Msg("error writing to container using agent")
+					break loop
+				}
+			case "resize":
+				if err := session.Resize(event.Width, event.Height); err != nil {
+					log.Error().Err(err).Msg("error resizing terminal using agent")
+				}
+			}
 		}
 		cancel()
-		containerWriter.Close()
+		session.Writer.Close()
 	})
 
 	wg.Go(func() {
-		if _, err := stdcopy.StdCopy(stdout, stdout, containerReader); err != nil {
+		if _, err := stdcopy.StdCopy(stdout, stdout, session.Reader); err != nil {
 			log.Error().Err(err).Msg("error while writing to ws using agent")
 		}
 		cancel()

internal/support/docker/docker_service.go

@@ -2,6 +2,7 @@ package docker_support
 
 import (
 	"context"
+	"encoding/json"
 	"io"
 	"sync"
 	"time"
@@ -111,9 +112,9 @@ func (d *DockerClientService) SubscribeContainersStarted(ctx context.Context, co
 	d.store.SubscribeNewContainers(ctx, containers)
 }
 
-func (d *DockerClientService) Attach(ctx context.Context, container container.Container, stdin io.Reader, stdout io.Writer) error {
+func (d *DockerClientService) Attach(ctx context.Context, c container.Container, stdin io.Reader, stdout io.Writer) error {
 	cancelCtx, cancel := context.WithCancel(ctx)
-	containerWriter, containerReader, err := d.client.ContainerAttach(cancelCtx, container.ID)
+	session, err := d.client.ContainerAttach(cancelCtx, c.ID)
 	if err != nil {
 		cancel()
 		return err
@@ -122,20 +123,42 @@ func (d *DockerClientService) Attach(ctx context.Context, container container.Co
 	var wg sync.WaitGroup
 
 	wg.Go(func() {
-		if _, err := io.Copy(containerWriter, stdin); err != nil {
-			log.Error().Err(err).Msg("error while reading from ws")
+		decoder := json.NewDecoder(stdin)
+	loop:
+		for {
+			var event container.ExecEvent
+			if err := decoder.Decode(&event); err != nil {
+				if err != io.EOF {
+					log.Error().Err(err).Msg("error while decoding event from ws")
+				}
+				break
+			}
+
+			switch event.Type {
+			case "userinput":
+				if _, err := session.Writer.Write([]byte(event.Data)); err != nil {
+					log.Error().Err(err).Msg("error while writing to container")
+					break loop
+				}
+			case "resize":
+				if err := session.Resize(event.Width, event.Height); err != nil {
+					log.Error().Err(err).Msg("error while resizing terminal")
+				}
+			default:
+				log.Warn().Str("type", event.Type).Msg("unknown event type")
+			}
 		}
 		cancel()
-		containerWriter.Close()
+		session.Writer.Close()
 	})
 
 	wg.Go(func() {
-		if container.Tty {
-			if _, err := io.Copy(stdout, containerReader); err != nil {
+		if c.Tty {
+			if _, err := io.Copy(stdout, session.Reader); err != nil {
 				log.Error().Err(err).Msg("error while writing to ws")
 			}
 		} else {
-			if _, err := stdcopy.StdCopy(stdout, stdout, containerReader); err != nil {
+			if _, err := stdcopy.StdCopy(stdout, stdout, session.Reader); err != nil {
 				log.Error().Err(err).Msg("error while writing to ws")
 			}
 		}
@@ -147,25 +170,48 @@ func (d *DockerClientService) Attach(ctx context.Context, container container.Co
 	return nil
 }
 
-func (d *DockerClientService) Exec(ctx context.Context, container container.Container, cmd []string, stdin io.Reader, stdout io.Writer) error {
+func (d *DockerClientService) Exec(ctx context.Context, c container.Container, cmd []string, stdin io.Reader, stdout io.Writer) error {
 	cancelCtx, cancel := context.WithCancel(ctx)
-	containerWriter, containerReader, err := d.client.ContainerExec(cancelCtx, container.ID, cmd)
+	session, err := d.client.ContainerExec(cancelCtx, c.ID, cmd)
 	if err != nil {
 		cancel()
 		return err
 	}
 
 	var wg sync.WaitGroup
+
 	wg.Go(func() {
-		if _, err := io.Copy(containerWriter, stdin); err != nil {
-			log.Error().Err(err).Msg("error while reading from ws")
+		decoder := json.NewDecoder(stdin)
+	loop:
+		for {
+			var event container.ExecEvent
+			if err := decoder.Decode(&event); err != nil {
+				if err != io.EOF {
+					log.Error().Err(err).Msg("error while decoding event from ws")
+				}
+				break
+			}
+
+			switch event.Type {
+			case "userinput":
+				if _, err := session.Writer.Write([]byte(event.Data)); err != nil {
+					log.Error().Err(err).Msg("error while writing to container")
+					break loop
+				}
+			case "resize":
+				if err := session.Resize(event.Width, event.Height); err != nil {
+					log.Error().Err(err).Msg("error while resizing terminal")
+				}
+			default:
+				log.Warn().Str("type", event.Type).Msg("unknown event type")
+			}
 		}
 		cancel()
-		containerWriter.Close()
+		session.Writer.Close()
 	})
 
 	wg.Go(func() {
-		if _, err := stdcopy.StdCopy(stdout, stdout, containerReader); err != nil {
+		if _, err := stdcopy.StdCopy(stdout, stdout, session.Reader); err != nil {
 			log.Error().Err(err).Msg("error while writing to ws")
 		}
 		cancel()

internal/support/k8s/k8s_service.go

@@ -2,6 +2,7 @@ package k8s_support
 
 import (
 	"context"
+	"encoding/json"
 	"io"
 	"sync"
 
@@ -92,9 +93,9 @@ func (k *K8sClientService) SubscribeContainersStarted(ctx context.Context, conta
 	k.store.SubscribeNewContainers(ctx, containers)
 }
 
-func (k *K8sClientService) Attach(ctx context.Context, container container.Container, stdin io.Reader, stdout io.Writer) error {
+func (k *K8sClientService) Attach(ctx context.Context, c container.Container, stdin io.Reader, stdout io.Writer) error {
 	cancelCtx, cancel := context.WithCancel(ctx)
-	writer, reader, err := k.client.ContainerAttach(cancelCtx, container.ID)
+	session, err := k.client.ContainerAttach(cancelCtx, c.ID)
 	if err != nil {
 		cancel()
 		return err
@@ -103,16 +104,37 @@ func (k *K8sClientService) Attach(ctx context.Context, container container.Conta
 	var wg sync.WaitGroup
 
 	wg.Go(func() {
-		defer writer.Close()
+		defer session.Writer.Close()
 		defer cancel()
-		if _, err := io.Copy(writer, stdin); err != nil {
-			log.Error().Err(err).Msg("error copying stdin")
+
+		decoder := json.NewDecoder(stdin)
+	loop:
+		for {
+			var event container.ExecEvent
+			if err := decoder.Decode(&event); err != nil {
+				if err != io.EOF {
+					log.Error().Err(err).Msg("error decoding event")
+				}
+				break
+			}
+
+			switch event.Type {
+			case "userinput":
+				if _, err := session.Writer.Write([]byte(event.Data)); err != nil {
+					log.Error().Err(err).Msg("error writing to container")
+					break loop
+				}
+			case "resize":
+				if err := session.Resize(event.Width, event.Height); err != nil {
+					log.Error().Err(err).Msg("error resizing terminal")
+				}
+			}
 		}
 	})
 
 	wg.Go(func() {
 		defer cancel()
-		if _, err := io.Copy(stdout, reader); err != nil {
+		if _, err := io.Copy(stdout, session.Reader); err != nil {
 			log.Error().Err(err).Msg("error copying stdout")
 		}
 	})
@@ -121,9 +143,9 @@ func (k *K8sClientService) Attach(ctx context.Context, container container.Conta
 	return nil
 }
 
-func (k *K8sClientService) Exec(ctx context.Context, container container.Container, cmd []string, stdin io.Reader, stdout io.Writer) error {
+func (k *K8sClientService) Exec(ctx context.Context, c container.Container, cmd []string, stdin io.Reader, stdout io.Writer) error {
 	cancelCtx, cancel := context.WithCancel(ctx)
-	writer, reader, err := k.client.ContainerExec(cancelCtx, container.ID, cmd)
+	session, err := k.client.ContainerExec(cancelCtx, c.ID, cmd)
 	if err != nil {
 		cancel()
 		return err
@@ -132,16 +154,37 @@ func (k *K8sClientService) Exec(ctx context.Context, container container.Contain
 	var wg sync.WaitGroup
 
 	wg.Go(func() {
-		defer writer.Close()
+		defer session.Writer.Close()
 		defer cancel()
-		if _, err := io.Copy(writer, stdin); err != nil {
-			log.Error().Err(err).Msg("error copying stdin")
+
+		decoder := json.NewDecoder(stdin)
+	loop:
+		for {
+			var event container.ExecEvent
+			if err := decoder.Decode(&event); err != nil {
+				if err != io.EOF {
+					log.Error().Err(err).Msg("error decoding event")
+				}
+				break
+			}
+
+			switch event.Type {
+			case "userinput":
+				if _, err := session.Writer.Write([]byte(event.Data)); err != nil {
+					log.Error().Err(err).Msg("error writing to container")
+					break loop
+				}
+			case "resize":
+				if err := session.Resize(event.Width, event.Height); err != nil {
+					log.Error().Err(err).Msg("error resizing terminal")
+				}
+			}
 		}
 	})
 
 	wg.Go(func() {
 		defer cancel()
-		if _, err := io.Copy(stdout, reader); err != nil {
+		if _, err := io.Copy(stdout, session.Reader); err != nil {
 			log.Error().Err(err).Msg("error copying stdout")
 		}
 	})