500 lines
13 KiB
Go
500 lines
13 KiB
Go
/*
|
|
Copyright 2018 The KubeSphere Authors.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package controllers
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/golang/glog"
|
|
"k8s.io/api/core/v1"
|
|
"k8s.io/apimachinery/pkg/api/errors"
|
|
metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"k8s.io/apimachinery/pkg/labels"
|
|
|
|
"kubesphere.io/kubesphere/pkg/client"
|
|
)
|
|
|
|
const (
|
|
unknown = "-"
|
|
deploySurffix = "-Deployment"
|
|
daemonSurffix = "-DaemonSet"
|
|
stateSurffix = "-StatefulSet"
|
|
)
|
|
|
|
type ApplicationCtl struct {
|
|
OpenpitrixAddr string
|
|
}
|
|
|
|
type Application struct {
|
|
Name string `json:"name"`
|
|
RepoName string `json:"repoName"`
|
|
Runtime string `json:"namespace"`
|
|
RuntimeId string `json:"runtime_id"`
|
|
Version string `json:"version"`
|
|
VersionId string `json:"version_id"`
|
|
Status string `json:"status"`
|
|
UpdateTime time.Time `json:"updateTime"`
|
|
CreateTime time.Time `json:"createTime"`
|
|
App string `json:"app"`
|
|
AppId string `json:"app_id"`
|
|
Description string `json:"description,omitempty"`
|
|
WorkLoads *workLoads `json:"workloads,omitempty"`
|
|
Services *[]Service `json:"services,omitempty"`
|
|
Ingresses *[]ing `json:"ingresses,omitempty"`
|
|
ClusterID string `json:"cluster_id"`
|
|
}
|
|
|
|
type ing struct {
|
|
Name string `json:"name"`
|
|
Rules []ingressRule `json:"rules"`
|
|
}
|
|
|
|
type clusterRole struct {
|
|
ClusterID string `json:"cluster_id"`
|
|
Role string `json:"role"`
|
|
}
|
|
|
|
type cluster struct {
|
|
ClusterID string `json:"cluster_id"`
|
|
Name string `json:"name"`
|
|
AppID string `json:"app_id"`
|
|
VersionID string `json:"version_id"`
|
|
Status string `json:"status"`
|
|
UpdateTime time.Time `json:"status_time"`
|
|
CreateTime time.Time `json:"create_time"`
|
|
RunTimeId string `json:"runtime_id"`
|
|
Description string `json:"description"`
|
|
ClusterRoleSets []clusterRole `json:"cluster_role_set"`
|
|
}
|
|
|
|
type clusters struct {
|
|
Total int `json:"total_count"`
|
|
Clusters []cluster `json:"cluster_set"`
|
|
}
|
|
|
|
type versionList struct {
|
|
Total int `json:"total_count"`
|
|
Versions []version `json:"app_version_set"`
|
|
}
|
|
|
|
type version struct {
|
|
Name string `json:"name"`
|
|
VersionID string `json:"version_id"`
|
|
}
|
|
|
|
type runtime struct {
|
|
RuntimeID string `json:"runtime_id"`
|
|
Zone string `json:"zone"`
|
|
}
|
|
|
|
type runtimeList struct {
|
|
Total int `json:"total_count"`
|
|
Runtimes []runtime `json:"runtime_set"`
|
|
}
|
|
|
|
type app struct {
|
|
AppId string `json:"app_id"`
|
|
Name string `json:"name"`
|
|
ChartName string `json:"chart_name"`
|
|
RepoId string `json:"repo_id"`
|
|
}
|
|
|
|
type repo struct {
|
|
RepoId string `json:"repo_id"`
|
|
Name string `json:"name"`
|
|
Url string `json:"url"`
|
|
}
|
|
|
|
type workLoads struct {
|
|
Deployments []Deployment `json:"deployments,omitempty"`
|
|
Statefulsets []Statefulset `json:"statefulsets,omitempty"`
|
|
Daemonsets []Daemonset `json:"daemonsets,omitempty"`
|
|
}
|
|
|
|
//type description struct {
|
|
// Creator string `json:"creator"`
|
|
//}
|
|
|
|
type appList struct {
|
|
Total int `json:"total_count"`
|
|
Apps []app `json:"app_set"`
|
|
}
|
|
|
|
type repoList struct {
|
|
Total int `json:"total_count"`
|
|
Repos []repo `json:"repo_set"`
|
|
}
|
|
|
|
func (ctl *ApplicationCtl) GetAppInfo(appId string) (string, string, string, error) {
|
|
url := fmt.Sprintf("%s/v1/apps?app_id=%s", ctl.OpenpitrixAddr, appId)
|
|
resp, err := makeHttpRequest("GET", url, "")
|
|
if err != nil {
|
|
glog.Error(err)
|
|
return unknown, unknown, unknown, err
|
|
}
|
|
|
|
var apps appList
|
|
err = json.Unmarshal(resp, &apps)
|
|
if err != nil {
|
|
glog.Error(err)
|
|
return unknown, unknown, unknown, err
|
|
}
|
|
|
|
if len(apps.Apps) == 0 {
|
|
return unknown, unknown, unknown, err
|
|
}
|
|
|
|
return apps.Apps[0].ChartName, apps.Apps[0].RepoId, apps.Apps[0].AppId, nil
|
|
}
|
|
|
|
func (ctl *ApplicationCtl) GetRepo(repoId string) (string, error) {
|
|
url := fmt.Sprintf("%s/v1/repos?repo_id=%s", ctl.OpenpitrixAddr, repoId)
|
|
resp, err := makeHttpRequest("GET", url, "")
|
|
if err != nil {
|
|
glog.Error(err)
|
|
return unknown, err
|
|
}
|
|
|
|
var repos repoList
|
|
err = json.Unmarshal(resp, &repos)
|
|
if err != nil {
|
|
glog.Error(err)
|
|
return unknown, err
|
|
}
|
|
|
|
if len(repos.Repos) == 0 {
|
|
return unknown, err
|
|
}
|
|
|
|
return repos.Repos[0].Name, nil
|
|
}
|
|
|
|
func (ctl *ApplicationCtl) GetVersion(versionId string) (string, error) {
|
|
versionUrl := fmt.Sprintf("%s/v1/app_versions?version_id=%s", ctl.OpenpitrixAddr, versionId)
|
|
resp, err := makeHttpRequest("GET", versionUrl, "")
|
|
if err != nil {
|
|
glog.Error(err)
|
|
return unknown, err
|
|
}
|
|
|
|
var versions versionList
|
|
err = json.Unmarshal(resp, &versions)
|
|
if err != nil {
|
|
glog.Error(err)
|
|
return unknown, err
|
|
}
|
|
|
|
if len(versions.Versions) == 0 {
|
|
return unknown, nil
|
|
}
|
|
return versions.Versions[0].Name, nil
|
|
}
|
|
|
|
func (ctl *ApplicationCtl) GetRuntime(runtimeId string) (string, error) {
|
|
|
|
versionUrl := fmt.Sprintf("%s/v1/runtimes?runtime_id=%s", ctl.OpenpitrixAddr, runtimeId)
|
|
resp, err := makeHttpRequest("GET", versionUrl, "")
|
|
if err != nil {
|
|
glog.Error(err)
|
|
return unknown, err
|
|
}
|
|
|
|
var runtimes runtimeList
|
|
err = json.Unmarshal(resp, &runtimes)
|
|
if err != nil {
|
|
glog.Error(err)
|
|
return unknown, err
|
|
}
|
|
|
|
if len(runtimes.Runtimes) == 0 {
|
|
return unknown, nil
|
|
}
|
|
|
|
return runtimes.Runtimes[0].Zone, nil
|
|
}
|
|
|
|
func (ctl *ApplicationCtl) GetWorkLoads(namespace string, clusterRoles []clusterRole) *workLoads {
|
|
|
|
var works workLoads
|
|
for _, clusterRole := range clusterRoles {
|
|
workLoadName := clusterRole.Role
|
|
if len(workLoadName) > 0 {
|
|
if strings.HasSuffix(workLoadName, deploySurffix) {
|
|
name := strings.Split(workLoadName, deploySurffix)[0]
|
|
ctl := ResourceControllers.Controllers[Deployments]
|
|
_, items, _ := ctl.ListWithConditions(fmt.Sprintf("namespace='%s' and name = '%s'", namespace, name), nil)
|
|
works.Deployments = append(works.Deployments, items.([]Deployment)...)
|
|
continue
|
|
}
|
|
|
|
if strings.HasSuffix(workLoadName, daemonSurffix) {
|
|
name := strings.Split(workLoadName, daemonSurffix)[0]
|
|
ctl := ResourceControllers.Controllers[Daemonsets]
|
|
_, items, _ := ctl.ListWithConditions(fmt.Sprintf("namespace='%s' and name = '%s'", namespace, name), nil)
|
|
works.Daemonsets = append(works.Daemonsets, items.([]Daemonset)...)
|
|
continue
|
|
}
|
|
|
|
if strings.HasSuffix(workLoadName, stateSurffix) {
|
|
name := strings.Split(workLoadName, stateSurffix)[0]
|
|
ctl := ResourceControllers.Controllers[Statefulsets]
|
|
_, items, _ := ctl.ListWithConditions(fmt.Sprintf("namespace='%s' and name = '%s'", namespace, name), nil)
|
|
works.Statefulsets = append(works.Statefulsets, items.([]Statefulset)...)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
return &works
|
|
}
|
|
|
|
//
|
|
//func (ctl *ApplicationCtl) getCreator(desc string) string {
|
|
// var dc description
|
|
// err := json.Unmarshal([]byte(desc), &dc)
|
|
// if err != nil {
|
|
// return unknown
|
|
// }
|
|
// return dc.Creator
|
|
//}
|
|
|
|
func (ctl *ApplicationCtl) getLabels(namespace string, workloads *workLoads) *[]map[string]string {
|
|
k8sClient := client.NewK8sClient()
|
|
|
|
var workloadLables []map[string]string
|
|
if workloads == nil {
|
|
return nil
|
|
}
|
|
|
|
for _, workload := range workloads.Deployments {
|
|
deploy, err := k8sClient.AppsV1().Deployments(namespace).Get(workload.Name, metaV1.GetOptions{})
|
|
if errors.IsNotFound(err) {
|
|
continue
|
|
}
|
|
workloadLables = append(workloadLables, deploy.Labels)
|
|
}
|
|
|
|
for _, workload := range workloads.Daemonsets {
|
|
daemonset, err := k8sClient.AppsV1().DaemonSets(namespace).Get(workload.Name, metaV1.GetOptions{})
|
|
if errors.IsNotFound(err) {
|
|
continue
|
|
}
|
|
workloadLables = append(workloadLables, daemonset.Labels)
|
|
}
|
|
|
|
for _, workload := range workloads.Statefulsets {
|
|
statefulset, err := k8sClient.AppsV1().StatefulSets(namespace).Get(workload.Name, metaV1.GetOptions{})
|
|
if errors.IsNotFound(err) {
|
|
continue
|
|
}
|
|
workloadLables = append(workloadLables, statefulset.Labels)
|
|
}
|
|
|
|
return &workloadLables
|
|
}
|
|
|
|
func isExist(svcs []Service, svc v1.Service) bool {
|
|
for _, item := range svcs {
|
|
if item.Name == svc.Name && item.Namespace == svc.Namespace {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ctl *ApplicationCtl) getSvcs(namespace string, workLoadLabels *[]map[string]string) *[]Service {
|
|
if len(*workLoadLabels) == 0 {
|
|
return nil
|
|
}
|
|
k8sClient := client.NewK8sClient()
|
|
var services []Service
|
|
for _, label := range *workLoadLabels {
|
|
labelSelector := labels.Set(label).AsSelector().String()
|
|
svcs, err := k8sClient.CoreV1().Services(namespace).List(metaV1.ListOptions{LabelSelector: labelSelector})
|
|
if err != nil {
|
|
glog.Errorf("get app's svc failed, reason: %v", err)
|
|
}
|
|
for _, item := range svcs.Items {
|
|
if !isExist(services, item) {
|
|
services = append(services, *generateSvcObject(item))
|
|
}
|
|
}
|
|
}
|
|
|
|
return &services
|
|
}
|
|
|
|
func (ctl *ApplicationCtl) getIng(namespace string, services *[]Service) *[]ing {
|
|
if services == nil {
|
|
return nil
|
|
}
|
|
|
|
ingCtl := ResourceControllers.Controllers[Ingresses]
|
|
var ings []ing
|
|
for _, svc := range *services {
|
|
_, items, err := ingCtl.ListWithConditions(fmt.Sprintf("namespace = '%s' and rules like '%%%s%%' ", namespace, svc.Name), nil)
|
|
if err != nil {
|
|
glog.Error(err)
|
|
return nil
|
|
}
|
|
|
|
glog.Error(items)
|
|
for _, ingress := range items.([]Ingress) {
|
|
var rules []ingressRule
|
|
err := json.Unmarshal([]byte(ingress.Rules), &rules)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
exist := false
|
|
var tmpRules []ingressRule
|
|
for _, rule := range rules {
|
|
if rule.Service == svc.Name {
|
|
exist = true
|
|
tmpRules = append(tmpRules, rule)
|
|
}
|
|
}
|
|
|
|
if exist {
|
|
ings = append(ings, ing{Name: ingress.Name, Rules: tmpRules})
|
|
}
|
|
}
|
|
}
|
|
|
|
return &ings
|
|
}
|
|
|
|
func (ctl *ApplicationCtl) ListApplication(runtimeId string, match, fuzzy map[string]string, paging *Paging) (int, interface{}, error) {
|
|
limit := paging.Limit
|
|
offset := paging.Offset
|
|
if strings.HasSuffix(ctl.OpenpitrixAddr, "/") {
|
|
ctl.OpenpitrixAddr = strings.TrimSuffix(ctl.OpenpitrixAddr, "/")
|
|
}
|
|
|
|
defaultStatus := "status=active&status=stopped&status=pending&status=ceased"
|
|
|
|
url := fmt.Sprintf("%s/v1/clusters?limit=%s&offset=%s", ctl.OpenpitrixAddr, strconv.Itoa(limit), strconv.Itoa(offset))
|
|
|
|
if len(fuzzy["name"]) > 0 {
|
|
url = fmt.Sprintf("%s&search_word=%s", url, fuzzy["name"])
|
|
}
|
|
|
|
if len(match["status"]) > 0 {
|
|
url = fmt.Sprintf("%s&status=%s", url, match["status"])
|
|
} else {
|
|
url = fmt.Sprintf("%s&%s", url, defaultStatus)
|
|
}
|
|
|
|
if len(runtimeId) > 0 {
|
|
url = fmt.Sprintf("%s&runtime_id=%s", url, runtimeId)
|
|
}
|
|
|
|
resp, err := makeHttpRequest("GET", url, "")
|
|
if err != nil {
|
|
glog.Errorf("request %s failed, reason: %s", url, err)
|
|
return 0, nil, err
|
|
}
|
|
|
|
var clusterList clusters
|
|
err = json.Unmarshal(resp, &clusterList)
|
|
|
|
if err != nil {
|
|
return 0, nil, err
|
|
}
|
|
|
|
var apps []Application
|
|
|
|
for _, item := range clusterList.Clusters {
|
|
var app Application
|
|
|
|
app.Name = item.Name
|
|
app.ClusterID = item.ClusterID
|
|
app.UpdateTime = item.UpdateTime
|
|
app.Status = item.Status
|
|
versionInfo, _ := ctl.GetVersion(item.VersionID)
|
|
app.Version = versionInfo
|
|
app.VersionId = item.VersionID
|
|
runtimeInfo, _ := ctl.GetRuntime(item.RunTimeId)
|
|
app.Runtime = runtimeInfo
|
|
app.RuntimeId = item.RunTimeId
|
|
appInfo, _, appId, _ := ctl.GetAppInfo(item.AppID)
|
|
app.App = appInfo
|
|
app.AppId = appId
|
|
|
|
apps = append(apps, app)
|
|
}
|
|
|
|
return clusterList.Total, apps, nil
|
|
}
|
|
|
|
func (ctl *ApplicationCtl) GetApp(clusterId string) (*Application, error) {
|
|
if strings.HasSuffix(ctl.OpenpitrixAddr, "/") {
|
|
ctl.OpenpitrixAddr = strings.TrimSuffix(ctl.OpenpitrixAddr, "/")
|
|
}
|
|
|
|
url := fmt.Sprintf("%s/v1/clusters?cluster_id=%s", ctl.OpenpitrixAddr, clusterId)
|
|
|
|
resp, err := makeHttpRequest("GET", url, "")
|
|
if err != nil {
|
|
glog.Error(err)
|
|
return nil, err
|
|
}
|
|
|
|
var clusterList clusters
|
|
err = json.Unmarshal(resp, &clusterList)
|
|
|
|
if err != nil {
|
|
glog.Error(err)
|
|
return nil, err
|
|
}
|
|
|
|
if len(clusterList.Clusters) == 0 {
|
|
return nil, fmt.Errorf("NotFound, clusterId:%s", clusterId)
|
|
}
|
|
|
|
item := clusterList.Clusters[0]
|
|
var app Application
|
|
|
|
app.Name = item.Name
|
|
app.ClusterID = item.ClusterID
|
|
app.UpdateTime = item.UpdateTime
|
|
app.CreateTime = item.CreateTime
|
|
app.Status = item.Status
|
|
versionInfo, _ := ctl.GetVersion(item.VersionID)
|
|
app.Version = versionInfo
|
|
app.VersionId = item.VersionID
|
|
|
|
runtimeInfo, _ := ctl.GetRuntime(item.RunTimeId)
|
|
app.Runtime = runtimeInfo
|
|
app.RuntimeId = item.RunTimeId
|
|
appInfo, repoId, appId, _ := ctl.GetAppInfo(item.AppID)
|
|
app.App = appInfo
|
|
app.AppId = appId
|
|
app.Description = item.Description
|
|
|
|
app.RepoName, _ = ctl.GetRepo(repoId)
|
|
app.WorkLoads = ctl.GetWorkLoads(app.Runtime, item.ClusterRoleSets)
|
|
workloadLabels := ctl.getLabels(app.Runtime, app.WorkLoads)
|
|
app.Services = ctl.getSvcs(app.Runtime, workloadLabels)
|
|
app.Ingresses = ctl.getIng(app.Runtime, app.Services)
|
|
|
|
return &app, nil
|
|
}
|