func ResizeReplicationController(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string, replicationControllerName string, delta int, maximumSize int, minimumSize int) (resized bool, size int, returnedError error) { defer func() { if err := recover(); err != nil { log.Error("ResizeReplicationController Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) resized = false size = -1 returnedError = err.(error) } }() headerMap := make(map[string]string) headerMap["Authorization"] = kubeApiServerToken url := kubeApiServerEndPoint + "/api/v1/namespaces/" + namespace + "/replicationcontrollers/" + replicationControllerName + "/" result, err := restclient.RequestGet(url, headerMap, true) jsonMap, _ := result.(map[string]interface{}) if err != nil { log.Error("Get replication controller information failure where delta: %d, endpoint: %s, token: %s, namespace: %s, replicationControllerName: %s, err: %s", delta, kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationControllerName, err.Error()) return false, -1, err } else { replicas, _ := jsonparse.ConvertToInt64(jsonMap["spec"].(map[string]interface{})["replicas"]) currentSize := int(replicas) newSize := currentSize + delta if newSize < minimumSize { newSize = minimumSize } if newSize > maximumSize { newSize = maximumSize } if newSize == currentSize { return false, currentSize, nil } jsonMap["spec"].(map[string]interface{})["replicas"] = float64(newSize) result, err := restclient.RequestPut(url, jsonMap, headerMap, true) resultJsonMap, _ := result.(map[string]interface{}) if err != nil { return false, currentSize, err } else { replicas, _ := jsonparse.ConvertToInt64(resultJsonMap["spec"].(map[string]interface{})["replicas"]) return true, int(replicas), nil } } }
func GetAllReplicationControllerAndRelatedPodSlice(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string) ( returnedReplicationControllerAndRelatedPodSlice []ReplicationControllerAndRelatedPod, returnedError error) { defer func() { if err := recover(); err != nil { log.Error("GetAllReplicationController Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) returnedReplicationControllerAndRelatedPodSlice = nil returnedError = err.(error) } }() headerMap := make(map[string]string) headerMap["Authorization"] = kubeApiServerToken result, err := restclient.RequestGet(kubeApiServerEndPoint+"/api/v1/namespaces/"+namespace+"/replicationcontrollers/", headerMap, true) replicationControllerJsonMap, _ := result.(map[string]interface{}) if err != nil { log.Error("Fail to get all replication controller inofrmation with endpoint %s, token: %s, namespace: %s, error %s", kubeApiServerEndPoint, kubeApiServerToken, namespace, err.Error()) return nil, err } else { result, err := restclient.RequestGet(kubeApiServerEndPoint+"/api/v1/namespaces/"+namespace+"/pods/", headerMap, true) podJsonMap, _ := result.(map[string]interface{}) if err != nil { log.Error("Fail to get all pod information with endpoint %s, token: %s, namespace: %s, error %s", kubeApiServerEndPoint, kubeApiServerToken, namespace, err.Error()) return nil, err } else { replicationControllerAndRelatedPodSlice := make([]ReplicationControllerAndRelatedPod, 0) itemSlice, _ := replicationControllerJsonMap["items"].([]interface{}) for _, item := range itemSlice { name, _ := item.(map[string]interface{})["metadata"].(map[string]interface{})["name"].(string) namespace, _ := item.(map[string]interface{})["metadata"].(map[string]interface{})["namespace"].(string) replicaAmount, _ := jsonparse.ConvertToInt64(item.(map[string]interface{})["spec"].(map[string]interface{})["replicas"]) aliveReplicaAmount, _ := jsonparse.ConvertToInt64(item.(map[string]interface{})["status"].(map[string]interface{})["replicas"]) selectorField, _ := item.(map[string]interface{})["spec"].(map[string]interface{})["selector"].(map[string]interface{}) labelField, _ := item.(map[string]interface{})["metadata"].(map[string]interface{})["labels"].(map[string]interface{}) selectorMap := make(map[string]string) for key, value := range selectorField { selectorMap[key], _ = value.(string) } labelMap := make(map[string]string) for key, value := range labelField { labelMap[key], _ = value.(string) } podSlice, _ := GetAllPodBelongToReplicationControllerFromData(name, podJsonMap) replicationControllerAndRelatedPod := ReplicationControllerAndRelatedPod{ name, namespace, int(replicaAmount), int(aliveReplicaAmount), selectorMap, labelMap, podSlice, } replicationControllerAndRelatedPodSlice = append(replicationControllerAndRelatedPodSlice, replicationControllerAndRelatedPod) } return replicationControllerAndRelatedPodSlice, nil } } }
func MonitorPod(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string, podName string) (returnedPodMetric *PodMetric, returnedError error) { defer func() { if err := recover(); err != nil { log.Error("MonitorPod Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) returnedPodMetric = nil returnedError = err.(error) } }() headerMap := make(map[string]string) headerMap["Authorization"] = kubeApiServerToken result, err := restclient.RequestGet(kubeApiServerEndPoint+"/api/v1/namespaces/"+namespace+"/pods/"+podName+"/", headerMap, true) jsonMap, _ := result.(map[string]interface{}) if err != nil { log.Error("Fail to get pod inofrmation with endpoint: %s, token: %s, namespace: %s, pod name: %s, error %s", kubeApiServerEndPoint, kubeApiServerToken, namespace, podName, err.Error()) return nil, err } urlSlice, containerNameSlice, kubeletHost := getContainerLocationFromPodInformation(jsonMap) jsonMap["container_url_slice"] = urlSlice dataSlice, errorSlice := getContainerMonitorData(urlSlice) jsonMap["container_monitor_data_slice"] = dataSlice jsonMap["container_monitor_error_slice"] = errorSlice podMetric := &PodMetric{} podMetric.KubeletHost = kubeletHost podMetric.Namespace = namespace podMetric.PodName = podName podMetric.ValidContainerSlice = make([]bool, len(dataSlice)) podMetric.ContainerMetricSlice = make([]ContainerMetric, len(dataSlice)) errorMessage := "The following index of container has error: " errorHappened := false for index, data := range dataSlice { if errorSlice[index] != nil { errorMessage = errorMessage + errorSlice[index].Error() podMetric.ValidContainerSlice[index] = false errorHappened = true } else { podMetric.ValidContainerSlice[index] = true podMetric.ContainerMetricSlice[index] = ContainerMetric{} podMetric.ContainerMetricSlice[index].ContainerName = containerNameSlice[index] length := len(data["stats"].([]interface{})) // CPU podMetric.ContainerMetricSlice[index].CpuUsageTotalSlice = make([]int64, length) // Memory podMetric.ContainerMetricSlice[index].MemoryUsageSlice = make([]int64, length) // Disk I/O podMetric.ContainerMetricSlice[index].DiskIOServiceBytesStatsTotalSlice = make([]int64, length) podMetric.ContainerMetricSlice[index].DiskIOServicedStatsTotalSlice = make([]int64, length) // Network podMetric.ContainerMetricSlice[index].NetworkRXBytesSlice = make([]int64, length) podMetric.ContainerMetricSlice[index].NetworkTXBytesSlice = make([]int64, length) podMetric.ContainerMetricSlice[index].NetworkRXPacketsSlice = make([]int64, length) podMetric.ContainerMetricSlice[index].NetworkTXPacketsSlice = make([]int64, length) for i := 0; i < length; i++ { // CPU podMetric.ContainerMetricSlice[index].CpuUsageTotalSlice[i], _ = jsonparse.ConvertToInt64(data["stats"].([]interface{})[i].(map[string]interface{})["cpu"].(map[string]interface{})["usage"].((map[string]interface{}))["total"]) // Memory podMetric.ContainerMetricSlice[index].MemoryUsageSlice[i], _ = jsonparse.ConvertToInt64(data["stats"].([]interface{})[i].(map[string]interface{})["memory"].(map[string]interface{})["usage"]) // Disk I/O ioServiceBytesSlice := data["stats"].([]interface{})[i].(map[string]interface{})["diskio"].(map[string]interface{})["io_service_bytes"] if ioServiceBytesSlice != nil { for _, ioServiceBytes := range ioServiceBytesSlice.([]interface{}) { value, _ := jsonparse.ConvertToInt64(ioServiceBytes.(map[string]interface{})["stats"].(map[string]interface{})["Total"]) podMetric.ContainerMetricSlice[index].DiskIOServiceBytesStatsTotalSlice[i] += value } } ioServicedSlice := data["stats"].([]interface{})[i].(map[string]interface{})["diskio"].(map[string]interface{})["io_serviced"] if ioServicedSlice != nil { for _, ioServiced := range ioServicedSlice.([]interface{}) { value, _ := jsonparse.ConvertToInt64(ioServiced.(map[string]interface{})["stats"].(map[string]interface{})["Total"]) podMetric.ContainerMetricSlice[index].DiskIOServicedStatsTotalSlice[i] += value } } // Network podMetric.ContainerMetricSlice[index].NetworkRXBytesSlice[i], _ = jsonparse.ConvertToInt64(data["stats"].([]interface{})[i].(map[string]interface{})["network"].(map[string]interface{})["rx_bytes"]) podMetric.ContainerMetricSlice[index].NetworkTXBytesSlice[i], _ = jsonparse.ConvertToInt64(data["stats"].([]interface{})[i].(map[string]interface{})["network"].(map[string]interface{})["tx_bytes"]) podMetric.ContainerMetricSlice[index].NetworkRXPacketsSlice[i], _ = jsonparse.ConvertToInt64(data["stats"].([]interface{})[i].(map[string]interface{})["network"].(map[string]interface{})["rx_packets"]) podMetric.ContainerMetricSlice[index].NetworkTXPacketsSlice[i], _ = jsonparse.ConvertToInt64(data["stats"].([]interface{})[i].(map[string]interface{})["network"].(map[string]interface{})["tx_packets"]) } } } if errorHappened { log.Error("Fail to get all container inofrmation with endpoint %s, token: %s, namespace: %s, pod name: %s, error %s", kubeApiServerEndPoint, kubeApiServerToken, namespace, podName, errorMessage) return podMetric, errors.New(errorMessage) } else { return podMetric, nil } }
func GetAllPodBelongToReplicationControllerFromData(replicationControllerName string, jsonMap map[string]interface{}) (returnedPodSlice []Pod, returnedError error) { defer func() { if err := recover(); err != nil { log.Error("GetAllPodBelongToReplicationControllerFromData Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) returnedPodSlice = nil returnedError = err.(error) } }() generateName := replicationControllerName + "-" podSlice := make([]Pod, 0) for _, data := range jsonMap["items"].([]interface{}) { generateNameField, _ := data.(map[string]interface{})["metadata"].(map[string]interface{})["generateName"].(string) nameField, nameFieldOk := data.(map[string]interface{})["metadata"].(map[string]interface{})["name"].(string) if generateName == generateNameField || replicationControllerName == nameField { if nameFieldOk { containerSlice := make([]PodContainer, 0) containerFieldSlice, containerFieldSliceOk := data.(map[string]interface{})["spec"].(map[string]interface{})["containers"].([]interface{}) containerStatusSlice, containerStatusSliceOk := data.(map[string]interface{})["status"].(map[string]interface{})["containerStatuses"].([]interface{}) if containerFieldSliceOk && containerStatusSliceOk { for _, containerField := range containerFieldSlice { portSlice := make([]PodContainerPort, 0) portFieldSlice, portFieldSliceOk := containerField.(map[string]interface{})["ports"].([]interface{}) if portFieldSliceOk { for _, portField := range portFieldSlice { portName, _ := portField.(map[string]interface{})["name"].(string) portContainerPort, _ := jsonparse.ConvertToInt64(portField.(map[string]interface{})["containerPort"]) portProtocol, _ := portField.(map[string]interface{})["protocol"].(string) podContainerPort := PodContainerPort{ portName, int(portContainerPort), portProtocol, } portSlice = append(portSlice, podContainerPort) } } containerName, _ := containerField.(map[string]interface{})["name"].(string) containerImage, _ := containerField.(map[string]interface{})["image"].(string) containerId := "" containerReady := false containerRestartCount := 0 for _, containerStatus := range containerStatusSlice { name, _ := containerStatus.(map[string]interface{})["name"].(string) if name == containerName { containerId, _ = containerStatus.(map[string]interface{})["containerID"].(string) containerReady, _ = containerStatus.(map[string]interface{})["ready"].(bool) restartCount, _ := jsonparse.ConvertToInt64(containerStatus.(map[string]interface{})["restartCount"]) containerRestartCount = int(restartCount) } } podContainer := PodContainer{ containerName, containerImage, containerId, containerRestartCount, containerReady, portSlice, } containerSlice = append(containerSlice, podContainer) } } namespace, _ := data.(map[string]interface{})["metadata"].(map[string]interface{})["namespace"].(string) creationTimestamp, _ := data.(map[string]interface{})["metadata"].(map[string]interface{})["creationTimestamp"].(string) createdTime, err := time.Parse(time.RFC3339, creationTimestamp) age := "" if err == nil { age = GetTheFirstTimeUnit(time.Now().Sub(createdTime)) } phase, _ := data.(map[string]interface{})["status"].(map[string]interface{})["phase"].(string) hostIP, _ := data.(map[string]interface{})["status"].(map[string]interface{})["hostIP"].(string) podIP, _ := data.(map[string]interface{})["status"].(map[string]interface{})["podIP"].(string) pod := Pod{ nameField, namespace, hostIP, podIP, phase, age, containerSlice, } podSlice = append(podSlice, pod) } } } return podSlice, nil }
func GetReplicationController(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string, replicationControllerName string) (replicationController *ReplicationController, returnedError error) { defer func() { if err := recover(); err != nil { log.Error("GetReplicationController Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) replicationController = nil returnedError = err.(error) } }() headerMap := make(map[string]string) headerMap["Authorization"] = kubeApiServerToken url := kubeApiServerEndPoint + "/api/v1/namespaces/" + namespace + "/replicationcontrollers/" + replicationControllerName result, err := restclient.RequestGet(url, headerMap, true) jsonMap, _ := result.(map[string]interface{}) if err != nil { return nil, err } else { replicationController := new(ReplicationController) replicationController.Name, _ = jsonMap["metadata"].(map[string]interface{})["name"].(string) selector := jsonMap["spec"].(map[string]interface{})["selector"] if selector != nil { replicationController.Selector.Name, _ = selector.(map[string]interface{})["name"].(string) replicationController.Selector.Version, _ = selector.(map[string]interface{})["version"].(string) } replicas, _ := jsonparse.ConvertToInt64(jsonMap["spec"].(map[string]interface{})["replicas"]) replicationController.ReplicaAmount = int(replicas) replicationControllerLabelMap := jsonMap["metadata"].(map[string]interface{})["labels"] if replicationControllerLabelMap != nil { replicationController.Label.Name, _ = replicationControllerLabelMap.(map[string]interface{})["name"].(string) } containerSlice := jsonMap["spec"].(map[string]interface{})["template"].(map[string]interface{})["spec"].(map[string]interface{})["containers"] if containerSlice != nil { replicationController.ContainerSlice = make([]ReplicationControllerContainer, 0) for _, container := range containerSlice.([]interface{}) { replicationControllerContainer := ReplicationControllerContainer{} replicationControllerContainer.Name, _ = container.(map[string]interface{})["name"].(string) replicationControllerContainer.Image, _ = container.(map[string]interface{})["image"].(string) portSlice, _ := container.(map[string]interface{})["ports"].([]interface{}) replicationControllerContainer.PortSlice = make([]ReplicationControllerContainerPort, 0) for _, port := range portSlice { replicationControllerContainerPort := ReplicationControllerContainerPort{} replicationControllerContainerPort.Name, _ = port.(map[string]interface{})["name"].(string) containerPort, _ := jsonparse.ConvertToInt64(port.(map[string]interface{})["containerPort"]) replicationControllerContainerPort.ContainerPort = int(containerPort) replicationControllerContainer.PortSlice = append(replicationControllerContainer.PortSlice, replicationControllerContainerPort) } environmentSlice, _ := container.(map[string]interface{})["env"].([]interface{}) replicationControllerContainer.EnvironmentSlice = make([]ReplicationControllerContainerEnvironment, 0) for _, environment := range environmentSlice { name := environment.(map[string]interface{})["name"].(string) value := environment.(map[string]interface{})["value"].(string) replicationControllerContainer.EnvironmentSlice = append(replicationControllerContainer.EnvironmentSlice, ReplicationControllerContainerEnvironment{name, value}) } replicationControllerContainer.ResourceMap, _ = container.(map[string]interface{})["resources"].(map[string]interface{}) replicationController.ContainerSlice = append(replicationController.ContainerSlice, replicationControllerContainer) } } return replicationController, nil } }
func GetHistoricalReplicationControllerMetrics(namespace string, replicationControllerName string, aggregationAmount int, from time.Time, to time.Time) (returnedJsonMap map[string]interface{}, returnedError error) { byteSlice, err := searchHistoricalReplicationControllerMetrics(namespace, replicationControllerName, aggregationAmount, from, to) if err != nil { return nil, err } else { jsonMap := make(map[string]interface{}) decoder := json.NewDecoder(bytes.NewReader(byteSlice)) decoder.UseNumber() err := decoder.Decode(&jsonMap) if err != nil { return nil, err } else { timestampSlice := make([]string, 0) replicationControllerJsonMap := make(map[string]interface{}) timeBucketSlice, _ := jsonMap["aggregations"].(map[string]interface{})["aggregation_time_interval"].(map[string]interface{})["buckets"].([]interface{}) timeBucketAmount := len(timeBucketSlice) for timeIndex, timeBucket := range timeBucketSlice { timestamp, _ := timeBucket.(map[string]interface{})["key_as_string"].(string) timestampSlice = append(timestampSlice, timestamp) podBucketSlice, _ := timeBucket.(map[string]interface{})["aggregation_pod"].(map[string]interface{})["buckets"].([]interface{}) for _, podBucket := range podBucketSlice { podName, _ := podBucket.(map[string]interface{})["key"].(string) containerBucketSlice, _ := podBucket.(map[string]interface{})["aggregation_container"].(map[string]interface{})["buckets"].([]interface{}) podJsonMap, _ := replicationControllerJsonMap[podName].(map[string]interface{}) if podJsonMap == nil { podJsonMap = make(map[string]interface{}) } for _, containerBucket := range containerBucketSlice { containerName, _ := containerBucket.(map[string]interface{})["key"].(string) documentCount, _ := jsonparse.ConvertToInt64(containerBucket.(map[string]interface{})["doc_count"]) minimumCpuUsageTotal, _ := jsonparse.ConvertToInt64(containerBucket.(map[string]interface{})["minimum_cpu_usage_total"].(map[string]interface{})["value"]) averageMemoryUsage, _ := jsonparse.ConvertToInt64(containerBucket.(map[string]interface{})["average_memory_usage"].(map[string]interface{})["value"]) minimumDiskioIoServiceBytesStatsTotal, _ := jsonparse.ConvertToInt64(containerBucket.(map[string]interface{})["minimum_diskio_io_service_bytes_stats_total"].(map[string]interface{})["value"]) minimumDiskioIoServicedStatsTotal, _ := jsonparse.ConvertToInt64(containerBucket.(map[string]interface{})["minimum_diskio_io_serviced_stats_total"].(map[string]interface{})["value"]) minimumNetworkRxPackets, _ := jsonparse.ConvertToInt64(containerBucket.(map[string]interface{})["minimum_network_rx_packets"].(map[string]interface{})["value"]) minimumNetworkTxPackets, _ := jsonparse.ConvertToInt64(containerBucket.(map[string]interface{})["minimum_network_tx_packets"].(map[string]interface{})["value"]) minimumNetworkRxBytes, _ := jsonparse.ConvertToInt64(containerBucket.(map[string]interface{})["minimum_network_rx_bytes"].(map[string]interface{})["value"]) minimumNetworkTxBytes, _ := jsonparse.ConvertToInt64(containerBucket.(map[string]interface{})["minimum_network_tx_bytes"].(map[string]interface{})["value"]) containerJsonMap, _ := podJsonMap[containerName].(map[string]interface{}) if containerJsonMap == nil { containerJsonMap = make(map[string]interface{}) } appendToSliceInJsonMap(timeBucketAmount, timeIndex, containerJsonMap, "documentCountSlice", int64(documentCount)) appendToSliceInJsonMap(timeBucketAmount, timeIndex, containerJsonMap, "minimumCpuUsageTotalSlice", int64(minimumCpuUsageTotal)) appendToSliceInJsonMap(timeBucketAmount, timeIndex, containerJsonMap, "averageMemoryUsageSlice", int64(averageMemoryUsage)) appendToSliceInJsonMap(timeBucketAmount, timeIndex, containerJsonMap, "minimumDiskioIoServiceBytesStatsTotalSlice", int64(minimumDiskioIoServiceBytesStatsTotal)) appendToSliceInJsonMap(timeBucketAmount, timeIndex, containerJsonMap, "minimumDiskioIoServicedStatsTotalSlice", int64(minimumDiskioIoServicedStatsTotal)) appendToSliceInJsonMap(timeBucketAmount, timeIndex, containerJsonMap, "minimumNetworkRxPacketsSlice", int64(minimumNetworkRxPackets)) appendToSliceInJsonMap(timeBucketAmount, timeIndex, containerJsonMap, "minimumNetworkTxPacketsSlice", int64(minimumNetworkTxPackets)) appendToSliceInJsonMap(timeBucketAmount, timeIndex, containerJsonMap, "minimumNetworkRxBytesSlice", int64(minimumNetworkRxBytes)) appendToSliceInJsonMap(timeBucketAmount, timeIndex, containerJsonMap, "minimumNetworkTxBytesSlice", int64(minimumNetworkTxBytes)) podJsonMap[containerName] = containerJsonMap } replicationControllerJsonMap[podName] = podJsonMap } } // Interpolate the hole for podName, _ := range replicationControllerJsonMap { for containerName, _ := range replicationControllerJsonMap[podName].(map[string]interface{}) { for metricsName, _ := range replicationControllerJsonMap[podName].(map[string]interface{})[containerName].(map[string]interface{}) { fillTheNullDataWithInterpolationForInt64Slice(replicationControllerJsonMap[podName].(map[string]interface{})[containerName].(map[string]interface{})[metricsName].([]interface{})) } } } // Add timestamp replicationControllerJsonMap["timestamp"] = timestampSlice return replicationControllerJsonMap, nil } } }
func MonitorNode(kubeApiServerEndPoint string, kubeApiServerToken string) (returnedNodeMetricSlice []NodeMetric, returnedError error) { defer func() { if err := recover(); err != nil { log.Error("MonitorNode Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) returnedNodeMetricSlice = nil returnedError = err.(error) } }() headerMap := make(map[string]string) headerMap["Authorization"] = kubeApiServerToken result, err := restclient.RequestGet(kubeApiServerEndPoint+"/api/v1/nodes", headerMap, true) jsonMap, _ := result.(map[string]interface{}) if err != nil { log.Error("Fail to get node inofrmation with endpoint: %s, token: %s, error %s", kubeApiServerEndPoint, kubeApiServerToken, err.Error()) return nil, err } urlSlice, addressSlice := getNodeLocationFromNodeInformation(jsonMap) dataSlice, errorSlice := getNodeMonitorData(urlSlice) nodeAmount := len(dataSlice) nodeMetricSlice := make([]NodeMetric, nodeAmount) errorMessage := "The following index of container has error: " errorHappened := false for index, data := range dataSlice { if errorSlice[index] != nil { errorMessage = errorMessage + errorSlice[index].Error() nodeMetricSlice[index].Valid = false nodeMetricSlice[index].KubeletHost = addressSlice[index] errorHappened = true } else { nodeMetricSlice[index].Valid = true nodeMetricSlice[index].KubeletHost = addressSlice[index] length := len(data["stats"].([]interface{})) // CPU nodeMetricSlice[index].CpuUsageTotalSlice = make([]int64, length) // Memory nodeMetricSlice[index].MemoryUsageSlice = make([]int64, length) // Disk I/O nodeMetricSlice[index].DiskIOServiceBytesStatsTotalSlice = make([]int64, length) nodeMetricSlice[index].DiskIOServicedStatsTotalSlice = make([]int64, length) // Network nodeMetricSlice[index].NetworkRXBytesSlice = make([]int64, length) nodeMetricSlice[index].NetworkTXBytesSlice = make([]int64, length) nodeMetricSlice[index].NetworkRXPacketsSlice = make([]int64, length) nodeMetricSlice[index].NetworkTXPacketsSlice = make([]int64, length) for i := 0; i < length; i++ { // CPU nodeMetricSlice[index].CpuUsageTotalSlice[i], _ = jsonparse.ConvertToInt64(data["stats"].([]interface{})[i].(map[string]interface{})["cpu"].(map[string]interface{})["usage"].((map[string]interface{}))["total"]) // Memory nodeMetricSlice[index].MemoryUsageSlice[i], _ = jsonparse.ConvertToInt64(data["stats"].([]interface{})[i].(map[string]interface{})["memory"].(map[string]interface{})["usage"]) // Disk I/O ioServiceBytesSlice := data["stats"].([]interface{})[i].(map[string]interface{})["diskio"].(map[string]interface{})["io_service_bytes"].([]interface{}) for _, ioServiceBytes := range ioServiceBytesSlice { value, _ := jsonparse.ConvertToInt64(ioServiceBytes.(map[string]interface{})["stats"].(map[string]interface{})["Total"]) nodeMetricSlice[index].DiskIOServiceBytesStatsTotalSlice[i] += value } ioServicedSlice := data["stats"].([]interface{})[i].(map[string]interface{})["diskio"].(map[string]interface{})["io_serviced"].([]interface{}) for _, ioServiced := range ioServicedSlice { value, _ := jsonparse.ConvertToInt64(ioServiced.(map[string]interface{})["stats"].(map[string]interface{})["Total"]) nodeMetricSlice[index].DiskIOServicedStatsTotalSlice[i] += value } // Network nodeMetricSlice[index].NetworkRXBytesSlice[i], _ = jsonparse.ConvertToInt64(data["stats"].([]interface{})[i].(map[string]interface{})["network"].(map[string]interface{})["rx_bytes"]) nodeMetricSlice[index].NetworkTXBytesSlice[i], _ = jsonparse.ConvertToInt64(data["stats"].([]interface{})[i].(map[string]interface{})["network"].(map[string]interface{})["tx_bytes"]) nodeMetricSlice[index].NetworkRXPacketsSlice[i], _ = jsonparse.ConvertToInt64(data["stats"].([]interface{})[i].(map[string]interface{})["network"].(map[string]interface{})["rx_packets"]) nodeMetricSlice[index].NetworkTXPacketsSlice[i], _ = jsonparse.ConvertToInt64(data["stats"].([]interface{})[i].(map[string]interface{})["network"].(map[string]interface{})["tx_packets"]) } } } if errorHappened { log.Error("Fail to get all node inofrmation with endpoint %s, token: %s, error %s", kubeApiServerEndPoint, kubeApiServerToken, errorMessage) return nodeMetricSlice, nil } else { return nodeMetricSlice, nil } }