chore: Pull upstream changes 2023-11

cmd/aws-lambda-rie/main.go

@@ -11,6 +11,7 @@ import (
 	"runtime/debug"
 
 	"github.com/jessevdk/go-flags"
+	"go.amzn.com/lambda/interop"
 	"go.amzn.com/lambda/rapidcore"
 
 	log "github.com/sirupsen/logrus"
@@ -103,7 +104,7 @@ func isBootstrapFileExist(filePath string) bool {
 	return !os.IsNotExist(err) && !file.IsDir()
 }
 
-func getBootstrap(args []string, opts options) (*rapidcore.Bootstrap, string) {
+func getBootstrap(args []string, opts options) (interop.Bootstrap, string) {
 	var bootstrapLookupCmd []string
 	var handler string
 	currentWorkingDir := "/var/task" // default value
@@ -149,5 +150,5 @@ func getBootstrap(args []string, opts options) (*rapidcore.Bootstrap, string) {
 		log.Panic("insufficient arguments: bootstrap not provided")
 	}
 
-	return rapidcore.NewBootstrapSingleCmd(bootstrapLookupCmd, currentWorkingDir, ""), handler
+	return NewSimpleBootstrap(bootstrapLookupCmd, currentWorkingDir), handler
 }

cmd/aws-lambda-rie/simple_bootstrap.go

@@ -0,0 +1,69 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"go.amzn.com/lambda/fatalerror"
+	"go.amzn.com/lambda/interop"
+	"go.amzn.com/lambda/rapidcore/env"
+)
+
+// the type implement a simpler version of the Bootstrap
+// this is useful in the Standalone Core implementation.
+type simpleBootstrap struct {
+	cmd        []string
+	workingDir string
+}
+
+func NewSimpleBootstrap(cmd []string, currentWorkingDir string) interop.Bootstrap {
+	if currentWorkingDir == "" {
+		// use the root directory as the default working directory
+		currentWorkingDir = "/"
+	}
+
+	// a single candidate command makes it automatically valid
+	return &simpleBootstrap{
+		cmd:        cmd,
+		workingDir: currentWorkingDir,
+	}
+}
+
+func (b *simpleBootstrap) Cmd() ([]string, error) {
+	return b.cmd, nil
+}
+
+// Cwd returns the working directory of the bootstrap process
+// The path is validated against the chroot identified by `root`
+func (b *simpleBootstrap) Cwd() (string, error) {
+	if !filepath.IsAbs(b.workingDir) {
+		return "", fmt.Errorf("the working directory '%s' is invalid, it needs to be an absolute path", b.workingDir)
+	}
+
+	// evaluate the path relatively to the domain's mnt namespace root
+	if _, err := os.Stat(b.workingDir); os.IsNotExist(err) {
+		return "", fmt.Errorf("the working directory doesn't exist: %s", b.workingDir)
+	}
+
+	return b.workingDir, nil
+}
+
+// Env returns the environment variables available to
+// the bootstrap process
+func (b *simpleBootstrap) Env(e *env.Environment) map[string]string {
+	return e.RuntimeExecEnv()
+}
+
+// ExtraFiles returns the extra file descriptors apart from 1 & 2 to be passed to runtime
+func (b *simpleBootstrap) ExtraFiles() []*os.File {
+	return make([]*os.File, 0)
+}
+
+func (b *simpleBootstrap) CachedFatalError(err error) (fatalerror.ErrorType, string, bool) {
+	// not implemented as it is not needed in Core but we need to fullfil the interface anyway
+	return fatalerror.ErrorType(""), "", false
+}

cmd/aws-lambda-rie/simple_bootstrap_test.go

@@ -0,0 +1,78 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package main
+
+import (
+	"os"
+	"reflect"
+	"testing"
+
+	"go.amzn.com/lambda/rapidcore/env"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSimpleBootstrap(t *testing.T) {
+	tmpFile, err := os.CreateTemp("", "oci-test-bootstrap")
+	assert.NoError(t, err)
+	defer os.Remove(tmpFile.Name())
+
+	// Setup single cmd candidate
+	file := []string{tmpFile.Name(), "--arg1 s", "foo"}
+	cmdCandidate := file
+
+	// Setup working dir
+	cwd, err := os.Getwd()
+	assert.NoError(t, err)
+
+	// Setup environment
+	environment := env.NewEnvironment()
+	environment.StoreRuntimeAPIEnvironmentVariable("host:port")
+	environment.StoreEnvironmentVariablesFromInit(map[string]string{}, "", "", "", "", "", "")
+
+	// Test
+	b := NewSimpleBootstrap(cmdCandidate, cwd)
+	bCwd, err := b.Cwd()
+	assert.NoError(t, err)
+	assert.Equal(t, cwd, bCwd)
+	assert.True(t, reflect.DeepEqual(environment.RuntimeExecEnv(), b.Env(environment)))
+
+	cmd, err := b.Cmd()
+	assert.NoError(t, err)
+	assert.Equal(t, file, cmd)
+}
+
+func TestSimpleBootstrapCmdNonExistingCandidate(t *testing.T) {
+	// Setup inexistent single cmd candidate
+	file := []string{"/foo/bar", "--arg1 s", "foo"}
+	cmdCandidate := file
+
+	// Setup working dir
+	cwd, err := os.Getwd()
+	assert.NoError(t, err)
+
+	// Setup environment
+	environment := env.NewEnvironment()
+	environment.StoreRuntimeAPIEnvironmentVariable("host:port")
+	environment.StoreEnvironmentVariablesFromInit(map[string]string{}, "", "", "", "", "", "")
+
+	// Test
+	b := NewSimpleBootstrap(cmdCandidate, cwd)
+	bCwd, err := b.Cwd()
+	assert.NoError(t, err)
+	assert.Equal(t, cwd, bCwd)
+	assert.True(t, reflect.DeepEqual(environment.RuntimeExecEnv(), b.Env(environment)))
+
+	// No validations run against single candidates
+	cmd, err := b.Cmd()
+	assert.NoError(t, err)
+	assert.Equal(t, file, cmd)
+}
+
+func TestSimpleBootstrapCmdDefaultWorkingDir(t *testing.T) {
+	b := NewSimpleBootstrap([]string{}, "")
+	bCwd, err := b.Cwd()
+	assert.NoError(t, err)
+	assert.Equal(t, "/", bCwd)
+}

lambda/agents/agent.go

@@ -20,10 +20,18 @@ func ListExternalAgentPaths(dir string, root string) []string {
 	}
 	fullDir := path.Join(root, dir)
 	files, err := os.ReadDir(fullDir)
+
 	if err != nil {
-		log.WithError(err).Warning("Cannot list external agents")
+		if os.IsNotExist(err) {
+			log.Infof("The extension's directory %q does not exist, assuming no extensions to be loaded.", fullDir)
+		} else {
+			// TODO - Should this return an error rather than ignore failing to load?
+			log.WithError(err).Error("Cannot list external agents")
+		}
+
 		return agentPaths
 	}
+
 	for _, file := range files {
 		if !file.IsDir() {
 			// The returned path is absolute wrt to `root`. This allows

lambda/appctx/appctx.go

@@ -13,16 +13,19 @@ type Key int
 type InitType int
 
 const (
-	// AppCtxInvokeErrorResponseKey is used for storing deferred invoke error response.
+	// AppCtxInvokeErrorTraceDataKey is used for storing deferred invoke error cause header value.
 	// Only used by xray. TODO refactor xray interface so it doesn't use appctx
-	AppCtxInvokeErrorResponseKey Key = iota
+	AppCtxInvokeErrorTraceDataKey Key = iota
 
 	// AppCtxRuntimeReleaseKey is used for storing runtime release information (parsed from User_Agent Http header string).
 	AppCtxRuntimeReleaseKey
 
 	// AppCtxInteropServerKey is used to store a reference to the interop server.
 	AppCtxInteropServerKey
 
+	// AppCtxResponseSenderKey is used to store a reference to the response sender
+	AppCtxResponseSenderKey
+
 	// AppCtxFirstFatalErrorKey is used to store first unrecoverable error message encountered to propagate it to slicer with DONE(errortype) or DONEFAIL(errortype)
 	AppCtxFirstFatalErrorKey
 

lambda/appctx/appctxutil.go

@@ -119,16 +119,16 @@ func UpdateAppCtxWithRuntimeRelease(request *http.Request, appCtx ApplicationCon
 	return false
 }
 
-// StoreErrorResponse stores response in the applicaton context.
-func StoreErrorResponse(appCtx ApplicationContext, errorResponse *interop.ErrorResponse) {
-	appCtx.Store(AppCtxInvokeErrorResponseKey, errorResponse)
+// StoreInvokeErrorTraceData stores invocation error x-ray cause header in the applicaton context.
+func StoreInvokeErrorTraceData(appCtx ApplicationContext, invokeError *interop.InvokeErrorTraceData) {
+	appCtx.Store(AppCtxInvokeErrorTraceDataKey, invokeError)
 }
 
-// LoadErrorResponse retrieves response from the application context.
-func LoadErrorResponse(appCtx ApplicationContext) *interop.ErrorResponse {
-	v, ok := appCtx.Load(AppCtxInvokeErrorResponseKey)
+// LoadInvokeErrorTraceData retrieves invocation error x-ray cause header from the application context.
+func LoadInvokeErrorTraceData(appCtx ApplicationContext) *interop.InvokeErrorTraceData {
+	v, ok := appCtx.Load(AppCtxInvokeErrorTraceDataKey)
 	if ok {
-		return v.(*interop.ErrorResponse)
+		return v.(*interop.InvokeErrorTraceData)
 	}
 	return nil
 }
@@ -147,6 +147,20 @@ func LoadInteropServer(appCtx ApplicationContext) interop.Server {
 	return nil
 }
 
+// StoreResponseSender stores a reference to the response sender
+func StoreResponseSender(appCtx ApplicationContext, server interop.InvokeResponseSender) {
+	appCtx.Store(AppCtxResponseSenderKey, server)
+}
+
+// LoadResponseSender retrieves the response sender
+func LoadResponseSender(appCtx ApplicationContext) interop.InvokeResponseSender {
+	v, ok := appCtx.Load(AppCtxResponseSenderKey)
+	if ok {
+		return v.(interop.InvokeResponseSender)
+	}
+	return nil
+}
+
 // StoreFirstFatalError stores unrecoverable error code in appctx once. This error is considered to be the rootcause of failure
 func StoreFirstFatalError(appCtx ApplicationContext, err fatalerror.ErrorType) {
 	if existing := appCtx.StoreIfNotExists(AppCtxFirstFatalErrorKey, err); existing != nil {