v1.0.0

.gitignore

+.idea
\ No newline at end of file

config/config.go

+package config
+
+import (
+	"flag"
+	"gopkg.in/yaml.v3"
+	"io/ioutil"
+)
+
+type Config struct {
+	NodeConnections []NodeConnection `yaml:"NodeConnections"`
+}
+
+type NodeConnection struct {
+	Node1               string   `yaml:"Node1"`
+	Node2               string   `yaml:"Node2"`
+	RequiredConnections []string `yaml:"RequiredConnections"`
+}
+
+var confFile = flag.String("config", "/opt/memory-defaults/config.yaml", "Config file to use")
+
+func LoadConfig() (*Config, error) {
+	file, err := ioutil.ReadFile(*confFile)
+	if err != nil {
+		return nil, err
+	}
+
+	var conf Config
+	err = yaml.Unmarshal(file, &conf)
+	if err != nil {
+		return nil, err
+	}
+	return &conf, nil
+}
+
+func (conf *Config) GetConnections() []Connection {
+	var con []Connection
+	for _, connections := range conf.NodeConnections {
+		for _, connection := range connections.RequiredConnections {
+			con = append(con, Connection{
+				Node1: connections.Node1,
+				Node2: connections.Node2,
+				Name:  connection,
+			})
+		}
+	}
+	return con
+}
+
+type Connection struct {
+	Node1 string
+	Node2 string
+	Name  string
+}

go.mod

+module memory-defaults
+
+go 1.18
+
+require gopkg.in/yaml.v3 v3.0.1 // indirect

go.sum

+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

linstor/add-connection.go

+package linstor
+
+import (
+	"memory-defaults/config"
+	"os"
+	"os/exec"
+)
+
+func AddConnection(res string, conn config.Connection) error {
+	cmd := exec.Command("linstor", "rc", "path", "create", conn.Node1, conn.Node2, res, conn.Name, conn.Name, conn.Name)
+	cmd.Stdout, cmd.Stderr = os.Stdout, os.Stderr
+	err := cmd.Run()
+	return err
+}

linstor/resource-def-list.go

+package linstor
+
+import (
+	"encoding/json"
+	"memory-defaults/config"
+	"os/exec"
+	"strings"
+)
+
+type ResourceDefinition struct {
+	RscName     string        `json:"rsc_name"`
+	RscDfnUuid  string        `json:"rsc_dfn_uuid"`
+	VlmDfns     []interface{} `json:"vlm_dfns"`
+	RscDfnProps []struct {
+		Key   string `json:"key"`
+		Value string `json:"value"`
+	} `json:"rsc_dfn_props"`
+	RscDfnPort   int    `json:"rsc_dfn_port"`
+	RscDfnSecret string `json:"rsc_dfn_secret"`
+}
+
+type RDGet struct {
+	Definitions []ResourceDefinition `json:"rsc_dfns"`
+}
+
+func ListResourceDefs() ([]ResourceDefinition, error) {
+	out, er := exec.Command("linstor", "-m", "rd", "list").CombinedOutput()
+	if er != nil {
+		return nil, er
+	}
+
+	var rds []RDGet
+	er = json.Unmarshal(out, &rds)
+
+	return rds[0].Definitions, er
+}
+
+type ResourceConnection struct {
+	NodeName1 string `json:"node_name_1"`
+	NodeName2 string `json:"node_name_2"`
+	Props     []struct {
+		Key   string `json:"key"`
+		Value string `json:"value"`
+	} `json:"props"`
+}
+
+func (rc *ResourceConnection) ToConnections() []config.Connection {
+	var paths = make(map[string]bool)
+	for _, prop := range rc.Props {
+		if strings.Contains(prop.Key, "Paths") {
+			paths[prop.Value] = true
+		}
+	}
+	var conns []config.Connection
+	for k := range paths {
+		conns = append(conns, config.Connection{
+			Node1: rc.NodeName1,
+			Node2: rc.NodeName2,
+			Name:  k,
+		})
+	}
+	return conns
+}
+
+type RCGet struct {
+	Conns []ResourceConnection `json:"rsc_connections"`
+}
+
+func ListResourceConnections(resourceName string) ([]ResourceConnection, error) {
+	out, er := exec.Command("linstor", "-m", "rc", "list", resourceName).CombinedOutput()
+	if er != nil {
+		return nil, er
+	}
+
+	var rcs []RCGet
+	er = json.Unmarshal(out, &rcs)
+
+	return rcs[0].Conns, er
+}

main.go

+package main
+
+import (
+	"flag"
+	"fmt"
+	"memory-defaults/config"
+	"memory-defaults/linstor"
+)
+
+func main() {
+	flag.Parse()
+	conf, err := config.LoadConfig()
+	if err != nil {
+		panic(err)
+	}
+
+	conns := conf.GetConnections()
+
+	res, err := linstor.ListResourceDefs()
+	if err != nil {
+		panic(err)
+	}
+
+	globalMissing := make(map[string][]*config.Connection)
+
+	for _, re := range res {
+		rcs, err := linstor.ListResourceConnections(re.RscName)
+		if err != nil {
+			panic(err)
+		}
+
+		var connsGood []*config.Connection
+		for _, rc := range rcs {
+			c := rc.ToConnections()
+			for _, has := range c {
+				for i, want := range conns {
+					if has.Node1 == want.Node1 && has.Node2 == want.Node2 && has.Name == want.Name {
+						connsGood = append(connsGood, &conns[i])
+					}
+					if has.Node1 == want.Node2 && has.Node2 == want.Node1 && has.Name == want.Name {
+						connsGood = append(connsGood, &conns[i])
+					}
+				}
+			}
+		}
+		var missingConns []*config.Connection
+		for i := range conns {
+			hasConnection := false
+			for _, c := range connsGood {
+				if c == &conns[i] {
+					hasConnection = true
+					break
+				}
+			}
+			if !hasConnection {
+				missingConns = append(missingConns, &conns[i])
+			}
+		}
+		if len(missingConns) != 0 {
+			globalMissing[re.RscName] = missingConns
+			fmt.Printf("%s is missing connections: \n", re.RscName)
+			for _, conn := range missingConns {
+				fmt.Printf("  %s -> %s on %s\n", conn.Node1, conn.Node2, conn.Name)
+			}
+		}
+	}
+
+	for resName, connections := range globalMissing {
+		for _, connection := range connections {
+			err := linstor.AddConnection(resName, *connection)
+			if err != nil {
+				panic(err)
+			}
+		}
+	}
+}