added function management

Author: dstpierre

cmd/function.go

@@ -0,0 +1,40 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+)
+
+// funcitonCmd operates on server-side functions
+var functionCmd = &cobra.Command{
+	Use:   "function",
+	Short: "Manage your server-side functions.",
+	Long: fmt.Sprintf(`
+%s
+
+You can create, update, list and view run history for all your functions.
+
+You'll need a rootToken in your 
+config file.
+	`,
+		clbold(clsecondary("Manage functions")),
+	),
+	Run: func(cmd *cobra.Command, args []string) {
+
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(functionCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// accountCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// accountCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}

cmd/functionCreate.go

@@ -0,0 +1,97 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+	"github.com/staticbackendhq/backend-go"
+)
+
+// functionCreate creates a new server-side function
+var functionCreateCmd = &cobra.Command{
+	Use:   "add",
+	Short: "Create a new server-side function",
+	Long: fmt.Sprintf(`
+%s
+
+Create a function that executes on a recurring schedule:
+
+backend funciton add --name trial_expire --trigger daily_task_trial_expire --source ./functions/trial_expire.js
+
+You may create server-side functions that execute based on those triggers:
+
+%s: invoke via a URL
+%s: a topic/event that will run your function when published
+	`,
+		clbold(clsecondary("Create a function")),
+		clbold("web"),
+		clbold("any_topic_here"),
+	),
+	Run: func(cmd *cobra.Command, args []string) {
+		if setBackend() == false {
+			return
+		}
+
+		tok, ok := getRootToken()
+		if !ok {
+			return
+		}
+
+		name, err := cmd.Flags().GetString("name")
+		if err != nil || len(name) == 0 {
+			fmt.Printf("%s: the --name option is required\n", cldanger("missing parameter"))
+			return
+		}
+
+		trigger, err := cmd.Flags().GetString("trigger")
+		if err != nil || len(trigger) == 0 {
+			fmt.Printf("%s: the --trigger option is required\n", cldanger("missing parameter"))
+			return
+		}
+
+		source, err := cmd.Flags().GetString("source")
+		if err != nil || len(trigger) == 0 {
+			fmt.Printf("%s: the --source option is required\n", cldanger("missing parameter"))
+			return
+		}
+
+		b, err := os.ReadFile(source)
+		if err != nil {
+			fmt.Printf("%s: %v\n", cldanger("error reading source file"), err)
+			return
+		}
+
+		fn := backend.Function{
+			FunctionName: name,
+			TriggerTopic: trigger,
+			Code:         string(b),
+		}
+
+		if err := backend.AddFunction(tok, fn); err != nil {
+			fmt.Printf("%s: %v\n", cldanger("error adding your function"), err)
+			return
+		}
+
+		fmt.Println("%s: %s", clgreen("Function created successfully"), clbold(name))
+		if trigger == "web" {
+			fmt.Printf("%s: %s\n", clsecondary("Function URL"), clbold("[your_domain]/fn/exec/"+name))
+		} else {
+			fmt.Printf("%s: %s\n", clsecondary("Function will trigger on topic"), clbold(trigger))
+		}
+	},
+}
+
+func init() {
+	functionCmd.AddCommand(functionCreateCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// accountCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	functionCreateCmd.Flags().String("name", "", "function name")
+	functionCreateCmd.Flags().String("trigger", "", "execution trigger either web or topic")
+	functionCreateCmd.Flags().String("source", "", "path of the JavaScript file")
+}

cmd/functionDelete.go

@@ -0,0 +1,53 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/staticbackendhq/backend-go"
+)
+
+// functionList lists all server-side functions
+var functionDeleteCmd = &cobra.Command{
+	Use:   "delete name",
+	Short: "Delete the function by its name",
+	Long: fmt.Sprintf(`
+%s
+
+This will delete the function permanently, including all of its run history.
+	`,
+		clbold(clsecondary("Delete a functions")),
+	),
+	Run: func(cmd *cobra.Command, args []string) {
+		if setBackend() == false {
+			return
+		}
+
+		tok, ok := getRootToken()
+		if !ok {
+			return
+		}
+
+		if len(args) != 1 {
+			fmt.Printf("%s: only a name should be specified\n", cldanger("argument missmatch"))
+			return
+		}
+
+		if err := backend.DeleteFunction(tok, args[0]); err != nil {
+			fmt.Printf("%s: %v\n", cldanger("error deleting your function"), err)
+			return
+		}
+
+		fmt.Printf("%s: the function %s has been deleted\n", clsuccess("success"))
+	},
+}
+
+func init() {
+	functionCmd.AddCommand(functionDeleteCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// accountCmd.PersistentFlags().String("foo", "", "A help for foo")
+}

cmd/functionInfo.go

@@ -0,0 +1,97 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"text/tabwriter"
+
+	"github.com/spf13/cobra"
+	"github.com/staticbackendhq/backend-go"
+)
+
+// functionInfo returns all run history for a specific function
+var functionInfoCmd = &cobra.Command{
+	Use:   "info name",
+	Short: "Display run history for a function",
+	Long: fmt.Sprintf(`
+%s
+
+This command displays the last 100 run history and function output.
+
+This is useful to diagnose if you're using the %s runtime function inside your 
+function code.
+	`,
+		clbold(clsecondary("Display function run hostory")),
+		clbold("log"),
+	),
+	Run: func(cmd *cobra.Command, args []string) {
+		if setBackend() == false {
+			return
+		}
+
+		tok, ok := getRootToken()
+		if !ok {
+			return
+		}
+
+		if len(args) != 1 {
+			fmt.Printf("%s: only a name should be specified\n", cldanger("argument missmatch"))
+			return
+		}
+
+		fn, err := backend.FunctionInfo(tok, args[0])
+		if err != nil {
+			fmt.Printf("%s: %v\n", cldanger("error while retrieving the function"), err)
+			return
+		}
+
+		w := tabwriter.NewWriter(os.Stdout, 0, 4, 2, ' ', tabwriter.DiscardEmptyColumns)
+
+		fmt.Fprintf(w, "NAME\tVERSION\tTRIGGER\tLAST RUN\n")
+
+		fmt.Fprintf(w, "%s\t%d\t%s\t%s\n",
+			fn.FunctionName,
+			fn.Version,
+			fn.TriggerTopic,
+			fn.LastRun.Format("2006/01/02 15:04"),
+		)
+
+		w.Flush()
+
+		fmt.Printf("\n==== %s ====\n\n", clbold("RUN HISTORY"))
+
+		start := len(fn.History)
+		end := start - 100
+		if end < 0 {
+			end = 0
+		}
+		if start > 0 {
+			for i := start; i >= end; i-- {
+				run := fn.History[i]
+				fmt.Printf("%s:%d | %s:%s | %s:%v\n",
+					clsecondary("version"),
+					run.Version,
+					clsecondary("start"),
+					run.Started.Format("2006/01/02 15:04"),
+					clsecondary("execution time"),
+					run.Completed.Sub(run.Started),
+				)
+				for _, o := range run.Output {
+					fmt.Println("\t", o)
+				}
+
+				fmt.Println("------------------")
+			}
+		}
+	},
+}
+
+func init() {
+	functionCmd.AddCommand(functionInfoCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// accountCmd.PersistentFlags().String("foo", "", "A help for foo")
+}

cmd/functionList.go

@@ -0,0 +1,86 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/spf13/cobra"
+	"github.com/staticbackendhq/backend-go"
+)
+
+// functionList lists all server-side functions
+var functionListCmd = &cobra.Command{
+	Use:   "list [trigger]",
+	Short: "List server-side functions",
+	Long: fmt.Sprintf(`
+%s
+
+If you specify a %s only functions for that trigger will be included.
+
+Otherwise, all functions are displayed.
+	`,
+		clbold(clsecondary("List functions")),
+		clbold("trigger"),
+	),
+	Run: func(cmd *cobra.Command, args []string) {
+		if setBackend() == false {
+			return
+		}
+
+		tok, ok := getRootToken()
+		if !ok {
+			return
+		}
+
+		var trigger string
+		if len(args) == 1 {
+			trigger = args[0]
+		}
+
+		results, err := backend.ListFunctions(tok)
+		if err != nil {
+			fmt.Printf("%s: %v\n", cldanger("An error occured"), err)
+			return
+		}
+
+		// filter for trigger if supplied
+		var filtered []backend.Function
+		if len(trigger) > 0 {
+			for _, f := range results {
+				if strings.EqualFold(trigger, f.TriggerTopic) {
+					filtered = append(filtered, f)
+				}
+			}
+		} else {
+			filtered = append(filtered, results...)
+		}
+
+		fmt.Printf("%s result(s)\n\n", clbold(len(filtered)))
+		w := tabwriter.NewWriter(os.Stdout, 0, 4, 2, ' ', tabwriter.DiscardEmptyColumns)
+
+		fmt.Fprintf(w, "NAME\tVERSION\tTRIGGER\tLAST RUN\n")
+
+		for _, f := range filtered {
+			fmt.Fprintf(w, "%s\t%d\t%s\t%s\n",
+				f.FunctionName,
+				f.Version,
+				f.TriggerTopic,
+				f.LastRun.Format("2006/01/02 15:04"),
+			)
+		}
+
+		w.Flush()
+	},
+}
+
+func init() {
+	functionCmd.AddCommand(functionListCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// accountCmd.PersistentFlags().String("foo", "", "A help for foo")
+}