Added exec support for actions

Author: akclace

internal/app/action/action.go

@@ -17,17 +17,21 @@ import (
 
 	"github.com/claceio/clace/internal/app/apptype"
 	"github.com/claceio/clace/internal/app/starlark_type"
+	"github.com/claceio/clace/internal/types"
 	"github.com/go-chi/chi"
 	"go.starlark.net/starlark"
+	"go.starlark.net/starlarkstruct"
 )
 
-//go:embed *.go.html static/*
+//go:embed *.go.html astatic/*
 var embedHtml embed.FS
 
 // Action represents a single action that is exposed by the App. Actions
 // provide a way to trigger app operations, with an auto-generated form UI
 // and an API interface
 type Action struct {
+	*types.Logger
+	isDev          bool
 	name           string
 	description    string
 	path           string
@@ -41,7 +45,7 @@ type Action struct {
 }
 
 // NewAction creates a new action
-func NewAction(name, description, apath string, run, suggest starlark.Callable,
+func NewAction(logger *types.Logger, isDev bool, name, description, apath string, run, suggest starlark.Callable,
 	params []apptype.AppParam, paramValuesStr map[string]string, paramDict starlark.StringDict, appPath string) (*Action, error) {
 	tmpl, err := template.New("form").ParseFS(embedHtml, "*.go.html")
 	if err != nil {
@@ -52,7 +56,16 @@ func NewAction(name, description, apath string, run, suggest starlark.Callable,
 		return a.Index - b.Index
 	})
 
+	subLogger := logger.With().Str("action", name).Logger()
+	appLogger := types.Logger{Logger: &subLogger}
+
+	pagePath := path.Join(appPath, apath)
+	if pagePath == "/" {
+		pagePath = ""
+	}
+
 	return &Action{
+		Logger:         &appLogger,
 		name:           name,
 		description:    description,
 		path:           apath,
@@ -62,28 +75,212 @@ func NewAction(name, description, apath string, run, suggest starlark.Callable,
 		paramValuesStr: paramValuesStr,
 		paramDict:      paramDict,
 		template:       tmpl,
-		pagePath:       path.Join(appPath, apath),
+		pagePath:       pagePath,
 	}, nil
 }
 
 func (a *Action) BuildRouter() (*chi.Mux, error) {
-	fSys, err := fs.Sub(embedHtml, "static")
+	fSys, err := fs.Sub(embedHtml, "astatic")
 	if err != nil {
 		return nil, err
 	}
 	staticServer := http.FileServer(http.FS(fSys))
 
 	r := chi.NewRouter()
-	r.Post("/", a.runHandler)
+	r.Post("/", a.runAction)
 	r.Get("/", a.getForm)
-	r.Handle("/static/*", http.StripPrefix(path.Join(a.pagePath, "/static/"), staticServer))
+	r.Handle("/astatic/*", http.StripPrefix(path.Join(a.pagePath, "/astatic/"), staticServer))
 	return r, nil
 }
 
-func (a *Action) runHandler(w http.ResponseWriter, r *http.Request) {
-	// Parse the form
-	// Validate the form
-	// Run the action
+func (a *Action) runAction(w http.ResponseWriter, r *http.Request) {
+	thread := &starlark.Thread{
+		Name:  a.name,
+		Print: func(_ *starlark.Thread, msg string) { fmt.Println(msg) },
+	}
+
+	// Save the request context in the starlark thread local
+	thread.SetLocal(types.TL_CONTEXT, r.Context())
+	//isHtmxRequest := r.Header.Get("HX-Request") == "true" && !(r.Header.Get("HX-Boosted") == "true")
+
+	r.ParseForm()
+	var err error
+	dryRun := false
+	dryRunStr := r.Form.Get("dry-run")
+	if dryRunStr != "" {
+		dryRun, err = strconv.ParseBool(dryRunStr)
+		if err != nil {
+			http.Error(w, fmt.Sprintf("invalid value for dry-run: %s", dryRunStr), http.StatusBadRequest)
+			return
+		}
+	}
+
+	deferredCleanup := func() error {
+		// Check for any deferred cleanups
+		err = RunDeferredCleanup(thread)
+		if err != nil {
+			a.Error().Err(err).Msg("error cleaning up plugins")
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return err
+		}
+		return nil
+	}
+
+	defer deferredCleanup()
+
+	args := starlark.StringDict{}
+	// Make a copy of the app level param dict
+	for k, v := range a.paramDict {
+		args[k] = v
+	}
+
+	// Update args with submitted form values
+	for _, param := range a.params {
+		formValue := r.Form.Get(param.Name)
+		if formValue == "" {
+			if param.Type == starlark_type.BOOLEAN {
+				// Form does not submit unchecked checkboxes, set to false
+				args[param.Name] = starlark.Bool(false)
+			}
+		} else {
+			newVal, err := apptype.ParamStringToType(param.Name, param.Type, formValue)
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+			args[param.Name] = newVal
+		}
+	}
+
+	argsValue := Args{members: args}
+
+	// Call the handler function
+	var ret starlark.Value
+	ret, err = starlark.Call(thread, a.run, starlark.Tuple{starlark.Bool(dryRun), &argsValue}, nil)
+	if err != nil {
+		a.Error().Err(err).Msg("error calling action run handler")
+
+		firstFrame := ""
+		if evalErr, ok := err.(*starlark.EvalError); ok {
+			// Iterate through the CallFrame stack for debugging information
+			for i, frame := range evalErr.CallStack {
+				a.Warn().Msgf("Function: %s, Position: %s\n", frame.Name, frame.Pos)
+				if i == 0 {
+					firstFrame = fmt.Sprintf("Function %s, Position %s", frame.Name, frame.Pos)
+				}
+			}
+		}
+
+		msg := err.Error()
+		if firstFrame != "" && a.isDev {
+			msg = msg + " : " + firstFrame
+		}
+
+		// No err handler defined, abort
+		http.Error(w, msg, http.StatusInternalServerError)
+		return
+	}
+
+	var valuesMap []map[string]any
+	var valuesStr []string
+	var message string
+	var paramErrors map[string]any
+
+	resultStruct, ok := ret.(*starlarkstruct.Struct)
+	if ok {
+		message, err = apptype.GetOptionalStringAttr(resultStruct, "message")
+		if err != nil {
+			http.Error(w, fmt.Sprintf("error getting result attr message: %s", err), http.StatusInternalServerError)
+			return
+		}
+
+		valuesMap, err = apptype.GetListMapAttr(resultStruct, "values", true)
+		if err != nil {
+			valuesStr, err = apptype.GetListStringAttr(resultStruct, "values", true)
+			if err != nil {
+				http.Error(w, fmt.Sprintf("error getting result values, not a list of string or list of maps: %s", err), http.StatusInternalServerError)
+				return
+			}
+		}
+
+		paramErrors, err = apptype.GetDictAttr(resultStruct, "param_errors", true)
+		if err != nil {
+			http.Error(w, fmt.Sprintf("error getting result attr paramErrors: %s", err), http.StatusInternalServerError)
+			return
+		}
+	} else {
+		// Not a result struct
+		message = ret.String()
+	}
+
+	a.Info().Msgf("action result message: %s valuesStr %s valuesMap %s paramErrors %s", message, valuesStr, valuesMap, paramErrors)
+
+	if deferredCleanup() != nil {
+		return
+	}
+
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Render the result message
+	err = a.template.ExecuteTemplate(w, "message", message)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+
+	// Render the param error messages if any, using HTMX OOB
+	for paramName, paramError := range paramErrors {
+		tv := struct {
+			Name    string
+			Message string
+		}{
+			Name:    paramName,
+			Message: fmt.Sprintf("%s", paramError),
+		}
+		err = a.template.ExecuteTemplate(w, "paramError", tv)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+	}
+
+	if len(valuesStr) > 0 {
+		// Render the result values, using HTMX OOB
+		err = a.template.ExecuteTemplate(w, "result-textarea", valuesStr)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+	}
+
+}
+
+func RunDeferredCleanup(thread *starlark.Thread) error {
+	deferMap := thread.Local(types.TL_DEFER_MAP)
+	if deferMap == nil {
+		return nil
+	}
+
+	strictFailures := []string{}
+	for pluginName, pluginMap := range deferMap.(map[string]map[string]apptype.DeferEntry) {
+		for key, entry := range pluginMap {
+			err := entry.Func()
+			if err != nil {
+				fmt.Printf("error cleaning up %s %s: %s\n", pluginName, key, err)
+			}
+			if entry.Strict {
+				strictFailures = append(strictFailures, fmt.Sprintf("%s:%s", pluginName, key))
+			}
+		}
+	}
+
+	thread.SetLocal(types.TL_DEFER_MAP, nil) // reset the defer map
+
+	if len(strictFailures) > 0 {
+		return fmt.Errorf("resource has not be closed, check handler code: %s", strings.Join(strictFailures, ", "))
+	}
+
+	return nil
 }
 
 type ParamDef struct {

internal/app/action/args.go

@@ -0,0 +1,49 @@
+// Copyright (c) ClaceIO, LLC
+// SPDX-License-Identifier: Apache-2.0
+
+package action
+
+import (
+	"fmt"
+
+	"go.starlark.net/starlark"
+)
+
+// Args is a starlark.Value that represents the arguments being passed to the Action handler. It contains value for the params.
+type Args struct {
+	members starlark.StringDict
+}
+
+func (a *Args) Attr(name string) (starlark.Value, error) {
+	v, ok := a.members[name]
+	if !ok {
+		return starlark.None, fmt.Errorf("Args has no attribute '%s'", name)
+	}
+
+	return v, nil
+}
+
+func (a *Args) AttrNames() []string {
+	return a.members.Keys()
+}
+
+func (a *Args) String() string {
+	return a.members.String()
+}
+
+func (a *Args) Type() string {
+	return "Args"
+}
+
+func (a *Args) Freeze() {
+}
+
+func (a *Args) Truth() starlark.Bool {
+	return true
+}
+
+func (a *Args) Hash() (uint32, error) {
+	return 0, fmt.Errorf("Hash not implemented for Args")
+}
+
+var _ starlark.Value = (*Args)(nil)

internal/app/action/astatic/htmx.min.js

@@ -1,6 +1,16 @@
 {{ template "header" . }}
 
 
+<script>
+  document.body.addEventListener("htmx:sendError", function (event) {
+    ActionMessage.innerText = "API call failed: Server is not reachable";
+  });
+  document.body.addEventListener("htmx:responseError", function (event) {
+    ActionMessage.innerText =
+      "API call failed: " + event.detail.xhr.responseText;
+  });
+</script>
+
 <p class="text-center">
   {{ .description }}
 </p>
@@ -23,9 +33,12 @@
               id="param_{{ .Name }}"
               name="{{ .Name }}"
               type="checkbox"
+              value="true"
               class="checkbox checkbox-primary justify-self-center"
               {{ .Value }} />
-            <div id="param_{{ .Name }}_Error" class="text-error mt-1"></div>
+            <div class="pl-4">
+              <div id="param_{{ .Name }}_error" class="text-error mt-1"></div>
+            </div>
           </div>
         {{ else if eq .InputType "select" }}
           <div>
@@ -40,7 +53,7 @@
                 <option value="{{ . }}">{{ . }}</option>
               {{ end }}
             </select>
-            <div id="{{ .Name }}_Error" class="text-error mt-1"></div>
+            <div id="param_{{ .Name }}_error" class="text-error mt-1"></div>
           </div>
         {{ else }}
           <div>
@@ -50,7 +63,7 @@
               type="text"
               class="input input-bordered w-full"
               value="{{ .Value }}" />
-            <div id="{{ .Name }}_Error" class="text-error mt-1"></div>
+            <div id="param_{{ .Name }}_error" class="text-error mt-1"></div>
           </div>
         {{ end }}
       </div>
@@ -59,9 +72,22 @@
 
     <!-- Submit Button -->
     <div class="form-control mt-6">
-      <button type="submit" class="btn btn-primary w-full">Run</button>
+      <button
+        type="submit"
+        hx-post="{{ .path }}"
+        hx-target="#ActionMessage"
+        hx-swap="innerHTML"
+        class="btn btn-primary w-full">
+        Run
+      </button>
     </div>
   </form>
 </div>
 
+<p id="ActionMessage" class="pt-6 text-center"></p>
+
+<div class="pt-6 card w-full shadow-2xl p-6 rounded-lg">
+  <div id="action_result"></div>
+</div>
+
 {{ template "footer" . }}