Add wiring funcs for Kubernetes

Author: vaastav

plugins/kubernetes/ir.go

@@ -0,0 +1,20 @@
+package kubernetes
+
+import "github.com/blueprint-uservices/blueprint/blueprint/pkg/ir"
+
+// An IRNode representing a Kubernetes applicaiton deployment which is a collection of Kubernetes Pod + Service Deployment instances.
+type Application struct {
+	AppName string
+	Nodes   []ir.IRNode
+	Edges   []ir.IRNode
+}
+
+// Implements IRNode
+func (n *Application) Name() string {
+	return n.AppName
+}
+
+// Implements IRNode
+func (n *Application) String() string {
+	return ir.PrettyPrintNamespace(n.AppName, "KubeApp", n.Edges, n.Nodes)
+}

plugins/kubernetes/kubepod/wiring.go

@@ -0,0 +1,63 @@
+// Package kubepod is a plugin for instantiating multiple container instances in a single Kubernetes pod deployment.
+//
+// # Wiring Spec Usage
+//
+// To use the kubepod plugin in your wiring spec, you can declare a Kubernetes Pod Deployment, giving it a name and specifying which container instances to include
+//
+//	kubepod.NewKubePod(spec, "my_pod", "my_container_1", "my_container_2")
+//
+// You can add containers to existing pods:
+//
+//	kubepod.AddContainerToPod(spec, "my_pod", "my_container_3")
+//
+// To deploy an application-level service in a Kubernetes Pod, make sure you first deploy the service to a process (with the [goproc] plugin) and to a container image (with the [linuxcontainer] plugin)
+//
+// # Artifacts Generated
+//
+// During compilation, the plugin generates a `podName-deployment.yaml` file that instantiates the pod as a Kubernetes deployment and a `podName-service.yaml` file that converts the deployed pod into a Kubernetes service.
+//
+// # Running Artifacts
+//
+// You need to have a working kubernetes cluster and `kubectl` installed.
+// To deploy the pods to the cluster, use the following commands:
+//
+//	kubectl apply -f podName-deployment.yaml
+//	kubectl apply -f podName-service.yaml
+//
+// [linuxcontainer]: https://github.com/Blueprint-uServices/blueprint/tree/main/plugins/linuxcontainer
+// [goproc]: https://github.com/Blueprint-uServices/blueprint/tree/main/plugins/goproc
+package kubepod
+
+import (
+	"github.com/blueprint-uservices/blueprint/blueprint/pkg/coreplugins/namespaceutil"
+	"github.com/blueprint-uservices/blueprint/blueprint/pkg/ir"
+	"github.com/blueprint-uservices/blueprint/blueprint/pkg/wiring"
+)
+
+// [AddContainerToPod] can be used by wiring specs to add more containers to a pod
+func AddContainerToPod(spec wiring.WiringSpec, podName string, containerName string) {
+	namespaceutil.AddNodeTo[PodDeployment](spec, podName, containerName)
+}
+
+// [NewKubePod] can be used by wiring specs to create a Kubernetes Pod that instantiates a single Kubernetes Pod consisting of multiple containers.
+//
+// Further containers can be added to the Pod by calling [AddContainerToPod].
+//
+// During compilation, generates the deployment.yaml and service.yaml files for the pod.
+//
+// Returns podName
+func NewKubePod(spec wiring.WiringSpec, podName string, containers ...string) string {
+
+	// If any children were provided in this call, add them to the pod via a property
+	for _, containerName := range containers {
+		AddContainerToPod(spec, podName, containerName)
+	}
+
+	spec.Define(podName, &PodDeployment{}, func(ns wiring.Namespace) (ir.IRNode, error) {
+		pod := &PodDeployment{PodName: podName}
+		_, err := namespaceutil.InstantiateNamespace(ns, pod)
+		return pod, err
+	})
+
+	return podName
+}

plugins/kubernetes/wiring.go

@@ -0,0 +1,95 @@
+// Package kubernetes is a plugin for instantiating multiple container instances in a Kubernetes cluster.
+//
+// # Wiring Spec Usage
+//
+// To use the kubernetes plugin in your wiring spec, you can declare a Kuberenetes application, giving it a name and specifying which containers to include. Each container will be deployed in a separate pod in the Kubernetes cluster.
+//
+//	kubernetes.NewApplication(spec, "my_app", "my_container_1", "my_container_2")
+//
+// You can add more containers to an existing application:
+//
+//	kubernetes.AddContainerToDeployment(spec, "my_app", "my_container_3")
+//
+// You can also deploy multiple containers in a single pod:
+//
+//	kubernetes.AddPodToApplication(spec, "my_app", "my_container_4", "my_container_5")
+//
+// # Artifacts Generated
+//
+// During compilation, the plugin generates deployment.yaml and service.yaml files for each Pod.
+//
+// # Running Artifacts
+//
+// You need to have a working kubernetes cluster and `kubectl` installed.
+// To deploy the pods to the cluster, use the following commands:
+//
+//	kubectl apply -f podName-deployment.yaml
+//	kubectl apply -f podName-service.yaml
+//
+package kubernetes
+
+import (
+	"github.com/blueprint-uservices/blueprint/blueprint/pkg/coreplugins/namespaceutil"
+	"github.com/blueprint-uservices/blueprint/blueprint/pkg/ir"
+	"github.com/blueprint-uservices/blueprint/blueprint/pkg/wiring"
+	"github.com/blueprint-uservices/blueprint/plugins/kubernetes/kubepod"
+)
+
+// [AddContainerToApplication] can be used by wiring specs to add more containers to a Kubernetes application
+func AddContainerToApplication(spec wiring.WiringSpec, appName string, containerName string) {
+	AddPodToApplication(spec, appName, containerName)
+}
+
+// [AddPodToApplication] can be used by wiring specs to bundle multiple containers in a single Kubernetes Pod and add that pod to an application
+func AddPodToApplication(spec wiring.WiringSpec, appName string, containers ...string) {
+	podName := kubepod.NewKubePod(spec, containers[0], containers...)
+	namespaceutil.AddNodeTo[Application](spec, appName, podName)
+}
+
+// [NewApplication] can be used by wiring specs to create a Kubernetes Application that instantiates a number of kubernetes pod deployments as services. For each provided container, a new pod deployment is created with that container added to the pod.
+//
+// Further pod deployments for containers can be generated by calling [AddContainerToApplication].
+//
+// If one wishes to bundle multiple containers into a single pod, then that can be done by calling [AddPodToApplication]. Note that the containers provided to that must not have already been added to the application before.
+//
+// During compilation, generates the various configuration files for generating pod deployments and services.
+//
+// Returns appName
+func NewApplication(spec wiring.WiringSpec, appName string, containers ...string) string {
+
+	// If any children were provided in this call, add them to the app via a property
+	for _, containerName := range containers {
+		AddContainerToApplication(spec, appName, containerName)
+	}
+
+	spec.Define(appName, &Application{}, func(ns wiring.Namespace) (ir.IRNode, error) {
+		application := &Application{AppName: appName}
+		_, err := namespaceutil.InstantiateNamespace(ns, &applicationNamespace{application})
+		return application, err
+	})
+
+	return appName
+}
+
+// A [wiring.NamespaceHandler] used to build kubernetes deployments
+type applicationNamespace struct {
+	*Application
+}
+
+// Implements [wiring.NamespaceHandler]
+func (application *Application) Accepts(nodeType any) bool {
+	_, isPodDeploymentNode := nodeType.(kubepod.PodDeployment)
+	return isPodDeploymentNode
+}
+
+// Implements [wiring.NamespaceHandler]
+func (application *Application) AddEdge(name string, edge ir.IRNode) error {
+	application.Edges = append(application.Edges, edge)
+	return nil
+}
+
+// Implements [wiring.NamespaceHandler]
+func (application *Application) AddNode(name string, node ir.IRNode) error {
+	application.Nodes = append(application.Nodes, node)
+	return nil
+}