feat: start cloudinit package

Author: erlnby

bridge.go

@@ -0,0 +1,66 @@
+package main
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+)
+
+func SetupNetworkBridge(bridgeName string, ethInterface string, tapInterface string, originalIP string) error {
+	if err := runCommand("ip", "link", "add", "name", bridgeName, "type", "bridge"); err != nil {
+		return fmt.Errorf("failed to create bridge: %v", err)
+	}
+
+	if err := runCommand("ip", "link", "set", "dev", bridgeName, "up"); err != nil {
+		return cleanupBridge(bridgeName, fmt.Errorf("failed to bring bridge up: %v", err))
+	}
+
+	if err := runCommand("ip", "link", "set", ethInterface, "master", bridgeName); err != nil {
+		return cleanupBridge(bridgeName, fmt.Errorf("failed to add %s to bridge: %v", ethInterface, err))
+	}
+
+	if err := runCommand("ip", "link", "set", "dev", ethInterface, "up"); err != nil {
+		return cleanupBridge(bridgeName, fmt.Errorf("failed to bring %s up: %v", ethInterface, err))
+	}
+
+	if err := runCommand("ip", "tuntap", "add", "dev", tapInterface, "mode", "tap"); err != nil {
+		return cleanupBridge(bridgeName, fmt.Errorf("failed to create tap interface: %v", err))
+	}
+
+	if err := runCommand("ip", "link", "set", tapInterface, "master", bridgeName); err != nil {
+		return cleanupTap(tapInterface, cleanupBridge(bridgeName,
+			fmt.Errorf("failed to add tap to bridge: %v", err)))
+	}
+
+	if err := runCommand("ip", "link", "set", tapInterface, "up"); err != nil {
+		return cleanupTap(tapInterface, cleanupBridge(bridgeName,
+			fmt.Errorf("failed to bring tap up: %v", err)))
+	}
+
+	if originalIP != "" {
+		if err := runCommand("ip", "addr", "del", originalIP, "dev", ethInterface); err != nil {
+			return cleanupTap(tapInterface, cleanupBridge(bridgeName,
+				fmt.Errorf("failed to remove IP from %s: %v", ethInterface, err)))
+		}
+	}
+
+	return nil
+}
+
+func runCommand(command string, args ...string) error {
+	cmd := exec.Command(command, args...)
+	if output, err := cmd.CombinedOutput(); err != nil {
+		return fmt.Errorf("%s: %v, output: %s", strings.Join(cmd.Args, " "), err, string(output))
+	}
+	return nil
+}
+
+func cleanupBridge(bridgeName string, err error) error {
+	_ = runCommand("ip", "link", "del", bridgeName)
+	return err
+}
+
+func cleanupTap(tapName string, err error) error {
+	_ = runCommand("ip", "link", "del", tapName)
+	return err
+}

cloud-init.sh

@@ -0,0 +1,25 @@
+package cloudinit
+
+import (
+	"fmt"
+	"os/exec"
+)
+
+func CreateCloudInitISO(outputFile string) error {
+	cmd := exec.Command(
+		"genisoimage",
+		"-o", outputFile,
+		"-volid", "cidata",
+		"-joliet", "-rock",
+		"ci-config/user-data",
+		"ci-config/meta-data",
+		"ci-config/network-config",
+	)
+
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("error creating ISO: %v\nOutput: %s", err, string(output))
+	}
+
+	return nil
+}

cloudinit/iso.go

@@ -0,0 +1,36 @@
+package cloudinit
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"gopkg.in/yaml.v3"
+)
+
+type MetaData struct {
+	InstanceID    string `yaml:"instance-id"`
+	LocalHostname string `yaml:"local-hostname"`
+}
+
+func GenerateMetaData(instanceID, localHostname string) (string, error) {
+	config := MetaData{
+		InstanceID:    instanceID,
+		LocalHostname: localHostname,
+	}
+
+	yamlData, err := yaml.Marshal(&config)
+	if err != nil {
+		return "", fmt.Errorf("error marshal YAML: %w", err)
+	}
+
+	tmpDir := os.TempDir()
+	filePath := filepath.Join(tmpDir, "meta-data")
+
+	err = os.WriteFile(filePath, []byte(yamlData), 0644)
+	if err != nil {
+		return "", fmt.Errorf("error writing file: %w", err)
+	}
+
+	return filePath, nil
+}

cloudinit/metadata.go

@@ -0,0 +1,54 @@
+package cloudinit
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"gopkg.in/yaml.v3"
+)
+
+var DefaultNetplanConfig = NetplanConfig{
+	Version: 2,
+	Ethernets: map[string]Ethernet{
+		"ens3": {
+			DHCP4: false,
+			Nameservers: Nameserver{
+				Addresses: []string{"8.8.8.8", "1.1.1.1"},
+			},
+		},
+	},
+}
+
+type NetplanConfig struct {
+	Version   int                 `yaml:"version"`
+	Ethernets map[string]Ethernet `yaml:"ethernets"`
+}
+
+type Nameserver struct {
+	Addresses []string `yaml:"addresses"`
+}
+
+type Ethernet struct {
+	DHCP4       bool       `yaml:"dhcp4"`
+	Addresses   []string   `yaml:"addresses"`
+	Gateway4    string     `yaml:"gateway4"`
+	Nameservers Nameserver `yaml:"nameservers"`
+}
+
+func GenerateNetplanConfig(netplanConfig *NetplanConfig) (string, error) {
+	yamlData, err := yaml.Marshal(&netplanConfig)
+	if err != nil {
+		return "", fmt.Errorf("error marshal YAML: %w", err)
+	}
+
+	tmpDir := os.TempDir()
+	filePath := filepath.Join(tmpDir, "network-config")
+
+	err = os.WriteFile(filePath, []byte(yamlData), 0644)
+	if err != nil {
+		return "", fmt.Errorf("error writing file: %w", err)
+	}
+
+	return filePath, nil
+}

cloudinit/networkconfig.go

@@ -0,0 +1,60 @@
+package cloudinit
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"gopkg.in/yaml.v3"
+)
+
+var DefaultUserData = UserData{
+	Hostname:          "my-vm",
+	ManageEtcHosts:    true,
+	FQDN:              "my-vm",
+	User:              "user",
+	Password:          "",
+	SSHAuthorizedKeys: []string{},
+	Chpasswd: ChpasswdType{
+		Expire: false,
+	},
+	Users: []string{
+		"default",
+	},
+}
+
+type ChpasswdType struct {
+	Expire bool `yaml:"expire"`
+}
+
+type UserData struct {
+	Hostname          string       `yaml:"hostname"`
+	ManageEtcHosts    bool         `yaml:"manage_etc_hosts"`
+	FQDN              string       `yaml:"fqdn"`
+	User              string       `yaml:"user"`
+	Password          string       `yaml:"password"`
+	SSHAuthorizedKeys []string     `yaml:"ssh_authorized_keys"`
+	Chpasswd          ChpasswdType `yaml:"chpasswd"`
+	Users             []string     `yaml:"users"`
+}
+
+func CreateCloudInitFile(userData *UserData) (string, error) {
+	var config UserData
+
+	yamlData, err := yaml.Marshal(&config)
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal config: %v", err)
+	}
+
+	yamlContent := "#cloud-config\n" + string(yamlData)
+
+	tmpDir := os.TempDir()
+	filePath := filepath.Join(tmpDir, "user-data")
+
+	err = os.WriteFile(filePath, []byte(yamlContent), 0644)
+	if err != nil {
+		return "", fmt.Errorf("error writing file: %w", err)
+	}
+
+	return filePath, nil
+}

cloudinit/userdata.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+)
+
+func CreateDiskImage(baseImagePath, diskImagePath, diskSize string) error {
+	if _, err := os.Stat(baseImagePath); os.IsNotExist(err) {
+		return fmt.Errorf("base image %s does not exist", baseImagePath)
+	}
+
+	if _, err := os.Stat(diskImagePath); err == nil {
+		fmt.Printf("disk image %s already exists, skipping creation\n", diskImagePath)
+		return nil
+	}
+
+	cmd := exec.Command(
+		"qemu-img",
+		"create",
+		"-b", baseImagePath,
+		"-F", "qcow2",
+		"-f", "qcow2",
+		diskImagePath,
+		diskSize,
+	)
+
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("failed to create disk image: %v, output: %s", err, string(output))
+	}
+
+	if _, err := os.Stat(diskImagePath); os.IsNotExist(err) {
+		return fmt.Errorf("command succeeded but disk image %s was not created", diskImagePath)
+	}
+
+	return nil
+}

disk.go

@@ -1,13 +1,39 @@
+variable "GO_VERSION" {
+    default = null
+}
+
+variable "DESTDIR" {
+    default = "./bin"
+}
+
+variable "IMAGE" {
+    default = "erlnby/yadro-app"
+}
+
+target "_common" {
+    dockerfile = "runtime.Dockerfile"
+    args = {
+        GO_VERSION = GO_VERSION
+        BUILDKIT_CONTEXT_KEEP_GIT_DIR = 1
+    }
+}
+
 group "default" {
     targets = ["runtime", "ubuntu"]
 }
 
 target "runtime" {
-    dockerfile = "runtime.Dockerfile"
+    inherits = ["_common"]
     tags = ["devmachines/runtime"]
 }
 
 target "ubuntu" {
     dockerfile = "ubuntu.Dockerfile"
     tags = ["devmachines/ubuntu"]
 }
+
+target "binariy" {
+    inherits = ["_common"]
+    target = "binary"
+    output = ["${DESTDIR}/build"]
+}

docker-bake.hcl

@@ -1,3 +1,5 @@
 module github.com/utkin-tech/devmachines
 
 go 1.24.2
+
+require gopkg.in/yaml.v3 v3.0.1 // indirect