portainer/api/kubernetes/cli/service.go

package cli

import (
	"context"

	models "github.com/portainer/portainer/api/http/models/kubernetes"

	v1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	labels "k8s.io/apimachinery/pkg/labels"
	"k8s.io/apimachinery/pkg/util/intstr"
)

// GetServices gets all the services for a given namespace in a k8s endpoint.
func (kcl *KubeClient) GetServices(namespace string, lookupApplications bool) ([]models.K8sServiceInfo, error) {
	client := kcl.cli.CoreV1().Services(namespace)

	services, err := client.List(context.Background(), metav1.ListOptions{})
	if err != nil {
		return nil, err
	}

	var result []models.K8sServiceInfo

	for _, service := range services.Items {
		servicePorts := make([]models.K8sServicePort, 0)
		for _, port := range service.Spec.Ports {
			servicePorts = append(servicePorts, models.K8sServicePort{
				Name:       port.Name,
				NodePort:   int(port.NodePort),
				Port:       int(port.Port),
				Protocol:   string(port.Protocol),
				TargetPort: port.TargetPort.String(),
			})
		}

		ingressStatus := make([]models.K8sServiceIngress, 0)
		for _, status := range service.Status.LoadBalancer.Ingress {
			ingressStatus = append(ingressStatus, models.K8sServiceIngress{
				IP:   status.IP,
				Host: status.Hostname,
			})
		}

		var applications []models.K8sApplication
		if lookupApplications {
			applications, _ = kcl.getOwningApplication(namespace, service.Spec.Selector)
		}

		result = append(result, models.K8sServiceInfo{
			Name:                          service.Name,
			UID:                           string(service.GetUID()),
			Type:                          string(service.Spec.Type),
			Namespace:                     service.Namespace,
			CreationTimestamp:             service.GetCreationTimestamp().String(),
			AllocateLoadBalancerNodePorts: service.Spec.AllocateLoadBalancerNodePorts,
			Ports:                         servicePorts,
			IngressStatus:                 ingressStatus,
			Labels:                        service.GetLabels(),
			Annotations:                   service.GetAnnotations(),
			ClusterIPs:                    service.Spec.ClusterIPs,
			ExternalName:                  service.Spec.ExternalName,
			ExternalIPs:                   service.Spec.ExternalIPs,
			Applications:                  applications,
		})
	}

	return result, nil
}

func (kcl *KubeClient) fillService(info models.K8sServiceInfo) v1.Service {
	var service v1.Service

	service.Name = info.Name
	service.Spec.Type = v1.ServiceType(info.Type)
	service.Namespace = info.Namespace
	service.Annotations = info.Annotations
	service.Labels = info.Labels
	service.Spec.AllocateLoadBalancerNodePorts = info.AllocateLoadBalancerNodePorts
	service.Spec.Selector = info.Selector

	// Set ports.
	for _, p := range info.Ports {
		var port v1.ServicePort
		port.Name = p.Name
		port.NodePort = int32(p.NodePort)
		port.Port = int32(p.Port)
		port.Protocol = v1.Protocol(p.Protocol)
		port.TargetPort = intstr.FromString(p.TargetPort)
		service.Spec.Ports = append(service.Spec.Ports, port)
	}

	// Set ingresses.
	for _, i := range info.IngressStatus {
		service.Status.LoadBalancer.Ingress = append(
			service.Status.LoadBalancer.Ingress,
			v1.LoadBalancerIngress{IP: i.IP, Hostname: i.Host},
		)
	}

	return service
}

// CreateService creates a new service in a given namespace in a k8s endpoint.
func (kcl *KubeClient) CreateService(namespace string, info models.K8sServiceInfo) error {
	serviceClient := kcl.cli.CoreV1().Services(namespace)
	service := kcl.fillService(info)

	_, err := serviceClient.Create(context.Background(), &service, metav1.CreateOptions{})
	return err
}

// DeleteServices processes a K8sServiceDeleteRequest by deleting each service
// in its given namespace.
func (kcl *KubeClient) DeleteServices(reqs models.K8sServiceDeleteRequests) error {
	var err error
	for namespace := range reqs {
		for _, service := range reqs[namespace] {
			serviceClient := kcl.cli.CoreV1().Services(namespace)
			err = serviceClient.Delete(
				context.Background(),
				service,
				metav1.DeleteOptions{},
			)
		}
	}

	return err
}

// UpdateService updates service in a given namespace in a k8s endpoint.
func (kcl *KubeClient) UpdateService(namespace string, info models.K8sServiceInfo) error {
	serviceClient := kcl.cli.CoreV1().Services(namespace)
	service := kcl.fillService(info)

	_, err := serviceClient.Update(context.Background(), &service, metav1.UpdateOptions{})
	return err
}

// getOwningApplication gets the application that owns the given service selector.
func (kcl *KubeClient) getOwningApplication(namespace string, selector map[string]string) ([]models.K8sApplication, error) {
	if len(selector) == 0 {
		return nil, nil
	}

	selectorLabels := labels.SelectorFromSet(selector).String()

	// look for replicasets first, limit 1 (we only support one owner)
	replicasets, err := kcl.cli.AppsV1().ReplicaSets(namespace).List(context.TODO(), metav1.ListOptions{LabelSelector: selectorLabels, Limit: 1})
	if err != nil {
		return nil, err
	}

	var meta metav1.Object
	if replicasets != nil && len(replicasets.Items) > 0 {
		meta = replicasets.Items[0].GetObjectMeta()
	} else {
		// otherwise look for matching pods, limit 1 (we only support one owner)
		pods, err := kcl.cli.CoreV1().Pods(namespace).List(context.TODO(), metav1.ListOptions{LabelSelector: selectorLabels, Limit: 1})
		if err != nil {
			return nil, err
		}

		if pods == nil || len(pods.Items) == 0 {
			return nil, nil
		}

		meta = pods.Items[0].GetObjectMeta()
	}

	return makeApplication(meta), nil
}

func makeApplication(meta metav1.Object) []models.K8sApplication {
	ownerReferences := meta.GetOwnerReferences()
	if len(ownerReferences) == 0 {
		return nil
	}

	// Currently, we only support one owner reference
	ownerReference := ownerReferences[0]
	return []models.K8sApplication{
		{
			// Only the name is used right now, but we can add more fields in the future
			Name: ownerReference.Name,
		},
	}
}