mirror of
https://github.com/kubevela/kubevela.git
synced 2026-05-20 08:13:23 +00:00
f6664106a2
Signed-off-by: barnettZQG <barnett.zqg@gmail.com>
(cherry picked from commit 8852ac691a)
Co-authored-by: barnettZQG <barnett.zqg@gmail.com>
407 lines
11 KiB
Go
407 lines
11 KiB
Go
/*
|
|
Copyright 2021 The KubeVela 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 cli
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"strings"
|
|
|
|
. "github.com/onsi/ginkgo"
|
|
. "github.com/onsi/gomega"
|
|
corev1 "k8s.io/api/core/v1"
|
|
networkv1beta1 "k8s.io/api/networking/v1beta1"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"k8s.io/apimachinery/pkg/util/intstr"
|
|
"sigs.k8s.io/controller-runtime/pkg/client"
|
|
"sigs.k8s.io/yaml"
|
|
|
|
"github.com/oam-dev/kubevela/apis/core.oam.dev/common"
|
|
"github.com/oam-dev/kubevela/apis/core.oam.dev/v1beta1"
|
|
"github.com/oam-dev/kubevela/apis/types"
|
|
helmapi "github.com/oam-dev/kubevela/pkg/appfile/helm/flux2apis"
|
|
"github.com/oam-dev/kubevela/pkg/oam"
|
|
common2 "github.com/oam-dev/kubevela/pkg/utils/common"
|
|
)
|
|
|
|
var _ = Describe("Test velaQL", func() {
|
|
var appName = "test-velaql"
|
|
var namespace = "default"
|
|
It("Test GetServiceEndpoints", func() {
|
|
arg := common2.Args{}
|
|
arg.SetConfig(cfg)
|
|
arg.SetClient(k8sClient)
|
|
|
|
// prepare
|
|
testApp := &v1beta1.Application{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: appName,
|
|
Namespace: namespace,
|
|
},
|
|
Spec: v1beta1.ApplicationSpec{
|
|
Components: []common.ApplicationComponent{
|
|
{
|
|
Name: "endpoints-test",
|
|
Type: "webservice",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
err := k8sClient.Create(context.TODO(), testApp)
|
|
Expect(err).Should(BeNil())
|
|
|
|
testApp.Status = common.AppStatus{
|
|
AppliedResources: []common.ClusterObjectReference{
|
|
{
|
|
Cluster: "",
|
|
ObjectReference: corev1.ObjectReference{
|
|
Kind: "Ingress",
|
|
Namespace: "default",
|
|
Name: "ingress-http",
|
|
APIVersion: "networking.k8s.io/v1beta1",
|
|
},
|
|
},
|
|
{
|
|
Cluster: "",
|
|
ObjectReference: corev1.ObjectReference{
|
|
Kind: "Ingress",
|
|
Namespace: "default",
|
|
Name: "ingress-https",
|
|
APIVersion: "networking.k8s.io/v1",
|
|
},
|
|
},
|
|
{
|
|
Cluster: "",
|
|
ObjectReference: corev1.ObjectReference{
|
|
Kind: "Ingress",
|
|
Namespace: "default",
|
|
Name: "ingress-paths",
|
|
APIVersion: "networking.k8s.io/v1",
|
|
},
|
|
},
|
|
{
|
|
Cluster: "",
|
|
ObjectReference: corev1.ObjectReference{
|
|
Kind: "Service",
|
|
Namespace: "default",
|
|
Name: "nodeport",
|
|
},
|
|
},
|
|
{
|
|
Cluster: "",
|
|
ObjectReference: corev1.ObjectReference{
|
|
Kind: "Service",
|
|
Namespace: "default",
|
|
Name: "loadbalancer",
|
|
},
|
|
},
|
|
{
|
|
Cluster: "",
|
|
ObjectReference: corev1.ObjectReference{
|
|
Kind: helmapi.HelmReleaseGVK.Kind,
|
|
Namespace: "default",
|
|
Name: "helmRelease",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
err = k8sClient.Status().Update(context.TODO(), testApp)
|
|
Expect(err).Should(BeNil())
|
|
|
|
var mr []v1beta1.ManagedResource
|
|
for i := range testApp.Status.AppliedResources {
|
|
mr = append(mr, v1beta1.ManagedResource{
|
|
OAMObjectReference: common.OAMObjectReference{
|
|
Component: "endpoints-test",
|
|
},
|
|
ClusterObjectReference: testApp.Status.AppliedResources[i],
|
|
})
|
|
}
|
|
rt := &v1beta1.ResourceTracker{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: appName,
|
|
Namespace: namespace,
|
|
Labels: map[string]string{
|
|
oam.LabelAppName: testApp.Name,
|
|
oam.LabelAppNamespace: testApp.Namespace,
|
|
},
|
|
},
|
|
Spec: v1beta1.ResourceTrackerSpec{
|
|
Type: v1beta1.ResourceTrackerTypeRoot,
|
|
ManagedResources: mr,
|
|
},
|
|
}
|
|
err = k8sClient.Create(context.TODO(), rt)
|
|
Expect(err).Should(BeNil())
|
|
|
|
testServicelist := []map[string]interface{}{
|
|
{
|
|
"name": "clusterip",
|
|
"ports": []corev1.ServicePort{
|
|
{Port: 80, TargetPort: intstr.FromInt(80), Name: "80port"},
|
|
{Port: 81, TargetPort: intstr.FromInt(81), Name: "81port"},
|
|
},
|
|
"type": corev1.ServiceTypeClusterIP,
|
|
},
|
|
{
|
|
"name": "nodeport",
|
|
"ports": []corev1.ServicePort{
|
|
{Port: 80, TargetPort: intstr.FromInt(80), NodePort: 30229},
|
|
},
|
|
"type": corev1.ServiceTypeNodePort,
|
|
},
|
|
{
|
|
"name": "loadbalancer",
|
|
"ports": []corev1.ServicePort{
|
|
{Port: 80, TargetPort: intstr.FromInt(80), Name: "80port"},
|
|
{Port: 81, TargetPort: intstr.FromInt(81), Name: "81port"},
|
|
},
|
|
"type": corev1.ServiceTypeLoadBalancer,
|
|
"status": corev1.ServiceStatus{
|
|
LoadBalancer: corev1.LoadBalancerStatus{
|
|
Ingress: []corev1.LoadBalancerIngress{
|
|
{
|
|
IP: "10.10.10.10",
|
|
},
|
|
{
|
|
Hostname: "text.example.com",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"name": "helm1",
|
|
"ports": []corev1.ServicePort{
|
|
{Port: 80, NodePort: 30002, TargetPort: intstr.FromInt(80)},
|
|
},
|
|
"type": corev1.ServiceTypeNodePort,
|
|
"labels": map[string]string{
|
|
"helm.toolkit.fluxcd.io/name": "helmRelease",
|
|
"helm.toolkit.fluxcd.io/namespace": "default",
|
|
},
|
|
},
|
|
}
|
|
for _, s := range testServicelist {
|
|
service := &corev1.Service{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: s["name"].(string),
|
|
Namespace: "default",
|
|
},
|
|
Spec: corev1.ServiceSpec{
|
|
Ports: s["ports"].([]corev1.ServicePort),
|
|
Type: s["type"].(corev1.ServiceType),
|
|
},
|
|
}
|
|
|
|
if s["labels"] != nil {
|
|
service.Labels = s["labels"].(map[string]string)
|
|
}
|
|
err := k8sClient.Create(context.TODO(), service)
|
|
Expect(err).Should(BeNil())
|
|
if s["status"] != nil {
|
|
service.Status = s["status"].(corev1.ServiceStatus)
|
|
err := k8sClient.Status().Update(context.TODO(), service)
|
|
Expect(err).Should(BeNil())
|
|
}
|
|
}
|
|
var prefixbeta = networkv1beta1.PathTypePrefix
|
|
testIngress := []client.Object{
|
|
&networkv1beta1.Ingress{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "ingress-http",
|
|
Namespace: "default",
|
|
},
|
|
Spec: networkv1beta1.IngressSpec{
|
|
Rules: []networkv1beta1.IngressRule{
|
|
{
|
|
Host: "ingress.domain",
|
|
IngressRuleValue: networkv1beta1.IngressRuleValue{
|
|
HTTP: &networkv1beta1.HTTPIngressRuleValue{
|
|
Paths: []networkv1beta1.HTTPIngressPath{
|
|
{
|
|
Path: "/",
|
|
Backend: networkv1beta1.IngressBackend{
|
|
ServiceName: "clusterip",
|
|
ServicePort: intstr.FromInt(80),
|
|
},
|
|
PathType: &prefixbeta,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
&networkv1beta1.Ingress{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "ingress-https",
|
|
Namespace: "default",
|
|
},
|
|
Spec: networkv1beta1.IngressSpec{
|
|
TLS: []networkv1beta1.IngressTLS{
|
|
{
|
|
SecretName: "https-secret",
|
|
},
|
|
},
|
|
Rules: []networkv1beta1.IngressRule{
|
|
{
|
|
Host: "ingress.domain.https",
|
|
IngressRuleValue: networkv1beta1.IngressRuleValue{
|
|
HTTP: &networkv1beta1.HTTPIngressRuleValue{
|
|
Paths: []networkv1beta1.HTTPIngressPath{
|
|
{
|
|
Path: "/",
|
|
Backend: networkv1beta1.IngressBackend{
|
|
ServiceName: "clusterip",
|
|
ServicePort: intstr.FromInt(80),
|
|
},
|
|
PathType: &prefixbeta,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
&networkv1beta1.Ingress{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "ingress-paths",
|
|
Namespace: "default",
|
|
},
|
|
Spec: networkv1beta1.IngressSpec{
|
|
TLS: []networkv1beta1.IngressTLS{
|
|
{
|
|
SecretName: "https-secret",
|
|
},
|
|
},
|
|
Rules: []networkv1beta1.IngressRule{
|
|
{
|
|
Host: "ingress.domain.path",
|
|
IngressRuleValue: networkv1beta1.IngressRuleValue{
|
|
HTTP: &networkv1beta1.HTTPIngressRuleValue{
|
|
Paths: []networkv1beta1.HTTPIngressPath{
|
|
{
|
|
Path: "/test",
|
|
Backend: networkv1beta1.IngressBackend{
|
|
ServiceName: "clusterip",
|
|
ServicePort: intstr.FromInt(80),
|
|
},
|
|
PathType: &prefixbeta,
|
|
},
|
|
{
|
|
Path: "/test2",
|
|
Backend: networkv1beta1.IngressBackend{
|
|
ServiceName: "clusterip",
|
|
ServicePort: intstr.FromInt(80),
|
|
},
|
|
PathType: &prefixbeta,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
&networkv1beta1.Ingress{
|
|
TypeMeta: metav1.TypeMeta{
|
|
APIVersion: "networking.k8s.io/v1beta1",
|
|
},
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "ingress-helm",
|
|
Namespace: "default",
|
|
Labels: map[string]string{
|
|
"helm.toolkit.fluxcd.io/name": "helmRelease",
|
|
"helm.toolkit.fluxcd.io/namespace": "default",
|
|
},
|
|
},
|
|
Spec: networkv1beta1.IngressSpec{
|
|
Rules: []networkv1beta1.IngressRule{
|
|
{
|
|
Host: "ingress.domain.helm",
|
|
IngressRuleValue: networkv1beta1.IngressRuleValue{
|
|
HTTP: &networkv1beta1.HTTPIngressRuleValue{
|
|
Paths: []networkv1beta1.HTTPIngressPath{
|
|
{
|
|
Path: "/",
|
|
Backend: networkv1beta1.IngressBackend{
|
|
ServiceName: "clusterip",
|
|
ServicePort: intstr.FromInt(80),
|
|
},
|
|
PathType: &prefixbeta,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, ing := range testIngress {
|
|
err := k8sClient.Create(context.TODO(), ing)
|
|
Expect(err).Should(BeNil())
|
|
}
|
|
var node corev1.NodeList
|
|
err = k8sClient.List(context.TODO(), &node)
|
|
Expect(err).Should(BeNil())
|
|
var gatewayIP string
|
|
if len(node.Items) > 0 {
|
|
for _, address := range node.Items[0].Status.Addresses {
|
|
if address.Type == corev1.NodeInternalIP {
|
|
gatewayIP = address.Address
|
|
break
|
|
}
|
|
}
|
|
}
|
|
velaQL, err := ioutil.ReadFile("../../charts/vela-core/templates/velaql/endpoints.yaml")
|
|
Expect(err).Should(BeNil())
|
|
velaQLYaml := strings.Replace(string(velaQL), "{{ include \"systemDefinitionNamespace\" . }}", types.DefaultKubeVelaNS, 1)
|
|
var cm corev1.ConfigMap
|
|
err = yaml.Unmarshal([]byte(velaQLYaml), &cm)
|
|
Expect(err).Should(BeNil())
|
|
err = k8sClient.Create(context.Background(), &cm)
|
|
Expect(err).Should(BeNil())
|
|
endpoints, err := GetServiceEndpoints(context.TODO(), k8sClient, appName, namespace, arg, Filter{})
|
|
Expect(err).Should(BeNil())
|
|
urls := []string{
|
|
"http://ingress.domain",
|
|
"https://ingress.domain.https",
|
|
"https://ingress.domain.path/test",
|
|
"https://ingress.domain.path/test2",
|
|
fmt.Sprintf("http://%s:30229", gatewayIP),
|
|
"http://10.10.10.10",
|
|
"http://text.example.com",
|
|
"10.10.10.10:81",
|
|
"text.example.com:81",
|
|
// helmRelease
|
|
fmt.Sprintf("http://%s:30002", gatewayIP),
|
|
"http://ingress.domain.helm",
|
|
}
|
|
for i, endpoint := range endpoints {
|
|
Expect(endpoint.String()).Should(BeEquivalentTo(urls[i]))
|
|
}
|
|
})
|
|
})
|