Collector/Analyzer - Subnet Available

config/samples/troubleshoot_v1beta2_subnetavailable.yaml

@@ -0,0 +1,19 @@
+apiVersion: troubleshoot.sh/v1beta2
+kind: HostPreflight
+metadata:
+  name: subnet-available
+spec:
+  collectors:
+    # would output yes/no depending if there is a /22 available in 10.0.0.0/8
+    - subnetAvailable:
+      CIDRRangeAlloc: "10.0.0.0/8"
+      desiredCIDR: 22
+  analyzers:
+    - subnetAvailable:
+      outcomes:
+        - fail:
+          when: "no-subnet-available"
+          message: failed to find available subnet
+        - pass:
+          when: "a-subnet-is-available"
+          message: available /22 subnet found

go.mod

@@ -51,6 +51,7 @@ require (
 
 require (
 	cloud.google.com/go/compute/metadata v0.2.3 // indirect
+	github.com/apparentlymart/go-cidr v1.1.0 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
 	github.com/docker/distribution v2.8.1+incompatible // indirect
 	github.com/emicklei/go-restful/v3 v3.9.0 // indirect

go.sum

@@ -249,6 +249,8 @@ github.com/alexflint/go-filemutex v0.0.0-20171022225611-72bdc8eae2ae/go.mod h1:C
 github.com/andybalholm/brotli v1.0.1 h1:KqhlKozYbRtJvsPrrEeXcO+N2l6NYT5A2QAFmSULpEc=
 github.com/andybalholm/brotli v1.0.1/go.mod h1:loMXtMfwqflxFJPmdbJO0a3KNoPuLBgiu3qAvBg8x/Y=
 github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
+github.com/apparentlymart/go-cidr v1.1.0 h1:2mAhrMoF+nhXqxTzSZMUzDHkLjmIHC+Zzn4tdgBZjnU=
+github.com/apparentlymart/go-cidr v1.1.0/go.mod h1:EBcsNrHc3zQeuaeCeCtQruQm+n9/YjEn/vI25Lg7Gwc=
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
 github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY=

pkg/analyze/host_analyzer.go

@@ -38,6 +38,8 @@ func GetHostAnalyzer(analyzer *troubleshootv1beta2.HostAnalyze) (HostAnalyzer, b
 		return &AnalyzeHostTCPConnect{analyzer.TCPConnect}, true
 	case analyzer.IPV4Interfaces != nil:
 		return &AnalyzeHostIPV4Interfaces{analyzer.IPV4Interfaces}, true
+	case analyzer.SubnetAvailable != nil:
+		return &AnalyzeHostSubnetAvailable{analyzer.SubnetAvailable}, true
 	case analyzer.FilesystemPerformance != nil:
 		return &AnalyzeHostFilesystemPerformance{analyzer.FilesystemPerformance}, true
 	case analyzer.Certificate != nil:

pkg/analyze/host_subnetavailable.go

@@ -0,0 +1,82 @@
+package analyzer
+
+import (
+	"encoding/json"
+	"path/filepath"
+
+	"github.com/pkg/errors"
+	troubleshootv1beta2 "github.com/replicatedhq/troubleshoot/pkg/apis/troubleshoot/v1beta2"
+	"github.com/replicatedhq/troubleshoot/pkg/collect"
+)
+
+type AnalyzeHostSubnetAvailable struct {
+	hostAnalyzer *troubleshootv1beta2.SubnetAvailableAnalyze
+}
+
+func (a *AnalyzeHostSubnetAvailable) Title() string {
+	return hostAnalyzerTitleOrDefault(a.hostAnalyzer.AnalyzeMeta, "Subnet Available")
+}
+
+func (a *AnalyzeHostSubnetAvailable) IsExcluded() (bool, error) {
+	return isExcluded(a.hostAnalyzer.Exclude)
+}
+
+func (a *AnalyzeHostSubnetAvailable) Analyze(getCollectedFileContents func(string) ([]byte, error)) ([]*AnalyzeResult, error) {
+	hostAnalyzer := a.hostAnalyzer
+
+	name := filepath.Join("host-collectors/subnetAvailable", "result.json")
+	if hostAnalyzer.CollectorName != "" {
+		name = filepath.Join("host-collectors/subnetAvailable", hostAnalyzer.CollectorName+".json")
+	}
+	contents, err := getCollectedFileContents(name)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to get collected file")
+	}
+
+	isSubnetAvailable := &collect.SubnetAvailableResult{}
+	if err := json.Unmarshal(contents, isSubnetAvailable); err != nil {
+		return nil, errors.Wrap(err, "failed to unmarshal subnetAvailable result")
+	}
+
+	result := &AnalyzeResult{
+		Title: a.Title(),
+	}
+
+	for _, outcome := range hostAnalyzer.Outcomes {
+		if outcome.Fail != nil {
+			if outcome.Fail.When == "" {
+				result.IsFail = true
+				result.Message = outcome.Fail.Message
+				result.URI = outcome.Fail.URI
+
+				return []*AnalyzeResult{result}, nil
+			}
+
+			if string(isSubnetAvailable.Status) == outcome.Fail.When {
+				result.IsFail = true
+				result.Message = outcome.Fail.Message
+				result.URI = outcome.Fail.URI
+
+				return []*AnalyzeResult{result}, nil
+			}
+		} else if outcome.Pass != nil {
+			if outcome.Pass.When == "" {
+				result.IsPass = true
+				result.Message = outcome.Pass.Message
+				result.URI = outcome.Pass.URI
+
+				return []*AnalyzeResult{result}, nil
+			}
+
+			if string(isSubnetAvailable.Status) == outcome.Pass.When {
+				result.IsPass = true
+				result.Message = outcome.Pass.Message
+				result.URI = outcome.Pass.URI
+
+				return []*AnalyzeResult{result}, nil
+			}
+		}
+	}
+
+	return []*AnalyzeResult{result}, nil
+}

pkg/apis/troubleshoot/v1beta2/hostanalyzer_shared.go

@@ -86,6 +86,12 @@ type IPV4InterfacesAnalyze struct {
 	Outcomes      []*Outcome `json:"outcomes" yaml:"outcomes"`
 }
 
+type SubnetAvailableAnalyze struct {
+	AnalyzeMeta   `json:",inline" yaml:",inline"`
+	CollectorName string     `json:"collectorName,omitempty" yaml:"collectorName,omitempty"`
+	Outcomes      []*Outcome `json:"outcomes" yaml:"outcomes"`
+}
+
 type FilesystemPerformanceAnalyze struct {
 	AnalyzeMeta   `json:",inline" yaml:",inline"`
 	CollectorName string     `json:"collectorName,omitempty" yaml:"collectorName,omitempty"`
@@ -137,6 +143,8 @@ type HostAnalyze struct {
 
 	IPV4Interfaces *IPV4InterfacesAnalyze `json:"ipv4Interfaces,omitempty" yaml:"ipv4Interfaces,omitempty"`
 
+	SubnetAvailable *SubnetAvailableAnalyze `json:"subnetAvailable,omitempty" yaml:"subnetAvailable,omitempty"`
+
 	FilesystemPerformance *FilesystemPerformanceAnalyze `json:"filesystemPerformance,omitempty" yaml:"filesystemPerformance,omitempty"`
 
 	Certificate *CertificateAnalyze `json:"certificate,omitempty" yaml:"certificate,omitempty"`

pkg/apis/troubleshoot/v1beta2/hostcollector_shared.go

@@ -53,6 +53,12 @@ type IPV4Interfaces struct {
 	HostCollectorMeta `json:",inline" yaml:",inline"`
 }
 
+type SubnetAvailable struct {
+	HostCollectorMeta `json:",inline" yaml:",inline"`
+	CIDRRangeAlloc    string `json:"CIDRRangeAlloc" yaml:"CIDRRangeAlloc"`
+	DesiredCIDR       int    `json:"desiredCIDR" yaml:"desiredCIDR"`
+}
+
 type DiskUsage struct {
 	HostCollectorMeta `json:",inline" yaml:",inline"`
 	Path              string `json:"path"`
@@ -171,6 +177,7 @@ type HostCollect struct {
 	UDPPortStatus         *UDPPortStatus         `json:"udpPortStatus,omitempty" yaml:"udpPortStatus,omitempty"`
 	Kubernetes            *Kubernetes            `json:"kubernetes,omitempty" yaml:"kubernetes,omitempty"`
 	IPV4Interfaces        *IPV4Interfaces        `json:"ipv4Interfaces,omitempty" yaml:"ipv4Interfaces,omitempty"`
+	SubnetAvailable       *SubnetAvailable       `json:"subnetAvailable,omitempty" yaml:"subnetAvailable,omitempty"`
 	DiskUsage             *DiskUsage             `json:"diskUsage,omitempty" yaml:"diskUsage,omitempty"`
 	HTTP                  *HostHTTP              `json:"http,omitempty" yaml:"http,omitempty"`
 	Time                  *HostTime              `json:"time,omitempty" yaml:"time,omitempty"`

pkg/apis/troubleshoot/v1beta2/remote_collector_shared.go

@@ -56,6 +56,12 @@ type RemoteIPV4Interfaces struct {
 	RemoteCollectorMeta `json:",inline" yaml:",inline"`
 }
 
+type RemoteSubnetAvailable struct {
+	RemoteCollectorMeta `json:",inline" yaml:",inline"`
+	CIDRRangeAlloc      string `json:"CIDRRangeAlloc" yaml:"CIDRRangeAlloc"`
+	DesiredCIDR         int    `json:"desiredCIDR" yaml:"desiredCIDR"`
+}
+
 type RemoteDiskUsage struct {
 	RemoteCollectorMeta `json:",inline" yaml:",inline"`
 	Path                string `json:"path"`
@@ -149,6 +155,7 @@ type RemoteCollect struct {
 	TCPPortStatus         *RemoteTCPPortStatus         `json:"tcpPortStatus,omitempty" yaml:"tcpPortStatus,omitempty"`
 	UDPPortStatus         *RemoteUDPPortStatus         `json:"udpPortStatus,omitempty" yaml:"udpPortStatus,omitempty"`
 	IPV4Interfaces        *RemoteIPV4Interfaces        `json:"ipv4Interfaces,omitempty" yaml:"ipv4Interfaces,omitempty"`
+	SubnetAvailable       *RemoteSubnetAvailable       `json:"subnetAvailable,omitempty" yaml:"subnetAvailable,omitempty"`
 	DiskUsage             *RemoteDiskUsage             `json:"diskUsage,omitempty" yaml:"diskUsage,omitempty"`
 	HTTP                  *RemoteHTTP                  `json:"http,omitempty" yaml:"http,omitempty"`
 	Time                  *RemoteTime                  `json:"time,omitempty" yaml:"time,omitempty"`

pkg/collect/host_collector.go

@@ -45,6 +45,8 @@ func GetHostCollector(collector *troubleshootv1beta2.HostCollect, bundlePath str
 		return &CollectHostTCPConnect{collector.TCPConnect, bundlePath}, true
 	case collector.IPV4Interfaces != nil:
 		return &CollectHostIPV4Interfaces{collector.IPV4Interfaces, bundlePath}, true
+	case collector.SubnetAvailable != nil:
+		return &CollectHostSubnetAvailable{collector.SubnetAvailable, bundlePath}, true
 	case collector.FilesystemPerformance != nil:
 		return &CollectHostFilesystemPerformance{collector.FilesystemPerformance, bundlePath}, true
 	case collector.Certificate != nil: