Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
50 changes: 50 additions & 0 deletions cmd/internal/agentcontainer/lifecycle_terminal.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,50 @@
//go:build !windows

package agentcontainer

import (
"context"
"os"
"os/signal"
"syscall"

"github.com/devsy-org/devsy/pkg/agent/tunnel"
"github.com/devsy-org/devsy/pkg/devcontainer/setup"
"github.com/devsy-org/devsy/pkg/provider"
)

func (cmd *SetupContainerCmd) preAttach(
ctx context.Context,
state *containerState,
cfg *setup.ContainerSetupConfig,
open func(context.Context, tunnel.TunnelClient, provider.LifecycleTerminalRequest) (tunnel.TerminalSession, error),
) (setup.DeferredHooks, error) {
if cmd.protocolSet {
session, err := open(
ctx,
state.tunnelClient,
*state.workspaceInfo.CLIOptions.LifecycleTerminal,
)
if err != nil {
return setup.DeferredHooks{}, err
}
defer func() { _ = session.Close(ctx) }()
if err := setup.ValidateInteractivePostStart(
state.setupInfo.MergedConfig.PostStartCommands,
); err != nil {
return setup.DeferredHooks{}, err
}
cfg.Terminal = session
}
return setup.SetupContainerPreAttach(ctx, cfg)
}

func setupSignalContext(
ctx context.Context,
interactive bool,
) (context.Context, context.CancelFunc) {
if !interactive {
return ctx, func() {}
}
return signal.NotifyContext(ctx, os.Interrupt, syscall.SIGTERM, syscall.SIGHUP)
}
148 changes: 148 additions & 0 deletions cmd/internal/agentcontainer/lifecycle_terminal_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,148 @@
//go:build !windows

package agentcontainer

import (
"context"
"encoding/json"
"errors"
"os"
"os/signal"
"syscall"
"testing"
"time"

"github.com/devsy-org/devsy/cmd/flags"
"github.com/devsy-org/devsy/pkg/agent/tunnel"
"github.com/devsy-org/devsy/pkg/compress"
"github.com/devsy-org/devsy/pkg/devcontainer/config"
"github.com/devsy-org/devsy/pkg/devcontainer/setup"
"github.com/devsy-org/devsy/pkg/provider"
"github.com/devsy-org/devsy/pkg/types"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
)

type AgentContainerLifecycleTerminalSuite struct {
suite.Suite
}

func TestAgentContainerLifecycleTerminalSuite(t *testing.T) {
suite.Run(t, new(AgentContainerLifecycleTerminalSuite))
}

func (s *AgentContainerLifecycleTerminalSuite) TestLifecycleTerminalGuard() {
t := s.T()
require.NotNil(
t,
NewSetupContainerCmd(&flags.GlobalFlags{}).Flags().Lookup("lifecycle-terminal-protocol"),
)
for _, tc := range []struct {
set, present bool
version int
requestVersion uint32
valid bool
}{
{false, false, 0, 0, true},
{true, true, 1, 1, true},
{true, false, 1, 0, false},
{false, true, 0, 1, false},
{true, true, 0, 1, false},
{true, true, 2, 1, false},
{true, true, 1, 0, false},
{true, true, 1, 2, false},
} {
cmd := &SetupContainerCmd{protocolSet: tc.set, LifecycleTerminalProtocol: tc.version}
var request *provider.LifecycleTerminalRequest
if tc.present {
request = &provider.LifecycleTerminalRequest{ProtocolVersion: tc.requestVersion}
}
require.Equal(t, tc.valid, cmd.validateTerminal(request) == nil)
}
}

type testTerminalSession struct{ closed bool }

func (s *testTerminalSession) Begin(
context.Context,
tunnel.TerminalInvocation,
) (tunnel.TerminalAttachment, error) {
return nil, errors.New("unexpected begin")
}
func (s *testTerminalSession) Close(context.Context) error { s.closed = true; return nil }

func (s *AgentContainerLifecycleTerminalSuite) TestPreAttachClosesSessionOnInvalidHooks() {
t := s.T()
session := &testTerminalSession{}
info := &config.Result{MergedConfig: &config.MergedDevContainerConfig{}}
info.MergedConfig.PostStartCommands = []types.LifecycleHook{{"a": {"true"}, "b": {"true"}}}
state := &containerState{
setupInfo: info,
workspaceInfo: &provider.ContainerWorkspaceInfo{
CLIOptions: provider.CLIOptions{
LifecycleTerminal: &provider.LifecycleTerminalRequest{},
},
},
}
cmd := &SetupContainerCmd{protocolSet: true}
_, err := cmd.preAttach(
context.Background(),
state,
&setup.ContainerSetupConfig{SetupInfo: info},
func(context.Context, tunnel.TunnelClient, provider.LifecycleTerminalRequest) (tunnel.TerminalSession, error) {
return session, nil
},
)
require.ErrorContains(t, err, "postStartCommand")
require.True(t, session.closed)
}

func (s *AgentContainerLifecycleTerminalSuite) TestSetupSignalContext() {
t := s.T()
signals := make(chan os.Signal, 1)
signal.Notify(signals, os.Interrupt)
defer signal.Stop(signals)
ctx, stop := setupSignalContext(context.Background(), false)
defer stop()
require.NoError(t, syscall.Kill(os.Getpid(), syscall.SIGINT))
select {
case <-signals:
case <-time.After(5 * time.Second):
t.Fatal("signal not received")
}
require.NoError(t, ctx.Err())
interactive, cancel := setupSignalContext(context.Background(), true)
defer cancel()
require.NoError(t, syscall.Kill(os.Getpid(), syscall.SIGINT))
select {
case <-interactive.Done():
case <-time.After(5 * time.Second):
t.Fatal("context not canceled")
}
}

func (s *AgentContainerLifecycleTerminalSuite) TestRunRejectsRequestVersionBeforeInitialization() {
t := s.T()
info := provider.ContainerWorkspaceInfo{
CLIOptions: provider.CLIOptions{
LifecycleTerminal: &provider.LifecycleTerminalRequest{ProtocolVersion: 2},
},
}
data, err := json.Marshal(info)
require.NoError(t, err)
encoded, err := compress.Compress(string(data))
require.NoError(t, err)
command := &SetupContainerCmd{
ContainerWorkspaceInfo: encoded,
protocolSet: true,
LifecycleTerminalProtocol: 1,
}
setup, err := compress.Compress(`{}`)
require.NoError(t, err)
command.SetupInfo = setup
require.ErrorContains(
t,
command.Run(context.Background()),
"lifecycle terminal protocol and request mismatch",
)
}
49 changes: 35 additions & 14 deletions cmd/internal/agentcontainer/setup.go
Original file line number Diff line number Diff line change
Expand Up @@ -38,17 +38,19 @@ import (
type SetupContainerCmd struct {
*flags.GlobalFlags

ChownWorkspace bool
StreamMounts bool
InjectGitCredentials bool
Prebuild bool
ContainerWorkspaceInfo string
SetupInfo string
AccessKey string
PlatformHost string
WorkspaceHost string
DotfilesRepo string
DotfilesScript string
LifecycleTerminalProtocol int
protocolSet bool
ChownWorkspace bool
StreamMounts bool
InjectGitCredentials bool
Prebuild bool
ContainerWorkspaceInfo string
SetupInfo string
AccessKey string
PlatformHost string
WorkspaceHost string
DotfilesRepo string
DotfilesScript string
}

// NewSetupContainerCmd creates a new command.
Expand All @@ -61,6 +63,7 @@ func NewSetupContainerCmd(globalFlags *flags.GlobalFlags) *cobra.Command {
Short: "Sets up a container",
Args: cobra.NoArgs,
RunE: func(cobraCmd *cobra.Command, args []string) error {
cmd.protocolSet = cobraCmd.Flags().Changed("lifecycle-terminal-protocol")
return cmd.Run(cobraCmd.Context())
},
}
Expand All @@ -82,16 +85,22 @@ type containerState struct {

// Run runs the command logic.
func (cmd *SetupContainerCmd) Run(ctx context.Context) error {
tunnelClient, err := cmd.initializeTunnelClient(ctx)
workspaceInfo, setupInfo, err := cmd.parseWorkspaceAndSetupInfo()
if err != nil {
return err
}

workspaceInfo, setupInfo, err := cmd.parseWorkspaceAndSetupInfo()
if err := cmd.validateTerminal(workspaceInfo.CLIOptions.LifecycleTerminal); err != nil {
return err
}
tunnelClient, err := cmd.initializeTunnelClient(ctx)
if err != nil {
return err
}

ctx, stop := setupSignalContext(ctx, cmd.protocolSet)
defer stop()

state := &containerState{
workspaceInfo: workspaceInfo,
setupInfo: setupInfo,
Expand Down Expand Up @@ -128,6 +137,16 @@ func (cmd *SetupContainerCmd) Run(ctx context.Context) error {
return err
}

func (cmd *SetupContainerCmd) validateTerminal(request *provider2.LifecycleTerminalRequest) error {
if cmd.protocolSet != (request != nil) ||
(cmd.protocolSet && (cmd.LifecycleTerminalProtocol != int(tunnel.LifecycleTerminalProtocolVersion) ||
request.ProtocolVersion != tunnel.LifecycleTerminalProtocolVersion ||
int(request.ProtocolVersion) != cmd.LifecycleTerminalProtocol)) {
return fmt.Errorf("lifecycle terminal protocol and request mismatch")
}
return nil
}

func (cmd *SetupContainerCmd) reportSetup(
ctx context.Context,
state *containerState,
Expand Down Expand Up @@ -176,6 +195,8 @@ func (cmd *SetupContainerCmd) runSetup(ctx context.Context, state *containerStat
}

func (cmd *SetupContainerCmd) registerFlags(setupContainerCmd *cobra.Command) {
setupContainerCmd.Flags().
IntVar(&cmd.LifecycleTerminalProtocol, "lifecycle-terminal-protocol", 0, "Lifecycle terminal protocol version")
cmd.registerBehaviorFlags(setupContainerCmd)
cmd.registerWorkspaceInfoFlags(setupContainerCmd)
cmd.registerDotfilesFlags(setupContainerCmd)
Expand Down Expand Up @@ -345,7 +366,7 @@ func (cmd *SetupContainerCmd) finalizeSetup(ctx context.Context, state *containe
},
}

deferred, err := setup.SetupContainerPreAttach(ctx, cfg)
deferred, err := cmd.preAttach(ctx, state, cfg, tunnelserver.OpenLifecycleTerminal)
if err != nil {
return err
}
Expand Down
67 changes: 67 additions & 0 deletions cmd/internal/agentworkspace/lifecycle_terminal_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,67 @@
package agentworkspace

import (
"context"
"encoding/json"
"testing"

"github.com/devsy-org/devsy/cmd/flags"
"github.com/devsy-org/devsy/pkg/compress"
"github.com/devsy-org/devsy/pkg/provider"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
)

type AgentWorkspaceLifecycleTerminalSuite struct {
suite.Suite
}

func TestAgentWorkspaceLifecycleTerminalSuite(t *testing.T) {
suite.Run(t, new(AgentWorkspaceLifecycleTerminalSuite))
}

func (s *AgentWorkspaceLifecycleTerminalSuite) TestLifecycleTerminalGuard() {
t := s.T()
require.NotNil(t, NewUpCmd(&flags.GlobalFlags{}).Flags().Lookup("lifecycle-terminal-protocol"))
for _, tc := range []struct {
set, present bool
version int
requestVersion uint32
valid bool
}{
{false, false, 0, 0, true},
{true, true, 1, 1, true},
{true, false, 1, 0, false},
{false, true, 0, 1, false},
{true, true, 0, 1, false},
{true, true, 2, 1, false},
{true, true, 1, 0, false},
{true, true, 1, 2, false},
} {
cmd := &UpCmd{protocolSet: tc.set, LifecycleTerminalProtocol: tc.version}
var request *provider.LifecycleTerminalRequest
if tc.present {
request = &provider.LifecycleTerminalRequest{ProtocolVersion: tc.requestVersion}
}
require.Equal(t, tc.valid, cmd.validateTerminal(request) == nil)
}
}

func (s *AgentWorkspaceLifecycleTerminalSuite) TestRunRejectsRequestVersionBeforeInitialization() {
t := s.T()
info := provider.AgentWorkspaceInfo{
CLIOptions: provider.CLIOptions{
LifecycleTerminal: &provider.LifecycleTerminalRequest{ProtocolVersion: 2},
},
}
data, err := json.Marshal(info)
require.NoError(t, err)
encoded, err := compress.Compress(string(data))
require.NoError(t, err)
command := &UpCmd{WorkspaceInfo: encoded, protocolSet: true, LifecycleTerminalProtocol: 1}
require.ErrorContains(
t,
command.Run(context.Background()),
"lifecycle terminal protocol and request mismatch",
)
}
Loading
Loading