feat: adding support for LimitRange resource

Author: jgnagy

.rubocop.yml

@@ -35,6 +35,9 @@ Metrics/ClassLength:
   Exclude:
   - 'spec/**/*_spec.rb'
 
+Metrics/ParameterLists:
+  Max: 6
+
 Gemspec/RequireMFA:
   Enabled: false
 

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    metatron (0.8.6)
+    metatron (0.8.7)
       json (~> 2.6)
       rack (>= 2.2.8, < 4)
 

lib/metatron.rb

@@ -31,6 +31,7 @@ class ConfigError < Error; end
 require "metatron/templates/daemon_set"
 require "metatron/templates/deployment"
 require "metatron/templates/ingress"
+require "metatron/templates/limit_range"
 require "metatron/templates/namespace"
 require "metatron/templates/network_policy"
 require "metatron/templates/persistent_volume_claim"

lib/metatron/controller.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json" unless defined? JSON # allow for JSON to be loaded elsewhere
+
 module Metatron
   # Base class for API services
   class Controller

lib/metatron/templates/limit_range.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Metatron
+  module Templates
+    # The LimitRange Kubernetes resource
+    class LimitRange < Template
+      # Limit is an internal class used to represent the limits in a LimitRange resource,
+      # and to provide a consistent interface for rendering them. It is not intended to be
+      # used outside of this class. Eventually, it may be used to provide validation for
+      # the limits.
+      class Limit
+        attr_accessor :type, :default, :default_request, :max, :max_limit_request_ratio, :min
+
+        alias defaultRequest default_request
+        alias maxLimitRequestRatio max_limit_request_ratio
+
+        class << self
+          def to_limit(limit)
+            limit.is_a?(Limit) ? limit : new(**limit)
+          end
+        end
+
+        def initialize(type:, default: nil, default_request: nil, max: nil,
+                       max_limit_request_ratio: nil, min: nil)
+          @type = type
+          @default = default
+          @default_request = default_request
+          @max = max
+          @max_limit_request_ratio = max_limit_request_ratio
+          @min = min
+        end
+
+        def render
+          {
+            type:,
+            default:,
+            defaultRequest:,
+            max:,
+            maxLimitRequestRatio:,
+            min:
+          }.compact
+        end
+      end
+
+      include Concerns::Annotated
+      include Concerns::Namespaced
+
+      attr_accessor :limits
+
+      def initialize(name, limits = [])
+        super(name)
+        @limits = limits
+      end
+
+      def render
+        {
+          apiVersion:,
+          kind:,
+          metadata: {
+            name:,
+            labels: base_labels.merge(additional_labels)
+          }.merge(formatted_annotations).merge(formatted_namespace),
+          spec: formatted_limits
+        }.compact
+      end
+
+      private
+
+      def formatted_limits
+        return {} if limits.empty?
+
+        { limits: limits.map { Limit.to_limit(_1).render } }
+      end
+    end
+  end
+end

lib/metatron/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Metatron
-  VERSION = "0.8.6"
+  VERSION = "0.8.7"
 end

spec/metatron/templates/limit_range_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+RSpec.describe Metatron::Templates::LimitRange do
+  describe "for simple limit ranges" do
+    let(:limit_range) do
+      limit_range = described_class.new("test-limit-range")
+      limit_range.namespace = "test-namespace"
+      limit_range.limits << {
+        type: "Container",
+        default: { cpu: "500m" },
+        default_request: { cpu: "500m" },
+        max: { cpu: "1" },
+        min: { cpu: "100m" }
+      }
+      limit_range
+    end
+
+    let(:rendered_limit_range) do
+      {
+        apiVersion: "v1",
+        kind: "LimitRange",
+        metadata: {
+          labels: { "metatron.therubyist.org/name": "test-limit-range" },
+          name: "test-limit-range",
+          namespace: "test-namespace"
+        },
+        spec: {
+          limits: [
+            {
+              default: { cpu: "500m" },
+              defaultRequest: { cpu: "500m" },
+              max: { cpu: "1" },
+              min: { cpu: "100m" },
+              type: "Container"
+            }
+          ]
+        }
+      }
+    end
+
+    it "produces a hash" do
+      expect(limit_range.render).to be_a(Hash)
+    end
+
+    it "renders properly" do
+      expect(limit_range.render).to eq(rendered_limit_range)
+    end
+  end
+end