feat: add Rust support to Crossplane projects

apis/dev/v1alpha1/project_types.go

@@ -53,6 +53,7 @@ const (
 	SchemaLanguageJSON   = "json"
 	SchemaLanguageKCL    = "kcl"
 	SchemaLanguagePython = "python"
+	SchemaLanguageRust   = "rust"
 )
 
 // SupportedSchemaLanguages returns the set of language identifiers accepted
@@ -63,6 +64,7 @@ func SupportedSchemaLanguages() []string {
 		SchemaLanguageJSON,
 		SchemaLanguageKCL,
 		SchemaLanguagePython,
+		SchemaLanguageRust,
 	}
 }
 
@@ -133,7 +135,7 @@ type ProjectPackageMetadata struct {
 // produced both for the project's own XRDs and for its declared dependencies.
 type ProjectSchemas struct {
 	// Languages restricts schema generation to the listed languages.
-	// Supported values are "go", "json", "kcl", and "python". If not
+	// Supported values are "go", "json", "kcl", "python", and "rust". If not
 	// specified, schemas are generated for all supported languages.
 	Languages []string `json:"languages,omitempty"`
 }

cmd/crossplane/function/generate.go

@@ -57,6 +57,9 @@ var (
 	kclTemplates embed.FS
 	//go:embed all:templates/python
 	pythonTemplates embed.FS
+	// The rust template contains a .gitignore, which embed skips without all.
+	//go:embed all:templates/rust
+	rustTemplates embed.FS
 	//go:embed templates/go-templating/*
 	goTemplatingTemplates embed.FS
 
@@ -70,7 +73,7 @@ var (
 type generateCmd struct {
 	Name         string `arg:""                    help:"Name of the function to generate. Must be a valid DNS-1035 label."`
 	PipelinePath string `arg:""                    help:"Path to a Composition YAML file to add a pipeline step to."        optional:""`
-	Language     string `default:"go-templating"   enum:"go,go-templating,kcl,python"                                       help:"Language to use for the function." short:"l"`
+	Language     string `default:"go-templating"   enum:"go,go-templating,kcl,python,rust"                                  help:"Language to use for the function." short:"l"`
 	ProjectFile  string `default:"${project_file}" help:"Path to project definition file."                                  short:"f"`
 
 	projFS            afero.Fs
@@ -180,6 +183,7 @@ func (c *generateCmd) Run(sp terminal.SpinnerPrinter, cfg *config.Config) error
 		"go-templating": c.generateGoTemplatingFiles,
 		"kcl":           c.generateKCLFiles,
 		"python":        c.generatePythonFiles,
+		"rust":          c.generateRustFiles,
 	}
 
 	generator, ok := generators[c.Language]
@@ -341,6 +345,52 @@ func (c *generateCmd) generatePythonFiles(targetFS afero.Fs) error {
 	return renderTemplates(afero.NewBasePathFs(targetFS, "function"), tmpls, data)
 }
 
+type rustTemplateData struct {
+	Name        string
+	HasSchemas  bool
+	SchemasPath string
+}
+
+func (c *generateCmd) generateRustFiles(targetFS afero.Fs) error {
+	hasSchemas, err := afero.DirExists(c.schemasFS, "rust")
+	if err != nil {
+		return errors.Wrap(err, "cannot inspect rust schemas directory")
+	}
+	if hasSchemas {
+		entries, err := afero.ReadDir(c.schemasFS, "rust")
+		if err != nil {
+			return errors.Wrap(err, "cannot read rust schemas directory")
+		}
+		hasSchemas = len(entries) > 0
+	}
+
+	// Compute the relative path from the function dir to schemas/rust/.
+	fnDir := filepath.Join("/", c.proj.Spec.Paths.Functions, c.Name)
+	relRoot, err := filepath.Rel(fnDir, "/")
+	if err != nil {
+		return errors.Wrap(err, "cannot determine path to schemas directory")
+	}
+	schemasPath := filepath.ToSlash(filepath.Join(relRoot, c.proj.Spec.Paths.Schemas, "rust"))
+
+	// template.ParseFS doesn't handle subdirectories, so we need to template
+	// the top-level directory and the 'src' sub-directory separately.
+	data := rustTemplateData{
+		Name:        c.Name,
+		HasSchemas:  hasSchemas,
+		SchemasPath: schemasPath,
+	}
+	tmpls := template.Must(template.ParseFS(rustTemplates, "templates/rust/*.*"))
+	if err := renderTemplates(targetFS, tmpls, data); err != nil {
+		return err
+	}
+
+	if err := targetFS.Mkdir("src", 0o755); err != nil {
+		return errors.Wrap(err, "cannot create src directory")
+	}
+	tmpls = template.Must(template.ParseFS(rustTemplates, "templates/rust/src/*.*"))
+	return renderTemplates(afero.NewBasePathFs(targetFS, "src"), tmpls, data)
+}
+
 type goTemplateData struct {
 	ModulePath string
 	Imports    []goImport

cmd/crossplane/function/generate_test.go

@@ -233,6 +233,75 @@ func TestGeneratePythonFiles(t *testing.T) {
 	}
 }
 
+func TestGenerateRustFiles(t *testing.T) {
+	cases := map[string]struct {
+		seedSchemas     map[string][]byte
+		seedSchemaDirs  []string
+		wantFiles       []string
+		wantContains    map[string][]byte
+		wantNotContains map[string][]byte
+	}{
+		"NoSchemas": {
+			wantFiles: []string{
+				".gitignore",
+				"Cargo.toml",
+				"README.md",
+				"rust-toolchain.toml",
+				"src/main.rs",
+				"src/function.rs",
+			},
+			wantContains: map[string][]byte{
+				"Cargo.toml": []byte(`name = "my-func"`),
+				"README.md":  []byte("# my-func"),
+			},
+			wantNotContains: map[string][]byte{
+				"Cargo.toml":      []byte("crossplane-models"),
+				"README.md":       []byte("crossplane-models"),
+				"src/function.rs": []byte("crossplane_models"),
+			},
+		},
+		"WithSchemas": {
+			seedSchemas: map[string][]byte{
+				"rust/Cargo.toml": nil,
+			},
+			wantContains: map[string][]byte{
+				"Cargo.toml":      []byte(`crossplane-models = { path = "../../schemas/rust" }`),
+				"README.md":       []byte("`../../schemas/rust`"),
+				"src/function.rs": []byte("use crossplane_models::"),
+			},
+		},
+		"EmptySchemasDirectory": {
+			seedSchemaDirs: []string{"rust"},
+			wantNotContains: map[string][]byte{
+				"Cargo.toml": []byte("crossplane-models"),
+			},
+		},
+	}
+
+	for name, tc := range cases {
+		t.Run(name, func(t *testing.T) {
+			schemasFS := seedFS(t, tc.seedSchemas)
+			for _, dir := range tc.seedSchemaDirs {
+				if err := schemasFS.MkdirAll(dir, 0o755); err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			c := &generateCmd{
+				Name:      "my-func",
+				schemasFS: schemasFS,
+				proj:      testProject(),
+			}
+			fs := afero.NewMemMapFs()
+			if err := c.generateRustFiles(fs); err != nil {
+				t.Fatal(err)
+			}
+			assertFiles(t, fs, tc.wantFiles)
+			assertContains(t, fs, tc.wantContains, tc.wantNotContains)
+		})
+	}
+}
+
 func TestGenerateGoFiles(t *testing.T) {
 	cases := map[string]struct {
 		seedSchemas  map[string][]byte

cmd/crossplane/function/help/generate.md

@@ -11,6 +11,7 @@ The following are valid arguments to the `--language` / `-l` flag:
 - `go`
 - `kcl`
 - `python`
+- `rust`
 
 ## Examples
 
@@ -27,6 +28,12 @@ Create a Python function in `functions/fn2`:
 crossplane function generate fn2 --language python
 ```
 
+Create a Rust function in `functions/fn3`:
+
+```shell
+crossplane function generate fn3 --language rust
+```
+
 Create a Go function in `functions/compose-cluster` and add it as a pipeline
 step in the given Composition:
 

cmd/crossplane/function/templates/rust/.gitignore.tmpl

@@ -0,0 +1 @@
+target/

cmd/crossplane/function/templates/rust/Cargo.toml.tmpl

@@ -0,0 +1,37 @@
+[package]
+name = "{{ .Name }}"
+version = "0.1.0"
+edition = "2024"
+license = "Apache-2.0"
+publish = false
+description = "A Crossplane composition function."
+
+# The function image runs this binary, whatever the package is called.
+[[bin]]
+name = "function"
+path = "src/main.rs"
+
+[dependencies]
+function-sdk-rust = "0.3"
+tonic = "0.14"
+tokio = { version = "1", features = ["rt-multi-thread", "macros"] }
+clap = { version = "4", features = ["derive", "env"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tracing = "0.1"
+{{- if .HasSchemas }}
+# Every generated model. To compile only the API groups this function imports,
+# add default-features = false and list their features, which
+# {{ .SchemasPath }}/Cargo.toml names.
+crossplane-models = { path = "{{ .SchemasPath }}" }
+{{- end }}
+
+[lints.rust]
+unsafe_code = "forbid"
+
+[lints.clippy]
+all = { level = "warn", priority = -1 }
+
+# Function images should be small.
+[profile.release]
+strip = true

cmd/crossplane/function/templates/rust/README.md.tmpl

@@ -0,0 +1,30 @@
+# {{ .Name }}
+
+A Crossplane composition function written in Rust with
+[function-sdk-rust](https://github.com/crossplane/function-sdk-rust).
+
+- Build: `cargo build`
+- Test: `cargo test`
+- Lint: `cargo clippy --all-targets -- -D warnings`
+- Format: `cargo fmt`
+- Run locally without mTLS: `cargo run -- --insecure`
+- Package: `crossplane project build` from the project root
+
+Cargo writes `Cargo.lock` on the first build. Commit it to have
+`crossplane project build` resolve the same dependency versions every time: the
+build uses the lock file when there is one.
+{{- if .HasSchemas }}
+
+Typed models for this project's XRDs and its dependencies are generated into
+`{{ .SchemasPath }}` as the `crossplane-models` crate, which this function
+depends on by path. Each API group and version is a module named after the
+reversed group, and exports every type of that version. The kinds of
+`platform.example.org/v1alpha1` are imported like this:
+
+```rust
+use crossplane_models::org::example::platform::v1alpha1::{XBucket, XBucketSpec};
+```
+
+The models are regenerated by `crossplane project build` and
+`crossplane dependency add`.
+{{- end }}

cmd/crossplane/function/templates/rust/rust-toolchain.toml

@@ -0,0 +1,6 @@
+# The toolchain for working on this function, with the components that format
+# and lint it. crossplane project build compiles with the toolchain of its build
+# image instead.
+[toolchain]
+channel = "stable"
+components = ["clippy", "rustfmt"]

cmd/crossplane/function/templates/rust/src/function.rs.tmpl

@@ -0,0 +1,84 @@
+//! A Crossplane composition function.
+
+use function_sdk_rust::proto::v1::function_runner_service_server::FunctionRunnerService;
+use function_sdk_rust::proto::v1::{RunFunctionRequest, RunFunctionResponse};
+use function_sdk_rust::response;
+use tonic::{Request, Response, Status};
+
+/// The composition function.
+#[derive(Debug, Default)]
+pub struct Function;
+
+#[tonic::async_trait]
+impl FunctionRunnerService for Function {
+    async fn run_function(
+        &self,
+        request: Request<RunFunctionRequest>,
+    ) -> Result<Response<RunFunctionResponse>, Status> {
+        let req = request.into_inner();
+        let tag = req.meta.as_ref().map(|m| m.tag.clone()).unwrap_or_default();
+        tracing::info!(tag, "running function");
+
+        let mut rsp = response::to(&req, response::DEFAULT_TTL);
+
+        // Add your composition logic here. For example, read the observed
+        // composite resource with function_sdk_rust::resource::get, and compose
+        // desired resources by updating rsp.desired.resources with
+        // function_sdk_rust::resource::update.
+{{- if .HasSchemas }}
+        //
+        // Both take any serde type, including the models generated for this
+        // project in the crossplane-models crate. A kind of
+        // platform.example.org/v1alpha1 is read like this:
+        //
+        //     use crossplane_models::org::example::platform::v1alpha1::XBucket;
+        //
+        //     let observed = req.observed.as_ref().and_then(|s| s.composite.as_ref());
+        //     let xr: XBucket = function_sdk_rust::resource::get(observed)
+        //         .map_err(|e| Status::invalid_argument(e.to_string()))?;
+{{- end }}
+
+        response::normal(&mut rsp, "Function completed successfully");
+
+        Ok(Response::new(rsp))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use function_sdk_rust::proto::v1::{Resource, State};
+    use function_sdk_rust::resource;
+
+    #[tokio::test]
+    async fn responds_to_an_observed_composite_resource() {
+        let mut composite = Resource::default();
+        resource::update(
+            &mut composite,
+            &serde_json::json!({
+                "apiVersion": "example.crossplane.io/v1alpha1",
+                "kind": "Example",
+                "metadata": {"name": "example"},
+                "spec": {},
+            }),
+        )
+        .unwrap();
+
+        let req = RunFunctionRequest {
+            observed: Some(State {
+                composite: Some(composite),
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+
+        let rsp = Function
+            .run_function(Request::new(req))
+            .await
+            .unwrap()
+            .into_inner();
+
+        let messages: Vec<_> = rsp.results.iter().map(|r| r.message.as_str()).collect();
+        assert_eq!(messages, ["Function completed successfully"]);
+    }
+}

cmd/crossplane/function/templates/rust/src/main.rs

@@ -0,0 +1,13 @@
+//! The composition function's CLI entrypoint.
+
+use clap::Parser;
+use function_sdk_rust::{Args, logging, serve};
+
+mod function;
+
+#[tokio::main]
+async fn main() -> Result<(), function_sdk_rust::Error> {
+    let args = Args::parse();
+    logging::configure(args.debug);
+    serve(function::Function, &args).await
+}