Releasing version 0.3.770

Author: CI

.gitignore

@@ -32,3 +32,5 @@ fnlb/fnlb
 /fnserver
 *iml
 target/
+clients/.bundle
+clients/vendor

Dockerfile

@@ -1,4 +1,24 @@
-FROM docker-remote.artifactory.oci.oraclecorp.com/docker:28-dind
+ARG BUILDER="builder-buildservice"
+# The builder-local is only used for local development where we could build the fnserver
+# in local linux container
+FROM ocr-docker-remote.artifactory.oci.oraclecorp.com/os/oraclelinux:8 AS builder-local
+RUN dnf -y install golang git ca-certificates && dnf clean all
+
+WORKDIR /home/fnserver
+
+COPY . .
+
+RUN CGO_ENABLED=0 go build -o fnserver ./cmd/fnserver/main.go
+
+# For build in buildserver, the artifact is copied from previous go build step.
+FROM scratch AS builder-buildservice
+
+WORKDIR /home/fnserver
+COPY fnserver .
+
+FROM ${BUILDER} AS fnserver-binary
+
+FROM docker-remote.artifactory.oci.oraclecorp.com/docker:29-dind
 
 RUN apk add --no-cache ca-certificates
 
@@ -8,7 +28,7 @@ ENTRYPOINT ["preentry.sh"]
 
 WORKDIR /app
 
-COPY fnserver .
+COPY --from=fnserver-binary /home/fnserver/fnserver .
 
 CMD ["./fnserver"]
 EXPOSE 8080

Makefile

@@ -103,15 +103,21 @@ test-build-arm:
 
 .PHONY: run
 run: build
-	GIN_MODE=debug ./fnserver
+	FN_HOT_START_TIMEOUT_MSECS=300000 FN_LOG_LEVEL=debug GIN_MODE=debug ./fnserver
 
 .PHONY: docker-build
 docker-build:
-	docker build --build-arg HTTPS_PROXY --build-arg HTTP_PROXY -t fnproject/fnserver:latest .
+	docker build --build-arg HTTPS_PROXY --build-arg HTTP_PROXY --build-arg BUILDER=builder-local -t fnproject/fnserver:latest .
 
 .PHONY: docker-run
 docker-run: docker-build
-	docker run --rm --privileged -it -e NO_PROXY -e HTTP_PROXY -e FN_LOG_LEVEL=debug -e "FN_DB_URL=sqlite3:///app/data/fn.db" -v ${CURDIR}/data:/app/data -p 8080:8080 fnproject/fnserver
+	docker run --rm --privileged -i --name fnserver -e FN_LOG_LEVEL=debug \
+    -v ${CURDIR}/data:/app/data -p 8080:8080 \
+    -v fniofsvol:/iofs:z -e FN_IOFS_DOCKER_PATH=fniofsvol -e FN_IOFS_PATH=/iofs \
+    -v /var/run/docker.sock:/var/run/docker.sock -e FN_HOT_START_TIMEOUT_MSECS=300000 \
+    -e FN_LOCAL_DEBUG=true -e FN_LOCAL_DEBUG_PORT=5678 \
+    --entrypoint ./fnserver \
+    fnproject/fnserver:latest
 
 .PHONY: docker-test
 docker-test:

api/agent/agent.go

@@ -33,7 +33,9 @@ import (
 )
 
 const (
-	pauseTimeout = 5 * time.Second // docker pause/unpause
+	pauseTimeout        = 5 * time.Second // docker pause/unpause
+	defaultDebugTimeout = 300             // minimum 5 mins timeout if debug mode is on.
+	// user could override it in func.yaml if they want larger value.
 )
 
 // Agent exposes an api to create calls from various parameters and then submit
@@ -145,6 +147,13 @@ func New(options ...Option) Agent {
 
 	a.resources = NewResourceTracker(&a.cfg)
 
+	if a.cfg.LocalDebug {
+		WithCallOptions(func(c *call) error {
+			c.Timeout = max(defaultDebugTimeout, c.Timeout)
+			return nil
+		})
+	}
+
 	for _, sup := range a.onStartup {
 		sup()
 	}
@@ -1170,6 +1179,7 @@ type container struct {
 	afterCall      drivers.AfterCall
 	dockerAuth     dockerdriver.Auther
 	authToken      string
+	exposedPort    *uint64
 
 	stderr io.Writer
 
@@ -1258,6 +1268,11 @@ func newHotContainer(ctx context.Context, evictor Evictor, caller *slotCaller, c
 	logger.WithField("FN_LISTENER", env["FN_LISTENER"]).
 		Debug("Setting FN_LISTENER in container")
 
+	var localDebugPort *uint64 = nil
+	if cfg.LocalDebug {
+		localDebugPort = &cfg.LocalDebugPort
+	}
+
 	return &container{
 		id:             id, // XXX we could just let docker generate ids...
 		image:          call.Image,
@@ -1273,6 +1288,7 @@ func newHotContainer(ctx context.Context, evictor Evictor, caller *slotCaller, c
 		messageQueue:   cfg.MaxMessageQueue,
 		tmpFsSize:      uint64(call.TmpFsSize),
 		disableNet:     call.disableNet,
+		exposedPort:    localDebugPort,
 		iofs:           iofs,
 		dockerAuth:     call.dockerAuth,
 		authToken:      authToken,
@@ -1366,6 +1382,7 @@ func (c *container) UDSAgentPath() string               { return c.iofs.AgentPat
 func (c *container) UDSDockerPath() string              { return c.iofs.DockerPath() }
 func (c *container) UDSDockerDest() string              { return iofsDockerMountDest }
 func (c *container) DisableNet() bool                   { return c.disableNet }
+func (c *container) ExposedPort() *uint64               { return c.exposedPort }
 
 // WriteStat publishes each metric in the specified Stats structure as a histogram metric
 func (c *container) WriteStat(ctx context.Context, stat driver_stats.Stat) {

api/agent/config.go

@@ -49,6 +49,8 @@ type Config struct {
 	ImageCleanMaxSize             uint64        `json:"image_clean_max_size"`
 	ImageCleanExemptTags          string        `json:"image_clean_exempt_tags"`
 	ImageEnableVolume             bool          `json:"image_enable_volume"`
+	LocalDebug                    bool          `json:"local_debug"`
+	LocalDebugPort                uint64        `json:"local_debug_port"`
 }
 
 const (
@@ -134,6 +136,11 @@ const (
 	// EnvDetachedHeadroom is the extra room we want to give to a detached function to run.
 	EnvDetachedHeadroom = "FN_EXECUTION_HEADROOM"
 
+	// EnvLocalDebug is the flag to control if Fn Container will be started with FN_LOCAL_DEBUG_PORT exposed
+	//   for debugger attachment
+	EnvLocalDebug     = "FN_LOCAL_DEBUG"
+	EnvLocalDebugPort = "FN_LOCAL_DEBUG_PORT"
+
 	// MaxMsDisabled is used to determine whether mr freeze is lying in wait. TODO remove this manuever
 	MaxMsDisabled = time.Duration(math.MaxInt64)
 
@@ -164,6 +171,7 @@ func NewConfig() (*Config, error) {
 	defaultMaxLockedMemory := uint64(64 * 1024)
 	defaultMaxPendingSignals := uint64(5000)
 	defaultMaxMessageQueue := uint64(819200)
+	defaultLocalDebugPort := uint64(5678)
 
 	var err error
 	err = setEnvMsecs(err, EnvFreezeIdle, &cfg.FreezeIdle, 50*time.Millisecond)
@@ -203,6 +211,8 @@ func NewConfig() (*Config, error) {
 	err = setEnvUint(err, EnvImageCleanMaxSize, &cfg.ImageCleanMaxSize, nil)
 	err = setEnvStr(err, EnvImageCleanExemptTags, &cfg.ImageCleanExemptTags)
 	err = setEnvBool(err, EnvImageEnableVolume, &cfg.ImageEnableVolume)
+	err = setEnvBool(err, EnvLocalDebug, &cfg.LocalDebug)
+	err = setEnvUint(err, EnvLocalDebugPort, &cfg.LocalDebugPort, &defaultLocalDebugPort)
 
 	if err != nil {
 		return cfg, err

api/agent/drivers/docker/cookie.go

@@ -262,6 +262,23 @@ func (c *cookie) configureWorkDir(log logrus.FieldLogger) {
 	c.opts.Config.WorkingDir = wd
 }
 
+func (c *cookie) configureLocalDebugPortMapping(log logrus.FieldLogger) {
+	if c.task.ExposedPort() != nil {
+		log.WithFields(logrus.Fields{"call_id": c.task.Id()}).Debug("configure local debug port mapping")
+		var port = fmt.Sprintf("%d/tcp", *c.task.ExposedPort())
+		c.opts.Config.ExposedPorts = map[docker.Port]struct{}{
+			docker.Port(port): {},
+		}
+		c.opts.HostConfig.PortBindings = map[docker.Port][]docker.PortBinding{
+			docker.Port(port): {{
+				HostIP:   "0.0.0.0",
+				HostPort: fmt.Sprintf("%d", *c.task.ExposedPort()),
+			}},
+		}
+	}
+
+}
+
 func (c *cookie) configureNetwork(log logrus.FieldLogger) {
 	if c.opts.HostConfig.NetworkMode != "" {
 		return

api/agent/drivers/docker/docker.go

@@ -375,6 +375,7 @@ func (drv *DockerDriver) CreateCookie(ctx context.Context, task drivers.Containe
 	cookie.configurePIDs(log)
 	cookie.configureULimits(log)
 	cookie.configureTmpFs(log)
+	cookie.configureLocalDebugPortMapping(log)
 	cookie.configureVolumes(log)
 	cookie.configureWorkDir(log)
 	cookie.configureIOFS(log)

api/agent/drivers/docker/docker_test.go

@@ -19,13 +19,14 @@ import (
 )
 
 type taskDockerTest struct {
-	id         string
-	cmd        string
-	disableNet bool
-	input      io.Reader
-	output     io.Writer
-	errors     io.Writer
-	logURL     string
+	id          string
+	cmd         string
+	disableNet  bool
+	input       io.Reader
+	output      io.Writer
+	errors      io.Writer
+	logURL      string
+	exposedPort *uint64
 }
 
 func (f *taskDockerTest) Command() string                                            { return f.cmd }
@@ -67,6 +68,7 @@ func (f *taskDockerTest) BeforeCall(context.Context, *models.Call, drivers.CallE
 func (f *taskDockerTest) AfterCall(context.Context, *models.Call, drivers.CallExtensions) error {
 	return nil
 }
+func (f *taskDockerTest) ExposedPort() *uint64 { return f.exposedPort }
 
 func createTask(id string) *taskDockerTest {
 	return &taskDockerTest{
@@ -557,3 +559,59 @@ func TestRunnerDockerInvalidSyslog(t *testing.T) {
 	}
 
 }
+
+func TestRunnerDockerLocalDebug(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(30)*time.Second)
+	defer cancel()
+
+	dkr := NewDocker(drivers.Config{})
+	defer dkr.Close()
+
+	var output bytes.Buffer
+	var errors bytes.Buffer
+	var exposedPort uint64 = 5678
+
+	task := createTask("test-docker-local-debug")
+	task.output = &output
+	task.errors = &errors
+	task.exposedPort = &exposedPort
+
+	cookie, err := dkr.CreateCookie(ctx, task)
+	if err != nil {
+		t.Fatal("Couldn't create task cookie")
+	}
+
+	defer cookie.Close(ctx)
+
+	err = commonCookiePull(ctx, cookie)
+	if err != nil {
+		t.Fatal(err)
+	}
+	err, result := commonCookieRun(ctx, cookie)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Error() != nil {
+		t.Fatal(result.Error())
+	}
+
+	if result.Status() != "success" {
+		t.Fatalf("Test should successfully run the image: %s output: %s errors: %s",
+			result.Error(), output.String(), errors.String())
+	}
+
+	port := docker.Port("5678/tcp")
+	var containerOptions docker.CreateContainerOptions
+	containerOptions = cookie.ContainerOptions().(docker.CreateContainerOptions)
+	if _, ok := containerOptions.Config.ExposedPorts[port]; !ok {
+		t.Errorf("Expected ExposedPorts to contain 5678/tcp, got: %+v", containerOptions.Config.ExposedPorts)
+	}
+	bindings, ok := containerOptions.HostConfig.PortBindings[port]
+	if !ok || len(bindings) != 1 {
+		t.Fatalf("Expected PortBindings for '5678/tcp', got: %+v", containerOptions.HostConfig.PortBindings)
+	}
+	binding := bindings[0]
+	if binding.HostIP != "0.0.0.0" || binding.HostPort != "5678" {
+		t.Errorf("Expected HostIP '0.0.0.0' and HostPort '5678', got HostIP '%s', HostPort '%s'", binding.HostIP, binding.HostPort)
+	}
+}

api/agent/drivers/driver.go

@@ -209,6 +209,9 @@ type ContainerTask interface {
 	// Returns true if network is disabled.
 	DisableNet() bool
 
+	// Port exposed in Fn Container for local debugger to attach to
+	ExposedPort() *uint64
+
 	// BeforeCall is invoked just prior to running an invocation.
 	// The Task is definitely going to be used for this invocation.
 	// Invocation extensions are passed to the Before and After calls

api/version/version.go

@@ -1,4 +1,4 @@
 package version
 
 // Version of Functions
-var Version = "0.3.769"
+var Version = "0.3.770"