orchparty 1.3.1 → 2.0.0.pre.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: d6da06fafe3d156196070c46a8e701daf77fa1911918aa37b79426d41a9a0f3f
-  data.tar.gz: f8c0db2274c9be102923960e3fb92a3d23166d41589609c92c0ccd08c42cab73
+SHA1:
+  metadata.gz: 64ca2dd610de3fdec263d50a80ba31f580868789
+  data.tar.gz: 75f7bc9648af4321b7e521e22826177cd2d72234
 SHA512:
-  metadata.gz: a456ed27ca5e82f0e986151025d764cd080a6580ddcddb9c735885f39bb830c248912c45c16c66237cf494e404a7db23aecb63dc5aa3f05ef6ad0ee6a6dff94e
-  data.tar.gz: '048376cb4d93fa130e66674fe6c43bb21d8297fc95303072b2db60046b87d00dd951448d96151fe1bd596fb5b2afe52f78b1f15bf8e2909d17cb08f312c2e82b'
+  metadata.gz: 1af9d753efabbaa79ec4125e43025049af2a44e39ee1468ba45fe23486d16719a5f4b698dc4bd411487e180c5c6189aaca275143d7d2f367845fdd101724a03a
+  data.tar.gz: 0f3efe9774f8aea508e4c231d2e365b3623f5e5e78ac06a4ec8f92dc8cd3cd62bac764773e4b75c51648deb48b48195b8ee35347b22d7386cc305a71d1280f42

data/lib/orchparty/ast.rb

@@ -8,6 +8,10 @@ module Orchparty
       include Hashie::Extensions::MethodAccess
       include Hashie::Extensions::Mash::KeepOriginalKeys
       disable_warnings
+
+      def get_binding
+        binding
+      end
     end
 
     def self.hash(args = {})
@@ -27,7 +31,7 @@ module Orchparty
     end
 
     def self.application(args = {})
-      Node.new({services: {}, _mixins: {}, _mix:[], volumes: {}, _variables: {}, networks: {}}).merge(args)
+      Node.new({services: {}, _mixins: {}, _mix:[], volumes: {}, _variables: {}, networks: {}, _service_order: []}).merge(args)
     end
 
     def self.all(args = {})
@@ -41,5 +45,9 @@ module Orchparty
     def self.service(args = {})
       Node.new(_mix:[], _variables: {}).merge(args)
     end
+
+    def self.chart(args = {})
+      Node.new(_mix:[], _variables: {}, _services: []).merge(args)
+    end
   end
 end

data/lib/orchparty/cli.rb

@@ -11,6 +11,40 @@ class OrchPartyApp
 
   subcommand_option_handling :normal
 
+  desc "install kubernetes application"
+  command :print do |com|
+    com.flag [:cluster_name,:c,'cluster-name'], required: true, :desc => 'The cluster to install the app'
+    com.flag [:filename,:f,'file-name'], required: true, :desc => 'The Orchparty input file'
+    com.flag [:application,:a], required: true, :desc => 'The application that should be installed'
+    com.switch :"force-variable-definition", :default_value => false, :desc => "Raises an Error if the input contains a not defined variable"
+    com.flag [:method,:m], required: true, :desc => 'method to print upgrade/install'
+    com.action do |_, args|
+      Orchparty.print(cluster_name: args[:c], application_name: args[:a], force_variable_definition: args["force-variable-definition"], file_name: args[:f], method: args[:m])
+    end
+  end
+
+  desc "install kubernetes application"
+  command :install do |com|
+    com.flag [:cluster_name,:c,'cluster-name'], required: true, :desc => 'The cluster to install the app'
+    com.flag [:filename,:f,'file-name'], required: true, :desc => 'The Orchparty input file'
+    com.flag [:application,:a], required: true, :desc => 'The application that should be installed'
+    com.switch :"force-variable-definition", :default_value => false, :desc => "Raises an Error if the input contains a not defined variable"
+    com.action do |_, args|
+      Orchparty.install(cluster_name: args[:c], application_name: args[:a], force_variable_definition: args["force-variable-definition"], file_name: args[:f])
+    end
+  end
+
+  desc "upgrade kubernetes application"
+  command :upgrade do |com|
+    com.flag [:cluster_name,:c,'cluster-name'], required: true, :desc => 'The cluster to install the app'
+    com.flag [:filename,:f,'file-name'], required: true, :desc => 'The Orchparty input file'
+    com.flag [:application,:a], required: true, :desc => 'The application that should be installed'
+    com.switch :"force-variable-definition", :default_value => false, :desc => "Raises an Error if the input contains a not defined variable"
+    com.action do |_, args|
+      Orchparty.upgrade(cluster_name: args[:c], application_name: args[:a], force_variable_definition: args["force-variable-definition"], file_name: args[:f])
+    end
+  end
+
   desc "Compiles a Orchparty input file to a orchestration framework configuration"
   command :generate do |com|
     Orchparty.plugins.each do |name, plugin|

data/lib/orchparty/dsl_parser_kubernetes.rb

@@ -0,0 +1,304 @@
+require 'pathname'
+require 'securerandom'
+module Orchparty
+  module Kubernetes
+    class DSLParser
+      attr_reader :filename
+
+      def initialize(filename)
+        @filename = filename
+      end
+
+      def parse
+        file_content = File.read(filename)
+        builder = RootBuilder.new
+        builder.instance_eval(file_content, filename)
+        builder._build
+      end
+    end
+
+    class Builder
+      def self.build(*args, block)
+        builder = self.new(*args)
+        builder.instance_eval(&block) if block
+        builder._build
+      end
+
+      def assign_or_merge(node, key, value)
+        if node[key]
+          node[key] = node[key].deep_merge_concat(value)
+        else
+          node[key] = value
+        end
+      end
+    end
+
+    class RootBuilder < Builder
+
+      def initialize
+        @root = AST.root
+      end
+
+      def import(rel_file)
+        old_file_path = Pathname.new(caller[0][/[^:]+/]).parent
+        rel_file_path = Pathname.new rel_file
+        new_file_path = old_file_path + rel_file_path
+        file_content = File.read(new_file_path)
+        instance_eval(file_content, new_file_path.expand_path.to_s)
+      end
+
+      def application(name, &block)
+        @root.applications[name] = ApplicationBuilder.build(name, block)
+        self
+      end
+
+      def mixin(name, &block)
+        @root._mixins[name] = MixinBuilder.build(name, block)
+        self
+      end
+
+      def _build
+        @root
+      end
+    end
+
+    class MixinBuilder < Builder
+
+      def initialize(name)
+        @mixin = AST.mixin(name: name)
+      end
+
+      def service(name, &block)
+        result = ServiceMixinBuilder.build(name, block)
+        @mixin.services[name] = result
+        @mixin._mixins[name] = result
+        self
+      end
+
+      def helm(name, &block)
+        result = ServiceBuilder.build(name, "helm", block)
+        @mixin.services[name] = result
+        @mixin._mixins[name] = result
+        self
+      end
+
+
+      def apply(name, &block)
+        result = ServiceBuilder.build(name, "apply", block)
+        @mixin.services[name] = result
+        @mixin._mixins[name] = result
+        self
+      end
+
+      def mixin(name, &block)
+        @mixin._mixins[name] = ServiceMixinBuilder.build(name, block)
+      end
+
+      def volumes(&block)
+        @mixin.volumes = HashBuilder.build(block)
+      end
+
+      def networks(&block)
+        @mixin.networks = HashBuilder.build(block)
+      end
+
+      def _build
+        @mixin
+      end
+    end
+
+    class ApplicationBuilder < Builder
+
+      def initialize(name)
+        @application = AST.application(name: name)
+      end
+
+      def mix(name)
+        @application._mix << name
+      end
+
+      def mixin(name, &block)
+        @application._mixins[name] = ApplicationMixinBuilder.build(block)
+        self
+      end
+
+      def all(&block)
+        @application.all = AllBuilder.build(block)
+        self
+      end
+
+      def variables(&block)
+        @application._variables = VariableBuilder.build(block)
+        self
+      end
+
+      def volumes(&block)
+        @application.volumes = HashBuilder.build(block)
+        self
+      end
+
+      def helm(name, &block)
+        result = ServiceBuilder.build(name, "helm", block)
+        @application.services[name] = result
+        @application._service_order << name
+        self
+      end
+
+      def label(&block)
+        name = SecureRandom.hex
+        result = ServiceWithoutNameBuilder.build("label", block)
+        @application.services[name] = result
+        @application._service_order << name
+        self
+      end
+
+      def apply(name, &block)
+        result = ServiceBuilder.build(name, "apply", block)
+        @application.services[name] = result
+        @application._service_order << name
+        self
+      end
+
+      def secret_generic(name, &block)
+        result = ServiceBuilder.build(name, "secret_generic", block)
+        @application.services[name] = result
+        @application._service_order << name
+        self
+      end
+
+      def wait(&block)
+        name = SecureRandom.hex
+        result = ServiceBuilder.build(name, "wait", block)
+        @application.services[name] = result
+        @application._service_order << name
+        self
+      end
+
+      def chart(name, &block)
+        @application.services[name] = ChartBuilder.build(name, @application, "chart", block)
+        @application._service_order << name
+        self
+      end
+
+      def _build
+        @application
+      end
+    end
+
+    class HashBuilder < Builder
+
+      def method_missing(_, *values, &block)
+        if block_given?
+          value = HashBuilder.build(block)
+          if values.count == 1
+            @hash ||= AST.hash
+            @hash[values.first.to_sym] = value
+          else
+            @hash ||= AST.array
+            @hash << value
+          end
+        else
+          value = values.first
+          if value.is_a? Hash
+            @hash ||= AST.hash
+            key, value = value.first
+            @hash[key.to_sym] = value
+          else
+            @hash ||= AST.array
+            @hash << value
+          end
+        end
+        self
+      end
+
+      def _build
+        @hash
+      end
+    end
+
+    class VariableBuilder < HashBuilder
+      def _build
+        super || {}
+      end
+    end
+
+    class CommonBuilder < Builder
+
+      def initialize(node)
+        @node = node
+      end
+
+      def mix(name)
+        @node._mix << name
+      end
+
+      def method_missing(name, *values, &block)
+        if block_given?
+          assign_or_merge(@node, name,  HashBuilder.build(block))
+        else
+          assign_or_merge(@node, name, values.first)
+        end
+      end
+
+      def _build
+        @node
+      end
+
+      def variables(&block)
+        @node._variables ||= {}
+        @node._variables = @node._variables.merge(VariableBuilder.build(block))
+        self
+      end
+    end
+
+    class AllBuilder < CommonBuilder
+      def initialize
+        super AST.all
+      end
+    end
+
+    class ApplicationMixinBuilder < CommonBuilder
+      def initialize
+        super AST.application_mixin
+      end
+    end
+
+    class ServiceWithoutNameBuilder < CommonBuilder
+
+      def initialize( type)
+        super AST.service(_type: type)
+      end
+    end
+
+    class ServiceBuilder < CommonBuilder
+
+      def initialize(name, type)
+        super AST.service(name: name, _type: type)
+      end
+    end
+
+    class ServiceMixinBuilder < CommonBuilder
+
+      def initialize(name)
+        super AST.service(name: name)
+      end
+    end
+
+    class ChartBuilder < CommonBuilder
+      def initialize(name, application, type)
+        super AST.chart(name: name, _type: type )
+        @application = application
+      end
+
+      def service(name, &block)
+        result = ServiceBuilder.build(name, "chart-service", block)
+
+        name = "chart-#{@node.name}-#{name}"
+        @application.services[name] = result
+        @application._service_order << name
+        @node._services << name
+        self
+      end
+    end
+  end
+end

data/lib/orchparty/kubernetes_application.rb

@@ -0,0 +1,309 @@
+require 'erb'
+require 'erubis'
+require 'open3'
+require 'ostruct'
+require 'byebug'
+require 'yaml'
+require 'tempfile'
+require 'active_support'
+require 'active_support/core_ext'
+
+
+module Orchparty
+  module Services
+
+    class Context
+      attr_accessor :cluster_name
+      attr_accessor :namespace
+      attr_accessor :dir_path
+      attr_accessor :app_config
+
+      def initialize(cluster_name: , namespace:, file_path: , app_config:)
+        self.cluster_name = cluster_name
+        self.namespace = namespace
+        self.dir_path = file_path
+        self.app_config = app_config
+      end
+
+      def template(file_path, helm, flag: "-f ", fix_file_path: nil)
+        return "" unless file_path
+        file_path = File.join(self.dir_path, file_path)
+        if(file_path.end_with?(".erb"))
+          helm.application = OpenStruct.new(cluster_name: cluster_name, namespace: namespace)
+          template = ERB.new File.read(file_path )
+          yaml = template.result(helm.get_binding)
+          file = Tempfile.new("kube-deploy.yaml")
+          file.write(yaml)
+          file.close
+          file_path = file.path
+        end
+        "#{flag}#{fix_file_path || file_path}"
+      end
+
+      def print_install(helm)
+        puts "---"
+        puts install_cmd(helm, value_path(helm))
+        puts "---"
+        puts File.read(template(value_path(helm), helm, flag: "")) if value_path(helm)
+      end
+
+      def print_upgrade(helm)
+        puts "---"
+        puts install_cmd(helm, value_path(helm))
+        puts "---"
+        puts File.read(template(value_path(helm), helm, flag: "")) if value_path(helm)
+      end
+
+
+      def upgrade(helm)
+        puts system(upgrade_cmd(helm))
+      end
+
+
+      def install(helm)
+        puts system(install_cmd(helm))
+      end
+    end
+
+    class Helm < Context
+
+      def value_path(helm)
+        helm[:values]
+      end
+
+      def upgrade_cmd(helm, fix_file_path = nil)
+        "helm upgrade --namespace #{namespace} --kube-context #{cluster_name} --version #{helm.version} #{helm.name} #{helm.chart} #{template(value_path(helm), helm, fix_file_path: fix_file_path)}"
+      end
+
+      def install_cmd(helm, fix_file_path = nil)
+        "helm install --namespace #{namespace} --kube-context #{cluster_name} --version #{helm.version} --name #{helm.name} #{helm.chart} #{template(value_path(helm), helm, fix_file_path: fix_file_path)}"
+      end
+    end
+
+    class Apply < Context
+
+      def value_path(apply)
+        apply[:name]
+      end
+
+      def upgrade_cmd(apply, fix_file_path = nil)
+        "kubectl apply --namespace #{namespace} --context #{cluster_name} #{template(value_path(apply), apply, fix_file_path: fix_file_path)}"
+      end
+
+      def install_cmd(apply, fix_file_path = nil)
+        "kubectl apply --namespace #{namespace} --context #{cluster_name} #{template(value_path(apply), apply, fix_file_path: fix_file_path)}"
+      end
+    end
+
+    class SecretGeneric < Context
+
+      def value_path(secret)
+        secret[:from_file]
+      end
+
+      def upgrade_cmd(secret, fix_file_path=nil)
+        "kubectl --namespace #{namespace} --context #{cluster_name} create secret generic --dry-run -o yaml #{secret[:name]}  #{template(value_path(secret), secret, flag: "--from-file=", fix_file_path: fix_file_path)} | kubectl apply -f -"
+      end
+
+      def install_cmd(secret, fix_file_path=nil)
+        "kubectl --namespace #{namespace} --context #{cluster_name} create secret generic --dry-run -o yaml #{secret[:name]}  #{template(value_path(secret), secret, flag: "--from-file=", fix_file_path: fix_file_path)} | kubectl apply -f -"
+      end
+    end
+
+    class Label < Context
+
+      def print_install(label)
+        puts "---"
+        puts install_cmd(label)
+      end
+
+      def print_upgrade(label)
+        puts "---"
+        puts upgrade_cmd(label)
+      end
+
+      def upgrade(label)
+        puts system(upgrade_cmd(label))
+      end
+
+      def install(label)
+        puts system(install_cmd(label))
+      end
+
+      def upgrade_cmd(label)
+        "kubectl --namespace #{namespace} --context #{cluster_name} label --overwrite #{label[:resource]} #{label[:name]} #{label["value"]}"
+      end
+
+      def install_cmd(label)
+        "kubectl --namespace #{namespace} --context #{cluster_name} label --overwrite #{label[:resource]} #{label[:name]} #{label["value"]}"
+      end
+    end
+
+    class Wait < Context
+
+      def print_install(wait)
+        puts "---"
+        puts wait.cmd
+      end
+
+      def print_upgrade(wait)
+        puts "---"
+        puts wait.cmd
+      end
+
+      def upgrade(wait)
+        eval(wait.cmd)
+      end
+
+      def install(wait)
+        eval(wait.cmd)
+      end
+    end
+
+    class Chart < Context
+
+      class CleanBinding
+        def get_binding(params)
+          params.instance_eval do
+            binding
+          end
+        end
+      end
+
+      def build_chart(chart)
+        params = chart._services.map {|s| app_config.services[s.to_sym] }.map{|s| [s.name, s]}.to_h
+        Dir.mktmpdir do |dir|
+          run(templates_path: File.join(self.dir_path, chart.template), params: params, output_chart_path: dir, chart: chart)
+          yield dir
+        end
+      end
+
+
+      def run(templates_path:, params:, output_chart_path:, chart: )
+
+        system("mkdir -p #{output_chart_path}")
+        system("mkdir -p #{File.join(output_chart_path, 'templates')}")
+
+        system("cp #{File.join(templates_path, 'values.yaml')} #{File.join(output_chart_path, 'values.yaml')}")
+        system("cp #{File.join(templates_path, '.helmignore')} #{File.join(output_chart_path, '.helmignore')}")
+        system("cp #{File.join(templates_path, 'templates/_helpers.tpl')} #{File.join(output_chart_path, 'templates/_helpers.tpl')}")
+
+        generate_chart_yaml(
+          templates_path: templates_path,
+          output_chart_path: output_chart_path,
+          chart_name: chart.name,
+        )
+
+        params.each do |app_name, subparams|
+          subparams[:chart] = chart
+          generate_documents_from_erbs(
+            templates_path: templates_path,
+            app_name: app_name,
+            params: subparams,
+            output_chart_path: output_chart_path
+          )
+        end
+      end
+
+      def generate_documents_from_erbs(templates_path:, app_name:, params:, output_chart_path:)
+        kind = params.fetch(:kind)
+
+        Dir[File.join(templates_path, kind, '*.erb')].each do |template_path|
+          template_name = File.basename(template_path, '.erb')
+          output_path = File.join(output_chart_path, 'templates', "#{app_name}-#{template_name}")
+
+          template = Erubis::Eruby.new(File.read(template_path))
+          params.app_name = app_name
+          document = template.result(CleanBinding.new.get_binding(params))
+          File.write(output_path, document)
+        end
+      end
+
+      def generate_chart_yaml(templates_path:, output_chart_path:, chart_name: )
+        template_path = File.join(templates_path, 'Chart.yaml.erb')
+        output_path = File.join(output_chart_path, 'Chart.yaml')
+
+        template = Erubis::Eruby.new(File.read(template_path))
+        params = Hashie::Mash.new(chart_name: chart_name)
+        document = template.result(CleanBinding.new.get_binding(params))
+        File.write(output_path, document)
+      end
+
+
+
+      def print_install(chart)
+        build_chart(chart) do |chart_path|
+          puts `helm template --namespace #{namespace} --kube-context #{cluster_name} --name #{chart.name} #{chart_path}`
+        end
+      end
+
+      def print_upgrade(chart)
+        print_install(chart)
+      end
+
+      def install(chart)
+        build_chart(chart) do |chart_path|
+          puts system("helm install --namespace #{namespace} --kube-context #{cluster_name} --name #{chart.name} #{chart_path}")
+        end
+      end
+
+      def upgrade(chart)
+        build_chart(chart) do |chart_path|
+          puts system("helm upgrade --namespace #{namespace} --kube-context #{cluster_name} #{chart.name} #{chart_path}")
+        end
+      end
+
+    end
+  end
+end
+
+
+
+class KubernetesApplication
+  attr_accessor :cluster_name
+  attr_accessor :file_path
+  attr_accessor :namespace
+  attr_accessor :app_config
+
+  def initialize(app_config: [], namespace:, cluster_name:, file_name:)
+    self.file_path = Pathname.new(file_name).parent.expand_path
+    self.cluster_name = cluster_name
+    self.namespace = namespace
+    self.app_config = app_config
+  end
+
+  def install
+    each_service(:install)
+  end
+
+  def upgrade
+    each_service(:upgrade)
+  end
+
+  def print(method)
+    each_service("print_#{method}".to_sym)
+  end
+
+  def combine_charts(app_config)
+    services = app_config._service_order.map(&:to_s)
+    app_config._service_order.each do |name|
+      current_service = app_config[:services][name]
+      if current_service._type == "chart"
+        current_service._services.each do |n|
+          services.delete n.to_s
+        end
+      end
+    end
+    services
+  end
+
+  def each_service(method)
+    services = combine_charts(app_config)
+    services.each do |name|
+      service = app_config[:services][name]
+      "::Orchparty::Services::#{service._type.classify}".constantize.new(cluster_name: cluster_name, namespace: namespace, file_path: file_path, app_config: app_config).send(method, service)
+    end
+  end
+
+end
+

data/lib/orchparty/transformations.rb

@@ -14,5 +14,11 @@ module Orchparty
       ast = RemoveInternal.new.transform(ast)
       ast = Sort.new.transform(ast)
     end
+
+    def self.transform_kubernetes(ast, opts = {})
+      ast = All.new.transform(ast)
+      ast = Mixin.new.transform(ast)
+      ast = Variable.new(opts).transform(ast)
+    end
   end
 end

data/lib/orchparty/version.rb

@@ -1,3 +1,3 @@
 module Orchparty
-  VERSION = "1.3.1"
+  VERSION = "2.0.0-beta"
 end

data/lib/orchparty.rb

@@ -4,7 +4,9 @@ require "orchparty/ast"
 require "orchparty/context"
 require "orchparty/transformations"
 require "orchparty/dsl_parser"
+require "orchparty/dsl_parser_kubernetes"
 require "orchparty/plugin"
+require "orchparty/kubernetes_application"
 require "hash"
 
 module Orchparty
@@ -30,4 +32,22 @@ module Orchparty
   def self.generate(plugin_name, options, plugin_options)
     plugins[plugin_name].generate(ast(options), plugin_options)
   end
+
+  def self.install(cluster_name: , application_name: , force_variable_definition:,  file_name: )
+    app_config = Transformations.transform_kubernetes(Orchparty::Kubernetes::DSLParser.new(file_name).parse, force_variable_definition: force_variable_definition).applications[application_name]
+    app = KubernetesApplication.new(app_config: app_config, namespace: application_name, cluster_name: cluster_name, file_name: file_name)
+    app.install
+  end
+
+  def self.upgrade(cluster_name: , application_name: , force_variable_definition:,  file_name: )
+    app_config = Transformations.transform_kubernetes(Orchparty::Kubernetes::DSLParser.new(file_name).parse, force_variable_definition: force_variable_definition).applications[application_name]
+    app = KubernetesApplication.new(app_config: app_config, namespace: application_name, cluster_name: cluster_name, file_name: file_name)
+    app.upgrade
+  end
+
+  def self.print(cluster_name: , application_name: , force_variable_definition:,  file_name:, method: )
+    app_config = Transformations.transform_kubernetes(Orchparty::Kubernetes::DSLParser.new(file_name).parse, force_variable_definition: force_variable_definition).applications[application_name]
+    app = KubernetesApplication.new(app_config: app_config, namespace: application_name, cluster_name: cluster_name, file_name: file_name)
+    app.print(method)
+  end
 end

data/orchparty.gemspec

@@ -26,6 +26,8 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "hashie", "~> 3.5.6"
   spec.add_dependency "gli", "~> 2.16.0"
+  spec.add_dependency "activesupport"
+  spec.add_dependency "erubis"
   spec.add_development_dependency "bundler", "~> 2.0.1"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: orchparty
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 2.0.0.pre.beta
 platform: ruby
 authors:
 - Jannis Huebl
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-06 00:00:00.000000000 Z
+date: 2019-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -38,6 +38,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.16.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: erubis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -112,6 +140,8 @@ files:
 - lib/orchparty/cli.rb
 - lib/orchparty/context.rb
 - lib/orchparty/dsl_parser.rb
+- lib/orchparty/dsl_parser_kubernetes.rb
+- lib/orchparty/kubernetes_application.rb
 - lib/orchparty/plugin.rb
 - lib/orchparty/plugins/docker_compose_v1.rb
 - lib/orchparty/plugins/docker_compose_v2.rb
@@ -138,11 +168,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3
+rubyforge_project: 
+rubygems_version: 2.6.14.4
 signing_key: 
 specification_version: 4
 summary: Write your orchestration configuration with a Ruby DSL that allows you to