Profile: Create/Delete/Overwrite/Rename. Fog updates. (#102)

Author: EliCDavis

cmd/polyform/main.go

@@ -47,8 +47,8 @@ import (
 func main() {
 	app := generator.App{
 		Name:        "Polyform",
-		Version:     "0.23.2",
-		Description: "Immutable mesh processing program",
+		Version:     "",
+		Description: "Immutable mesh processing pipelines",
 		Authors: []schema.Author{
 			{
 				Name: "Eli C Davis",

generator/app_server.go

@@ -148,6 +148,13 @@ func (as *AppServer) Handler(indexFile string) (*http.ServeMux, error) {
 	mux.Handle("/parameter/value/", parameterValueEndpoint(as.app.graphInstance, graphSaver))
 	mux.Handle("/parameter/name/", parameterNameEndpoint(as.app.graphInstance, graphSaver))
 	mux.Handle("/parameter/description/", parameterDescriptionEndpoint(as.app.graphInstance, graphSaver))
+
+	mux.Handle("/profile", profileEndpoint(as.app.graphInstance, graphSaver))
+	mux.Handle("/profile/apply", applyProfileEndpoint(as.app.graphInstance, graphSaver))
+	mux.Handle("/profile/rename", renameProfileEndpoint(as.app.graphInstance, graphSaver))
+	mux.Handle("/profile/overwrite", overwriteProfileEndpoint(as.app.graphInstance, graphSaver))
+	mux.Handle("/profiles", profilesEndpoint(as.app.graphInstance))
+
 	mux.Handle("/new-graph", newGraphEndpoint(as.app, as))
 	mux.Handle("/load-example", exampleGraphEndpoint(as.app, as))
 	mux.Handle("/graph", graphEndpoint(as.app, as))

generator/app_server_profile.go

@@ -0,0 +1,109 @@
+package generator
+
+import (
+	"errors"
+	"net/http"
+	"strings"
+
+	"github.com/EliCDavis/polyform/generator/endpoint"
+	"github.com/EliCDavis/polyform/generator/graph"
+)
+
+func profileEndpoint(graphInstance *graph.Instance, saver *GraphSaver) endpoint.Handler {
+	type ProfileRequest struct {
+		Name string `json:"name"`
+	}
+
+	return endpoint.Handler{
+		Methods: map[string]endpoint.Method{
+
+			http.MethodPost: endpoint.JsonBodyMethod(func(request endpoint.Request[ProfileRequest]) error {
+				cleanName := strings.TrimSpace(request.Body.Name)
+
+				if cleanName == "" {
+					return errors.New("profile name can not be empty")
+				}
+
+				graphInstance.SaveProfile(cleanName)
+
+				saver.Save()
+				return nil
+			}),
+
+			http.MethodDelete: endpoint.JsonBodyMethod(func(request endpoint.Request[ProfileRequest]) error {
+				err := graphInstance.DeleteProfile(request.Body.Name)
+				if err != nil {
+					return err
+				}
+				saver.Save()
+
+				return nil
+			}),
+		},
+	}
+}
+
+func profilesEndpoint(graphInstance *graph.Instance) endpoint.Handler {
+	return endpoint.Handler{
+		Methods: map[string]endpoint.Method{
+			http.MethodGet: endpoint.JsonResponseMethod(func(r *http.Request) ([]string, error) {
+				return graphInstance.Profiles(), nil
+			}),
+		},
+	}
+}
+
+func applyProfileEndpoint(graphInstance *graph.Instance, saver *GraphSaver) endpoint.Handler {
+	type ApplyProfileRequest struct {
+		Name string `json:"name"`
+	}
+
+	return endpoint.Handler{
+		Methods: map[string]endpoint.Method{
+			http.MethodPost: endpoint.JsonBodyMethod(func(request endpoint.Request[ApplyProfileRequest]) error {
+				err := graphInstance.LoadProfile(request.Body.Name)
+				if err != nil {
+					return err
+				}
+				saver.Save()
+				return nil
+			}),
+		},
+	}
+}
+
+func renameProfileEndpoint(graphInstance *graph.Instance, saver *GraphSaver) endpoint.Handler {
+	type RenameProfileRequest struct {
+		Original string `json:"original"`
+		New      string `json:"new"`
+	}
+
+	return endpoint.Handler{
+		Methods: map[string]endpoint.Method{
+			http.MethodPost: endpoint.JsonBodyMethod(func(request endpoint.Request[RenameProfileRequest]) error {
+				err := graphInstance.RenameProfile(request.Body.Original, request.Body.New)
+				if err != nil {
+					return err
+				}
+				saver.Save()
+				return nil
+			}),
+		},
+	}
+}
+
+func overwriteProfileEndpoint(graphInstance *graph.Instance, saver *GraphSaver) endpoint.Handler {
+	type OverwriteProfileRequest struct {
+		Name string `json:"name"`
+	}
+
+	return endpoint.Handler{
+		Methods: map[string]endpoint.Method{
+			http.MethodPost: endpoint.JsonBodyMethod(func(request endpoint.Request[OverwriteProfileRequest]) error {
+				graphInstance.SaveProfile(request.Body.Name)
+				saver.Save()
+				return nil
+			}),
+		},
+	}
+}

generator/endpoint/json.go

@@ -68,3 +68,16 @@ func JsonMethod[Body any, Response any](handler func(request Request[Body]) (Res
 		Handler:        handler,
 	}
 }
+
+func JsonBodyMethod[Body any](handler func(request Request[Body]) error) BodyMethod[Body] {
+	return BodyMethod[Body]{
+		Request: JsonRequestReader[Body]{},
+		Handler: handler,
+	}
+}
+
+func JsonResponseMethod[Response any](handler func(r *http.Request) (Response, error)) ResponseMethod[Response] {
+	return ResponseMethod[Response]{
+		ResponseWriter: JsonResponseWriter[Response]{},
+	}
+}

generator/examples/eyeball.json

@@ -27,8 +27,10 @@ type Instance struct {
 	namedManifests *namedOutputManager[manifest.Manifest]
 	variables      variable.System
 
+	profiles map[string]variable.Profile
+
 	// TODO: Make this a lock across the entire instance
-	producerLock gsync.Mutex
+	lock gsync.RWMutex
 }
 
 func New(typeFactory *refutil.TypeFactory) *Instance {
@@ -127,8 +129,8 @@ func (i *Instance) SetVariableDescription(variablePath, description string) erro
 }
 
 func (i *Instance) UpdateVariable(variablePath string, data []byte) (bool, error) {
-	i.producerLock.Lock()
-	defer i.producerLock.Unlock()
+	i.lock.Lock()
+	defer i.lock.Unlock()
 
 	variable, err := i.variables.Variable(variablePath)
 	if err != nil {
@@ -141,8 +143,8 @@ func (i *Instance) UpdateVariable(variablePath string, data []byte) (bool, error
 }
 
 func (i *Instance) VariableData(variablePath string) ([]byte, error) {
-	i.producerLock.Lock()
-	defer i.producerLock.Unlock()
+	i.lock.Lock()
+	defer i.lock.Unlock()
 
 	variable, err := i.variables.Variable(variablePath)
 	if err != nil {
@@ -153,6 +155,76 @@ func (i *Instance) VariableData(variablePath string) ([]byte, error) {
 
 // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
 
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+// Profiles
+// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+func (i *Instance) SaveProfile(profileName string) {
+	i.lock.Lock()
+	defer i.lock.Unlock()
+
+	i.profiles[profileName] = i.variables.GetProfile()
+}
+
+func (i *Instance) LoadProfile(profileName string) error {
+	i.lock.Lock()
+	defer i.lock.Unlock()
+
+	if profile, ok := i.profiles[profileName]; ok {
+		return i.variables.ApplyProfile(profile)
+	}
+
+	return fmt.Errorf("no profile exists with name %q", profileName)
+}
+
+func (i *Instance) RenameProfile(profile, newName string) error {
+	i.lock.Lock()
+	defer i.lock.Unlock()
+
+	if _, ok := i.profiles[profile]; !ok {
+		return fmt.Errorf("profile %q does not exist", profile)
+	}
+
+	if _, ok := i.profiles[newName]; ok {
+		return fmt.Errorf("profile %q already exists", profile)
+	}
+
+	i.profiles[newName] = i.profiles[profile]
+
+	delete(i.profiles, profile)
+
+	return nil
+}
+
+func (i *Instance) DeleteProfile(profileName string) error {
+	i.lock.Lock()
+	defer i.lock.Unlock()
+
+	if _, ok := i.profiles[profileName]; !ok {
+		return fmt.Errorf("graph contains no profile named %q", profileName)
+	}
+
+	delete(i.profiles, profileName)
+	return nil
+}
+
+func (i *Instance) Profiles() []string {
+	i.lock.RLock()
+	defer i.lock.RUnlock()
+
+	profiles := make([]string, 0, len(i.profiles))
+
+	for profile := range i.profiles {
+		profiles = append(profiles, profile)
+	}
+
+	sort.Strings(profiles)
+
+	return profiles
+}
+
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+
 func (i *Instance) IsPortNamed(node nodes.Node, portName string) (string, bool) {
 	return i.namedManifests.IsPortNamed(node, portName)
 }
@@ -316,6 +388,7 @@ func (i *Instance) Reset() {
 	i.namedManifests = &namedOutputManager[manifest.Manifest]{
 		namedPorts: make(map[string]namedOutputEntry[manifest.Manifest]),
 	}
+	i.profiles = make(map[string]variable.Profile)
 }
 
 type sortedReference struct {
@@ -397,6 +470,10 @@ func (i *Instance) ApplyAppSchema(jsonPayload []byte) error {
 		return err
 	}
 
+	for profile, data := range appSchema.Profiles {
+		i.profiles[profile] = data.Data
+	}
+
 	createdNodes := make(map[string]nodes.Node)
 
 	// Create the Nodes
@@ -506,6 +583,9 @@ func (i *Instance) ApplyAppSchema(jsonPayload []byte) error {
 }
 
 func (i *Instance) Schema() schema.GraphInstance {
+	i.lock.RLock()
+	defer i.lock.RUnlock()
+
 	var noteMetadata map[string]any
 	if notes := i.metadata.Get("notes"); notes != nil {
 		casted, ok := notes.(map[string]any)
@@ -523,8 +603,14 @@ func (i *Instance) Schema() schema.GraphInstance {
 		Producers: make(map[string]schema.Producer),
 		Notes:     noteMetadata,
 		Variables: variableSchema,
+		Profiles:  make([]string, 0, len(i.profiles)),
 	}
 
+	for profile := range i.profiles {
+		appSchema.Profiles = append(appSchema.Profiles, profile)
+	}
+	sort.Strings(appSchema.Profiles)
+
 	appNodeSchema := make(map[string]schema.NodeInstance)
 
 	for node := range i.nodeIDs {
@@ -585,6 +671,15 @@ func (i *Instance) EncodeToAppSchema(appSchema *schema.App, encoder *jbtf.Encode
 		nodeInstances[id] = nodeSchema
 	}
 
+	if appSchema.Profiles == nil {
+		appSchema.Profiles = make(map[string]schema.AppProfile)
+	}
+	for name, data := range i.profiles {
+		appSchema.Profiles[name] = schema.AppProfile{
+			Data: data,
+		}
+	}
+
 	if appSchema.Producers == nil {
 		appSchema.Producers = make(map[string]schema.Producer)
 	}
@@ -803,17 +898,17 @@ func (i *Instance) Parameter(nodeId string) Parameter {
 }
 
 func (i *Instance) UpdateParameter(nodeId string, data []byte) (bool, error) {
-	i.producerLock.Lock()
-	defer i.producerLock.Unlock()
+	i.lock.Lock()
+	defer i.lock.Unlock()
 
 	r, err := i.Parameter(nodeId).ApplyMessage(data)
 	i.incModelVersion()
 	return r, err
 }
 
 func (i *Instance) ParameterData(nodeId string) []byte {
-	i.producerLock.Lock()
-	defer i.producerLock.Unlock()
+	i.lock.Lock()
+	defer i.lock.Unlock()
 	return i.Parameter(nodeId).ToMessage()
 }
 
@@ -954,8 +1049,8 @@ func (i *Instance) Manifest(producerName string) manifest.Manifest {
 		panic(fmt.Errorf("no producer registered for: %s", producerName))
 	}
 
-	i.producerLock.Lock()
-	defer i.producerLock.Unlock()
+	i.lock.Lock()
+	defer i.lock.Unlock()
 
 	return producer.port.Value()
 }