Implement ZTP plugin

Author: damyan

example/ztp_config.yaml

@@ -0,0 +1 @@
+provisioningScriptAddress: "http://[2001:db8::1]/ztp/provisioning.sh"

internal/api/ztp_config.go

@@ -0,0 +1,8 @@
+// SPDX-FileCopyrightText: 2024 SAP SE or an SAP affiliate company and IronCore contributors
+// SPDX-License-Identifier: MIT
+
+package api
+
+type ZTPConfig struct {
+	ProvisioningScriptAddress string `yaml:"provisioningScriptAddress"`
+}

main.go

@@ -39,6 +39,7 @@ import (
 	"github.com/ironcore-dev/fedhcp/plugins/onmetal"
 	"github.com/ironcore-dev/fedhcp/plugins/oob"
 	"github.com/ironcore-dev/fedhcp/plugins/pxeboot"
+	"github.com/ironcore-dev/fedhcp/plugins/ztp"
 	"k8s.io/apimachinery/pkg/util/sets"
 )
 
@@ -66,6 +67,7 @@ var desiredPlugins = []*plugins.Plugin{
 	&httpboot.Plugin,
 	&metal.Plugin,
 	&macfilter.Plugin,
+	&ztp.Plugin,
 }
 
 var (

plugins/ztp/plugin.go

@@ -0,0 +1,117 @@
+// SPDX-FileCopyrightText: 2025 SAP SE or an SAP affiliate company and IronCore contributors
+// SPDX-License-Identifier: MIT
+
+package ztp
+
+import (
+	"fmt"
+	"net/url"
+	"os"
+
+	"github.com/ironcore-dev/fedhcp/internal/api"
+	"gopkg.in/yaml.v2"
+
+	"github.com/coredhcp/coredhcp/handler"
+	"github.com/coredhcp/coredhcp/logger"
+	"github.com/coredhcp/coredhcp/plugins"
+	"github.com/insomniacslk/dhcp/dhcpv6"
+)
+
+var log = logger.GetLogger("plugins/ztp")
+
+// Plugin wraps plugin registration information
+var Plugin = plugins.Plugin{
+	Name:   "ztp",
+	Setup6: setup6,
+}
+
+var (
+	provisioningScript string
+)
+
+const (
+	optionZTPCode = 239
+)
+
+// args[0] = path to config file
+func parseArgs(args ...string) (string, error) {
+	if len(args) != 1 {
+		return "", fmt.Errorf("exactly one argument must be passed to the plugin, got %d", len(args))
+	}
+	return args[0], nil
+}
+
+func loadConfig(args ...string) (*api.ZTPConfig, error) {
+	path, err := parseArgs(args...)
+	if err != nil {
+		return nil, fmt.Errorf("invalid configuration: %v", err)
+	}
+
+	log.Debugf("Reading config file %s", path)
+	configData, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read config file: %v", err)
+	}
+
+	config := &api.ZTPConfig{}
+	if err = yaml.Unmarshal(configData, config); err != nil {
+		return nil, fmt.Errorf("failed to parse config file: %v", err)
+	}
+
+	return config, nil
+}
+
+func parseConfig(args ...string) (*url.URL, error) {
+	ztpConfig, err := loadConfig(args...)
+	if err != nil {
+		return nil, err
+	}
+	scriptURL, err := url.Parse(ztpConfig.ProvisioningScriptAddress)
+	if err != nil {
+		return nil, fmt.Errorf("invalid ztp script scriptURL: %v", err)
+	}
+
+	if (scriptURL.Scheme != "http" && scriptURL.Scheme != "https") || scriptURL.Host == "" || scriptURL.Path == "" {
+		return nil, fmt.Errorf("malformed ZTP script parameter, should be a valid URL")
+	}
+
+	return scriptURL, nil
+}
+
+func setup6(args ...string) (handler.Handler6, error) {
+	scriptURL, err := parseConfig(args...)
+	if err != nil {
+		return nil, err
+	}
+
+	provisioningScript = scriptURL.String()
+
+	log.Printf("loaded ZTP plugin for DHCPv6.")
+	return handler6, nil
+}
+
+func handler6(req, resp dhcpv6.DHCPv6) (dhcpv6.DHCPv6, bool) {
+	log.Debugf("Received DHCPv6 request: %s", req.Summary())
+
+	if provisioningScript == "" {
+		// nothing to do
+		return resp, false
+	}
+
+	var opt dhcpv6.Option
+
+	// TODO: ZTP check?
+	buf := []byte(provisioningScript)
+	opt = &dhcpv6.OptionGeneric{
+		OptionCode: optionZTPCode,
+		OptionData: buf,
+	}
+
+	if opt != nil {
+		resp.AddOption(opt)
+		log.Debugf("Added option %s", opt)
+	}
+
+	log.Debugf("Sent DHCPv6 response: %s", resp.Summary())
+	return resp, false
+}

plugins/ztp/plugin_test.go

@@ -0,0 +1,69 @@
+// SPDX-FileCopyrightText: 2025 SAP SE or an SAP affiliate company and IronCore contributors
+// SPDX-License-Identifier: MIT
+
+package ztp
+
+import (
+	"net"
+	"os"
+
+	"github.com/insomniacslk/dhcp/dhcpv6"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("ZTP Plugin", func() {
+	Describe("Configuration Loading", func() {
+		It("should return an error if the configuration file is missing", func() {
+			_, err := loadConfig("nonexistent.yaml")
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("should return an error if the configuration file is invalid", func() {
+			invalidConfigPath := "invalid_test_config.yaml"
+
+			file, err := os.CreateTemp(GinkgoT().TempDir(), invalidConfigPath)
+			Expect(err).NotTo(HaveOccurred())
+			defer func() {
+				_ = file.Close()
+			}()
+			Expect(os.WriteFile(file.Name(), []byte("Invalid YAML"), 0644)).To(Succeed())
+
+			_, err = loadConfig(file.Name())
+			Expect(err).To(HaveOccurred())
+		})
+	})
+
+	Describe("DHCPv6 Message Handling", func() {
+		It("should return ZTP option 239", func() {
+			req := createRequest("11:22:33:44:55:66")
+			stub, err := dhcpv6.NewMessage()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(stub).NotTo(BeNil())
+
+			stub.MessageType = dhcpv6.MessageTypeReply
+			resp, stop := handler6(req, stub)
+			Expect(stop).To(BeFalse())
+
+			opt := resp.GetOneOption(optionZTPCode).(*dhcpv6.OptionGeneric)
+			Expect(opt).NotTo(BeNil())
+			Expect(int(opt.OptionCode)).To(Equal(optionZTPCode))
+			Expect(opt.OptionData).To(Equal([]byte(provisioningScript)))
+		})
+	})
+})
+
+func createRequest(mac string) dhcpv6.DHCPv6 {
+	hwAddr, err := net.ParseMAC(mac)
+	Expect(err).NotTo(HaveOccurred())
+	Expect(hwAddr).NotTo(BeNil())
+
+	req, err := dhcpv6.NewMessage()
+	Expect(err).NotTo(HaveOccurred())
+	Expect(req).NotTo(BeNil())
+
+	req.MessageType = dhcpv6.MessageTypeRequest
+	req.AddOption(dhcpv6.OptRequestedOption(optionZTPCode))
+	return req
+}

plugins/ztp/suite_test.go

@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: 2025 SAP SE or an SAP affiliate company and IronCore contributors
+// SPDX-License-Identifier: MIT
+
+package ztp
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/ironcore-dev/fedhcp/internal/api"
+	"gopkg.in/yaml.v3"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"sigs.k8s.io/controller-runtime/pkg/envtest"
+	logf "sigs.k8s.io/controller-runtime/pkg/log"
+	"sigs.k8s.io/controller-runtime/pkg/log/zap"
+	//+kubebuilder:scaffold:imports
+)
+
+const (
+	pollingInterval               = 50 * time.Millisecond
+	eventuallyTimeout             = 3 * time.Second
+	consistentlyDuration          = 1 * time.Second
+	testConfigPath                = "config.yaml"
+	testZtpProvisioningScriptPath = "https://2001:db8::1/ztp/provisioning.sh"
+)
+
+var (
+	testEnv *envtest.Environment
+)
+
+func TestZTP(t *testing.T) {
+	SetDefaultConsistentlyPollingInterval(pollingInterval)
+	SetDefaultEventuallyPollingInterval(pollingInterval)
+	SetDefaultEventuallyTimeout(eventuallyTimeout)
+	SetDefaultConsistentlyDuration(consistentlyDuration)
+	RegisterFailHandler(Fail)
+
+	RunSpecs(t, "ZTP Plugin Suite")
+}
+
+var _ = BeforeSuite(func() {
+	logf.SetLogger(zap.New(zap.WriteTo(GinkgoWriter), zap.UseDevMode(true)))
+	log.Print("BeforeSuite: Runs once before all tests")
+
+	configFile := testConfigPath
+	config := &api.ZTPConfig{
+		ProvisioningScriptAddress: testZtpProvisioningScriptPath,
+	}
+	configData, err := yaml.Marshal(config)
+	Expect(err).NotTo(HaveOccurred())
+
+	file, err := os.CreateTemp(GinkgoT().TempDir(), configFile)
+	Expect(err).NotTo(HaveOccurred())
+	defer func() {
+		_ = file.Close()
+	}()
+	Expect(os.WriteFile(file.Name(), configData, 0644)).To(Succeed())
+
+	_, err = setup6(file.Name())
+	Expect(err).NotTo(HaveOccurred())
+	Expect(provisioningScript).NotTo(BeEmpty())
+})