resolve conflicts

Signed-off-by: huanggze <loganhuang@yunify.com>

pkg/models/log/logcollector.go

@@ -23,40 +23,13 @@ import (
 	"k8s.io/apimachinery/pkg/labels"
 	"kubesphere.io/kubesphere/pkg/constants"
 	"kubesphere.io/kubesphere/pkg/informers"
+	"kubesphere.io/kubesphere/pkg/utils/stringutils"
 	"reflect"
 	"strconv"
 	"strings"
 	"time"
 )
 
-func intersection(s1, s2 []string) (inter []string) {
-	hash := make(map[string]bool)
-	for _, e := range s1 {
-		hash[e] = true
-	}
-	for _, e := range s2 {
-		// If elements present in the hashmap then append intersection list.
-		if hash[e] {
-			inter = append(inter, e)
-		}
-	}
-	//Remove dups from slice.
-	inter = removeDups(inter)
-	return
-}
-
-//Remove dups from slice.
-func removeDups(elements []string) (nodups []string) {
-	encountered := make(map[string]bool)
-	for _, element := range elements {
-		if !encountered[element] {
-			nodups = append(nodups, element)
-			encountered[element] = true
-		}
-	}
-	return
-}
-
 func in(value interface{}, container interface{}) int {
 	if container == nil {
 		return -1
@@ -116,105 +89,68 @@ func queryLabel(label string, labelsQuery []string) bool {
 	return result
 }
 
-func QueryWorkspace(workspaceMatch string, workspaceQuery string) (bool, []string) {
-	if workspaceMatch == "" && workspaceQuery == "" {
-		return false, nil
-	}
+// list namespaces that match search conditions
+func MatchNamespace(nsFilter []string, nsQuery []string, wsFilter []string, wsQuery []string) (bool, []string) {
 
 	nsLister := informers.SharedInformerFactory().Core().V1().Namespaces().Lister()
 	nsList, err := nsLister.List(labels.Everything())
 	if err != nil {
-		glog.Error("failed to list namespace, error: ", err)
+		glog.Errorf("failed to list namespace, error: %s", err)
 		return true, nil
 	}
 
 	var namespaces []string
 
-	var hasMatch = false
-	var workspacesMatch []string
-	if workspaceMatch != "" {
-		workspacesMatch = strings.Split(strings.Replace(workspaceMatch, ",", " ", -1), " ")
-		hasMatch = true
-	}
-
-	var hasQuery = false
-	var workspacesQuery []string
-	if workspaceQuery != "" {
-		workspacesQuery = strings.Split(strings.ToLower(strings.Replace(workspaceQuery, ",", " ", -1)), " ")
-		hasQuery = true
+	// if no search condition is set on both namespace and workspace,
+	// then return all namespaces
+	if nsQuery == nil && nsFilter == nil && wsQuery == nil && wsFilter == nil {
+		for _, ns := range nsList {
+			namespaces = append(namespaces, ns.Name)
+		}
+		return false, namespaces
 	}
 
 	for _, ns := range nsList {
-		labels := ns.GetLabels()
-		_, ok := labels[constants.WorkspaceLabelKey]
-		if ok {
-			var namespaceCanAppend = true
-			if hasMatch {
-				if !matchLabel(labels[constants.WorkspaceLabelKey], workspacesMatch) {
-					namespaceCanAppend = false
-				}
-			}
-			if hasQuery {
-				if !queryLabel(strings.ToLower(labels[constants.WorkspaceLabelKey]), workspacesQuery) {
-					namespaceCanAppend = false
-				}
-			}
-
-			if namespaceCanAppend {
-				namespaces = append(namespaces, ns.GetName())
-			}
-		}
-	}
-
-	return true, namespaces
-}
-
-func MatchNamespace(namespaceMatch string, namespaceFilled bool, namespaces []string) (bool, []string) {
-	if namespaceMatch == "" {
-		return namespaceFilled, namespaces
-	}
-
-	namespacesMatch := strings.Split(strings.Replace(namespaceMatch, ",", " ", -1), " ")
-
-	if namespaceFilled {
-		return true, intersection(namespacesMatch, namespaces)
-	}
-
-	return true, namespacesMatch
-}
-
-func GetNamespaceCreationTimeMap(namespaces []string) (bool, map[string]string) {
-
-	namespaceWithCreationTime := make(map[string]string)
-
-	nsLister := informers.SharedInformerFactory().Core().V1().Namespaces().Lister()
-
-	if len(namespaces) == 0 {
-		nsList, err := nsLister.List(labels.Everything())
-		if err != nil {
-			glog.Error("failed to list namespace, error: ", err)
-			return true, namespaceWithCreationTime
-		}
-
-		for _, ns := range nsList {
+		if stringutils.StringIn(ns.Name, nsFilter) ||
+			stringutils.StringIn(ns.Annotations[constants.WorkspaceLabelKey], wsFilter) ||
+			containsIn(ns.Name, nsQuery) ||
+			containsIn(ns.Annotations[constants.WorkspaceLabelKey], wsQuery) {
 			namespaces = append(namespaces, ns.Name)
 		}
 	}
 
+	// if namespaces is equal to nil, indicates no namespace matched
+	// it causes the query to return no result
+	return namespaces == nil, namespaces
+}
+
+func containsIn(str string, subStrs []string) bool {
+	for _, sub := range subStrs {
+		if strings.Contains(str, sub) {
+			return true
+		}
+	}
+	return false
+}
+
+func MakeNamespaceCreationTimeMap(namespaces []string) map[string]string {
+
+	namespaceWithCreationTime := make(map[string]string)
+
+	nsLister := informers.SharedInformerFactory().Core().V1().Namespaces().Lister()
 	for _, item := range namespaces {
 		ns, err := nsLister.Get(item)
 		if err != nil {
-			glog.Error("failed to get namespace, error: ", err)
+			// the ns doesn't exist
 			continue
 		}
-
 		namespaceWithCreationTime[ns.Name] = strconv.FormatInt(ns.CreationTimestamp.UnixNano()/int64(time.Millisecond), 10)
 	}
 
-	return true, namespaceWithCreationTime
+	return namespaceWithCreationTime
 }
 
-func QueryWorkload(workloadMatch string, workloadQuery string, namespaces []string) (bool, []string) {
+func MatchWorkload(workloadMatch string, workloadQuery string, namespaces []string) (bool, []string) {
 	if workloadMatch == "" && workloadQuery == "" {
 		return false, nil
 	}
@@ -292,51 +228,7 @@ func QueryWorkload(workloadMatch string, workloadQuery string, namespaces []stri
 		}
 	}
 
-	return true, pods
-}
-
-func MatchPod(podMatch string, podFilled bool, pods []string) (bool, []string) {
-	if podMatch == "" {
-		return podFilled, pods
-	}
-
-	podsMatch := strings.Split(strings.Replace(podMatch, ",", " ", -1), " ")
-
-	if podFilled {
-		return true, intersection(podsMatch, pods)
-	}
-
-	return true, podsMatch
-}
-
-func MatchContainer(containerMatch string) (bool, []string) {
-	if containerMatch == "" {
-		return false, nil
-	}
-
-	return true, strings.Split(strings.Replace(containerMatch, ",", " ", -1), " ")
-}
-
-func GetWorkspaceOfNamesapce(namespace string) string {
-	var workspace string
-	workspace = ""
-
-	nsLister := informers.SharedInformerFactory().Core().V1().Namespaces().Lister()
-	nsList, err := nsLister.List(labels.Everything())
-	if err != nil {
-		glog.Error("failed to list namespace, error: ", err)
-		return workspace
-	}
-
-	for _, ns := range nsList {
-		if ns.GetName() == namespace {
-			labels := ns.GetLabels()
-			_, ok := labels[constants.WorkspaceLabelKey]
-			if ok {
-				workspace = labels[constants.WorkspaceLabelKey]
-			}
-		}
-	}
-
-	return workspace
+	// if workloads is equal to nil, indicates no workload matched
+	// it causes the query to return no result
+	return pods == nil, pods
 }