kube_cluster 0.3.8 → 0.3.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (22) hide show
  1. checksums.yaml +4 -4
  2. data/Gemfile.lock +9 -5
  3. data/Rakefile +1 -1
  4. data/bin/test +2 -15
  5. data/kube_cluster.gemspec +3 -2
  6. data/lib/kube/cluster/manifest.rb +160 -193
  7. data/lib/kube/cluster/middleware/annotations.rb +43 -51
  8. data/lib/kube/cluster/middleware/hpa_for_deployment.rb +136 -158
  9. data/lib/kube/cluster/middleware/ingress_for_service.rb +84 -110
  10. data/lib/kube/cluster/middleware/labels.rb +60 -73
  11. data/lib/kube/cluster/middleware/namespace.rb +49 -55
  12. data/lib/kube/cluster/middleware/pod_anti_affinity.rb +102 -113
  13. data/lib/kube/cluster/middleware/resource_preset.rb +145 -169
  14. data/lib/kube/cluster/middleware/security_context.rb +127 -154
  15. data/lib/kube/cluster/middleware/service_for_deployment.rb +123 -146
  16. data/lib/kube/cluster/resource/dirty_tracking.rb +328 -418
  17. data/lib/kube/cluster/version.rb +1 -1
  18. data/lib/kube/cluster.rb +4 -9
  19. data/lib/kube/helm/chart.rb +326 -325
  20. data/lib/kube/helm/endpoint.rb +59 -65
  21. data/lib/kube/helm/repo.rb +159 -166
  22. metadata +7 -7
data/lib/kube/cluster/middleware/labels.rb CHANGED
@@ -1,9 +1,7 @@
1
1
  # frozen_string_literal: true
2
2
 
3
- if __FILE__ == $0
4
- require "bundler/setup"
5
- require "kube/cluster"
6
- end
3
+ require "bundler/setup"
4
+ require "kube/cluster"
7
5
 
8
6
  module Kube
9
7
  module Cluster
@@ -63,93 +61,82 @@ module Kube
63
61
  end
64
62
  end
65
63
 
66
- if __FILE__ == $0
67
- require "minitest/autorun"
64
+ test do
65
+ Middleware = Kube::Cluster::Middleware
68
66
 
69
- class LabelsMiddlewareTest < Minitest::Test
70
- Middleware = Kube::Cluster::Middleware
67
+ it "adds_standard_labels" do
68
+ m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
71
69
 
72
- def test_adds_standard_labels
73
- m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
70
+ Middleware::Labels.new(app: "web", managed_by: "kube_cluster").call(m)
71
+ labels = m.resources.first.to_h.dig(:metadata, :labels)
74
72
 
75
- Middleware::Labels.new(app: "web", managed_by: "kube_cluster").call(m)
76
- labels = m.resources.first.to_h.dig(:metadata, :labels)
73
+ labels[:"app.kubernetes.io/name"].should == "web"
74
+ end
77
75
 
78
- assert_equal "web", labels[:"app.kubernetes.io/name"]
79
- assert_equal "kube_cluster", labels[:"app.kubernetes.io/managed-by"]
80
- end
76
+ it "maps_all_standard_keys" do
77
+ m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
81
78
 
82
- def test_maps_all_standard_keys
83
- m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
84
-
85
- Middleware::Labels.new(
86
- app: "web",
87
- instance: "my-release",
88
- version: "1.0.0",
89
- component: "frontend",
90
- part_of: "platform",
91
- managed_by: "kube_cluster",
92
- ).call(m)
93
-
94
- labels = m.resources.first.to_h.dig(:metadata, :labels)
95
-
96
- assert_equal "web", labels[:"app.kubernetes.io/name"]
97
- assert_equal "my-release", labels[:"app.kubernetes.io/instance"]
98
- assert_equal "1.0.0", labels[:"app.kubernetes.io/version"]
99
- assert_equal "frontend", labels[:"app.kubernetes.io/component"]
100
- assert_equal "platform", labels[:"app.kubernetes.io/part-of"]
101
- assert_equal "kube_cluster", labels[:"app.kubernetes.io/managed-by"]
102
- end
79
+ Middleware::Labels.new(
80
+ app: "web",
81
+ instance: "my-release",
82
+ version: "1.0.0",
83
+ component: "frontend",
84
+ part_of: "platform",
85
+ managed_by: "kube_cluster",
86
+ ).call(m)
103
87
 
104
- def test_resource_labels_override_middleware_defaults
105
- m = manifest(Kube::Cluster["ConfigMap"].new {
106
- metadata.name = "test"
107
- metadata.labels = { "app.kubernetes.io/name": "override" }
108
- })
88
+ labels = m.resources.first.to_h.dig(:metadata, :labels)
109
89
 
110
- Middleware::Labels.new(app: "default").call(m)
111
- labels = m.resources.first.to_h.dig(:metadata, :labels)
90
+ labels[:"app.kubernetes.io/managed-by"].should == "kube_cluster"
91
+ end
112
92
 
113
- assert_equal "override", labels[:"app.kubernetes.io/name"]
114
- end
93
+ it "resource_labels_override_middleware_defaults" do
94
+ m = manifest(Kube::Cluster["ConfigMap"].new {
95
+ metadata.name = "test"
96
+ metadata.labels = { "app.kubernetes.io/name": "override" }
97
+ })
115
98
 
116
- def test_preserves_existing_labels
117
- m = manifest(Kube::Cluster["ConfigMap"].new {
118
- metadata.name = "test"
119
- metadata.labels = { custom: "value" }
120
- })
99
+ Middleware::Labels.new(app: "default").call(m)
100
+ labels = m.resources.first.to_h.dig(:metadata, :labels)
121
101
 
122
- Middleware::Labels.new(app: "web").call(m)
123
- labels = m.resources.first.to_h.dig(:metadata, :labels)
102
+ labels[:"app.kubernetes.io/name"].should == "override"
103
+ end
124
104
 
125
- assert_equal "value", labels[:custom]
126
- assert_equal "web", labels[:"app.kubernetes.io/name"]
127
- end
105
+ it "preserves_existing_labels" do
106
+ m = manifest(Kube::Cluster["ConfigMap"].new {
107
+ metadata.name = "test"
108
+ metadata.labels = { custom: "value" }
109
+ })
128
110
 
129
- def test_passes_through_non_standard_keys
130
- m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
111
+ Middleware::Labels.new(app: "web").call(m)
112
+ labels = m.resources.first.to_h.dig(:metadata, :labels)
131
113
 
132
- Middleware::Labels.new(:"team.io/name" => "platform").call(m)
133
- labels = m.resources.first.to_h.dig(:metadata, :labels)
114
+ labels[:custom].should == "value"
115
+ end
134
116
 
135
- assert_equal "platform", labels[:"team.io/name"]
136
- end
117
+ it "passes_through_non_standard_keys" do
118
+ m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
137
119
 
138
- def test_converts_values_to_strings
139
- m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
120
+ Middleware::Labels.new(:"team.io/name" => "platform").call(m)
121
+ labels = m.resources.first.to_h.dig(:metadata, :labels)
140
122
 
141
- Middleware::Labels.new(version: 2).call(m)
142
- labels = m.resources.first.to_h.dig(:metadata, :labels)
123
+ labels[:"team.io/name"].should == "platform"
124
+ end
143
125
 
144
- assert_equal "2", labels[:"app.kubernetes.io/version"]
145
- end
126
+ it "converts_values_to_strings" do
127
+ m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
146
128
 
147
- private
129
+ Middleware::Labels.new(version: 2).call(m)
130
+ labels = m.resources.first.to_h.dig(:metadata, :labels)
148
131
 
149
- def manifest(*resources)
150
- m = Kube::Cluster::Manifest.new
151
- resources.each { |r| m << r }
152
- m
153
- end
132
+ labels[:"app.kubernetes.io/version"].should == "2"
154
133
  end
134
+
135
+ private
136
+
137
+ def manifest(*resources)
138
+ m = Kube::Cluster::Manifest.new
139
+ resources.each { |r| m << r }
140
+ m
141
+ end
155
142
  end
data/lib/kube/cluster/middleware/namespace.rb CHANGED
@@ -1,9 +1,7 @@
1
1
  # frozen_string_literal: true
2
2
 
3
- if __FILE__ == $0
4
- require "bundler/setup"
5
- require "kube/cluster"
6
- end
3
+ require "bundler/setup"
4
+ require "kube/cluster"
7
5
 
8
6
  module Kube
9
7
  module Cluster
@@ -35,78 +33,74 @@ module Kube
35
33
  end
36
34
  end
37
35
 
38
- if __FILE__ == $0
39
- require "minitest/autorun"
40
-
41
- class NamespaceMiddlewareTest < Minitest::Test
42
- Middleware = Kube::Cluster::Middleware
36
+ test do
37
+ Middleware = Kube::Cluster::Middleware
43
38
 
44
- def test_sets_namespace_on_configmap
45
- m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
39
+ it "sets_namespace_on_configmap" do
40
+ m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
46
41
 
47
- Middleware::Namespace.new("production").call(m)
42
+ Middleware::Namespace.new("production").call(m)
48
43
 
49
- assert_equal "production", m.resources.first.to_h.dig(:metadata, :namespace)
50
- end
44
+ m.resources.first.to_h.dig(:metadata, :namespace).should == "production"
45
+ end
51
46
 
52
- def test_sets_namespace_on_deployment
53
- m = manifest(Kube::Cluster["Deployment"].new { metadata.name = "web" })
47
+ it "sets_namespace_on_deployment" do
48
+ m = manifest(Kube::Cluster["Deployment"].new { metadata.name = "web" })
54
49
 
55
- Middleware::Namespace.new("staging").call(m)
50
+ Middleware::Namespace.new("staging").call(m)
56
51
 
57
- assert_equal "staging", m.resources.first.to_h.dig(:metadata, :namespace)
58
- end
52
+ m.resources.first.to_h.dig(:metadata, :namespace).should == "staging"
53
+ end
59
54
 
60
- def test_skips_namespace_resource
61
- m = manifest(Kube::Cluster["Namespace"].new { metadata.name = "my-ns" })
55
+ it "skips_namespace_resource" do
56
+ m = manifest(Kube::Cluster["Namespace"].new { metadata.name = "my-ns" })
62
57
 
63
- Middleware::Namespace.new("production").call(m)
58
+ Middleware::Namespace.new("production").call(m)
64
59
 
65
- assert_nil m.resources.first.to_h.dig(:metadata, :namespace)
66
- end
60
+ m.resources.first.to_h.dig(:metadata, :namespace).should.be.nil
61
+ end
67
62
 
68
- def test_skips_cluster_role
69
- m = manifest(Kube::Cluster["ClusterRole"].new { metadata.name = "admin" })
63
+ it "skips_cluster_role" do
64
+ m = manifest(Kube::Cluster["ClusterRole"].new { metadata.name = "admin" })
70
65
 
71
- Middleware::Namespace.new("production").call(m)
66
+ Middleware::Namespace.new("production").call(m)
72
67
 
73
- assert_nil m.resources.first.to_h.dig(:metadata, :namespace)
74
- end
68
+ m.resources.first.to_h.dig(:metadata, :namespace).should.be.nil
69
+ end
75
70
 
76
- def test_skips_cluster_role_binding
77
- m = manifest(Kube::Cluster["ClusterRoleBinding"].new { metadata.name = "admin-binding" })
71
+ it "skips_cluster_role_binding" do
72
+ m = manifest(Kube::Cluster["ClusterRoleBinding"].new { metadata.name = "admin-binding" })
78
73
 
79
- Middleware::Namespace.new("production").call(m)
74
+ Middleware::Namespace.new("production").call(m)
80
75
 
81
- assert_nil m.resources.first.to_h.dig(:metadata, :namespace)
82
- end
76
+ m.resources.first.to_h.dig(:metadata, :namespace).should.be.nil
77
+ end
83
78
 
84
- def test_overwrites_existing_namespace
85
- m = manifest(Kube::Cluster["ConfigMap"].new {
86
- metadata.name = "test"
87
- metadata.namespace = "old"
88
- })
79
+ it "overwrites_existing_namespace" do
80
+ m = manifest(Kube::Cluster["ConfigMap"].new {
81
+ metadata.name = "test"
82
+ metadata.namespace = "old"
83
+ })
89
84
 
90
- Middleware::Namespace.new("new").call(m)
85
+ Middleware::Namespace.new("new").call(m)
91
86
 
92
- assert_equal "new", m.resources.first.to_h.dig(:metadata, :namespace)
93
- end
87
+ m.resources.first.to_h.dig(:metadata, :namespace).should == "new"
88
+ end
94
89
 
95
- def test_returns_new_resource_instance
96
- resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
97
- m = manifest(resource)
90
+ it "returns_new_resource_instance" do
91
+ resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
92
+ m = manifest(resource)
98
93
 
99
- Middleware::Namespace.new("production").call(m)
94
+ Middleware::Namespace.new("production").call(m)
100
95
 
101
- refute_same resource, m.resources.first
102
- end
96
+ resource.equal?(m.resources.first).should.be.false
97
+ end
103
98
 
104
- private
99
+ private
105
100
 
106
- def manifest(*resources)
107
- m = Kube::Cluster::Manifest.new
108
- resources.each { |r| m << r }
109
- m
110
- end
111
- end
101
+ def manifest(*resources)
102
+ m = Kube::Cluster::Manifest.new
103
+ resources.each { |r| m << r }
104
+ m
105
+ end
112
106
  end
data/lib/kube/cluster/middleware/pod_anti_affinity.rb CHANGED
@@ -1,9 +1,7 @@
1
1
  # frozen_string_literal: true
2
2
 
3
- if __FILE__ == $0
4
- require "bundler/setup"
5
- require "kube/cluster"
6
- end
3
+ require "bundler/setup"
4
+ require "kube/cluster"
7
5
 
8
6
  module Kube
9
7
  module Cluster
@@ -65,134 +63,125 @@ module Kube
65
63
  end
66
64
  end
67
65
 
68
- if __FILE__ == $0
69
- require "minitest/autorun"
66
+ test do
67
+ Middleware = Kube::Cluster::Middleware
70
68
 
71
- class PodAntiAffinityMiddlewareTest < Minitest::Test
72
- Middleware = Kube::Cluster::Middleware
69
+ it "injects_soft_anti_affinity_on_deployment" do
70
+ m = manifest(Kube::Cluster["Deployment"].new {
71
+ metadata.name = "web"
72
+ spec.selector.matchLabels = { app: "web", instance: "prod" }
73
+ spec.template.metadata.labels = { app: "web" }
74
+ spec.template.spec.containers = [
75
+ { name: "web", image: "nginx:latest" },
76
+ ]
77
+ })
73
78
 
74
- def test_injects_soft_anti_affinity_on_deployment
75
- m = manifest(Kube::Cluster["Deployment"].new {
76
- metadata.name = "web"
77
- spec.selector.matchLabels = { app: "web", instance: "prod" }
78
- spec.template.metadata.labels = { app: "web" }
79
- spec.template.spec.containers = [
80
- { name: "web", image: "nginx:latest" },
81
- ]
82
- })
79
+ Middleware::PodAntiAffinity.new.call(m)
80
+ affinity = m.resources.first.to_h.dig(:spec, :template, :spec, :affinity)
83
81
 
84
- Middleware::PodAntiAffinity.new.call(m)
85
- affinity = m.resources.first.to_h.dig(:spec, :template, :spec, :affinity)
82
+ paa = affinity.dig(:podAntiAffinity, :preferredDuringSchedulingIgnoredDuringExecution)
83
+ paa.size.should == 1
84
+ end
86
85
 
87
- paa = affinity.dig(:podAntiAffinity, :preferredDuringSchedulingIgnoredDuringExecution)
88
- assert_equal 1, paa.size
86
+ it "custom_topology_key" do
87
+ m = manifest(Kube::Cluster["Deployment"].new {
88
+ metadata.name = "web"
89
+ spec.selector.matchLabels = { app: "web" }
90
+ spec.template.metadata.labels = { app: "web" }
91
+ spec.template.spec.containers = [
92
+ { name: "web", image: "nginx:latest" },
93
+ ]
94
+ })
89
95
 
90
- term = paa.first
91
- assert_equal 1, term[:weight]
92
- assert_equal "kubernetes.io/hostname", term.dig(:podAffinityTerm, :topologyKey)
93
- assert_equal({ app: "web", instance: "prod" }, term.dig(:podAffinityTerm, :labelSelector, :matchLabels))
94
- end
96
+ Middleware::PodAntiAffinity.new(
97
+ topology_key: "topology.kubernetes.io/zone",
98
+ ).call(m)
95
99
 
96
- def test_custom_topology_key
97
- m = manifest(Kube::Cluster["Deployment"].new {
98
- metadata.name = "web"
99
- spec.selector.matchLabels = { app: "web" }
100
- spec.template.metadata.labels = { app: "web" }
101
- spec.template.spec.containers = [
102
- { name: "web", image: "nginx:latest" },
103
- ]
104
- })
100
+ affinity = m.resources.first.to_h.dig(:spec, :template, :spec, :affinity)
101
+ term = affinity.dig(:podAntiAffinity, :preferredDuringSchedulingIgnoredDuringExecution, 0)
105
102
 
106
- Middleware::PodAntiAffinity.new(
107
- topology_key: "topology.kubernetes.io/zone",
108
- ).call(m)
103
+ term.dig(:podAffinityTerm, :topologyKey).should == "topology.kubernetes.io/zone"
104
+ end
109
105
 
110
- affinity = m.resources.first.to_h.dig(:spec, :template, :spec, :affinity)
111
- term = affinity.dig(:podAntiAffinity, :preferredDuringSchedulingIgnoredDuringExecution, 0)
106
+ it "custom_weight" do
107
+ m = manifest(Kube::Cluster["Deployment"].new {
108
+ metadata.name = "web"
109
+ spec.selector.matchLabels = { app: "web" }
110
+ spec.template.metadata.labels = { app: "web" }
111
+ spec.template.spec.containers = [
112
+ { name: "web", image: "nginx:latest" },
113
+ ]
114
+ })
115
+
116
+ Middleware::PodAntiAffinity.new(weight: 100).call(m)
117
+ term = m.resources.first.to_h.dig(:spec, :template, :spec, :affinity,
118
+ :podAntiAffinity, :preferredDuringSchedulingIgnoredDuringExecution, 0)
119
+
120
+ term[:weight].should == 100
121
+ end
112
122
 
113
- assert_equal "topology.kubernetes.io/zone", term.dig(:podAffinityTerm, :topologyKey)
114
- end
123
+ it "skips_resources_with_existing_affinity" do
124
+ m = manifest(Kube::Cluster["Deployment"].new {
125
+ metadata.name = "web"
126
+ spec.selector.matchLabels = { app: "web" }
127
+ spec.template.metadata.labels = { app: "web" }
128
+ spec.template.spec.affinity = { nodeAffinity: { custom: true } }
129
+ spec.template.spec.containers = [
130
+ { name: "web", image: "nginx:latest" },
131
+ ]
132
+ })
133
+
134
+ Middleware::PodAntiAffinity.new.call(m)
135
+ affinity = m.resources.first.to_h.dig(:spec, :template, :spec, :affinity)
136
+
137
+ affinity.should == { nodeAffinity: { custom: true } }
138
+ end
115
139
 
116
- def test_custom_weight
117
- m = manifest(Kube::Cluster["Deployment"].new {
118
- metadata.name = "web"
119
- spec.selector.matchLabels = { app: "web" }
120
- spec.template.metadata.labels = { app: "web" }
121
- spec.template.spec.containers = [
122
- { name: "web", image: "nginx:latest" },
123
- ]
124
- })
125
-
126
- Middleware::PodAntiAffinity.new(weight: 100).call(m)
127
- term = m.resources.first.to_h.dig(:spec, :template, :spec, :affinity,
128
- :podAntiAffinity, :preferredDuringSchedulingIgnoredDuringExecution, 0)
129
-
130
- assert_equal 100, term[:weight]
131
- end
140
+ it "skips_non_pod_bearing_resources" do
141
+ resource = Kube::Cluster["ConfigMap"].new { metadata.name = "config" }
142
+ m = manifest(resource)
132
143
 
133
- def test_skips_resources_with_existing_affinity
134
- m = manifest(Kube::Cluster["Deployment"].new {
135
- metadata.name = "web"
136
- spec.selector.matchLabels = { app: "web" }
137
- spec.template.metadata.labels = { app: "web" }
138
- spec.template.spec.affinity = { nodeAffinity: { custom: true } }
139
- spec.template.spec.containers = [
140
- { name: "web", image: "nginx:latest" },
141
- ]
142
- })
143
-
144
- Middleware::PodAntiAffinity.new.call(m)
145
- affinity = m.resources.first.to_h.dig(:spec, :template, :spec, :affinity)
146
-
147
- assert_equal({ nodeAffinity: { custom: true } }, affinity)
148
- end
144
+ Middleware::PodAntiAffinity.new.call(m)
149
145
 
150
- def test_skips_non_pod_bearing_resources
151
- resource = Kube::Cluster["ConfigMap"].new { metadata.name = "config" }
152
- m = manifest(resource)
146
+ m.resources.first.to_h.should == resource.to_h
147
+ end
153
148
 
154
- Middleware::PodAntiAffinity.new.call(m)
149
+ it "skips_resources_without_match_labels" do
150
+ m = manifest(Kube::Cluster["Deployment"].new {
151
+ metadata.name = "web"
152
+ spec.template.metadata.labels = { app: "web" }
153
+ spec.template.spec.containers = [
154
+ { name: "web", image: "nginx:latest" },
155
+ ]
156
+ })
155
157
 
156
- assert_equal resource.to_h, m.resources.first.to_h
157
- end
158
+ Middleware::PodAntiAffinity.new.call(m)
159
+ affinity = m.resources.first.to_h.dig(:spec, :template, :spec, :affinity)
158
160
 
159
- def test_skips_resources_without_match_labels
160
- m = manifest(Kube::Cluster["Deployment"].new {
161
- metadata.name = "web"
162
- spec.template.metadata.labels = { app: "web" }
163
- spec.template.spec.containers = [
164
- { name: "web", image: "nginx:latest" },
165
- ]
166
- })
161
+ affinity.should.be.nil
162
+ end
167
163
 
168
- Middleware::PodAntiAffinity.new.call(m)
169
- affinity = m.resources.first.to_h.dig(:spec, :template, :spec, :affinity)
164
+ it "applies_to_statefulset" do
165
+ m = manifest(Kube::Cluster["StatefulSet"].new {
166
+ metadata.name = "db"
167
+ spec.selector.matchLabels = { app: "db" }
168
+ spec.template.metadata.labels = { app: "db" }
169
+ spec.template.spec.containers = [
170
+ { name: "postgres", image: "postgres:16" },
171
+ ]
172
+ })
170
173
 
171
- assert_nil affinity
172
- end
174
+ Middleware::PodAntiAffinity.new.call(m)
175
+ affinity = m.resources.first.to_h.dig(:spec, :template, :spec, :affinity)
173
176
 
174
- def test_applies_to_statefulset
175
- m = manifest(Kube::Cluster["StatefulSet"].new {
176
- metadata.name = "db"
177
- spec.selector.matchLabels = { app: "db" }
178
- spec.template.metadata.labels = { app: "db" }
179
- spec.template.spec.containers = [
180
- { name: "postgres", image: "postgres:16" },
181
- ]
182
- })
177
+ affinity.dig(:podAntiAffinity).should.not.be.nil
178
+ end
183
179
 
184
- Middleware::PodAntiAffinity.new.call(m)
185
- affinity = m.resources.first.to_h.dig(:spec, :template, :spec, :affinity)
180
+ private
186
181
 
187
- refute_nil affinity.dig(:podAntiAffinity)
182
+ def manifest(*resources)
183
+ m = Kube::Cluster::Manifest.new
184
+ resources.each { |r| m << r }
185
+ m
188
186
  end
189
-
190
- private
191
-
192
- def manifest(*resources)
193
- m = Kube::Cluster::Manifest.new
194
- resources.each { |r| m << r }
195
- m
196
- end
197
- end
198
187
  end