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 (etcdClient *EtcdClient) GetKeysAPI() (returnedKeysAPI client.KeysAPI, returnedError error) {
defer func() {
if err := recover(); err != nil {
log.Error("GetKeysAPI Error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
etcdClient.KeysAPI = nil
returnedKeysAPI = nil
returnedError = err.(error)
}
}()
if etcdClient.KeysAPI != nil {
return etcdClient.KeysAPI, nil
} else {
config := client.Config{
Endpoints: etcdClient.EtcdEndpoints,
Transport: client.DefaultTransport,
HeaderTimeoutPerRequest: etcdClient.EtcdHeaderTimeoutPerRequest,
}
configuredClient, err := client.New(config)
if err != nil {
etcdClient.KeysAPI = nil
log.Error(err)
return nil, err
}
keysAPI := client.NewKeysAPI(configuredClient)
etcdClient.KeysAPI = keysAPI
return keysAPI, 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 (cassandraClient *CassandraClient) CreateTableIfNotExist(tableSchema string, retryAmount int, retryInterval time.Duration) (returnedError error) {
defer func() {
if err := recover(); err != nil {
log.Error("CreateTableIfNotExist Error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
returnedError = err.(error)
}
}()
session, err := cassandraClient.GetSession()
if err != nil {
return err
}
for i := 0; i < retryAmount; i++ {
if err := session.Query(tableSchema).Exec(); err == nil {
return nil
} else {
log.Error("Check if not exist then create table schema %s error: %s", tableSchema, err)
returnedError = err
}
time.Sleep(retryInterval)
}
return returnedError
}
func (configuration *Configuration) createConfigurationFileIfNotExist(programName string, configurationContent string) (returnedError error) {
defer func() {
if err := recover(); err != nil {
log.Error("configuration Error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
returnedError = err.(error)
}
}()
directoryPath := rootPath + string(os.PathSeparator) + programName
if err := os.MkdirAll(directoryPath, os.ModePerm); err != nil {
return err
}
fileNameAndPath := directoryPath + string(os.PathSeparator) + fileName
if _, err := os.Stat(fileNameAndPath); os.IsNotExist(err) {
outputFile, err := os.Create(fileNameAndPath)
if err != nil {
log.Error("createConfigurationFileIfNotExist create file %s with error: %s", fileNameAndPath, err)
return err
}
outputFile.WriteString(configurationContent)
}
configuration.fileNameAndPath = fileNameAndPath
return 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 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
}
}
func DeleteReplicationControllerAndRelatedPod(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string, replicationControllerName string) (returnedError error) {
defer func() {
if err := recover(); err != nil {
log.Error("DeleteReplicationControllerAndRelatedPod Error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
returnedError = err.(error)
}
}()
err := DeleteReplicationController(kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationControllerName)
if err != nil {
return err
} else {
nameSlice, err := GetAllPodNameBelongToReplicationController(kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationControllerName)
if err != nil {
return err
} else {
for _, name := range nameSlice {
err := DeletePod(kubeApiServerEndPoint, kubeApiServerToken, namespace, name)
if err != nil {
return err
}
}
return nil
}
}
}
func (glusterfsCluster *GlusterfsCluster) parseSize(field string) (returnedSize int, returnedError error) {
defer func() {
if err := recover(); err != nil {
log.Error("Parse size error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
returnedSize = -1
returnedError = err.(error)
}
}()
var value string
if strings.Contains(field, "=") {
value = strings.Split(field, "=")[1]
} else {
value = field
}
size, err := strconv.Atoi(strings.TrimSpace(value))
if err != nil {
log.Error("Parse size error %s", err)
return -1, err
} else {
return size, nil
}
}
func (glusterfsCluster *GlusterfsCluster) parseVolumeInfo(text string) (returnedGlusterfsVolumeSlice []GlusterfsVolume, returnedError error) {
defer func() {
if err := recover(); err != nil {
log.Error("parseVolumeInfo Error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
returnedGlusterfsVolumeSlice = nil
returnedError = err.(error)
}
}()
glusterfsVolumeSlice := make([]GlusterfsVolume, 0)
scanner := bufio.NewScanner(bytes.NewBufferString(text))
var glusterfsVolume *GlusterfsVolume = nil
for scanner.Scan() {
line := scanner.Text()
if line == " " {
if glusterfsVolume != nil {
glusterfsVolumeSlice = append(glusterfsVolumeSlice, *glusterfsVolume)
}
glusterfsVolume = &GlusterfsVolume{}
} else if strings.HasPrefix(line, "Volume Name: ") {
glusterfsVolume.VolumeName = line[len("Volume Name: "):]
} else if strings.HasPrefix(line, "Type: ") {
glusterfsVolume.Type = line[len("Type: "):]
} else if strings.HasPrefix(line, "Volume ID: ") {
glusterfsVolume.VolumeID = line[len("Volume ID: "):]
} else if strings.HasPrefix(line, "Status: ") {
glusterfsVolume.Status = line[len("Status: "):]
} else if strings.HasPrefix(line, "Number of Bricks: ") {
glusterfsVolume.NumberOfBricks = line[len("Number of Bricks: "):]
glusterfsVolume.Size, _ = glusterfsCluster.parseSize(glusterfsVolume.NumberOfBricks)
} else if strings.HasPrefix(line, "Transport-type: ") {
glusterfsVolume.TransportType = line[len("Transport-type: "):]
} else if line == "Bricks:" {
brickSlice := make([]string, 0)
for i := 0; i < glusterfsVolume.Size; i++ {
scanner.Scan()
brickSlice = append(brickSlice, scanner.Text())
}
glusterfsVolume.Bricks = brickSlice
} else {
// Ignore unexpected data
}
}
if glusterfsVolume != nil {
glusterfsVolumeSlice = append(glusterfsVolumeSlice, *glusterfsVolume)
}
if err := scanner.Err(); err != nil {
log.Error("Scanner error %s", err)
return nil, err
}
return glusterfsVolumeSlice, nil
}
func MonitorReplicationController(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string, replicationControllerName string) (returnedReplicationControllerMetric *ReplicationControllerMetric, returnedError error) {
defer func() {
if err := recover(); err != nil {
log.Error("MonitorReplicationController Error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
returnedReplicationControllerMetric = nil
returnedError = err.(error)
}
}()
exist, err := ExistReplicationController(kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationControllerName)
if err != nil {
log.Error("Fail to get the replication controller with endpoint: %s, token: %s, namespace: %s, replication controller name: %s", kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationControllerName)
return nil, err
}
if exist == false {
log.Error("Replication controller doesn't exist with endpoint: %s, token: %s, namespace: %s, replication controller name: %s", kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationControllerName)
return nil, err
}
podNameSlice, err := control.GetAllPodNameBelongToReplicationController(kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationControllerName)
if err != nil {
log.Error("Fail to get all pod name belong to the replication controller with endpoint: %s, token: %s, namespace: %s, replication controller name: %s", kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationControllerName)
return nil, err
}
replicationControllerMetric := &ReplicationControllerMetric{}
replicationControllerMetric.Namespace = namespace
replicationControllerMetric.ReplicationControllerName = replicationControllerName
replicationControllerMetric.Size = len(podNameSlice)
replicationControllerMetric.ValidPodSlice = make([]bool, replicationControllerMetric.Size)
replicationControllerMetric.PodMetricSlice = make([]PodMetric, replicationControllerMetric.Size)
errorMessage := "The following index of pod has error: "
errorHappened := false
for index, podName := range podNameSlice {
podMetric, err := MonitorPod(kubeApiServerEndPoint, kubeApiServerToken, namespace, podName)
if err != nil {
errorMessage = errorMessage + err.Error()
errorHappened = true
replicationControllerMetric.ValidPodSlice[index] = false
} else {
replicationControllerMetric.ValidPodSlice[index] = true
replicationControllerMetric.PodMetricSlice[index] = *podMetric
}
}
if errorHappened {
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, errorMessage)
return replicationControllerMetric, errors.New(errorMessage)
} else {
return replicationControllerMetric, nil
}
}
func BuildUpgrade(imageInformationName string, description string) (returnedOutputMessage string, returnedError error) {
defer func() {
if err := recover(); err != nil {
log.Error("BuildUpgrade Error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
returnedOutputMessage = ""
returnedError = err.(error)
}
}()
imageInformation, err := GetStorage().LoadImageInformation(imageInformationName)
if err != nil {
log.Error("Load image information error: %s", err)
return "", err
}
var buildError error = nil
imageRecord, outputMessage, err := Build(imageInformation, description)
if err != nil {
log.Error("Build error: %s Output message: %s", err, outputMessage)
if imageRecord == nil {
return outputMessage, err
} else {
buildError = err
outputMessage = outputMessage + "\n" + err.Error()
}
}
// Save image record
err = GetStorage().saveImageRecord(imageRecord)
if err != nil {
log.Error("Save image record error: %s", err)
return outputMessage, err
}
imageInformation.CurrentVersion = imageRecord.Version
// Save image information
err = GetStorage().SaveImageInformation(imageInformation)
if err != nil {
log.Error("Save image information error: %s", err)
return outputMessage, err
}
// Save build log
err = SendBuildLog(imageRecord, outputMessage)
if err != nil {
log.Error("Save build log error: %s", err)
return outputMessage, err
}
return outputMessage, buildError
}
func GetAvailablekubeApiServerEndPoint() (returnedEndPoint string, returnedToken string, returnedError error) {
defer func() {
if err := recover(); err != nil {
returnedEndPoint = ""
returnedToken = ""
returnedError = err.(error)
log.Error("GetAvailablekubeApiServerEndPoint Error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
}
}()
kubeApiServerEndPointSlice, ok := LocalConfiguration.GetStringSlice("kubeApiServerEndPoints")
if ok == false {
log.Error("Fail to get configuration kubeApiServerEndPoints")
return "", "", errors.New("Fail to get configuration kubeApiServerEndPoints")
}
kubeApiServerHealthCheckTimeoutInMilliSecond, ok := LocalConfiguration.GetInt("kubeApiServerHealthCheckTimeoutInMilliSecond")
if ok == false {
kubeApiServerHealthCheckTimeoutInMilliSecond = KubeApiServerHealthCheckTimeoutInMilliSecond
}
kubeApiServerToken, ok := LocalConfiguration.GetString("kubeApiServerToken")
if ok == false {
log.Error("Fail to get configuration kubeApiServerToken")
return "", "", errors.New("Fail to get configuration kubeApiServerToken")
}
token := "Bearer " + kubeApiServerToken
headerMap := make(map[string]string)
headerMap["Authorization"] = token
for _, kubeApiServerEndPoint := range kubeApiServerEndPointSlice {
result, err := restclient.HealthCheck(
kubeApiServerEndPoint,
headerMap,
time.Duration(kubeApiServerHealthCheckTimeoutInMilliSecond)*time.Millisecond)
if result {
return kubeApiServerEndPoint, token, nil
} else {
if err != nil {
log.Error(err)
}
}
}
log.Error("No available kube apiserver endpoint")
return "", "", errors.New("No available kube apiserver endpoint")
}
func DeleteReplicationController(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string, replicationControllerName string) (returnedError error) {
defer func() {
if err := recover(); err != nil {
log.Error("DeleteReplicationController 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
_, err := restclient.RequestDelete(url, nil, headerMap, true)
return err
}
func GetAllNodeIP(kubeApiServerEndPoint string, kubeApiServerToken string) (returnedIpSlice []string, returnedError error) {
defer func() {
if err := recover(); err != nil {
log.Error("GetAllNodeIP Error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
returnedIpSlice = nil
returnedError = err.(error)
}
}()
jsonMap := make(map[string]interface{})
headerMap := make(map[string]string)
headerMap["Authorization"] = kubeApiServerToken
url := kubeApiServerEndPoint + "/api/v1/nodes/"
_, err := restclient.RequestGetWithStructure(url, &jsonMap, headerMap)
if err != nil {
log.Error(err)
return nil, err
}
ipSlice := make([]string, 0)
itemSlice, _ := jsonMap["items"].([]interface{})
for _, item := range itemSlice {
itemJsonMap, _ := item.(map[string]interface{})
statusJsonMap, _ := itemJsonMap["status"].(map[string]interface{})
addressesJsonSlice, _ := statusJsonMap["addresses"].([]interface{})
address := ""
for _, value := range addressesJsonSlice {
addressJsonMap, _ := value.(map[string]interface{})
addressType, _ := addressJsonMap["type"].(string)
addressAddress, _ := addressJsonMap["address"].(string)
if addressType == "InternalIP" {
address = addressAddress
break
}
}
if len(address) > 0 {
ipSlice = append(ipSlice, address)
}
}
return ipSlice, 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 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 (configuration *Configuration) readConfigurationFromFile() (returnedError error) {
defer func() {
if err := recover(); err != nil {
log.Error("readConfigurationFromFile Error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
returnedError = err.(error)
}
}()
// open input file
inputFile, err := os.Open(configuration.fileNameAndPath)
if err != nil {
log.Error("readConfigurationFromFile open file error: %s", err)
return err
}
defer inputFile.Close()
byteSlice := make([]byte, 0)
buffer := make([]byte, 1024)
for {
// read a chunk
n, err := inputFile.Read(buffer)
if err != nil && err != io.EOF {
log.Error("readConfigurationFromFile read file error: %s", err)
return err
}
if n == 0 {
break
}
byteSlice = append(byteSlice, buffer[0:n]...)
}
jsonMap := make(map[string]interface{})
err = json.Unmarshal(byteSlice, &jsonMap)
if err != nil {
log.Error("readConfigurationFromFile parse file error: %s", err)
return err
}
configuration.jsonMap = jsonMap
return nil
}
func (cassandraClient *CassandraClient) GetSession() (returnedSession *gocql.Session, returnedError error) {
defer func() {
if err := recover(); err != nil {
log.Error("GetSession Error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
cassandraClient.session = nil
returnedSession = nil
returnedError = err.(error)
}
}()
if cassandraClient.session != nil {
return cassandraClient.session, nil
} else {
cluster := gocql.NewCluster(cassandraClient.clusterIp...)
cluster.Timeout = cassandraClient.timeout
cluster.Port = cassandraClient.clusterPort
session, err := cluster.CreateSession()
if err != nil {
log.Critical("Fail to create Cassandra session: %s", err)
cassandraClient.session = nil
return nil, err
} else {
if err := session.Query("CREATE KEYSPACE IF NOT EXISTS " + cassandraClient.keyspace + " WITH replication = " + cassandraClient.replicationStrategy).Exec(); err != nil {
log.Critical("Fail to check if not exist then create keyspace error: %s", err)
cassandraClient.session = nil
return nil, err
} else {
session.Close()
cluster.Keyspace = cassandraClient.keyspace
session, err := cluster.CreateSession()
if err != nil {
log.Critical("Fail to create Cassandra session: %s", err)
cassandraClient.session = nil
return nil, err
} else {
cassandraClient.session = session
return cassandraClient.session, nil
}
}
}
}
}
func periodicalRunHistoricalRecordEvent() {
defer func() {
if err := recover(); err != nil {
log.Error("periodicalRunHistoricalRecordEvent Error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
}
}()
kubeApiServerEndPoint, kubeApiServerToken, err := configuration.GetAvailablekubeApiServerEndPoint()
if err != nil {
log.Error("Fail to get configuration endpoint and token with error %s", err)
return
}
if err := event.RecordHistoricalEvent(kubeApiServerEndPoint, kubeApiServerToken); err != nil {
log.Error(err)
return
}
}
func RecordHistoricalAllNamespace(kubeApiServerEndPoint string, kubeApiServerToken string) (returnedError error) {
defer func() {
if err := recover(); err != nil {
log.Error("RecordHistoricalAllNamespace Error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
returnedError = err.(error)
}
}()
namespaceNameSlice, err := control.GetAllNamespaceName(kubeApiServerEndPoint, kubeApiServerToken)
if err != nil {
log.Error(err)
return err
}
allNamespaceContainerRecordSlice := make([]map[string]interface{}, 0)
for _, namespaceName := range namespaceNameSlice {
replicationControllerNameSlice, err := control.GetAllReplicationControllerName(kubeApiServerEndPoint, kubeApiServerToken, namespaceName)
if err != nil {
log.Error(err)
} else {
for _, replicationControllerName := range replicationControllerNameSlice {
replicationControllerContainerRecordSlice, err := RecordHistoricalReplicationController(kubeApiServerEndPoint, kubeApiServerToken, namespaceName, replicationControllerName)
if err != nil {
log.Error(err)
} else {
allNamespaceContainerRecordSlice = append(allNamespaceContainerRecordSlice, replicationControllerContainerRecordSlice...)
}
}
}
}
for _, containerRecord := range allNamespaceContainerRecordSlice {
index, _ := containerRecord["searchMetaData"].(map[string]interface{})["index"].(string)
documentType, _ := containerRecord["searchMetaData"].(map[string]interface{})["documentType"].(string)
id, _ := containerRecord["searchMetaData"].(map[string]interface{})["id"].(string)
if err := saveContainerRecord(index, documentType, id, containerRecord); err != nil {
log.Error("Save error %s", err)
}
}
return nil
}
func DeleteNamespace(kubeApiServerEndPoint string, kubeApiServerToken string, name string) (returnedError error) {
defer func() {
if err := recover(); err != nil {
log.Error("DeleteNamespace Error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
returnedError = err.(error)
}
}()
headerMap := make(map[string]string)
headerMap["Authorization"] = kubeApiServerToken
_, err := restclient.RequestDelete(kubeApiServerEndPoint+"/api/v1/namespaces/"+name, nil, headerMap, true)
if err != nil {
log.Error("Fail to delete namespace with endpoint: %s, token: %s, name: %s, error: %s", kubeApiServerEndPoint, kubeApiServerToken, name, err.Error())
return err
}
return nil
}
func DeleteEvent(kubeApiServerEndPoint string, kubeApiServerToken string, selfLink string) (returnedError error) {
defer func() {
if err := recover(); err != nil {
log.Error("DeleteEvent Error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
returnedError = err.(error)
}
}()
headerMap := make(map[string]string)
headerMap["Authorization"] = kubeApiServerToken
_, err := restclient.RequestDelete(kubeApiServerEndPoint+selfLink, nil, headerMap, true)
if err != nil {
log.Error("Fail to delete event selfLink %s with endpoint: %s, token: %s, error: %s", selfLink, kubeApiServerEndPoint, kubeApiServerToken, err.Error())
return err
}
return 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 CreateServiceWithJson(kubeApiServerEndPoint string, kubeApiServerToken string, namespace 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/"
_, err := restclient.RequestPost(url, bodyJsonMap, headerMap, true)
if err != nil {
log.Error(err)
return err
} else {
return 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 RecordHistoricalReplicationController(kubeApiServerEndPoint string, kubeApiServerToken string, namespace string, replicationControllerName string) (returnedReplicationControllerContainerRecordSlice []map[string]interface{}, returnedError error) {
defer func() {
if err := recover(); err != nil {
log.Error("RecordHistoricalReplicationController Error: %s", err)
log.Error(logger.GetStackTrace(4096, false))
returnedError = err.(error)
returnedReplicationControllerContainerRecordSlice = nil
}
}()
podNameSlice, err := control.GetAllPodNameBelongToReplicationController(kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationControllerName)
if err != nil {
log.Error("Fail to get all pod name belong to the replication controller with endpoint %s, token: %s, namespace: %s, replication controller name: %s", kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationControllerName)
return nil, err
}
errorBuffer := bytes.Buffer{}
errorBuffer.WriteString("The following container has error: ")
errorHappened := false
replicationControllerContainerRecordSlice := make([]map[string]interface{}, 0)
for _, podName := range podNameSlice {
podContainerRecordSlice, err := RecordHistoricalPod(kubeApiServerEndPoint, kubeApiServerToken, namespace, replicationControllerName, podName)
if err != nil {
errorHappened = true
log.Error("RecordHistoricalPod error %s", err)
errorBuffer.WriteString("RecordHistoricalPod error " + err.Error())
} else {
replicationControllerContainerRecordSlice = append(replicationControllerContainerRecordSlice, podContainerRecordSlice...)
}
}
if errorHappened {
log.Error("Fail to get all container inofrmation with endpoint %s, token: %s, namespace: %s, error %s", kubeApiServerEndPoint, kubeApiServerToken, namespace, errorBuffer.String())
return nil, errors.New(errorBuffer.String())
} else {
return replicationControllerContainerRecordSlice, 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 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
}
}