matsuri 0.1.0 → 0.3.0

data/lib/matsuri/kubernetes/deployment.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Matsuri
+  module Kubernetes
+    class Deployment < Matsuri::Kubernetes::Base
+      include Matsuri::Concerns::PodTemplate
+
+      let(:api_version) { 'apps/v1' }    # K8S 1.10
+      let(:kind)        { 'Deployment' } # http://kubernetes.io/docs/user-guide/deployments/
+
+      # Overridables
+
+      let(:spec) do
+        {
+          replicas: replicas,
+          selector: selector,
+          template: template,
+          strategy: strategy,
+          minReadySeconds: min_ready_seconds,
+          revisionHistoryLimit: revision_history_limit
+        }.compact
+      end
+
+      let(:selector) { { matchLabels: match_labels, matchExpressions: match_expressions } }
+
+      # Supplied by the owning stack through dep_options, or by the CLI
+      # positional; pod templates read it.
+      let(:image_tag) { options[:image_tag] }
+
+      # Explicitly define replicas
+      let(:replicas)          { fail Matsuri::UndefinedLet, 'Must define let(:replicas)' }
+      let(:match_labels)      { fail Matsuri::UndefinedLet, 'Must define let(:match_labels)' }
+
+      let(:match_expressions) { [] }
+
+      # Deployment Strategy. Defaults to Rolling Update. Recreate is the other one.
+      let(:strategy) { { type: 'RollingUpdate', rollingUpdate: rolling_update } }
+      let(:rolling_update) { { maxUnavailable: max_unavailable, maxSurge: max_surge } }
+      # See: http://kubernetes.io/docs/api-reference/extensions/v1beta1/definitions/#_v1beta1_rollingupdatedeployment
+      let(:max_unavailable) { 1 }
+      let(:max_surge)       { 1 }
+
+      # Minimum number of seconds for which a newly created pod should be ready without
+      # any of its container crashing, for it to be considered available.
+      # Defaults to 0 (pod will be considered available as soon as it is ready)
+      let(:min_ready_seconds) { 0 }
+
+      # The number of old ReplicaSets to retain to allow rollback. This is a pointer to
+      # distinguish between explicit zero and not specified.
+      let(:revision_history_limit) { nil }
+
+      let(:primary_container_path) { ['spec', 'template', 'spec', 'containers', 0] }
+
+      class << self
+        def load_path
+          Matsuri::Config.deployments_path
+        end
+
+        def definition_module_name
+          'Deployments'
+        end
+      end
+    end
+  end
+end

data/lib/matsuri/kubernetes/endpoints.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Matsuri
+  module Kubernetes
+    class Endpoints < Matsuri::Kubernetes::Base
+      let(:api_version) { 'v1' }    # K8S 1.10
+      let(:kind)        { 'Endpoints' }
+      let(:manifest) do
+        {
+          apiVersion:  api_version,
+          kind:        kind,
+          metadata:    final_metadata,
+          subsets:     subsets
+        }
+      end
+
+      # Overridables
+      let(:subsets) { [subset] }
+      let(:subset) do
+        {
+          addresses: addresses,
+          ports: ports
+        }
+      end
+
+      let(:addresses)         { [localhost, address] }
+      let(:localhost)         { { ip: '127.0.0.1' } }
+      let(:address)           { { ip: public_ip_address, targetRef: target_ref } }
+      let(:target_ref)        { fail Matsuri::UndefinedLet, 'Must define let(:target_ref)' }
+
+      let(:ports)             { [port(port_num)] }
+      let(:public_ip_address) { config.dev_addr }
+      let(:port_num)          { fail Matsuri::UndefinedLet, 'Must define let(:port_num)' }
+      let(:port_proto)        { 'tcp' }
+
+      # Helpers
+      # Optional:
+      #  target_port: the port exposed externally
+      #  protocol:    connection protocol (ex: tcp)
+      def port(num, protocol: 'TCP', name: nil)
+        _port = { port: num, protocol: protocol.to_s }
+        _port[:name] = name.to_s if name
+        return _port
+      end
+
+      class << self
+        def load_path
+          Matsuri::Config.endpoints_path
+        end
+
+        def definition_module_name
+          'Endpoints'
+        end
+      end
+    end
+  end
+end

data/lib/matsuri/kubernetes/horizontal_pod_autoscaler.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Matsuri
+  module Kubernetes
+    class HorizontalPodAutoscaler < Matsuri::Kubernetes::Base
+      # https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.22/#horizontalpodautoscalerspec-v2beta2-autoscaling
+      # https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/
+      # https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough/
+      let(:api_version) { 'autoscaling/v2beta2' }    # K8S 1.16+
+      let(:kind)        { 'HorizontalPodAutoscaler' }
+
+      let(:spec) do
+        {
+          scaleTargetRef: scale_target_ref,
+          minReplicas:    min_replicas,
+          maxReplicas:    max_replicas,
+          metrics:        metrics,
+          behavior:       behavior
+        }
+      end
+
+      let(:scale_target_ref) { fail Matsuri::UndefinedLet, 'Must define let(:scale_target_ref)' }
+      let(:min_replicas)     { 1 }
+      let(:max_replicas)     { nil }
+
+      let(:metrics)          { [metric] }
+      let(:metric)           { fail NotIm0lementedError, 'Must define let(:default_metric)' }
+
+      let(:behavior)            { { scaleUp: scale_up_behavior, scaleDown: scale_down_behavior }.compact }
+      let(:scale_down_behavior) { nil }
+      let(:scale_up_behavior)   { nil }
+
+      ### Helpers
+
+      # Extracts the version, name, and kind from a Matsuri ref
+      # Example: resource_ref_from_def(deployment_spec('my-deployment'))
+      def resource_ref_from_def(resource_def)
+        {
+          apiVersion: resource_def.api_version,
+          kind:       resource_def.kind,
+          name:       resource_def.name
+        }
+      end
+
+      def resource_metric_source(name, metric_target)
+        {
+          type: 'Resource',
+          resource: {
+            name: name,
+            target: metric_target
+          }
+        }
+      end
+
+      def pod_metric_source(name, metric_target, metric_selector: nil)
+        {
+          type: 'Pods',
+          pods: {
+            metric: { name: name, selector: metric_selector }.compact,
+            target: metric_target
+          }
+        }
+      end
+
+      def object_metric_source(name, metric_target, metric_selector: nil, described_object:)
+        {
+          type: 'Pods',
+          pods: {
+            metric: { name: name, selector: metric_selector }.compact,
+            describedObject: described_object,
+            target: metric_target
+          }
+        }
+      end
+
+      def utilization_metric_target(target)
+        { type: 'Utilization', averageUtilization: target }
+      end
+
+      def average_value_metric_target(target)
+        { type: 'AverageValue', averageValue: target }
+      end
+
+      def value_metric_target(target)
+        { type: 'Value', value: target }
+      end
+
+      def hpa_scaling_rule(policies:, select_policy: 'MaxPolicySelect', stabilization_window_seconds: nil)
+        {
+          policies: policies,
+          selectPolicy: select_policy,
+          stabilizationWindowSeconds: stabilization_window_seconds
+        }.compact
+      end
+
+      def hpa_scaling_policy(type:, value:, period_seconds:)
+        {
+          type:          type,
+          value:         value,
+          periodSeconds: period_seconds
+        }
+      end
+
+      class << self
+        def load_path
+          Matsuri::Config.horizontal_pod_autoscalers_path
+        end
+
+        def definition_module_name
+          'HorizontalPodAutoscalers'
+        end
+      end
+    end
+  end
+end
+

data/lib/matsuri/kubernetes/imported_manifest.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'matsuri/core_ext'
+require 'json'
+
+# rubocop:disable Lint/MissingCopEnableDirective
+# rubocop:disable Style/Alias
+module Matsuri
+  module Kubernetes
+    # Some quirks about this one:
+    # 1. The generated manifest is usually an array of hashes, not a hash
+    # 2. It isn't generated so much as imported from a raw manifest provided by an upstream vendor
+    # 3. There are helpers to transform the manifest and customize it locally
+    # 4. Apply-only: the CLI binds no other verb for imported manifests
+    class ImportedManifest < Matsuri::Kubernetes::Base
+      include Matsuri::Concerns::ImportManifest
+
+      # Override this to run transforms; the Transform::Kubernetes dialect
+      # is in scope (set_env, update_in, append_volume, ...)
+      let(:extracted_manifests) { imported_manifests }
+      let(:namespace)           { fail Matsuri::UndefinedLet, "Must define let(:namespace); check the imported manifest and use the namespace found there" }
+
+      # Identity for delivery messages; there is no single kind to derive it from
+      let(:resource_type)       { 'imported manifest' }
+
+      # Used to hook into ExportManifest concern
+      let(:manifest_for_export)         { normalize_manifests(extracted_manifests) }
+      let(:applied_manifest_for_export) { normalize_manifests(extracted_manifests) }
+
+      def normalize_manifests(manifests)
+        Array(manifests).map(&:deep_stringify_keys)
+      end
+
+      # Don't return a yaml array. Return a concated set of yaml files
+      def to_yaml
+        manifest_for_export.
+          map(&:to_yaml).
+          join('')
+      end
+
+      def applied_to_yaml
+        applied_manifest_for_export.
+          map(&:to_yaml).
+          join('')
+      end
+
+      ### Matsuri Registry
+      class << self
+        def load_path
+          Matsuri::Config.imported_manifests_path
+        end
+
+        def definition_module_name
+          'ImportedManifests'
+        end
+      end
+
+    end
+  end
+end
+

data/lib/matsuri/kubernetes/ingress.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Matsuri
+  module Kubernetes
+    class Ingress < Matsuri::Kubernetes::Base
+      let(:api_version) { 'networking.k8s.io/v1' }
+      let(:kind)        { 'Ingress' }
+
+      let(:default_annotations) { ingress_annotations }
+      let(:ingress_annotations) { {} } # Reserved for ingress controller annotations
+
+      # Overridables
+      let(:spec) do
+        {
+          ingressClassName: ingress_class,
+          defaultBackend:   default_backend,
+          rules:            rules,
+          tls:              tls
+        }.compact
+      end
+
+      # Names an IngressClass resource; replaces the retired
+      # kubernetes.io/ingress.class annotation.
+      let(:ingress_class)   { nil }
+      let(:default_backend) { nil }
+      let(:rules)           { nil }
+      let(:tls)             { nil }
+
+      ### Helpers
+      def http_rule(host:, paths:)
+        { host: host, http: { paths: maybe_array(paths) } }
+      end
+
+      # pathType is required in networking.k8s.io/v1: Prefix, Exact, or
+      # ImplementationSpecific. path may be omitted only for
+      # ImplementationSpecific.
+      def path(path = nil, service:, port:, path_type: 'Prefix')
+        { path: path, pathType: path_type, backend: backend(service: service, port: port) }.compact
+      end
+
+      def backend(service:, port:)
+        { service: { name: service, port: service_port(port) } }
+      end
+
+      # An Integer is a port number; anything else names a port.
+      def service_port(port)
+        port.is_a?(Integer) ? { number: port } : { name: port }
+      end
+
+      # Passing a hash to an array does not do this
+      def maybe_array(x)
+        x.is_a?(Array) ? x : [x]
+      end
+
+      class << self
+        def load_path
+          Matsuri::Config.ingresses_path
+        end
+
+        def definition_module_name
+          'Ingresses'
+        end
+      end
+    end
+  end
+end

data/lib/matsuri/kubernetes/persistent_volume.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Matsuri
+  module Kubernetes
+    # Kubernetes Persistent Volume
+    class PersistentVolume < Matsuri::Kubernetes::Base
+      let(:api_version)         { 'v1' }
+      let(:kind)                { 'PersistentVolume' }
+      let(:default_annotations) { { 'volume.beta.kubernetes.io/storage-class' => storage_class } } # http://kubernetes.io/docs/user-guide/persistent-volumes/
+
+      let(:spec) do
+        {
+          capacity:                      capacity,
+          accessModes:                   Array(access_modes),
+          persistentVolumeReclaimPolicy: reclaim_policy
+        }.merge(plugin_spec)
+      end
+
+      let(:storage_class)       { fail Matsuri::UndefinedLet, 'Must define let(:storage_class)' }
+      let(:access_modes)        { fail Matsuri::UndefinedLet, 'Must define let(:access_modes): ReadWriteOnce, ReadOnlyMany, ReadWriteMany' }
+      let(:capacity)            { { storage: storage_size } } # http://kubernetes.io/docs/user-guide/persistent-volumes/#capacity
+      let(:storage_size)        { fail Matsuri::UndefinedLet, 'Must define let(:storage_size)' }
+      let(:reclaim_policy)      { fail Matsuri::UndefinedLet, 'Must define let(:reclaim_policy): Retain, Recycle, Delete' }
+      let(:plugin_spec)         { fail Matsuri::UndefinedLet, 'Must define let(:public_spec). Ex: gce_persistent_disk' }
+
+      # GCE peristant disk plugin
+      # http://kubernetes.io/docs/api-reference/v1/definitions/#_v1_gcepersistentdiskvolumesource
+      let(:gce_persistent_disk) do
+        {
+          gcePersistentDisk: {
+            pdName:    gce_pd_name,
+            fsType:    gce_fstype,
+            partition: gce_partition,
+            readOnly:  gce_read_only?
+          }.compact
+        }
+      end
+
+      let(:gce_pd_name)    { fail Matsuri::UndefinedLet, 'Must define let(:gce_pd_name) to unique PD resource on GCE' }
+      let(:gce_fstype)     { 'ext4' } # Examples: ext4, xfs, ntfs
+      let(:gce_partition)  { nil }
+      let(:gce_read_only?) { false }
+
+      class << self
+        # Registry helpers
+        def load_path
+          Matsuri::Config.persistent_volumes_path
+        end
+
+        def definition_module_name
+          'PersistentVolumes'
+        end
+      end
+    end
+  end
+end

data/lib/matsuri/kubernetes/persistent_volume_claim.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Matsuri
+  module Kubernetes
+    # Kubernetes Persistent Volume Claim
+    # http://kubernetes.io/docs/user-guide/persistent-volumes/#persistentvolumeclaims
+    class PersistentVolumeClaim < Matsuri::Kubernetes::Base
+      let(:api_version)         { 'v1' }
+      let(:kind)                { 'PersistentVolumeClaim' }
+      let(:default_annotations) { { 'volume.beta.kubernetes.io/storage-class' => storage_class } } # http://kubernetes.io/docs/user-guide/persistent-volumes/
+
+      let(:spec) do
+        {
+          resources:   resources,
+          accessModes: Array(access_modes),
+          selector:    selector
+        }
+      end
+
+      let(:resources)    { { limits: limits, requests: requests }.compact }
+      let(:limits)       { nil }
+      let(:requests)     { { storage: storage_size } }
+      let(:storage_size) { fail Matsuri::UndefinedLet, 'Must define let(:storage_size)' }
+      let(:selector)     { { matchLabels: match_labels, matchExpressions: match_expressions }.compact }
+
+      let(:match_labels)      { fail Matsuri::UndefinedLet, 'Must define let(:match_labels)' }
+      let(:match_expressions) { nil }
+
+      class << self
+        # Registry helpers
+        def load_path
+          Matsuri::Config.persistent_volume_claims_path
+        end
+
+        def definition_module_name
+          'PersistentVolumeClaims'
+        end
+      end
+    end
+  end
+end