func GetAllReplicationControllerName(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string) (returnedNameSlice []string, returnedError error) { defer func() { if err := recover(); err != nil { log.Error("GetAllReplicationController Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) returnedNameSlice = nil returnedError = err.(error) } }() url := kubeApiServerEndPoint + "/api/v1/namespaces/" + namespace + "/replicationcontrollers/" headerMap := make(map[string]string) headerMap["Authorization"] = kubeApiServerToken jsonMap, err := restclient.RequestGet(url, headerMap, true) if err != nil { log.Error(err) return nil, err } else { nameSlice := make([]string, 0) for _, item := range jsonMap.(map[string]interface{})["items"].([]interface{}) { name, ok := item.(map[string]interface{})["metadata"].(map[string]interface{})["name"].(string) if ok { nameSlice = append(nameSlice, name) } } return nameSlice, nil } }
// @Title get // @Description get container log in the pod // @Param namespace path string true "The name of namespace" // @Param pod path string true "The name of pod" // @Success 200 {string} {} // @Failure 404 error reason // @router /podlog/:namespace/:pod [get] func (c *PodLogController) Get() { namespace := c.GetString(":namespace") pod := c.GetString(":pod") cloudoneProtocol := beego.AppConfig.String("cloudoneProtocol") cloudoneHost := beego.AppConfig.String("cloudoneHost") cloudonePort := beego.AppConfig.String("cloudonePort") url := cloudoneProtocol + "://" + cloudoneHost + ":" + cloudonePort + "/api/v1/podlogs/" + namespace + "/" + pod tokenHeaderMap, _ := c.GetSession("tokenHeaderMap").(map[string]string) result, err := restclient.RequestGet(url, tokenHeaderMap, true) if identity.IsTokenInvalidAndRedirect(c, c.Ctx, err) { return } jsonMap, _ := result.(map[string]interface{}) if err != nil { // Error c.Data["json"] = make(map[string]interface{}) c.Data["json"].(map[string]interface{})["error"] = err.Error() c.Ctx.Output.Status = 404 c.ServeJSON() return } else { c.Data["json"] = make(map[string]interface{}) c.Data["json"].(map[string]interface{})["logJsonMap"] = jsonMap c.ServeJSON() } }
func GetAllNamespaceName(kubeApiServerEndPoint string, kubeApiServerToken string) (returnedNameSlice []string, returnedError error) { defer func() { if err := recover(); err != nil { log.Error("GetAllNamespaceName Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) returnedNameSlice = nil returnedError = err.(error) } }() headerMap := make(map[string]string) headerMap["Authorization"] = kubeApiServerToken result, err := restclient.RequestGet(kubeApiServerEndPoint+"/api/v1/namespaces/", headerMap, true) if err != nil { log.Error("Fail to get all namespace name with endpoint: %s, token: %s, error: %s", kubeApiServerEndPoint, kubeApiServerToken, err.Error()) return nil, err } jsonMap, _ := result.(map[string]interface{}) nameSlice := make([]string, 0) for _, data := range jsonMap["items"].([]interface{}) { name, ok := data.(map[string]interface{})["metadata"].(map[string]interface{})["name"].(string) if ok { statusJsonMap, _ := data.(map[string]interface{})["status"].(map[string]interface{}) phase, _ := statusJsonMap["phase"].(string) if phase == "Active" { nameSlice = append(nameSlice, name) } } } return nameSlice, nil }
func GetAllEvent(kubeApiServerEndPoint string, kubeApiServerToken string) (returnedEventSlice []map[string]interface{}, returnedError error) { defer func() { if err := recover(); err != nil { log.Error("GetAllEvent Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) returnedEventSlice = nil returnedError = err.(error) } }() headerMap := make(map[string]string) headerMap["Authorization"] = kubeApiServerToken jsonMap, err := restclient.RequestGet(kubeApiServerEndPoint+"/api/v1/events/", headerMap, true) if err != nil { log.Error("Fail to get all event with endpoint: %s, token: %s, error: %s", kubeApiServerEndPoint, kubeApiServerToken, err.Error()) return nil, err } eventSlice := make([]map[string]interface{}, 0) for _, data := range jsonMap.(map[string]interface{})["items"].([]interface{}) { value, ok := data.(map[string]interface{}) if ok { eventSlice = append(eventSlice, value) } } return eventSlice, nil }
func UpdateReplicationControllerSize(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string, replicationControllerName string, size int) (returnedError error) { defer func() { if err := recover(); err != nil { log.Error("UpdateReplicationControllerSize Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) 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 size: %d, endpoint: %s, token: %s, namespace: %s, replicationControllerName: %s, err: %s", size, kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationControllerName, err.Error()) return err } else { jsonMap["spec"].(map[string]interface{})["replicas"] = float64(size) _, err := restclient.RequestPut(url, jsonMap, headerMap, true) if err != nil { return err } else { return nil } } }
func (privateRegistry *PrivateRegistry) GetAllImageTag(repositoryName string) ([]string, error) { result, err := restclient.RequestGet(privateRegistry.getPrivateRegistryEndpoint()+"/v2/"+repositoryName+"/tags/list", nil, false) if err != nil { log.Error("Fail to get all image tags with repository %s and private registry: %v, error: %s", repositoryName, privateRegistry, err) return nil, err } jsonMap, _ := result.(map[string]interface{}) tagJsonSlice, _ := jsonMap["tags"].([]interface{}) tagSlice := make([]string, 0) for _, tagJsonInterface := range tagJsonSlice { if tag, ok := tagJsonInterface.(string); ok { request, err := http.NewRequest("GET", privateRegistry.getPrivateRegistryEndpoint()+"/v2/"+repositoryName+"/manifests/"+tag, nil) if err != nil { log.Error(err) return nil, err } // For registry version 2.3 and later request.Header.Add("Accept", "application/vnd.docker.distribution.manifest.v2+json") response, err := restclient.GetInsecureHTTPSClient().Do(request) if err != nil { log.Error(err) return nil, err } digest := response.Header.Get("Docker-Content-Digest") if len(digest) > 0 { tagSlice = append(tagSlice, tag) } } } return tagSlice, nil }
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 getContainerMonitorData(urlSlice []string) ([]map[string]interface{}, []error) { dataMapSlice := make([]map[string]interface{}, 0) errorSlice := make([]error, 0) for _, url := range urlSlice { result, err := restclient.RequestGet(url, nil, true) jsonMap, _ := result.(map[string]interface{}) if err != nil { dataMapSlice = append(dataMapSlice, nil) errorSlice = append(errorSlice, err) } else { dataMapSlice = append(dataMapSlice, jsonMap) errorSlice = append(errorSlice, nil) } } return dataMapSlice, errorSlice }
func GetPodLog(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string, podName string) (returnedLog map[string]interface{}, returnedError error) { defer func() { if err := recover(); err != nil { log.Error("GetPodLog Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) returnedLog = nil returnedError = err.(error) } }() headerMap := make(map[string]string) headerMap["Authorization"] = kubeApiServerToken result, err := restclient.RequestGet(kubeApiServerEndPoint+"/api/v1/namespaces/"+namespace+"/pods/"+podName, headerMap, false) if err != nil { log.Error("Fail to get pod information with namespace %s pod %s endpoint: %s, token: %s, error: %s", namespace, podName, kubeApiServerEndPoint, kubeApiServerToken, err.Error()) return nil, err } containerNameSlice := make([]string, 0) jsonMap, _ := result.(map[string]interface{}) specJsonMap, _ := jsonMap["spec"].(map[string]interface{}) containerSlice, _ := specJsonMap["containers"].([]interface{}) for _, container := range containerSlice { containerJsonMap, _ := container.(map[string]interface{}) containerName, ok := containerJsonMap["name"].(string) if ok { containerNameSlice = append(containerNameSlice, containerName) } } logJsonMap := make(map[string]interface{}) for _, containerName := range containerNameSlice { byteSlice, err := restclient.RequestGetByteSliceResult(kubeApiServerEndPoint+"/api/v1/namespaces/"+namespace+"/pods/"+podName+"/log?container="+containerName, headerMap) if err != nil { log.Error("Fail to get log with namespace %s pod %s container %s endpoint: %s, token: %s, error: %s", namespace, podName, containerName, kubeApiServerEndPoint, kubeApiServerToken, err.Error()) return nil, err } else { logJsonMap[containerName] = string(byteSlice) } } return logJsonMap, nil }
func (privateRegistry *PrivateRegistry) GetAllRepository() ([]string, error) { result, err := restclient.RequestGet(privateRegistry.getPrivateRegistryEndpoint()+"/v2/_catalog", nil, false) if err != nil { log.Error("Fail to get all repository with private registry: %v, error: %s", privateRegistry, err) return nil, err } jsonMap, _ := result.(map[string]interface{}) repositoryJsonSlice, _ := jsonMap["repositories"].([]interface{}) repositorySlice := make([]string, 0) for _, repositoryJsonInterface := range repositoryJsonSlice { if repository, ok := repositoryJsonInterface.(string); ok { repositorySlice = append(repositorySlice, repository) } } return repositorySlice, nil }
func ExistReplicationController(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string, replicationControllerName string) (returnedExist bool, returnedError error) { defer func() { if err := recover(); err != nil { log.Error("ExistReplicationController Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) returnedExist = false returnedError = err.(error) } }() headerMap := make(map[string]string) headerMap["Authorization"] = kubeApiServerToken _, err := restclient.RequestGet(kubeApiServerEndPoint+"/api/v1/namespaces/"+namespace+"/replicationcontrollers/"+replicationControllerName, headerMap, true) if err != nil { log.Error("Fail to detect replication controller existence with endpoint: %s, token: %s, namespace: %s, replication controller name: %s, error %s", kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationControllerName, err.Error()) return false, err } else { return true, nil } }
func GetReplicationControllerNameFromSelector(kubeApiServerEndPoint, kubeApiServerToken, namespace string, targetSelectorName string) (returnedReplicationControllerNameSlice []string, returnedError error) { defer func() { if err := recover(); err != nil { log.Error("GetReplicationControllerNameFromSelector Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) returnedReplicationControllerNameSlice = nil returnedError = err.(error) } }() headerMap := make(map[string]string) headerMap["Authorization"] = kubeApiServerToken result, err := restclient.RequestGet(kubeApiServerEndPoint+"/api/v1/namespaces/"+namespace+"/replicationcontrollers/", headerMap, true) jsonMap, _ := result.(map[string]interface{}) if err != nil { log.Error("Fail to get all replication controller with endpoint: %s, token: %s, namespace: %s, selector name: %s", kubeApiServerEndPoint, kubeApiServerToken, namespace, targetSelectorName) return nil, err } nameSlice := make([]string, 0) for _, item := range jsonMap["items"].([]interface{}) { selector, ok := item.(map[string]interface{})["spec"].(map[string]interface{})["selector"].(map[string]interface{}) if ok { selectorName, ok := selector["name"].(string) if ok { if targetSelectorName == selectorName { name, ok := item.(map[string]interface{})["metadata"].(map[string]interface{})["name"].(string) if ok { nameSlice = append(nameSlice, name) } } } } } return nameSlice, nil }
func GetAllPodBelongToReplicationController(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string, replicationControllerName string) (returnedPodSlice []Pod, returnedError error) { defer func() { if err := recover(); err != nil { log.Error("GetAllPodBelongToReplicationController Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) returnedPodSlice = nil returnedError = err.(error) } }() headerMap := make(map[string]string) headerMap["Authorization"] = kubeApiServerToken result, err := restclient.RequestGet(kubeApiServerEndPoint+"/api/v1/namespaces/"+namespace+"/pods/", headerMap, true) jsonMap, _ := result.(map[string]interface{}) if err != nil { log.Error("Fail to get all pod inofrmation with endpoint %s, token: %s, namespace: %s, replication controller name: %s, error %s", kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationControllerName, err.Error()) return nil, err } return GetAllPodBelongToReplicationControllerFromData(replicationControllerName, jsonMap) }
func GetAllPodNameBelongToReplicationController(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string, replicationControllerName string) (returnedNameSlice []string, returnedError error) { defer func() { if err := recover(); err != nil { log.Error("GetAllPodNameBelongToReplicationController Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) returnedNameSlice = nil returnedError = err.(error) } }() headerMap := make(map[string]string) headerMap["Authorization"] = kubeApiServerToken result, err := restclient.RequestGet(kubeApiServerEndPoint+"/api/v1/namespaces/"+namespace+"/pods/", headerMap, true) if err != nil { log.Error("Fail to get replication controller inofrmation with endpoint %s, token: %s, namespace: %s, replication controller name: %s, error %s", kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationControllerName, err.Error()) return nil, err } jsonMap, _ := result.(map[string]interface{}) generateName := replicationControllerName + "-" podNameSlice := make([]string, 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 { if nameFieldOk { podNameSlice = append(podNameSlice, nameField) } } else if replicationControllerName == nameField { if nameFieldOk { podNameSlice = append(podNameSlice, nameField) } } } return podNameSlice, nil }
func (smsNexmo *SMSNexmo) SendSMSNexmo(smsNexmoURL string, smsNexmoAPIKey string, smsNexmoAPISecret string, sender string, receiverNumberSlice []string, text string) error { hasError := false buffer := bytes.Buffer{} for _, receiverNumber := range receiverNumberSlice { convertedURL, err := url.Parse(smsNexmoURL) if err != nil { log.Error("Parse url %s error %s", smsNexmoURL, err) return err } parameters := url.Values{} parameters.Add("api_key", smsNexmoAPIKey) parameters.Add("api_secret", smsNexmoAPISecret) parameters.Add("from", sender) parameters.Add("to", receiverNumber) parameters.Add("text", text) convertedURL.RawQuery = parameters.Encode() result, err := restclient.RequestGet(convertedURL.String(), nil, true) bodyJsonMap, _ := result.(map[string]interface{}) if err != nil { log.Error("Request url %s error bodyJsonMap %s error %s", convertedURL.String(), bodyJsonMap, err) hasError = true buffer.WriteString(err.Error()) } else { log.Info("SMS send to %s, bodyJsonMap %s", convertedURL.String(), bodyJsonMap) } } if hasError { return errors.New(buffer.String()) } else { return nil } }
func UpdateReplicationControllerWithJson(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string, replicationControllerName string, bodyJsonMap map[string]interface{}) (returnedError error) { defer func() { if err := recover(); err != nil { log.Error("UpdateReplicationControllerWithJson Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) 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) if err != nil { log.Error(err) return err } jsonMap, _ := result.(map[string]interface{}) metadataJsonMap, _ := jsonMap["metadata"].(map[string]interface{}) resourceVersion, _ := metadataJsonMap["resourceVersion"].(string) // Update requires the resoruce version bodyJsonMap["metadata"].(map[string]interface{})["resourceVersion"] = resourceVersion url = kubeApiServerEndPoint + "/api/v1/namespaces/" + namespace + "/replicationcontrollers/" + replicationControllerName _, err = restclient.RequestPut(url, bodyJsonMap, headerMap, true) if err != nil { log.Error(err) return err } else { return nil } }
func UpdateServiceWithJson(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string, serviceName string, bodyJsonMap map[string]interface{}) (returnedError error) { defer func() { if err := recover(); err != nil { log.Error("CreateServiceWithJson Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) returnedError = err.(error) } }() headerMap := make(map[string]string) headerMap["Authorization"] = kubeApiServerToken url := kubeApiServerEndPoint + "/api/v1/namespaces/" + namespace + "/services/" + serviceName result, err := restclient.RequestGet(url, headerMap, true) jsonMap, _ := result.(map[string]interface{}) metadataJsonMap, _ := jsonMap["metadata"].(map[string]interface{}) resourceVersion, _ := metadataJsonMap["resourceVersion"].(string) specJsonMap, _ := jsonMap["spec"].(map[string]interface{}) clusterIP, _ := specJsonMap["clusterIP"].(string) // Update requires the resoruce version and cluster ip bodyJsonMap["metadata"].(map[string]interface{})["resourceVersion"] = resourceVersion bodyJsonMap["spec"].(map[string]interface{})["clusterIP"] = clusterIP url = kubeApiServerEndPoint + "/api/v1/namespaces/" + namespace + "/services/" + serviceName _, err = restclient.RequestPut(url, bodyJsonMap, headerMap, true) if err != nil { log.Error(err) return err } else { return nil } }
func (c *PodLogController) Get() { c.TplName = "inventory/replicationcontroller/pod_log.html" guimessage := guimessagedisplay.GetGUIMessage(c) // Authorization for web page display c.Data["layoutMenu"] = c.GetSession("layoutMenu") cloudoneProtocol := beego.AppConfig.String("cloudoneProtocol") cloudoneHost := beego.AppConfig.String("cloudoneHost") cloudonePort := beego.AppConfig.String("cloudonePort") namespace := c.GetString("namespace") pod := c.GetString("pod") url := cloudoneProtocol + "://" + cloudoneHost + ":" + cloudonePort + "/api/v1/pods/" + namespace + "/" + pod + "/logs" tokenHeaderMap, _ := c.GetSession("tokenHeaderMap").(map[string]string) result, err := restclient.RequestGet(url, tokenHeaderMap, true) if identity.IsTokenInvalidAndRedirect(c, c.Ctx, err) { return } jsonMap, _ := result.(map[string]interface{}) if err != nil { // Error guimessage.AddDanger(guimessagedisplay.GetErrorMessage(err)) } else { c.Data["logJsonMap"] = jsonMap } guimessage.OutputMessage(c.Data) }
func GetAllService(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string) (returnedServiceSlice []Service, returnedError error) { defer func() { if err := recover(); err != nil { log.Error("GetAllService Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) returnedServiceSlice = nil returnedError = err.(error) } }() headerMap := make(map[string]string) headerMap["Authorization"] = kubeApiServerToken url := kubeApiServerEndPoint + "/api/v1/namespaces/" + namespace + "/services/" result, err := restclient.RequestGet(url, headerMap, true) jsonMap, _ := result.(map[string]interface{}) if err != nil { return nil, err } else { serviceSlice := make([]Service, 0) for _, item := range jsonMap["items"].([]interface{}) { service := Service{} service.Name, _ = item.(map[string]interface{})["metadata"].(map[string]interface{})["name"].(string) service.Namespace, _ = item.(map[string]interface{})["metadata"].(map[string]interface{})["namespace"].(string) service.LabelMap, _ = item.(map[string]interface{})["metadata"].(map[string]interface{})["labels"].(map[string]interface{}) service.ClusterIP, _ = item.(map[string]interface{})["spec"].(map[string]interface{})["clusterIP"].(string) service.Selector, _ = item.(map[string]interface{})["spec"].(map[string]interface{})["selector"].(map[string]interface{}) service.SessionAffinity, _ = item.(map[string]interface{})["spec"].(map[string]interface{})["sessionAffinity"].(string) portSlice := item.(map[string]interface{})["spec"].(map[string]interface{})["ports"].([]interface{}) servicePortSlice := make([]ServicePort, 0) for _, port := range portSlice { servicePort := ServicePort{} servicePort.Name, _ = port.(map[string]interface{})["name"].(string) servicePort.Protocol, _ = port.(map[string]interface{})["protocol"].(string) unknownTypePort := port.(map[string]interface{})["port"] switch knowTypePort := unknownTypePort.(type) { case json.Number: portInt64, _ := knowTypePort.Int64() servicePort.Port = int(portInt64) case string: servicePort.Port, _ = strconv.Atoi(knowTypePort) case int64: servicePort.Port = int(knowTypePort) case float64: servicePort.Port = int(knowTypePort) } unknownTypeTargetPort := port.(map[string]interface{})["targetPort"] switch knowTypeTargetPort := unknownTypeTargetPort.(type) { case json.Number: servicePort.TargetPort = knowTypeTargetPort.String() case string: servicePort.TargetPort = knowTypeTargetPort case int64: servicePort.TargetPort = strconv.FormatInt(knowTypeTargetPort, 10) case float64: servicePort.TargetPort = strconv.FormatFloat(knowTypeTargetPort, 'f', -1, 64) } unknownTypeNodePort := port.(map[string]interface{})["nodePort"] switch knowTypeNodePort := unknownTypeNodePort.(type) { case json.Number: nodePortInt64, _ := knowTypeNodePort.Int64() servicePort.NodePort = int(nodePortInt64) case string: servicePort.NodePort, _ = strconv.Atoi(knowTypeNodePort) case int64: servicePort.NodePort = int(knowTypeNodePort) case float64: servicePort.NodePort = int(knowTypeNodePort) default: servicePort.NodePort = -1 } servicePortSlice = append(servicePortSlice, servicePort) } service.PortSlice = servicePortSlice serviceSlice = append(serviceSlice, service) } return serviceSlice, 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 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 } }
func RecordHistoricalPod(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string, replicationControllerName string, podName string) (returnedPodContainerRecordSlice []map[string]interface{}, returnedError error) { defer func() { if err := recover(); err != nil { log.Error("RecordHistoricalPod Error: %s", err) log.Error(logger.GetStackTrace(4096, false)) returnedPodContainerRecordSlice = nil returnedError = err.(error) } }() podContainerRecordSlice := make([]map[string]interface{}, 0) headerMap := make(map[string]string) headerMap["Authorization"] = kubeApiServerToken result, err := restclient.RequestGet(kubeApiServerEndPoint+"/api/v1/namespaces/"+namespace+"/pods/"+podName+"/", headerMap, true) 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 } jsonMap, _ := result.(map[string]interface{}) errorBuffer := bytes.Buffer{} errorBuffer.WriteString("The following container has error: ") errorHappened := false kubeletHost, _ := jsonMap["status"].(map[string]interface{})["hostIP"].(string) uid, _ := jsonMap["metadata"].(map[string]interface{})["uid"].(string) containerSlice, _ := jsonMap["spec"].(map[string]interface{})["containers"].([]interface{}) for _, container := range containerSlice { containerName, _ := container.(map[string]interface{})["name"].(string) url := "https://" + kubeletHost + ":10250/stats/" + namespace + "/" + podName + "/" + uid + "/" + containerName result, err := restclient.RequestGet(url, nil, true) containerJsonMap, _ := result.(map[string]interface{}) if err != nil { errorHappened = true log.Error("Request to url %s error %s", url, err) errorBuffer.WriteString("Request to url " + url + " error " + err.Error()) } else { // ElasticSearch doesn't allow to use character '.' in the field name so it should be replaced with '_' if containerJsonMap["spec"].(map[string]interface{})["labels"] != nil { for key, value := range containerJsonMap["spec"].(map[string]interface{})["labels"].(map[string]interface{}) { if strings.Contains(key, ".") { newKey := strings.Replace(key, ".", "_", -1) containerJsonMap["spec"].(map[string]interface{})["labels"].(map[string]interface{})[newKey] = value delete(containerJsonMap["spec"].(map[string]interface{})["labels"].(map[string]interface{}), key) } } } // Historical data containerRecordSlice, err := splitHistoricalDataIntoSecondBased(namespace, replicationControllerName, podName, containerName, containerJsonMap) if err != nil { errorHappened = true log.Error("Save container record %s error %s", containerJsonMap, err) errorBuffer.WriteString("Save container record " + containerName + " error " + err.Error()) } else { podContainerRecordSlice = append(podContainerRecordSlice, containerRecordSlice...) } } } 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, errorBuffer.String()) return nil, errors.New(errorBuffer.String()) } else { return podContainerRecordSlice, nil } }
// @Title get // @Description get historical container data of the replication controller // @Param replicationController path string true "The name of replication controller or All" // @Param from query string true "from (format: 01/02/2006 15:04 PM)" // @Param to query string true "to (format: 01/02/2006 15:04 PM)" // @Success 200 {string} {} // @Failure 404 error reason // @router /:replicationController [get] func (c *DataController) Get() { replicationControllerName := c.GetString(":replicationController") fromText := c.GetString("from") toText := c.GetString("to") cloudoneAnalysisProtocol := beego.AppConfig.String("cloudoneAnalysisProtocol") cloudoneAnalysisHost := beego.AppConfig.String("cloudoneAnalysisHost") cloudoneAnalysisPort := beego.AppConfig.String("cloudoneAnalysisPort") namespaces, _ := c.GetSession("namespace").(string) timeZoneOffset, _ := c.GetSession("timeZoneOffset").(int) //current := time.Now() //_, serverTimeZoneOffsetInSecond := current.Zone() from, err := time.Parse("01/02/2006 15:04 PM", fromText) if err != nil { // Error errorJsonMap := make(map[string]interface{}) errorJsonMap["warning"] = "From time is not selected." c.Data["json"] = errorJsonMap c.ServeJSON() return /* from = current.Add(-1 * time.Hour) // Convert to UTC // Offset server time zone from = from.Add(-1 * time.Second * time.Duration(serverTimeZoneOffsetInSecond)) // Offset browser time zone since time from browser doesn't contain time zone from = from.Add(time.Minute * time.Duration(timeZoneOffset)) */ } else { // Convert to UTC // Offset browser time zone since time from browser doesn't contain time zone from = from.Add(time.Minute * time.Duration(timeZoneOffset)) } fromInRFC3339Nano := from.Format(time.RFC3339Nano) to, err := time.Parse("01/02/2006 15:04 PM", toText) if err != nil { // Error errorJsonMap := make(map[string]interface{}) errorJsonMap["warning"] = "To time is not selected." c.Data["json"] = errorJsonMap c.ServeJSON() return /* to = current // Convert to UTC // Offset server time zone to.Add(-1 * time.Second * time.Duration(serverTimeZoneOffsetInSecond)) // Offset browser time zone since time from browser doesn't contain time zone to = to.Add(time.Minute * time.Duration(timeZoneOffset)) */ } else { // Convert to UTC // Offset browser time zone since time from browser doesn't contain time zone to = to.Add(time.Minute * time.Duration(timeZoneOffset)) } toInRFC3339Nano := to.Format(time.RFC3339Nano) // Make sure from is before to if from.Before(to) == false { // Error errorJsonMap := make(map[string]interface{}) errorJsonMap["warning"] = "From need to be before to." c.Data["json"] = errorJsonMap c.ServeJSON() return } allHistoricalReplicationControllerMetricJsonMap := make(map[string]interface{}) if replicationControllerName != "" && replicationControllerName != allKeyword { encodingUrl, _ := url.Parse(cloudoneAnalysisProtocol + "://" + cloudoneAnalysisHost + ":" + cloudoneAnalysisPort + "/api/v1/historicalreplicationcontrollermetrics/" + namespaces + "/" + replicationControllerName) parameters := url.Values{} parameters.Add("from", fromInRFC3339Nano) parameters.Add("to", toInRFC3339Nano) parameters.Add("aggregationAmount", strconv.Itoa(aggregationAmount)) encodingUrl.RawQuery = parameters.Encode() tokenHeaderMap, _ := c.GetSession("tokenHeaderMap").(map[string]string) result, err := restclient.RequestGet(encodingUrl.String(), tokenHeaderMap, true) if identity.IsTokenInvalidAndRedirect(c, c.Ctx, err) { return } historicalReplicationControllerMetricJsonMap, ok := result.(map[string]interface{}) if err != nil || ok == false { // Error errorJsonMap := make(map[string]interface{}) errorJsonMap["error"] = err.Error() c.Data["json"] = errorJsonMap c.ServeJSON() return } allHistoricalReplicationControllerMetricJsonMap[replicationControllerName] = historicalReplicationControllerMetricJsonMap } else { encodingUrl, _ := url.Parse(cloudoneAnalysisProtocol + "://" + cloudoneAnalysisHost + ":" + cloudoneAnalysisPort + "/api/v1/historicalreplicationcontrollermetrics/" + namespaces) parameters := url.Values{} parameters.Add("from", fromInRFC3339Nano) parameters.Add("to", toInRFC3339Nano) parameters.Add("aggregationAmount", strconv.Itoa(aggregationAmount)) encodingUrl.RawQuery = parameters.Encode() tokenHeaderMap, _ := c.GetSession("tokenHeaderMap").(map[string]string) result, err := restclient.RequestGet(encodingUrl.String(), tokenHeaderMap, true) if identity.IsTokenInvalidAndRedirect(c, c.Ctx, err) { return } var ok bool allHistoricalReplicationControllerMetricJsonMap, ok = result.(map[string]interface{}) if err != nil || ok == false { // Error errorJsonMap := make(map[string]interface{}) errorJsonMap["error"] = err.Error() c.Data["json"] = errorJsonMap c.ServeJSON() return } } // At least two points to draw a line // Filtered out those less than 2 filterHistoricalReplicationControllerMetricJsonMap := make(map[string]interface{}) for key, historicalReplicationControllerMetricJsonMap := range allHistoricalReplicationControllerMetricJsonMap { timestampSlice, _ := historicalReplicationControllerMetricJsonMap.(map[string]interface{})["timestamp"].([]interface{}) resultAmount := len(timestampSlice) if resultAmount >= 2 { filterHistoricalReplicationControllerMetricJsonMap[key] = historicalReplicationControllerMetricJsonMap } } // No data to show if len(filterHistoricalReplicationControllerMetricJsonMap) == 0 { // Error errorJsonMap := make(map[string]interface{}) errorJsonMap["error"] = "Insufficient data" c.Data["json"] = errorJsonMap c.ServeJSON() return } // Due to boundary (start + end), it may be aggregationAmount or aggregationAmount + 1 for different replication controller metrics. // If the covered range has no data, it may be less. Force to use the smallest one to align. smallestResultAmount := aggregationAmount for _, historicalReplicationControllerMetricJsonMap := range filterHistoricalReplicationControllerMetricJsonMap { timestampSlice, _ := historicalReplicationControllerMetricJsonMap.(map[string]interface{})["timestamp"].([]interface{}) resultAmount := len(timestampSlice) if resultAmount < smallestResultAmount { smallestResultAmount = resultAmount } } resultAmount := smallestResultAmount differenceAmount := resultAmount - 1 // CPU usage total cpuUsageTotalJsonMap := make(map[string]interface{}) cpuUsageTotalJsonMap["metadata"] = make(map[string]interface{}) cpuUsageTotalJsonMap["metadata"].(map[string]interface{})["title"] = "CPU (ms/1s)" cpuUsageTotalJsonMap["metadata"].(map[string]interface{})["lineName"] = make([]string, 0) cpuUsageTotalJsonMap["data"] = make([]interface{}, differenceAmount) for i := 0; i < differenceAmount; i++ { cpuUsageTotalJsonMap["data"].([]interface{})[i] = make(map[string]interface{}) cpuUsageTotalJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"] = make([]int64, 0) } // Memory usage memoryUsageJsonMap := make(map[string]interface{}) memoryUsageJsonMap["metadata"] = make(map[string]interface{}) memoryUsageJsonMap["metadata"].(map[string]interface{})["title"] = "Memory(MB)" memoryUsageJsonMap["metadata"].(map[string]interface{})["lineName"] = make([]string, 0) memoryUsageJsonMap["data"] = make([]interface{}, resultAmount) for i := 0; i < resultAmount; i++ { memoryUsageJsonMap["data"].([]interface{})[i] = make(map[string]interface{}) memoryUsageJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"] = make([]int64, 0) } // Disk I/O byte diskIOServiceBytesStatsJsonMap := make(map[string]interface{}) diskIOServiceBytesStatsJsonMap["metadata"] = make(map[string]interface{}) diskIOServiceBytesStatsJsonMap["metadata"].(map[string]interface{})["title"] = "Disk I/O (Byte/s)" diskIOServiceBytesStatsJsonMap["metadata"].(map[string]interface{})["lineName"] = make([]string, 0) diskIOServiceBytesStatsJsonMap["data"] = make([]interface{}, differenceAmount) for i := 0; i < differenceAmount; i++ { diskIOServiceBytesStatsJsonMap["data"].([]interface{})[i] = make(map[string]interface{}) diskIOServiceBytesStatsJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"] = make([]int64, 0) } // Disk I/O count diskIOServicedStatsJsonMap := make(map[string]interface{}) diskIOServicedStatsJsonMap["metadata"] = make(map[string]interface{}) diskIOServicedStatsJsonMap["metadata"].(map[string]interface{})["title"] = "Disk I/O (count/s)" diskIOServicedStatsJsonMap["metadata"].(map[string]interface{})["lineName"] = make([]string, 0) diskIOServicedStatsJsonMap["data"] = make([]interface{}, differenceAmount) for i := 0; i < differenceAmount; i++ { diskIOServicedStatsJsonMap["data"].([]interface{})[i] = make(map[string]interface{}) diskIOServicedStatsJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"] = make([]int64, 0) } // Network RX Byte networkRXBytesJsonMap := make(map[string]interface{}) networkRXBytesJsonMap["metadata"] = make(map[string]interface{}) networkRXBytesJsonMap["metadata"].(map[string]interface{})["title"] = "Network RX (Bytes/s)" networkRXBytesJsonMap["metadata"].(map[string]interface{})["lineName"] = make([]string, 0) networkRXBytesJsonMap["data"] = make([]interface{}, differenceAmount) for i := 0; i < differenceAmount; i++ { networkRXBytesJsonMap["data"].([]interface{})[i] = make(map[string]interface{}) networkRXBytesJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"] = make([]int64, 0) } // Network TX Byte networkTXBytesJsonMap := make(map[string]interface{}) networkTXBytesJsonMap["metadata"] = make(map[string]interface{}) networkTXBytesJsonMap["metadata"].(map[string]interface{})["title"] = "Network TX (Bytes/s)" networkTXBytesJsonMap["metadata"].(map[string]interface{})["lineName"] = make([]string, 0) networkTXBytesJsonMap["data"] = make([]interface{}, differenceAmount) for i := 0; i < differenceAmount; i++ { networkTXBytesJsonMap["data"].([]interface{})[i] = make(map[string]interface{}) networkTXBytesJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"] = make([]int64, 0) } // Network RX Packet networkRXPacketsJsonMap := make(map[string]interface{}) networkRXPacketsJsonMap["metadata"] = make(map[string]interface{}) networkRXPacketsJsonMap["metadata"].(map[string]interface{})["title"] = "Network RX (packet/s)" networkRXPacketsJsonMap["metadata"].(map[string]interface{})["lineName"] = make([]string, 0) networkRXPacketsJsonMap["data"] = make([]interface{}, differenceAmount) for i := 0; i < differenceAmount; i++ { networkRXPacketsJsonMap["data"].([]interface{})[i] = make(map[string]interface{}) networkRXPacketsJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"] = make([]int64, 0) } // Network TX Packet networkTXPacketsJsonMap := make(map[string]interface{}) networkTXPacketsJsonMap["metadata"] = make(map[string]interface{}) networkTXPacketsJsonMap["metadata"].(map[string]interface{})["title"] = "Network TX (packet/s)" networkTXPacketsJsonMap["metadata"].(map[string]interface{})["lineName"] = make([]string, 0) networkTXPacketsJsonMap["data"] = make([]interface{}, differenceAmount) for i := 0; i < differenceAmount; i++ { networkTXPacketsJsonMap["data"].([]interface{})[i] = make(map[string]interface{}) networkTXPacketsJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"] = make([]int64, 0) } allHistoricalReplicationControllerMetricKeySlice := getAllKeyFromJsonMap(filterHistoricalReplicationControllerMetricJsonMap) for _, replicationControllerName := range allHistoricalReplicationControllerMetricKeySlice { differenceTimestampSlice := make([]string, 0) originalTimestampSlice := make([]string, 0) timestampSlice, _ := filterHistoricalReplicationControllerMetricJsonMap[replicationControllerName].(map[string]interface{})["timestamp"].([]interface{}) for index, value := range timestampSlice { timestamp, _ := time.Parse(time.RFC3339Nano, value.(string)) // Convert from UTC to local time zone timestamp = timestamp.Add(-1 * time.Minute * time.Duration(timeZoneOffset)) timestampText := timestamp.Format("2006-01-02 15:04:05") if index == 0 { originalTimestampSlice = append(originalTimestampSlice, timestampText) } else { originalTimestampSlice = append(originalTimestampSlice, timestampText) differenceTimestampSlice = append(differenceTimestampSlice, timestampText) } } allHistoricalPodJsonMap, _ := filterHistoricalReplicationControllerMetricJsonMap[replicationControllerName].(map[string]interface{}) allHistoricalPodKeySlice := getAllKeyFromJsonMap(allHistoricalPodJsonMap) for _, podName := range allHistoricalPodKeySlice { if podName != "timestamp" { allHistoricalContainerJsonMap, _ := allHistoricalPodJsonMap[podName].(map[string]interface{}) allHistoricalContainerKeySlice := getAllKeyFromJsonMap(allHistoricalContainerJsonMap) for _, containerName := range allHistoricalContainerKeySlice { historicalContainerJsonMap, _ := allHistoricalContainerJsonMap[containerName].(map[string]interface{}) // CPU usage total cpuUsageTotalJsonMap["metadata"].(map[string]interface{})["lineName"] = append( cpuUsageTotalJsonMap["metadata"].(map[string]interface{})["lineName"].([]string), replicationControllerName+"/"+podName+"/"+containerName) // Memory usage memoryUsageJsonMap["metadata"].(map[string]interface{})["lineName"] = append( memoryUsageJsonMap["metadata"].(map[string]interface{})["lineName"].([]string), replicationControllerName+"/"+podName+"/"+containerName) // Disk I/O byte diskIOServiceBytesStatsJsonMap["metadata"].(map[string]interface{})["lineName"] = append( diskIOServiceBytesStatsJsonMap["metadata"].(map[string]interface{})["lineName"].([]string), replicationControllerName+"/"+podName+"/"+containerName) // Disk I/O count diskIOServicedStatsJsonMap["metadata"].(map[string]interface{})["lineName"] = append( diskIOServicedStatsJsonMap["metadata"].(map[string]interface{})["lineName"].([]string), replicationControllerName+"/"+podName+"/"+containerName) // Network RX Byte networkRXBytesJsonMap["metadata"].(map[string]interface{})["lineName"] = append( networkRXBytesJsonMap["metadata"].(map[string]interface{})["lineName"].([]string), replicationControllerName+"/"+podName+"/"+containerName) // Network TX Byte networkTXBytesJsonMap["metadata"].(map[string]interface{})["lineName"] = append( networkTXBytesJsonMap["metadata"].(map[string]interface{})["lineName"].([]string), replicationControllerName+"/"+podName+"/"+containerName) // Network RX Packet networkRXPacketsJsonMap["metadata"].(map[string]interface{})["lineName"] = append( networkRXPacketsJsonMap["metadata"].(map[string]interface{})["lineName"].([]string), replicationControllerName+"/"+podName+"/"+containerName) // Network TX Packet networkTXPacketsJsonMap["metadata"].(map[string]interface{})["lineName"] = append( networkTXPacketsJsonMap["metadata"].(map[string]interface{})["lineName"].([]string), replicationControllerName+"/"+podName+"/"+containerName) for i := 0; i < differenceAmount; i++ { count, _ := historicalContainerJsonMap["documentCountSlice"].([]interface{})[i].(json.Number).Int64() // CPU usage total second, _ := historicalContainerJsonMap["minimumCpuUsageTotalSlice"].([]interface{})[i+1].(json.Number).Int64() first, _ := historicalContainerJsonMap["minimumCpuUsageTotalSlice"].([]interface{})[i].(json.Number).Int64() value := (second - first) / count // Convert from ns to ms value /= 1000000 cpuUsageTotalJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"] = append( cpuUsageTotalJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"].([]int64), value) cpuUsageTotalJsonMap["data"].([]interface{})[i].(map[string]interface{})["x"] = differenceTimestampSlice[i] // Disk I/O byte second, _ = historicalContainerJsonMap["minimumDiskioIoServiceBytesStatsTotalSlice"].([]interface{})[i+1].(json.Number).Int64() first, _ = historicalContainerJsonMap["minimumDiskioIoServiceBytesStatsTotalSlice"].([]interface{})[i].(json.Number).Int64() value = (second - first) / count diskIOServiceBytesStatsJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"] = append( diskIOServiceBytesStatsJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"].([]int64), value) diskIOServiceBytesStatsJsonMap["data"].([]interface{})[i].(map[string]interface{})["x"] = differenceTimestampSlice[i] // Disk I/O byte second, _ = historicalContainerJsonMap["minimumDiskioIoServicedStatsTotalSlice"].([]interface{})[i+1].(json.Number).Int64() first, _ = historicalContainerJsonMap["minimumDiskioIoServicedStatsTotalSlice"].([]interface{})[i].(json.Number).Int64() value = (second - first) / count diskIOServicedStatsJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"] = append( diskIOServicedStatsJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"].([]int64), value) diskIOServicedStatsJsonMap["data"].([]interface{})[i].(map[string]interface{})["x"] = differenceTimestampSlice[i] // Network RX Byte second, _ = historicalContainerJsonMap["minimumNetworkRxBytesSlice"].([]interface{})[i+1].(json.Number).Int64() first, _ = historicalContainerJsonMap["minimumNetworkRxBytesSlice"].([]interface{})[i].(json.Number).Int64() value = (second - first) / count networkRXBytesJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"] = append( networkRXBytesJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"].([]int64), value) networkRXBytesJsonMap["data"].([]interface{})[i].(map[string]interface{})["x"] = differenceTimestampSlice[i] // Network TX Byte second, _ = historicalContainerJsonMap["minimumNetworkTxBytesSlice"].([]interface{})[i+1].(json.Number).Int64() first, _ = historicalContainerJsonMap["minimumNetworkTxBytesSlice"].([]interface{})[i].(json.Number).Int64() value = (second - first) / count networkTXBytesJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"] = append( networkTXBytesJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"].([]int64), value) networkTXBytesJsonMap["data"].([]interface{})[i].(map[string]interface{})["x"] = differenceTimestampSlice[i] // Network RX Packet second, _ = historicalContainerJsonMap["minimumNetworkRxPacketsSlice"].([]interface{})[i+1].(json.Number).Int64() first, _ = historicalContainerJsonMap["minimumNetworkRxPacketsSlice"].([]interface{})[i].(json.Number).Int64() value = (second - first) / count networkRXPacketsJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"] = append( networkRXPacketsJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"].([]int64), value) networkRXPacketsJsonMap["data"].([]interface{})[i].(map[string]interface{})["x"] = differenceTimestampSlice[i] // Network TX Packet second, _ = historicalContainerJsonMap["minimumNetworkTxPacketsSlice"].([]interface{})[i+1].(json.Number).Int64() first, _ = historicalContainerJsonMap["minimumNetworkTxPacketsSlice"].([]interface{})[i].(json.Number).Int64() value = (second - first) / count networkTXPacketsJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"] = append( networkTXPacketsJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"].([]int64), value) networkTXPacketsJsonMap["data"].([]interface{})[i].(map[string]interface{})["x"] = differenceTimestampSlice[i] } for i := 0; i < resultAmount; i++ { // Memory usage value, _ := historicalContainerJsonMap["averageMemoryUsageSlice"].([]interface{})[i].(json.Number).Int64() // Convert from byte to MB value /= (1024 * 1024) memoryUsageJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"] = append( memoryUsageJsonMap["data"].([]interface{})[i].(map[string]interface{})["y"].([]int64), value) memoryUsageJsonMap["data"].([]interface{})[i].(map[string]interface{})["x"] = originalTimestampSlice[i] } } } } } chartSlice := make(map[string]interface{}) // CPU usage total chartSlice["cpuUsageTotal"] = cpuUsageTotalJsonMap // Memory usage chartSlice["memoryUsage"] = memoryUsageJsonMap // Disk I/O byte chartSlice["diskIOServiceBytesStats"] = diskIOServiceBytesStatsJsonMap // Disk I/O count chartSlice["diskIOServicedStats"] = diskIOServicedStatsJsonMap // Network RX Byte chartSlice["networkRXBytes"] = networkRXBytesJsonMap // Network TX Byte chartSlice["networkTXBytes"] = networkTXBytesJsonMap // Network RX Packet chartSlice["networkRXPackets"] = networkRXPacketsJsonMap // Network TX Packet chartSlice["networkTXPackets"] = networkTXPacketsJsonMap c.Data["json"] = chartSlice c.ServeJSON() }
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 } }