Merge branch 'master' into init_container_0.1.0

api/integreatly/v1alpha1/grafana_types.go

@@ -41,7 +41,7 @@ type GrafanaSpec struct {
 
 	// DashboardContentCacheDuration sets a default for when a `GrafanaDashboard` resource doesn't specify a `contentCacheDuration`.
 	// If left unset or 0 the default behavior is to cache indefinitely.
-	DashboardContentCacheDuration *metav1.Duration `json:"dashboardContentCacheDuration,omitempty"`
+	DashboardContentCacheDuration metav1.Duration `json:"dashboardContentCacheDuration,omitempty"`
 }
 
 type ReadinessProbeSpec struct {
@@ -107,15 +107,16 @@ type GrafanaDeployment struct {
 	Annotations map[string]string `json:"annotations,omitempty"`
 	Labels      map[string]string `json:"labels,omitempty"`
 	// +nullable
-	Replicas                      *int32                 `json:"replicas,omitempty"`
-	NodeSelector                  map[string]string      `json:"nodeSelector,omitempty"`
-	Tolerations                   []v1.Toleration        `json:"tolerations,omitempty"`
-	Affinity                      *v1.Affinity           `json:"affinity,omitempty"`
-	SecurityContext               *v1.PodSecurityContext `json:"securityContext,omitempty"`
-	ContainerSecurityContext      *v1.SecurityContext    `json:"containerSecurityContext,omitempty"`
-	TerminationGracePeriodSeconds *int64                 `json:"terminationGracePeriodSeconds,omitempty"`
-	EnvFrom                       []v1.EnvFromSource     `json:"envFrom,omitempty"`
-	Env                           []v1.EnvVar            `json:"env,omitempty"`
+	Replicas                      *int32                        `json:"replicas,omitempty"`
+	NodeSelector                  map[string]string             `json:"nodeSelector,omitempty"`
+	Tolerations                   []v1.Toleration               `json:"tolerations,omitempty"`
+	Affinity                      *v1.Affinity                  `json:"affinity,omitempty"`
+	TopologySpreadConstraints     []v1.TopologySpreadConstraint `json:"topologySpreadConstraints,omitempty"`
+	SecurityContext               *v1.PodSecurityContext        `json:"securityContext,omitempty"`
+	ContainerSecurityContext      *v1.SecurityContext           `json:"containerSecurityContext,omitempty"`
+	TerminationGracePeriodSeconds *int64                        `json:"terminationGracePeriodSeconds,omitempty"`
+	EnvFrom                       []v1.EnvFromSource            `json:"envFrom,omitempty"`
+	Env                           []v1.EnvVar                   `json:"env,omitempty"`
 	// +nullable
 	SkipCreateAdminAccount *bool  `json:"skipCreateAdminAccount,omitempty"`
 	PriorityClassName      string `json:"priorityClassName,omitempty"`

api/integreatly/v1alpha1/grafanadashboard_types.go

@@ -18,14 +18,14 @@ package v1alpha1
 
 import (
 	"bytes"
-	"crypto/sha1" // nolint
+	"compress/gzip"
+	"crypto/sha1" //nolint
 	"crypto/sha256"
 	"encoding/json"
 	"fmt"
 	"io"
 	"io/ioutil"
-
-	"compress/gzip"
+	"time"
 
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -82,7 +82,7 @@ type GrafanaDashboardRef struct {
 
 type GrafanaDashboardStatus struct {
 	ContentCache     []byte                 `json:"contentCache,omitempty"`
-	ContentTimestamp *metav1.Time           `json:"contentTimestamp,omitempty"`
+	ContentTimestamp metav1.Time            `json:"contentTimestamp,omitempty"`
 	ContentUrl       string                 `json:"contentUrl,omitempty"`
 	Error            *GrafanaDashboardError `json:"error,omitempty"`
 }
@@ -171,7 +171,7 @@ func (d *GrafanaDashboard) Parse(optional string) (map[string]interface{}, error
 		dashboardBytes = []byte(optional)
 	}
 
-	var parsed = make(map[string]interface{})
+	parsed := make(map[string]interface{})
 	err := json.Unmarshal(dashboardBytes, &parsed)
 	return parsed, err
 }
@@ -191,6 +191,34 @@ func (d *GrafanaDashboard) UID() string {
 	return fmt.Sprintf("%x", sha1.Sum([]byte(d.Namespace+d.Name))) // nolint
 }
 
+func (d *GrafanaDashboard) GetContentCache(url string) string {
+	var cacheDuration time.Duration
+	if d.Spec.ContentCacheDuration != nil {
+		cacheDuration = d.Spec.ContentCacheDuration.Duration
+	}
+
+	return d.Status.getContentCache(url, cacheDuration)
+}
+
+// getContentCache returns content cache when the following conditions are met: url is the same, data is not expired, gzipped data is not corrupted
+func (s *GrafanaDashboardStatus) getContentCache(url string, cacheDuration time.Duration) string {
+	if s.ContentUrl != url {
+		return ""
+	}
+
+	notExpired := cacheDuration <= 0 || s.ContentTimestamp.Add(cacheDuration).After(time.Now())
+	if !notExpired {
+		return ""
+	}
+
+	cache, err := Gunzip(s.ContentCache)
+	if err != nil {
+		return ""
+	}
+
+	return string(cache)
+}
+
 func Gunzip(compressed []byte) ([]byte, error) {
 	decoder, err := gzip.NewReader(bytes.NewReader(compressed))
 	if err != nil {

api/integreatly/v1alpha1/grafanadashboard_types_test.go

@@ -7,6 +7,10 @@ import (
 	"reflect"
 	"strings"
 	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
 // Encoded via cat | gzip | base64
@@ -78,3 +82,86 @@ func TestDecompress(t *testing.T) {
 		t.Fail()
 	}
 }
+
+func TestGrafanaDashboardStatus_getContentCache(t *testing.T) {
+	timestamp := metav1.Time{Time: time.Now().Add(-1 * time.Hour)}
+	infinite := 0 * time.Second
+	dashboardJSON := `{"dummyField": "dummyData"}`
+
+	cachedDashboard, err := Gzip(dashboardJSON)
+	assert.Nil(t, err)
+
+	url := "http://127.0.0.1:8080/1.json"
+
+	// Correctly populated cache
+	status := GrafanaDashboardStatus{
+		ContentCache:     cachedDashboard,
+		ContentTimestamp: timestamp,
+		ContentUrl:       url,
+	}
+
+	// Corrupted cache
+	statusCorrupted := GrafanaDashboardStatus{
+		ContentCache:     []byte("abc"),
+		ContentTimestamp: timestamp,
+		ContentUrl:       url,
+	}
+
+	tests := []struct {
+		name     string
+		status   GrafanaDashboardStatus
+		url      string
+		duration time.Duration
+		want     string
+	}{
+		{
+			name:     "no cache: fields are not populated",
+			url:      status.ContentUrl,
+			duration: infinite,
+			status:   GrafanaDashboardStatus{},
+			want:     "",
+		},
+		{
+			name:     "no cache: url is different",
+			url:      "http://another-url/2.json",
+			duration: infinite,
+			status:   status,
+			want:     "",
+		},
+		{
+			name:     "no cache: expired",
+			url:      status.ContentUrl,
+			duration: 1 * time.Minute,
+			status:   status,
+			want:     "",
+		},
+		{
+			name:     "no cache: corrupted gzip",
+			url:      statusCorrupted.ContentUrl,
+			duration: infinite,
+			status:   statusCorrupted,
+			want:     "",
+		},
+		{
+			name:     "valid cache: not expired yet",
+			url:      status.ContentUrl,
+			duration: 24 * time.Hour,
+			status:   status,
+			want:     dashboardJSON,
+		},
+		{
+			name:     "valid cache: not expired yet (infinite)",
+			url:      status.ContentUrl,
+			duration: infinite,
+			status:   status,
+			want:     dashboardJSON,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := tt.status.getContentCache(tt.url, tt.duration)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}

config/crd/bases/integreatly.org_grafanas.yaml

@@ -5201,6 +5201,143 @@ spec:
                           type: string
                       type: object
                     type: array
+                  topologySpreadConstraints:
+                    items:
+                      description: TopologySpreadConstraint specifies how to spread
+                        matching pods among the given topology.
+                      properties:
+                        labelSelector:
+                          description: LabelSelector is used to find matching pods.
+                            Pods that match this label selector are counted to determine
+                            the number of pods in their corresponding topology domain.
+                          properties:
+                            matchExpressions:
+                              description: matchExpressions is a list of label selector
+                                requirements. The requirements are ANDed.
+                              items:
+                                description: A label selector requirement is a selector
+                                  that contains values, a key, and an operator that
+                                  relates the key and values.
+                                properties:
+                                  key:
+                                    description: key is the label key that the selector
+                                      applies to.
+                                    type: string
+                                  operator:
+                                    description: operator represents a key's relationship
+                                      to a set of values. Valid operators are In,
+                                      NotIn, Exists and DoesNotExist.
+                                    type: string
+                                  values:
+                                    description: values is an array of string values.
+                                      If the operator is In or NotIn, the values array
+                                      must be non-empty. If the operator is Exists
+                                      or DoesNotExist, the values array must be empty.
+                                      This array is replaced during a strategic merge
+                                      patch.
+                                    items:
+                                      type: string
+                                    type: array
+                                required:
+                                - key
+                                - operator
+                                type: object
+                              type: array
+                            matchLabels:
+                              additionalProperties:
+                                type: string
+                              description: matchLabels is a map of {key,value} pairs.
+                                A single {key,value} in the matchLabels map is equivalent
+                                to an element of matchExpressions, whose key field
+                                is "key", the operator is "In", and the values array
+                                contains only "value". The requirements are ANDed.
+                              type: object
+                          type: object
+                        maxSkew:
+                          description: 'MaxSkew describes the degree to which pods
+                            may be unevenly distributed. When `whenUnsatisfiable=DoNotSchedule`,
+                            it is the maximum permitted difference between the number
+                            of matching pods in the target topology and the global
+                            minimum. The global minimum is the minimum number of matching
+                            pods in an eligible domain or zero if the number of eligible
+                            domains is less than MinDomains. For example, in a 3-zone
+                            cluster, MaxSkew is set to 1, and pods with the same labelSelector
+                            spread as 2/2/1: In this case, the global minimum is 1.
+                            | zone1 | zone2 | zone3 | |  P P  |  P P  |   P   | -
+                            if MaxSkew is 1, incoming pod can only be scheduled to
+                            zone3 to become 2/2/2; scheduling it onto zone1(zone2)
+                            would make the ActualSkew(3-1) on zone1(zone2) violate
+                            MaxSkew(1). - if MaxSkew is 2, incoming pod can be scheduled
+                            onto any zone. When `whenUnsatisfiable=ScheduleAnyway`,
+                            it is used to give higher precedence to topologies that
+                            satisfy it. It''s a required field. Default value is 1
+                            and 0 is not allowed.'
+                          format: int32
+                          type: integer
+                        minDomains:
+                          description: "MinDomains indicates a minimum number of eligible
+                            domains. When the number of eligible domains with matching
+                            topology keys is less than minDomains, Pod Topology Spread
+                            treats \"global minimum\" as 0, and then the calculation
+                            of Skew is performed. And when the number of eligible
+                            domains with matching topology keys equals or greater
+                            than minDomains, this value has no effect on scheduling.
+                            As a result, when the number of eligible domains is less
+                            than minDomains, scheduler won't schedule more than maxSkew
+                            Pods to those domains. If value is nil, the constraint
+                            behaves as if MinDomains is equal to 1. Valid values are
+                            integers greater than 0. When value is not nil, WhenUnsatisfiable
+                            must be DoNotSchedule. \n For example, in a 3-zone cluster,
+                            MaxSkew is set to 2, MinDomains is set to 5 and pods with
+                            the same labelSelector spread as 2/2/2: | zone1 | zone2
+                            | zone3 | |  P P  |  P P  |  P P  | The number of domains
+                            is less than 5(MinDomains), so \"global minimum\" is treated
+                            as 0. In this situation, new pod with the same labelSelector
+                            cannot be scheduled, because computed skew will be 3(3
+                            - 0) if new Pod is scheduled to any of the three zones,
+                            it will violate MaxSkew. \n This is an alpha field and
+                            requires enabling MinDomainsInPodTopologySpread feature
+                            gate."
+                          format: int32
+                          type: integer
+                        topologyKey:
+                          description: TopologyKey is the key of node labels. Nodes
+                            that have a label with this key and identical values are
+                            considered to be in the same topology. We consider each
+                            <key, value> as a "bucket", and try to put balanced number
+                            of pods into each bucket. We define a domain as a particular
+                            instance of a topology. Also, we define an eligible domain
+                            as a domain whose nodes match the node selector. e.g.
+                            If TopologyKey is "kubernetes.io/hostname", each Node
+                            is a domain of that topology. And, if TopologyKey is "topology.kubernetes.io/zone",
+                            each zone is a domain of that topology. It's a required
+                            field.
+                          type: string
+                        whenUnsatisfiable:
+                          description: 'WhenUnsatisfiable indicates how to deal with
+                            a pod if it doesn''t satisfy the spread constraint. -
+                            DoNotSchedule (default) tells the scheduler not to schedule
+                            it. - ScheduleAnyway tells the scheduler to schedule the
+                            pod in any location,   but giving higher precedence to
+                            topologies that would help reduce the   skew. A constraint
+                            is considered "Unsatisfiable" for an incoming pod if and
+                            only if every possible node assignment for that pod would
+                            violate "MaxSkew" on some topology. For example, in a
+                            3-zone cluster, MaxSkew is set to 1, and pods with the
+                            same labelSelector spread as 3/1/1: | zone1 | zone2 |
+                            zone3 | | P P P |   P   |   P   | If WhenUnsatisfiable
+                            is set to DoNotSchedule, incoming pod can only be scheduled
+                            to zone2(zone3) to become 3/2/1(3/1/2) as ActualSkew(2-1)
+                            on zone2(zone3) satisfies MaxSkew(1). In other words,
+                            the cluster can still be imbalanced, but scheduler won''t
+                            make it *more* imbalanced. It''s a required field.'
+                          type: string
+                      required:
+                      - maxSkew
+                      - topologyKey
+                      - whenUnsatisfiable
+                      type: object
+                    type: array
                 type: object
               ingress:
                 description: GrafanaIngress provides a means to configure the ingress

controllers/common/controllerState.go

@@ -7,7 +7,7 @@ var ControllerEvents = make(chan ControllerState, 1)
 type ControllerState struct {
 	DashboardSelectors            []*v1.LabelSelector
 	DashboardNamespaceSelector    *v1.LabelSelector
-	DashboardContentCacheDuration *v1.Duration
+	DashboardContentCacheDuration v1.Duration
 	AdminUrl                      string
 	GrafanaReady                  bool
 	ClientTimeout                 int