minfra-cli 0.1.0

data/lib/minfra/cli.rb

@@ -0,0 +1,80 @@
+require 'thor'
+require 'open3'
+require 'json'
+require 'ostruct'
+require 'orchparty'
+
+require_relative 'cli/logging'
+require_relative 'cli/config'
+require_relative 'cli/version'
+require_relative 'cli/hook'
+require_relative 'cli/common'
+require_relative 'cli/command'
+require_relative 'cli/templater'
+require_relative 'cli/ask'
+require_relative 'cli/document'
+require_relative 'cli/runner'
+require_relative 'cli/plugins'
+
+require 'active_support'
+require 'active_support/core_ext'
+
+require "ENV['MINFRA_PATH']/config/preload.rb" if File.exist?("ENV['MINFRA_PATH']/config/preload.rb")
+
+module Minfra
+  module Cli
+    extend Minfra::Cli::Logging
+
+    def self.root_path
+      Pathname.new(File.expand_path(File.join(__FILE__, '../../../')))
+    end
+
+    def self.config
+      @config ||= Config.new
+    end
+    def self.scan
+      root_path.join("lib/minfra/cli/commands").each_child do |command_path|
+        require command_path if command_path.to_s.match(/\.rb$/) && !command_path.to_s.match(/\#/)
+      end
+      # this is like railties but their called minfracs
+      $LOAD_PATH.each do |path|
+        minfra_path = Pathname.new(path).join("..","minfracs","init.rb")
+        if minfra_path.exist?
+          require minfra_path # this should register the command
+        end
+      end
+    end
+
+    def self.register(subcommand,info,command)
+      #debug("Registered command #{subcommand}")
+      @subcommands ||= {}
+      @subcommands[subcommand.to_sym]= OpenStruct.new(name: subcommand, info: info, command: command)
+    end
+
+    def self.resolve
+      @subcommands.values.each do |sub|
+        Minfra::Cli::Main.desc(sub.name,sub.info)
+        Minfra::Cli::Main.subcommand(sub.name,sub.command)
+      end
+    end
+
+    def self.subcommand(name)
+      @subcommands[name.to_sym]&.command
+    end
+
+    def self.before_hook(subcommand, command, &block)
+      subcommand(subcommand).before_hook(command, &block)
+    end
+
+    def self.after_hook(subcommand, command, &block)
+      subcommand(subcommand).after_hook(command, &block)
+    end
+  end
+end
+
+Minfra::Cli::Plugins.load
+Minfra::Cli.scan
+require_relative 'cli/main_command'
+Minfra::Cli.resolve
+
+

data/lib/orchparty/ast.rb

@@ -0,0 +1,53 @@
+require 'hashie'
+
+module Orchparty
+  class AST
+    class Node < ::Hashie::Mash
+      include Hashie::Extensions::DeepMerge
+      include Hashie::Extensions::DeepMergeConcat
+      include Hashie::Extensions::MethodAccess
+      include Hashie::Extensions::Mash::KeepOriginalKeys
+      disable_warnings
+
+      def get_binding
+        binding
+      end
+    end
+
+    def self.hash(args = {})
+      Node.new.merge(args)
+    end
+
+    def self.array(args = [])
+      args
+    end
+
+    def self.root(args = {})
+      Node.new(applications: {}, _mixins: {}).merge(args)
+    end
+
+    def self.mixin(args = {})
+      Node.new({services: {}, _mixins: {}, volumes: {}, _variables: {}, networks: {}, _service_order: []}).merge(args)
+    end
+
+    def self.application(args = {})
+      Node.new({services: {}, _mixins: {}, _mix:[], volumes: {}, _variables: {}, networks: {}, _service_order: []}).merge(args)
+    end
+
+    def self.all(args = {})
+      Node.new(_mix:[], _variables: {}).merge(args)
+    end
+
+    def self.application_mixin(args = {})
+      Node.new(_mix:[], _variables: {}).merge(args)
+    end
+
+    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

@@ -0,0 +1,69 @@
+require 'orchparty'
+require 'gli'
+
+Orchparty.load_all_available_plugins
+
+class OrchPartyApp
+  extend GLI::App
+
+  program_desc 'Write your orchestration configuration with a Ruby DSL that allows you to have mixins, imports and variables.'
+  version Orchparty::VERSION
+
+  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|
+        com.desc plugin.desc
+        com.command(name) do |plugin_command|
+          plugin_command.flag [:filename,:f,'file-name'], required: true, :desc => 'The Orchparty input file'
+          plugin_command.flag [:application,:a], required: true, :desc => 'The application that should be compiled'
+          plugin_command.switch :"force-variable-definition", :default_value => false, :desc => "Raises an Error if the input contains a not defined variable"
+          plugin.define_flags(plugin_command)
+          plugin_command.action do |global_options,plugin_options,args|
+            options = plugin_options.delete(GLI::Command::PARENT)
+            options[:application] = plugin_options[:application]
+            options[:filename] = plugin_options[:filename]
+            options[:force_variable_definition] = plugin_options[:"force-variable-definition"]
+            Orchparty.generate(name, options, plugin_options)
+          end
+        end
+    end
+  end
+end
+
+exit OrchPartyApp.run(ARGV)

data/lib/orchparty/context.rb

@@ -0,0 +1,22 @@
+module Orchparty
+    class Context < ::Hashie::Mash
+      include Hashie::Extensions::DeepMerge
+      include Hashie::Extensions::DeepMergeConcat
+      include Hashie::Extensions::MethodAccess
+      include Hashie::Extensions::Mash::KeepOriginalKeys
+
+
+     def method_missing(name, *args)
+       raise "#{name} not declared for #{application.name}.#{service.name}" if @_force_variable_definition && !key?(name)  && !key?(name.to_s)
+       super
+     end
+
+     def _force_variable_definition=(v)
+       @_force_variable_definition = v
+     end
+
+      def context
+        self
+      end
+    end
+end

data/lib/orchparty/dsl_parser.rb

@@ -0,0 +1,229 @@
+require 'pathname'
+module Orchparty
+  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)
+      builder._build
+    end
+
+    def assign_or_merge(node, key, value)
+      if node[key]
+        merged = node[key].deep_merge_concat(value)
+        puts "'#{key}' updated to '#{merged}'"
+        node[key] = merged
+      else
+        puts "'#{key}' set to '#{value}'"
+        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 = ServiceBuilder.build(name, block)
+      @mixin.services[name] = result
+      @mixin._mixins[name] = result
+      self
+    end
+
+    def variables(&block)
+      @mixin._variables = VariableBuilder.build(block)
+      self
+    end
+
+    def mixin(name, &block)
+      @mixin._mixins[name] = ServiceBuilder.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 networks(&block)
+      @application.networks = HashBuilder.build(block)
+    end
+
+    def service(name, &block)
+      @application.services[name] = ServiceBuilder.build(name, block)
+      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 ServiceBuilder < CommonBuilder
+
+    def initialize(name)
+      super AST.service(name: name)
+    end
+  end
+end