Report total memory under management for licensing

cmd/licensing-info/main.go

@@ -0,0 +1,51 @@
+// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+// or more contributor license agreements. Licensed under the Elastic License;
+// you may not use this file except in compliance with the Elastic License.
+
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+
+	eckscheme "github.com/elastic/cloud-on-k8s/pkg/controller/common/scheme"
+	"github.com/elastic/cloud-on-k8s/pkg/resource"
+	"k8s.io/client-go/kubernetes/scheme"
+	_ "k8s.io/client-go/plugin/pkg/client/auth/gcp" // auth on gke
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/client/config"
+)
+
+func main() {
+	licensingInfo, err := resource.NewLicensingReporter(newK8sClient()).Get()
+	if err != nil {
+		log.Fatal(err, "Failed to get licensing info")
+	}
+
+	bytes, err := json.Marshal(licensingInfo)
+	if err != nil {
+		log.Fatal(err, "Failed to marshal licensing info")
+	}
+
+	fmt.Print(string(bytes))
+}
+
+func newK8sClient() client.Client {
+	cfg, err := config.GetConfig()
+	if err != nil {
+		log.Fatal(err, "Failed to get a Kubernetes config")
+	}
+
+	err = eckscheme.SetupScheme()
+	if err != nil {
+		log.Fatal(err, "Failed to set up the ECK scheme")
+	}
+
+	c, err := client.New(cfg, client.Options{Scheme: scheme.Scheme})
+	if err != nil {
+		log.Fatal(err, "Failed to create a new Kubernetes client")
+	}
+
+	return c
+}

cmd/manager/main.go

@@ -12,15 +12,14 @@ import (
 	"strings"
 	"time"
 
-	"k8s.io/client-go/rest"
-
 	// allow gcp authentication
 	_ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"k8s.io/client-go/kubernetes"
 	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
+	"k8s.io/client-go/rest"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/cache"
 	logf "sigs.k8s.io/controller-runtime/pkg/log"
@@ -45,6 +44,7 @@ import (
 	"github.com/elastic/cloud-on-k8s/pkg/controller/webhook"
 	"github.com/elastic/cloud-on-k8s/pkg/dev"
 	"github.com/elastic/cloud-on-k8s/pkg/dev/portforward"
+	"github.com/elastic/cloud-on-k8s/pkg/resource"
 	"github.com/elastic/cloud-on-k8s/pkg/utils/net"
 )
 
@@ -321,6 +321,9 @@ func execute() {
 			log.Error(err, "unable to create controller", "controller", "LicenseTrial")
 			os.Exit(1)
 		}
+
+		r := resource.NewLicensingReporter(mgr.GetClient())
+		go r.Start(operatorNamespace)
 	}
 
 	log.Info("Starting the manager", "uuid", operatorInfo.OperatorUUID,

pkg/controller/apmserver/pod.go

@@ -31,14 +31,17 @@ const (
 	ConfigVolumePath = ApmBaseDir + "/config"
 )
 
-var DefaultResources = corev1.ResourceRequirements{
-	Requests: map[corev1.ResourceName]resource.Quantity{
-		corev1.ResourceMemory: resource.MustParse("512Mi"),
-	},
-	Limits: map[corev1.ResourceName]resource.Quantity{
-		corev1.ResourceMemory: resource.MustParse("512Mi"),
-	},
-}
+var (
+	DefaultMemoryLimits = resource.MustParse("512Mi")
+	DefaultResources    = corev1.ResourceRequirements{
+		Requests: map[corev1.ResourceName]resource.Quantity{
+			corev1.ResourceMemory: DefaultMemoryLimits,
+		},
+		Limits: map[corev1.ResourceName]resource.Quantity{
+			corev1.ResourceMemory: DefaultMemoryLimits,
+		},
+	}
+)
 
 func readinessProbe(tls bool) corev1.Probe {
 	scheme := corev1.URISchemeHTTP

pkg/controller/common/license/check.go

@@ -5,6 +5,7 @@
 package license
 
 import (
+	"sort"
 	"time"
 
 	"github.com/elastic/cloud-on-k8s/pkg/utils/k8s"
@@ -14,6 +15,7 @@ import (
 )
 
 type Checker interface {
+	CurrentEnterpriseLicense() (*EnterpriseLicense, error)
 	EnterpriseFeaturesEnabled() (bool, error)
 	Valid(l EnterpriseLicense) (bool, error)
 }
@@ -45,23 +47,42 @@ func (lc *checker) publicKeyFor(l EnterpriseLicense) ([]byte, error) {
 	}, &signatureSec)
 }
 
-// EnterpriseFeaturesEnabled returns true if a valid enterprise license is installed.
-func (lc *checker) EnterpriseFeaturesEnabled() (bool, error) {
+// CurrentEnterpriseLicense returns the currently valid Enterprise license if installed.
+func (lc *checker) CurrentEnterpriseLicense() (*EnterpriseLicense, error) {
 	licenses, err := EnterpriseLicenses(lc.k8sClient)
 	if err != nil {
-		return false, errors.Wrap(err, "failed to list enterprise licenses")
+		return nil, errors.Wrap(err, "failed to list enterprise licenses")
 	}
 
+	sort.Slice(licenses, func(i, j int) bool {
+		t1, t2 := EnterpriseLicenseTypeOrder[licenses[i].License.Type], EnterpriseLicenseTypeOrder[licenses[j].License.Type]
+		if t1 != t2 { // sort by type (first the most features)
+			return t1 > t2
+		}
+		// and by expiry date (first which expires in a long time)
+		return licenses[i].License.ExpiryDateInMillis > licenses[j].License.ExpiryDateInMillis
+	})
+
+	// pick the first valid Enterprise license in the sorted slice
 	for _, l := range licenses {
 		valid, err := lc.Valid(l)
 		if err != nil {
-			return false, err
+			return nil, err
 		}
 		if valid {
-			return true, nil
+			return &l, nil
 		}
 	}
-	return false, nil
+	return nil, nil
+}
+
+// EnterpriseFeaturesEnabled returns true if a valid enterprise license is installed.
+func (lc *checker) EnterpriseFeaturesEnabled() (bool, error) {
+	license, err := lc.CurrentEnterpriseLicense()
+	if err != nil {
+		return false, err
+	}
+	return license != nil, nil
 }
 
 // Valid returns true if the given Enterprise license is valid or an error if any.
@@ -83,6 +104,10 @@ func (lc *checker) Valid(l EnterpriseLicense) (bool, error) {
 
 type MockChecker struct{}
 
+func (MockChecker) CurrentEnterpriseLicense() (*EnterpriseLicense, error) {
+	return &EnterpriseLicense{}, nil
+}
+
 func (MockChecker) EnterpriseFeaturesEnabled() (bool, error) {
 	return true, nil
 }

pkg/controller/common/license/model.go

@@ -43,6 +43,12 @@ type LicenseSpec struct {
 	ClusterLicenses    []ElasticsearchLicense `json:"cluster_licenses"`
 }
 
+// EnterpriseLicenseTypeOrder license types mapped to ints in increasing order of feature sets for sorting purposes.
+var EnterpriseLicenseTypeOrder = map[OperatorLicenseType]int{
+	LicenseTypeEnterpriseTrial: 0,
+	LicenseTypeEnterprise:      1,
+}
+
 // StartTime is the date as of which this license is valid.
 func (l EnterpriseLicense) StartTime() time.Time {
 	return time.Unix(0, l.License.StartDateInMillis*int64(time.Millisecond))

pkg/controller/elasticsearch/nodespec/defaults.go

@@ -35,17 +35,18 @@ var (
 		{Name: "transport", ContainerPort: network.TransportPort, Protocol: corev1.ProtocolTCP},
 	}
 
+	DefaultMemoryLimits = resource.MustParse("2Gi")
 	// DefaultResources for the Elasticsearch container. The JVM default heap size is 1Gi, so we
 	// request at least 2Gi for the container to make sure ES can work properly.
 	// Not applying this minimum default would make ES randomly crash (OOM) on small machines.
 	// Similarly, we apply a default memory limit of 2Gi, to ensure the Pod isn't the first one to get evicted.
 	// No CPU requirement is set by default.
 	DefaultResources = corev1.ResourceRequirements{
 		Requests: map[corev1.ResourceName]resource.Quantity{
-			corev1.ResourceMemory: resource.MustParse("2Gi"),
+			corev1.ResourceMemory: DefaultMemoryLimits,
 		},
 		Limits: map[corev1.ResourceName]resource.Quantity{
-			corev1.ResourceMemory: resource.MustParse("2Gi"),
+			corev1.ResourceMemory: DefaultMemoryLimits,
 		},
 	}
 )

pkg/controller/kibana/config/settings.go

@@ -18,7 +18,11 @@ import (
 )
 
 // Kibana configuration settings file
-const SettingsFilename = "kibana.yml"
+const (
+	SettingsFilename = "kibana.yml"
+	EnvNodeOpts = "NODE_OPTS"
+)
+
 
 // CanonicalConfig contains configuration for Kibana ("kibana.yml"),
 // as a hierarchical key-value configuration.

pkg/controller/kibana/pod/pod.go

@@ -30,14 +30,17 @@ var ports = []corev1.ContainerPort{
 	{Name: "http", ContainerPort: int32(HTTPPort), Protocol: corev1.ProtocolTCP},
 }
 
-var DefaultResources = corev1.ResourceRequirements{
-	Requests: map[corev1.ResourceName]resource.Quantity{
-		corev1.ResourceMemory: resource.MustParse("1Gi"),
-	},
-	Limits: map[corev1.ResourceName]resource.Quantity{
-		corev1.ResourceMemory: resource.MustParse("1Gi"),
-	},
-}
+var (
+	DefaultMemoryLimits = resource.MustParse("1Gi")
+	DefaultResources    = corev1.ResourceRequirements{
+		Requests: map[corev1.ResourceName]resource.Quantity{
+			corev1.ResourceMemory: DefaultMemoryLimits,
+		},
+		Limits: map[corev1.ResourceName]resource.Quantity{
+			corev1.ResourceMemory: DefaultMemoryLimits,
+		},
+	}
+)
 
 // readinessProbe is the readiness probe for the Kibana container
 func readinessProbe(useTLS bool) corev1.Probe {

pkg/controller/license/license_controller.go

@@ -153,7 +153,7 @@ type ReconcileLicenses struct {
 	checker   license.Checker
 }
 
-// findLicense tries to find the best license available.
+// findLicense tries to find the best Elastic stack license available.
 func findLicense(c k8s.Client, checker license.Checker, minVersion *version.Version) (esclient.License, string, bool) {
 	licenseList, errs := license.EnterpriseLicensesOrErrors(c)
 	if len(errs) > 0 {
@@ -220,9 +220,6 @@ func (r *ReconcileLicenses) reconcileClusterLicense(cluster esv1.Elasticsearch)
 		return noResult, true, err
 	}
 	matchingSpec, parent, found := findLicense(r, r.checker, minVersion)
-	if err != nil {
-		return noResult, true, err
-	}
 	if !found {
 		// no license, delete cluster level licenses to revert to basic
 		log.V(1).Info("No enterprise license found. Attempting to remove cluster license secret", "namespace", cluster.Namespace, "es_name", cluster.Name)