BF: qhost should parse entries of hosts in unknown state

Author: dgruber

pkg/helper/helper_suite_test.go

@@ -16,6 +16,7 @@
 *
 ************************************************************************/
 /*___INFO__MARK_END__*/
+
 package helper_test
 
 import (

pkg/helper/memory.go

@@ -42,6 +42,11 @@ func ParseMemoryFromString(m string) (int64, error) {
 		return 0, errors.New("empty string")
 	}
 
+	// special value for unknown memory
+	if m == "-" {
+		return 0, nil
+	}
+
 	if m == "0" || m == "0.0" || m == "0.00" || m == "0.000" {
 		return 0, nil
 	}

pkg/qhost/v9.0/parsers.go

@@ -68,19 +68,20 @@ func ParseHosts(out string) ([]Host, error) {
 			return nil, fmt.Errorf("invalid NCPU: %s", fields[2])
 		}
 
-		host.NSOC, err = strconv.Atoi(fields[3])
+		host.NSOC, err = ParseIntOrUnknown(fields[3])
 		if err != nil {
 			return nil, fmt.Errorf("invalid NSOC: %s", fields[3])
 		}
-		host.NCOR, err = strconv.Atoi(fields[4])
+
+		host.NCOR, err = ParseIntOrUnknown(fields[4])
 		if err != nil {
 			return nil, fmt.Errorf("invalid NCOR: %s", fields[4])
 		}
-		host.NTHR, err = strconv.Atoi(fields[5])
+		host.NTHR, err = ParseIntOrUnknown(fields[5])
 		if err != nil {
 			return nil, fmt.Errorf("invalid NTHR: %s", fields[5])
 		}
-		host.LOAD, err = strconv.ParseFloat(fields[6], 64)
+		host.LOAD, err = ParseFloatOrUnknown(fields[6])
 		if err != nil {
 			return nil, fmt.Errorf("invalid LOAD: %s", fields[6])
 		}
@@ -105,6 +106,24 @@ func ParseHosts(out string) ([]Host, error) {
 	return hosts, nil
 }
 
+func ParseIntOrUnknown(v string) (int, error) {
+	if v == "-" {
+		return 0, nil
+	}
+	ret, err := strconv.Atoi(v)
+	if err != nil {
+		return 0, fmt.Errorf("no int or -: %s", v)
+	}
+	return ret, nil
+}
+
+func ParseFloatOrUnknown(v string) (float64, error) {
+	if v == "-" {
+		return 0, nil
+	}
+	return strconv.ParseFloat(v, 64)
+}
+
 /*
 HOSTNAME                ARCH         NCPU NSOC NCOR NTHR  LOAD  MEMTOT  MEMUSE  SWAPTO  SWAPUS
 ----------------------------------------------------------------------------------------------

pkg/qhost/v9.0/parsers_test.go

@@ -16,6 +16,15 @@ global                  -               -    -    -    -     -       -       -
 master                  lx-amd64        4    1    4    4  0.31   15.6G  422.9M    1.5G     0.0
 exec                    lx-amd64        4    1    4    4  0.31   15.6G  422.9M    1.5G     0.0
 `
+
+	sampleWithUnknownHost := `
+HOSTNAME                ARCH         NCPU NSOC NCOR NTHR  LOAD  MEMTOT  MEMUSE  SWAPTO  SWAPUS
+----------------------------------------------------------------------------------------------
+global                  -               -    -    -    -     -       -       -       -       -
+valid                   lx-amd64        4    1    4    4  0.31   15.6G  422.9M    1.5G     0.0
+unknown                 lx-amd64       14    -    -    -     -    7.7G       -    1.5G       -
+`
+
 	Context("ParseQhostOutput", func() {
 
 		It("should return error if output is invalid", func() {
@@ -46,6 +55,35 @@ exec                    lx-amd64        4    1    4    4  0.31   15.6G  422.9M
 			Expect(hosts[1].SWAPUS).To(Equal(int64(0.0)))
 		})
 
+		It("should parse without issues when host is unknown", func() {
+			hosts, err := qhost.ParseHosts(sampleWithUnknownHost)
+			Expect(err).To(BeNil())
+			Expect(hosts).To(HaveLen(2))
+			Expect(hosts[0].Name).To(Equal("valid"))
+			Expect(hosts[0].Arch).To(Equal("lx-amd64"))
+			Expect(hosts[0].NCPU).To(Equal(4))
+			Expect(hosts[0].NSOC).To(Equal(1))
+			Expect(hosts[0].NCOR).To(Equal(4))
+			Expect(hosts[0].NTHR).To(Equal(4))
+			Expect(hosts[0].LOAD).To(Equal(0.31))
+			Expect(hosts[0].MEMTOT).To(Equal(int64(156 * 1024 * 1024 * 1024 / 10)))
+			Expect(hosts[0].MEMUSE).To(Equal(int64(4229 * 1024 * 1024 / 10)))
+			Expect(hosts[0].SWAPTO).To(Equal(int64(1.5 * 1024 * 1024 * 1024)))
+			Expect(hosts[0].SWAPUS).To(Equal(int64(0.0)))
+			Expect(hosts[1].Name).To(Equal("unknown"))
+			Expect(hosts[1].Arch).To(Equal("lx-amd64"))
+			Expect(hosts[1].NCPU).To(Equal(14))
+			Expect(hosts[1].NSOC).To(Equal(0))
+			Expect(hosts[1].NCOR).To(Equal(0))
+			Expect(hosts[1].NTHR).To(Equal(0))
+			Expect(hosts[1].LOAD).To(Equal(0.0))
+			Expect(hosts[1].MEMTOT).To(Equal(int64(77 * 1024 * 1024 * 1024 / 10)))
+			Expect(hosts[1].MEMUSE).To(Equal(int64(0)))
+			Expect(hosts[1].SWAPTO).To(Equal(int64(1.5 * 1024 * 1024 * 1024)))
+			Expect(hosts[1].SWAPUS).To(Equal(int64(0.0)))
+
+		})
+
 	})
 
 	Context("ParseHostFullMetrics", func() {
@@ -435,6 +473,9 @@ master                  lx-amd64       14    1   14   14  1.50    7.7G    2.0G 1
    hl:np_load_short=0.119286
    hl:np_load_medium=0.107143
    hl:np_load_long=0.078571
+unknown                lx-amd64       14    -   -   -  -    7.7G    - 1024.0M   -
+   hl:arch=lx-amd64
+   hl:num_proc=14.000000
    `
 
 		It("should return error if output is invalid", func() {
@@ -455,20 +496,12 @@ master                  lx-amd64       14    1   14   14  1.50    7.7G    2.0G 1
 		It("should parse host full metrics with global host values", func() {
 			hosts, err := qhost.ParseHostFullMetrics(qhostFOutput2)
 			Expect(err).To(BeNil())
-			Expect(hosts).To(HaveLen(2))
+			Expect(hosts).To(HaveLen(3))
 			Expect(hosts[0].Name).To(Equal("global"))
 			Expect(hosts[1].Name).To(Equal("master"))
-			Expect(len(hosts[0].Resources)).To(Equal(1))
-			Expect(hosts[0].Resources["testc"]).To(Equal(
-				qhost.ResourceAvailability{
-					Name:                          "testc",
-					StringValue:                   "100000.000000",
-					FloatValue:                    100000.000000,
-					ResourceAvailabilityLimitedBy: "g",
-					Source:                        "c",
-					FullString:                    "gc:testc=100000.000000",
-				},
-			))
+			Expect(hosts[2].Name).To(Equal("unknown"))
+			Expect(len(hosts[2].Resources)).To(Equal(0))
+			Expect(hosts[2].MemUsed).To(Equal(int64(0)))
 		})
 
 	})