minfra-cli 0.1.0

data/lib/orchparty/dsl_parser_kubernetes.rb

@@ -0,0 +1,361 @@
+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 template(path)
+        chart_name = "_mixin_temp_name"
+        unless @mixin.services[chart_name]
+          @mixin.services[chart_name] = AST.chart(name: chart_name, _type: "chart" )
+          @mixin._service_order << chart_name
+        end
+        chart = @mixin.services[chart_name]
+        chart.template = path
+        self
+      end
+
+      def service(name, &block)
+
+        chart_name = "_mixin_temp_name"
+        unless @mixin.services[chart_name]
+          @mixin.services[chart_name] = AST.chart(name: chart_name, _type: "chart" )
+          @mixin._service_order << chart_name
+        end
+        chart = @mixin.services[chart_name]
+
+        result = ServiceBuilder.build(name, "chart-service", block)
+
+        name = "chart-#{chart.name}-#{name}"
+        @mixin.services[name] = result
+        @mixin._service_order << name
+        chart._services << name
+        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 template(path)
+        chart_name = @application.name
+        unless @application.services[chart_name]
+          @application.services[chart_name] = AST.chart(name: chart_name, _type: "chart" )
+          @application._service_order << chart_name
+        end
+        chart = @application.services[chart_name]
+        chart.template = path
+        self
+      end
+
+      def service(name, &block)
+
+        chart_name = @application.name
+        unless @application.services[chart_name]
+          @application.services[chart_name] = AST.chart(name: chart_name, _type: "chart" )
+          @application._service_order << chart_name
+        end
+        chart = @application.services[chart_name]
+
+        result = ServiceBuilder.build(name, "chart-service", block)
+
+        name = "chart-#{chart.name}-#{name}"
+        @application.services[name] = result
+        @application._service_order << name
+        chart._services << 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
+            begin
+              @hash[key.to_sym] = value
+            rescue 
+              warn "Problem with key: #{key} #{value}"
+              raise 
+            end 
+             
+          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,305 @@
+require 'erb'
+require 'erubis'
+require 'open3'
+require 'ostruct'
+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
+      attr_accessor :options
+
+      def initialize(cluster_name: , namespace:, file_path: , app_config:, out_io: STDOUT)
+        self.cluster_name = cluster_name
+        self.namespace = namespace
+        self.dir_path = file_path
+        self.app_config = app_config
+        @out_io = out_io
+        self.options=options
+      end
+
+      def template(file_path, helm, flag: "-f ", fix_file_path: nil)
+        return "" unless file_path
+        puts "Rendering: #{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 = Erubis::Eruby.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)
+        @out_io.puts "---"
+        @out_io.puts install_cmd(helm, value_path(helm))
+        @out_io.puts upgrade_cmd(helm, value_path(helm))
+        @out_io.puts "---"
+        @out_io.puts File.read(template(value_path(helm), helm, flag: "")) if value_path(helm)
+      end
+
+      # On 05.02.2021 we have decided that it would be best to print both commands.
+      # This way it would be possible to debug both upgrade and install and also people would not see git diffs all the time.
+      def print_upgrade(helm)
+        print_install(helm)
+      end
+
+      def upgrade(helm)
+        @out_io.puts system(upgrade_cmd(helm))
+      end
+
+      def install(helm)
+        @out_io.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 --create-namespace --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
+    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 --context #{cluster_name} 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 --context #{cluster_name} apply -f -"
+      end
+    end
+
+    class Label < Context
+      def print_install(label)
+        @out_io.puts "---"
+        @out_io.puts install_cmd(label)
+      end
+
+      def print_upgrade(label)
+        @out_io.puts "---"
+        @out_io.puts upgrade_cmd(label)
+      end
+
+      def upgrade(label)
+        @out_io.puts system(upgrade_cmd(label))
+      end
+
+      def install(label)
+        @out_io.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)
+        @out_io.puts "---"
+        @out_io.puts wait.cmd
+      end
+
+      def print_upgrade(wait)
+        @out_io.puts "---"
+        @out_io.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.expand_path(chart.template, self.dir_path), 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:)
+        if params[:kind].nil?
+          warn "ERROR: Could not generate service '#{app_name}'. Missing key: 'kind'."
+          exit 1
+        end
+
+        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
+          params.templates_path = templates_path
+          begin
+            document = template.result(CleanBinding.new.get_binding(params))
+          rescue Exception
+            puts "#{template_path} has a problem: #{$!.inspect}"
+            raise
+          end  
+          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|
+          @out_io.puts `helm template --namespace #{namespace} --kube-context #{cluster_name} #{chart.name} #{chart_path}`
+        end
+      end
+
+      def print_upgrade(chart)
+        print_install(chart)
+      end
+
+      def install(chart)
+        build_chart(chart) do |chart_path|
+          @out_io.puts system("helm install --create-namespace --namespace #{namespace} --kube-context #{cluster_name} #{chart.name} #{chart_path}")
+        end
+      end
+
+      def upgrade(chart)
+        build_chart(chart) do |chart_path|
+          @out_io.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:, out_io: STDOUT)
+    self.file_path = Pathname.new(file_name).parent.expand_path
+    self.cluster_name = cluster_name
+    self.namespace = namespace
+    self.app_config = app_config
+    @out_io= out_io
+  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, out_io: @out_io).send(method, service)
+    end
+  end
+end

data/lib/orchparty/plugin.rb

@@ -0,0 +1,24 @@
+module Orchparty
+  module Plugin
+    @plugins = {}
+
+    def self.load_plugin(name)
+      begin
+        require "orchparty/plugins/#{name}"
+        raise "Plugin didn't correctly register itself" unless @plugins[name]
+        @plugins[name]
+      rescue LoadError
+        puts "could not load the plugin #{name}, you might install it as a gem or you need to write it by your self ;)"
+        false
+      end
+    end
+
+    def self.plugins
+      @plugins
+    end
+
+    def self.register_plugin(name, mod)
+      @plugins[name] = mod
+    end
+  end
+end