Add PBF catalog commands func.yaml, and deploy support to Fn CLI (#723)

Author: Jaytee-fn

README.md

@@ -151,7 +151,42 @@ deploy:
 
 When these OCI-specific flags are used with a non-Oracle provider or local Fn server workflows, Fn CLI accepts them and emits user-friendly warnings where the settings are not applicable.
 
-### Pre-Built Function create support
+### Pre-Built Function (PBF) support
+List available Pre-Built Functions:
+
+```sh
+fn list pbfs
+fn list pbfs --search Document
+fn list pbfs --trigger http
+fn list pbfs --output json
+```
+
+Get a specific PBF listing:
+
+```sh
+fn get pbfs <pbf-name-or-ocid>
+```
+
+List versions for a PBF:
+
+```sh
+fn list pbfs versions <pbf-name-or-ocid>
+fn list pbfs versions <pbf-name-or-ocid> --current
+```
+
+Get a specific PBF version:
+
+```sh
+fn get pbfs version <pbf-listing-version-ocid>
+```
+
+List supported PBF trigger names:
+
+```sh
+fn list pbfs triggers
+fn list pbfs triggers http
+```
+
 Create a function from a Pre-Built Function (PBF) listing OCID:
 
 ```sh
@@ -164,7 +199,42 @@ For PBF create flows:
 - Fn CLI automatically resolves the minimum required memory from the current PBF version when possible
 - if you specify `--memory`, it must be greater than or equal to the PBF minimum requirement
 
-Current limitation: `--pbf` support is currently focused on `fn create function` and is not yet persisted through `func.yaml` / deploy flows.
+Persist a PBF-backed function definition using `fn init`:
+
+```sh
+fn init --name hello-pbf --pbf <pbf-listing-ocid>
+```
+
+Example `func.yaml` for a PBF-backed function:
+
+```yaml
+deploy:
+  oci:
+    pbf:
+      listing_id: <pbf-listing-ocid>
+```
+
+Deploy a persisted PBF-backed function:
+
+```sh
+fn deploy --app <app-name>
+```
+
+For PBF-backed deploys, Fn CLI skips image build/push/sign flows and creates or updates the function using PBF source details instead.
+
+Inspect/list output also surfaces PBF-backed functions:
+
+```sh
+fn inspect function <app-name> <function-name>
+fn list functions <app-name>
+```
+
+`fn list functions` includes a `SOURCE` column, for example:
+
+```text
+NAME          IMAGE   SOURCE                                      ID
+hello-pbf             pbf:<pbf-listing-ocid>                     <function-ocid>
+```
 
 ### Detached invoke examples
 Invoke a function in detached mode:

commands/commands.go

@@ -23,6 +23,7 @@ import (
 	"github.com/fnproject/cli/objects/app"
 	"github.com/fnproject/cli/objects/context"
 	"github.com/fnproject/cli/objects/fn"
+	"github.com/fnproject/cli/objects/pbf"
 	"github.com/fnproject/cli/objects/server"
 	"github.com/fnproject/cli/objects/trigger"
 	"github.com/urfave/cli"
@@ -97,6 +98,7 @@ var DeleteCmds = Cmd{
 
 var GetCmds = Cmd{
 	"config": ConfigCommand("get"),
+	"pbfs":   pbf.Get(),
 }
 
 var InspectCmds = Cmd{
@@ -110,6 +112,7 @@ var ListCmds = Cmd{
 	"config":    ConfigCommand("list"),
 	"apps":      app.List(),
 	"functions": fn.List(),
+	"pbfs":      pbf.List(),
 	"triggers":  trigger.List(),
 	"contexts":  context.List(),
 }

commands/deploy.go

@@ -355,7 +355,8 @@ func (p *deploycmd) deployFuncV20180708(c *cli.Context, app *models.App, funcfil
 	common.WarnIfOCIManagedFunctionSettingsUnsupported(os.Stderr, p.provider, funcfile.Name, funcfile)
 
 	oracleProvider, _ := getOracleProvider()
-	if oracleProvider != nil && oracleProvider.ImageCompartmentID != "" {
+	isPBFDeploy := funcfile.Deploy != nil && funcfile.Deploy.OCI != nil && funcfile.Deploy.OCI.PBF != nil && strings.TrimSpace(funcfile.Deploy.OCI.PBF.ListingID) != ""
+	if !isPBFDeploy && oracleProvider != nil && oracleProvider.ImageCompartmentID != "" {
 		// If the provider is Oracle and ImageCompartmentID is present, we need to deploy image to the ImageCompartmentID.
 		// The repository name should be unique throughout a tenancy. We check if a repository exists in the compartment and create it if it doesn't already exist.
 		// If the creation fails, it could be because the repository name aready exists in a different compartment.
@@ -393,36 +394,42 @@ func (p *deploycmd) deployFuncV20180708(c *cli.Context, app *models.App, funcfil
 		// TODO: this whole funcfile handling needs some love, way too confusing. Only bump makes permanent changes to it.
 	}
 
-	buildArgs := c.StringSlice("build-arg")
+	if !isPBFDeploy {
+		buildArgs := c.StringSlice("build-arg")
 
-	// In case of local ignore the architectures parameter
-	shape := ""
-	if !p.local && !p.localDebug {
-		// fetch the architectures
-		shape = app.Shape
-		if shape == "" {
-			shape = common.DefaultAppShape
-			app.Shape = shape
-		}
+		// In case of local ignore the architectures parameter
+		shape := ""
+		if !p.local && !p.localDebug {
+			// fetch the architectures
+			shape = app.Shape
+			if shape == "" {
+				shape = common.DefaultAppShape
+				app.Shape = shape
+			}
 
-		if _, ok := common.ShapeMap[shape]; !ok {
-			return errors.New(fmt.Sprintf("Invalid application : %s shape: %s", app.Name, shape))
+			if _, ok := common.ShapeMap[shape]; !ok {
+				return errors.New(fmt.Sprintf("Invalid application : %s shape: %s", app.Name, shape))
+			}
 		}
-	}
 
-	_, err := common.BuildFuncV20180708(common.IsVerbose(), funcfilePath, funcfile, buildArgs, p.noCache, shape, p.localDebug)
-	if err != nil {
-		return err
-	}
+		_, err := common.BuildFuncV20180708(common.IsVerbose(), funcfilePath, funcfile, buildArgs, p.noCache, shape, p.localDebug)
+		if err != nil {
+			return err
+		}
 
-	if err := p.signImage(funcfile); err != nil {
-		return err
+		if err := p.signImage(funcfile); err != nil {
+			return err
+		}
 	}
 	return p.updateFunction(c, app.ID, funcfile)
 }
 
 func (p *deploycmd) updateFunction(c *cli.Context, appID string, ff *common.FuncFileV20180708) error {
-	fmt.Printf("Updating function %s using image %s...\n", ff.Name, ff.ImageNameV20180708())
+	if ff.Deploy != nil && ff.Deploy.OCI != nil && ff.Deploy.OCI.PBF != nil && strings.TrimSpace(ff.Deploy.OCI.PBF.ListingID) != "" {
+		fmt.Printf("Updating function %s using PBF listing %s...\n", ff.Name, ff.Deploy.OCI.PBF.ListingID)
+	} else {
+		fmt.Printf("Updating function %s using image %s...\n", ff.Name, ff.ImageNameV20180708())
+	}
 	var detachedSeconds int
 	if ff.Deploy != nil && ff.Deploy.OCI != nil && ff.Deploy.OCI.DetachedMode != nil && ff.Deploy.OCI.DetachedMode.Timeout != "" {
 		_, seconds, err := common.ParseDetachedTimeoutSpec(ff.Deploy.OCI.DetachedMode.Timeout)
@@ -441,6 +448,11 @@ func (p *deploycmd) updateFunction(c *cli.Context, appID string, ff *common.Func
 	if err := function.WithFuncFileV20180708(ff, fn); err != nil {
 		return fmt.Errorf("Error getting function with funcfile: %s", err)
 	}
+	if ff.Deploy != nil && ff.Deploy.OCI != nil && ff.Deploy.OCI.PBF != nil {
+		if err := function.ResolvePBFMemoryForListing(p.provider, fn, ff.Deploy.OCI.PBF.ListingID); err != nil {
+			return err
+		}
+	}
 	if detachedSeconds > 0 && common.IsOracleProvider(p.provider) {
 		function.SetDetachedTimeoutAnnotation(fn, detachedSeconds)
 	}

commands/init.go

@@ -143,6 +143,10 @@ func initFlags(a *initFnCmd) []cli.Flag {
 			Name:  "provisioned-concurrency",
 			Usage: "Set OCI provisioned concurrency using 'none' or 'constant:<count>'",
 		},
+		cli.StringFlag{
+			Name:  "pbf",
+			Usage: "Initialize func.yaml for a Pre-Built Function using a PBF listing OCID",
+		},
 	}
 
 	return fgs
@@ -220,6 +224,15 @@ func (a *initFnCmd) init(c *cli.Context) error {
 		return err
 	}
 	common.SetProvisionedConcurrency(a.ff, pcConfig)
+	if pbfListingID := strings.TrimSpace(c.String("pbf")); pbfListingID != "" {
+		if a.ff.Deploy == nil {
+			a.ff.Deploy = &common.FuncDeployConfig{}
+		}
+		if a.ff.Deploy.OCI == nil {
+			a.ff.Deploy.OCI = &common.OCIFunctionDeployConfig{}
+		}
+		a.ff.Deploy.OCI.PBF = &common.OCIPBFSourceConfig{ListingID: pbfListingID}
+	}
 	freeformTags, err := common.ParseFreeformTagSpecs(c.StringSlice("tag"))
 	if err != nil {
 		return err
@@ -249,7 +262,6 @@ func (a *initFnCmd) init(c *cli.Context) error {
 			return fmt.Errorf("Runtime %s is no more supported for new apps. Please use python or %s runtime for new apps.", runtime, runtime[:strings.LastIndex(runtime, ".")])
 		}
 	}
-
 	path := c.Args().First()
 	if path != "" {
 		fmt.Printf("Creating function at: ./%s\n", path)
@@ -427,6 +439,9 @@ func (a *initFnCmd) BuildFuncFileV20180708(c *cli.Context, path string) error {
 	if c.String("init-image") != "" {
 		return nil
 	}
+	if strings.TrimSpace(c.String("pbf")) != "" {
+		return nil
+	}
 
 	var helper langs.LangHelper
 	if runtime == "" {

common/funcfile.go

@@ -87,10 +87,16 @@ type OCIProvisionedConcurrencyConfig struct {
 	Count    *int   `yaml:"count,omitempty" json:"count,omitempty"`
 }
 
+// OCIPBFSourceConfig stores Pre-Built Function source details for OCI Functions.
+type OCIPBFSourceConfig struct {
+	ListingID string `yaml:"listing_id,omitempty" json:"listing_id,omitempty"`
+}
+
 // OCIFunctionDeployConfig stores OCI-specific deploy configuration for a function.
 type OCIFunctionDeployConfig struct {
 	ProvisionedConcurrency *OCIProvisionedConcurrencyConfig `yaml:"provisioned_concurrency,omitempty" json:"provisioned_concurrency,omitempty"`
 	DetachedMode           *OCIDetachedModeConfig           `yaml:"detached_mode,omitempty" json:"detached_mode,omitempty"`
+	PBF                    *OCIPBFSourceConfig              `yaml:"pbf,omitempty" json:"pbf,omitempty"`
 	FreeformTags           map[string]string                `yaml:"freeform_tags,omitempty" json:"freeform_tags,omitempty"`
 	DefinedTags            OCIDefinedTags                   `yaml:"defined_tags,omitempty" json:"defined_tags,omitempty"`
 }
@@ -439,6 +445,9 @@ func (ff *FuncFileV20180708) HasOCIManagedFunctionSettings() bool {
 	if len(oci.FreeformTags) > 0 || len(oci.DefinedTags) > 0 {
 		return true
 	}
+	if oci.PBF != nil && strings.TrimSpace(oci.PBF.ListingID) != "" {
+		return true
+	}
 
 	return false
 }
@@ -459,6 +468,9 @@ func (ff *FuncFileV20180708) OCIManagedFunctionSettingNames() []string {
 		settings = append(settings, "detached_mode")
 	}
 	settings = append(settings, OCIManagedResourceTagSettingNames(ff)...)
+	if oci.PBF != nil && strings.TrimSpace(oci.PBF.ListingID) != "" {
+		settings = append(settings, "pbf")
+	}
 
 	return settings
 }