metatron 0.1.0

data/lib/metatron/templates/ingress.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Metatron
+  module Templates
+    # Template for basic Ingress k8s resource
+    class Ingress < Template
+      attr_accessor :ingress_class, :additional_labels, :additional_annotations, :rules, :tls,
+                    :cert_manager_cluster_issuer, :cert_manager_issuer, :cert_manager_challenge_type
+
+      def initialize(name, ingress_class = "nginx")
+        super(name)
+        @name = name
+        @ingress_class = ingress_class
+        @api_version = "networking.k8s.io/v1"
+        @kind = "Ingress"
+        @additional_labels = {}
+        @additional_annotations = {}
+      end
+
+      # Supports one of (they are all equivalent):
+      #   { host: "foo.bar", service: { name: "some_service", port: "some_port" } }
+      #   { "foo.bar" => { "some_service" => "some_port" } }
+      #   {
+      #     host: "foo.bar",
+      #     paths: [{ path: "/", service: { name: "some_service", port: "some_port" } }]
+      #   }
+      def add_rule(rule)
+        @rules ||= []
+        @rules << (rule.key?(:host) ? complex_rule(rule) : simple_rule(rule))
+      end
+
+      # Supports an array of hostnames to provide TLS for via some secret
+      # If the secret name isn't provide, its name will be derived from the first hostname
+      def add_tls(*tls, secret: nil)
+        @tls ||= []
+        @tls << {
+          hosts: tls.map(&:downcase),
+          secretName: secret || secret_name_from_hostname(tls.first)
+        }
+      end
+
+      def cert_manager_annotations
+        cert_manager = {}
+        if cert_manager_issuer
+          cert_manager[:"cert-manager.io/issuer"] = cert_manager_issuer
+        elsif cert_manager_cluster_issuer
+          cert_manager[:"cert-manager.io/cluster-issuer"] = cert_manager_cluster_issuer
+        end
+        unless cert_manager.empty?
+          cert_manager[:"cert-manager.io/acme-challenge-type"] = \
+            cert_manager_challenge_type || "http01"
+        end
+
+        {}.merge(cert_manager)
+      end
+
+      def formatted_annotations
+        ingress_annotations = { "kubernetes.io/ingress.class": ingress_class }
+        {
+          annotations: ingress_annotations
+            .merge(additional_annotations)
+            .merge(cert_manager_annotations)
+        }
+      end
+
+      def formatted_rules
+        (rules || []).empty? ? {} : { rules: }
+      end
+
+      def formatted_tls
+        (tls || []).empty? ? {} : { tls: }
+      end
+
+      def render
+        {
+          apiVersion:,
+          kind:,
+          metadata: {
+            name:,
+            labels: { "#{label_namespace}/name": name }.merge(additional_labels)
+          }.merge(formatted_annotations),
+          spec: formatted_rules.merge(formatted_tls)
+        }
+      end
+
+      def secret_name_from_hostname(hostname)
+        "#{hostname.downcase.gsub(".", "-")}-tls"
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength
+      def complex_rule(rule)
+        formatted_rule = {}
+        formatted_rule[:host] = rule[:host]
+        paths = if rule.key?(:paths)
+                  rule[:paths].map do |path|
+                    {
+                      pathType: "Prefix",
+                      path: path[:path],
+                      backend: {
+                        service: {
+                          name: path.dig(:service, :name),
+                          port: { name: path.dig(:service, :port) }
+                        }
+                      }
+                    }
+                  end
+                else
+                  [
+                    {
+                      pathType: "Prefix",
+                      path: "/",
+                      backend: {
+                        service: {
+                          name: rule.dig(:service, :name),
+                          port: { name: rule.dig(:service, :port) }
+                        }
+                      }
+                    }
+                  ]
+                end
+        formatted_rule[:http] = { paths: }
+        formatted_rule
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def simple_rule(rule)
+        formatted_rule = {}
+        formatted_rule[:host] = rule.keys.first.to_s
+        service_name, service_port = rule.values.first.to_a.first
+        formatted_rule[:http] = {
+          paths: [
+            pathType: "Prefix",
+            path: "/",
+            backend: {
+              service: {
+                name: service_name.to_s,
+                port: { name: service_port }
+              }
+            }
+          ]
+        }
+        formatted_rule
+      end
+    end
+  end
+end

data/lib/metatron/templates/pod.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Metatron
+  module Templates
+    # Template for basic Pod k8s resource
+    class Pod < Template
+      include Concerns::Annotated
+      include Concerns::PodProducer
+
+      def initialize(name)
+        super(name)
+        @kind = "Pod"
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def render
+        {
+          apiVersion:,
+          kind:,
+          metadata: {
+            labels: { "#{label_namespace}/name": name }.merge(additional_labels),
+            name:
+          }.merge(formatted_annotations),
+          spec: {
+            containers: [
+              {
+                name: "app",
+                image:,
+                imagePullPolicy:,
+                stdin: true,
+                tty: true,
+                resources: { limits: resource_limits, requests: resource_requests }
+              }.merge(probes)
+                .merge(formatted_environment)
+                .merge(formatted_envfrom)
+                .merge(formatted_ports)
+                .merge(formatted_volume_mounts)
+                .merge(formatted_container_security_context)
+            ] + additional_containers
+          }.merge(formatted_volumes).merge(formatted_security_context)
+        }
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/metatron/templates/secret.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Metatron
+  module Templates
+    # The Secret Kubernetes resource
+    class Secret < Template
+      include Concerns::Annotated
+
+      attr_accessor :additional_labels, :type, :data
+
+      def initialize(name, data = {})
+        super(name)
+        @data = data
+        @additional_labels = {}
+        @kind = "Secret"
+        @type = "Opaque"
+      end
+
+      def render
+        {
+          apiVersion:,
+          kind:,
+          metadata: {
+            name:,
+            labels: { "#{label_namespace}/name": name }.merge(additional_labels)
+          }.merge(formatted_annotations),
+          type:,
+          stringData: data
+        }
+      end
+    end
+  end
+end

data/lib/metatron/templates/service.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Metatron
+  module Templates
+    # The Service Kubernetes resource
+    class Service < Template
+      include Concerns::Annotated
+
+      attr_accessor :type, :selector, :additional_labels, :ports,
+                    :additional_selector_labels, :publish_not_ready_addresses
+
+      def initialize(name, port = nil)
+        super(name)
+        @kind = "Service"
+        @type = "ClusterIP"
+        @selector = { "#{label_namespace}/name": name }
+        @additional_labels = {}
+        @additional_selector_labels = {}
+        @publish_not_ready_addresses = false
+        return unless port
+
+        @ports = [
+          {
+            port: port.to_i,
+            targetPort: port.to_i,
+            protocol: "TCP",
+            name:
+          }
+        ]
+      end
+
+      alias publishNotReadyAddresses publish_not_ready_addresses
+
+      def formatted_ports
+        ports&.any? ? { ports: } : {}
+      end
+
+      def render
+        {
+          apiVersion:,
+          kind:,
+          metadata: {
+            name:,
+            labels: { "#{label_namespace}/name": name }.merge(additional_labels)
+          }.merge(formatted_annotations),
+          spec: {
+            type:,
+            selector: selector.merge(additional_selector_labels),
+            publishNotReadyAddresses:
+          }.merge(formatted_ports)
+        }
+      end
+    end
+  end
+end

data/lib/metatron/templates/stateful_set.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Metatron
+  module Templates
+    # Template for basic StatefulSet k8s resource
+    class StatefulSet < Template
+      include Concerns::Annotated
+      include Concerns::PodProducer
+
+      attr_accessor :replicas, :pod_annotations, :service_name,
+                    :pod_management_policy, :enable_service_links,
+                    :termination_grace_period_seconds, :additional_pod_labels
+
+      def initialize(name, replicas: 2)
+        super(name)
+        @replicas = replicas
+        @api_version = "apps/v1"
+        @kind = "StatefulSet"
+        @pod_annotations = {}
+        @pod_management_policy = "OrderedReady"
+        @additional_pod_labels = {}
+        @enable_service_links = true
+        @service_name = name
+        @termination_grace_period_seconds = 60
+      end
+
+      alias enableServiceLinks enable_service_links
+      alias podManagementPolicy pod_management_policy
+      alias terminationGracePeriodSeconds termination_grace_period_seconds
+      alias serviceName service_name
+
+      def formatted_pod_annotations
+        pod_annotations && !pod_annotations.empty? ? { annotations: pod_annotations } : {}
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize
+      def render
+        {
+          apiVersion:,
+          kind:,
+          metadata: {
+            name:,
+            labels: { "#{label_namespace}/name": name }.merge(additional_labels)
+          }.merge(formatted_annotations),
+          spec: {
+            replicas:,
+            serviceName:,
+            enableServiceLinks:,
+            strategy: { type: "RollingUpdate", rollingUpdate: { maxSurge: 2, maxUnavailable: 0 } },
+            selector: {
+              matchLabels: { "#{label_namespace}/name": name }.merge(additional_pod_labels)
+            },
+            template: {
+              metadata: {
+                labels: { "#{label_namespace}/name": name }.merge(additional_pod_labels)
+              }.merge(formatted_pod_annotations),
+              spec: {
+                terminationGracePeriodSeconds:,
+                containers: [
+                  {
+                    name: "app",
+                    image:,
+                    imagePullPolicy:,
+                    stdin: true,
+                    tty: true,
+                    resources: { limits: resource_limits, requests: resource_requests }
+                  }.merge(probes)
+                    .merge(formatted_environment)
+                    .merge(formatted_envfrom)
+                    .merge(formatted_ports)
+                    .merge(formatted_volume_mounts)
+                    .merge(formatted_security_context)
+                ] + additional_containers
+              }.merge(formatted_volumes)
+                .merge(formatted_affinity)
+            }
+          }
+        }
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/lib/metatron/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Metatron
+  VERSION = [
+    0, # major
+    1, # minor
+    0 # patch
+  ].join(".")
+end

data/lib/metatron.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Standard Library requirements
+require "base64"
+require "resolv"
+require "securerandom"
+require "time"
+require "logger"
+
+# External requirements
+require "sinatra/base"
+require "sinatra/custom_logger"
+
+# The top-level module for Bullion
+module Metatron
+  class Error < StandardError; end
+  class ConfigError < Error; end
+
+  LOGGER = Logger.new($stdout)
+
+  # Set up log level
+  LOGGER.level = ENV.fetch("LOG_LEVEL", :warn)
+end
+
+# Internal requirements
+require "metatron/version"
+require "metatron/template"
+require "metatron/templates/concerns/annotated"
+require "metatron/templates/concerns/pod_producer"
+require "metatron/templates/pod"
+require "metatron/templates/deployment"
+require "metatron/templates/ingress"
+require "metatron/templates/secret"
+require "metatron/templates/service"
+require "metatron/templates/stateful_set"
+require "metatron/controller"
+require "metatron/sync_controller"
+require "metatron/controllers/ping"
+require "metatron/controllers/sync"

data/metatron.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "lib/metatron/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "metatron"
+  spec.version       = Metatron::VERSION
+  spec.authors       = ["Jonathan Gnagy"]
+  spec.email         = ["jonathan.gnagy@gmail.com"]
+
+  spec.summary       = "So meta"
+  spec.homepage      = "https://github.com/jgnagy/metatron"
+  spec.license       = "MIT"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/jgnagy/metatron"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = "~> 3.1"
+
+  spec.add_runtime_dependency "json",                 "~> 2.6"
+  spec.add_runtime_dependency "puma",                 "~> 5.6"
+  spec.add_runtime_dependency "sinatra",              "~> 2.2"
+  spec.add_runtime_dependency "sinatra-contrib",      "~> 2.2"
+
+  spec.add_development_dependency "bundler",             "~> 2.3"
+  spec.add_development_dependency "byebug",              "~> 11"
+  spec.add_development_dependency "rack-test",           "~> 2.0"
+  spec.add_development_dependency "rake",                "~> 12.3"
+  spec.add_development_dependency "rspec",               "~> 3.10"
+  spec.add_development_dependency "rubocop",             "~> 1.31"
+  spec.add_development_dependency "rubocop-rake",        "~> 0.6"
+  spec.add_development_dependency "rubocop-rspec",       "~> 2.11"
+  spec.add_development_dependency "simplecov",           "~> 0.21"
+  spec.add_development_dependency "simplecov-cobertura", "~> 2.1"
+  spec.add_development_dependency "solargraph",          "~> 0.45"
+  spec.add_development_dependency "yard",                "~> 0.9"
+end

data/scripts/build.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+docker build -t metatron:local .

data/scripts/release.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+gem install bundler -v '~> 2.3'
+bundle install
+rm -rf pkg/*.gem
+bundle exec rake build
+bundle exec gem push pkg/*.gem

data/scripts/test.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+gem install bundler
+bundle install --jobs=4
+gem build ./metatron.gemspec
+bundle exec rake