minfra-cli 0.1.0

data/lib/minfra/cli/commands/stack.rb

@@ -0,0 +1,120 @@
+require 'fileutils'
+require_relative 'stack/app_template'
+require_relative 'stack/client_template'
+require_relative 'stack/kube_stack_template'
+
+module Minfra
+  module Cli
+    class Stack < Command
+
+      desc "describe","get information about a stack"
+      option :environment, aliases: ['-e']
+      def describe
+        pp @minfra_config.describe(options["environment"])
+      end
+
+      desc "dashboard <stack_name>", "openening a dashboard for a stack"
+      option :environment, aliases: ['-e']
+      option :deployment, aliases: ['-d']
+      option :cluster, aliases: ['-c']
+      def dashboard(stack_name='all')
+        kube.dashboard(stack_name, options[:environment], options[:deployment], options[:cluster])
+      end
+
+      desc "deploy <stack_name> '<message> (optional)'", "deploy a complete stack"
+      option :environment, aliases: ['-e']
+#      option :deployment, aliases: ['-d']
+      option :cluster, aliases: ['-c']
+      option :dev, type: :boolean # currently, about to be changed
+      option :explain, type: :boolean
+      option :install, type: :boolean
+      option :test, type: :boolean
+      option :opts
+      def deploy(stack_name, message='')
+        kube.deploy(stack_name, message)
+      end
+
+      desc "rollback <extraargs>", "rollback a deployment"
+      option :environment, aliases: ['-e']
+      option :deployment, aliases: ['-d']
+      option :cluster, aliases: ['-c']
+      def rollback(*args)
+        STDERR.puts "needs implementation"
+        exit 1
+        #kube.rollback(stack_name, options[:environment], options[:deployment], options[:cluster], args)
+      end
+
+      desc "destroy", "remove the whole stack"
+      option :environment, aliases: ['-e']
+      option :cluster, aliases: ['-c']
+      def destroy(stack_name)
+        kube.destroy(stack_name)
+      end
+
+      desc "list", "list all stacks in an environment"
+      option :environment, aliases: ['-e']
+      option :cluster, aliases: ['-c']
+      def list
+        kube.list
+      end
+
+      desc "app", "show the app a stack provides"
+      option :environment, aliases: ['-e']
+      def app(stack_name)
+        cluster=nil
+        deployment=nil
+        template = Minfra::Cli::StackM::AppTemplate.new(stack_name, minfra_config)
+        template.read
+        puts "Template: #{template.app_path}\n#{template.to_s}"
+        apps = AppResource.all(filter: {identifier: template.app.identifier} ).data
+        if apps.empty?
+          puts "Auth: app uninstalled"
+          atts = {
+            identifier: template.app.identifier,
+            name: template.app.name,
+            short_name: template.app.short_name,
+            description: template.app.description,
+            native: template.app.native,
+            start_url: template.app.start_url,
+            public: template.app.public
+          }
+          app_res=AppResource.build( {data: {attributes: atts, type: 'apps'}} )
+          app_res.save
+          app = app_res.data
+        else
+          app = apps.first  
+        end    
+        puts "Auth: app installed #{app.id}"
+
+        clients = OauthClientResource.all(filter: {app_id: app.id}).data
+          if clients.empty?
+            puts "Auth: client not registered"
+            atts= {redirect_uris: template.client.redirect_uris.map { |r| "#{app.start_url}#{r}" }, 
+                   native: template.client.native, ppid: template.client.ppid, name: template.client.name, app_id: app.id}
+            client_res=OauthClientResource.build( {data: {attributes: atts, type: 'oauth_clients'}} )
+            client_res.save
+            client=client_res.data
+          else
+            client = clients.first
+          end
+          puts "Auth: client registered #{client.id}"
+
+          client_template=Minfra::Cli::StackM::ClientTemplate.new(stack_name, client.name, minfra_config)
+          unless client_template.exist?
+            File.write(client_template.path.to_s, { name: client.name, identifier: client.identifier, secret: client.secret }.to_json)
+          end
+          
+
+        # TODO: create app configuration
+        # TODO: create provider
+      end
+
+       private
+       def kube
+         Kube.new(options, @minfra_config)
+       end
+    end
+  end
+end
+
+Minfra::Cli.register("stack", "dealing wit stacks", Minfra::Cli::Stack)

data/lib/minfra/cli/commands/tag.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Minfra
+  module Cli
+    class Tag
+      include Minfra::Cli::Logging
+
+      def initialize
+        @now = Time.now.utc
+        @format = '%Y_%m_%dT%H_%M_%SZ'
+        @tags_folder = '.tags'
+      end
+
+      def tag_current_commit_for_deploy(message, format)
+        @format = format if format
+
+        info 'Creating tag.'
+        debug "Using .tags folder..."
+        write_tag_folder_file(message)
+        run_cmd(cmd_add_tag_info("#{@tags_folder}/#{tag_name}"), :system)
+        run_cmd(cmd_create_tag_commit, :system)
+        run_cmd(cmd_tag_commit(message), :system)
+        info 'Pushing tag to remote.'
+        run_cmd(cmd_push, :system)
+        run_cmd(cmd_push_tag, :system)
+      end
+
+      def ensure_commit_is_pushed
+        info 'Checking that the current commit is present on the remote.'
+        output = run_cmd(cmd_ensure_commit_is_pushed)
+
+        if output.empty?
+          exit_error "The current commit is not present on the remote.\n" \
+                     'Please push your changes to origin and try again.'
+        end
+      end
+
+      def cmd_ensure_commit_is_pushed
+        'git branch -r --contains $(git rev-list --max-count=1 HEAD)'
+      end
+
+      def cmd_add_tag_info(file)
+        "git add #{file}"
+      end
+
+      def cmd_create_tag_commit
+        "git commit -m '#{tag_name}'"
+      end
+
+      def cmd_tag_commit(message)
+        "git tag -a #{tag_name} -m '#{message}'"
+      end
+
+      def cmd_push
+        "git push"
+      end
+
+      def cmd_push_tag
+        "git push origin #{tag_name}"
+      end
+
+      def git_current_branch
+        `git rev-parse --abbrev-ref HEAD`.strip
+      end
+      
+      #TBD: this should be more flexible
+      def tag_name
+        "#{git_current_branch}-REL-#{@now.strftime(@format)}"
+      end
+
+      def write_tag_folder_file(message)
+        File.write("#{@tags_folder}/#{tag_name}", "#{message}\n")
+      end
+
+      def write_tag_file(_message)
+        File.write(@tags_file.to_s, "#{tag_name}\n")
+      end
+
+      def run_cmd(cmd, _how = :system)
+        Runner.run(cmd)
+      end
+    end
+  end
+end
+
+#Minfra::Cli.register("tag", "creating tags", Minfra::Cli::Tag)

data/lib/minfra/cli/common.rb

@@ -0,0 +1,41 @@
+require 'pathname'
+
+module Minfra
+  module Cli
+    module Common
+
+      def exit_error(msg)
+        STDERR.puts("ERROR: #{msg}" )
+        exit 1
+      end
+
+      def run_cmd(cmd, type = :non_system, silence: false)
+        puts cmd unless silence
+        case type
+        when :exec
+          Kernel.exec(cmd)
+        when :bash
+          res = system(%{bash -c "#{Array.new(cmd).join(' && ')}"})
+          exit_error("failed!") unless res
+          nil # no output!
+        when :system
+          res = system(cmd)
+          exit_error("failed!") unless res
+          nil # no output!
+        else
+          `#{cmd}` # with output!
+        end
+      end
+
+      def parse_cmd(cmd, silence: false)
+        reply = JSON.parse(run_cmd(cmd, silence: silence))
+      rescue JSON::ParserError, TypeError
+        error "ERROR: #{$ERROR_INFO.message}"
+        error reply
+        error "command was: #{cmd}"
+        exit 1
+      end
+
+    end
+  end
+end

data/lib/minfra/cli/config.rb

@@ -0,0 +1,111 @@
+require 'pathname'
+require 'hashie/mash'
+require 'json'
+require_relative 'templater'
+module Minfra
+  module Cli
+    # responsible the read the config file(s) and add a small abstraction layer on top of it
+    class Config
+      include Logging
+      
+      class ConfigNotFoundError < StandardError
+      end
+      class EnvironmentNotFoundError < StandardError
+      end
+
+      attr_reader :base_path
+      attr_reader :config_path
+      attr_reader :stacks_path
+      attr_reader :me_path
+      attr_reader :kube_path
+      attr_reader :kube_config_path
+      attr_reader :kind_config_path
+
+      attr_reader :orch_env
+      attr_reader :orch_env_config
+      attr_reader :config
+      attr_reader :project
+
+      def self.load(orch_env, base_path_str = nil)
+        new(base_path_str).load(orch_env)
+      end
+
+      def initialize(base_path_str=nil)
+        init!(base_path_str)
+      end
+      
+      def init!(base_path_str=nil)
+        debug( "Config: initializing" )  
+        @base_path = Pathname.new(base_path_str || ENV["MINFRA_PATH"]).expand_path
+        @me_path = @base_path.join('me')
+        @project_config_path=@base_path.join("config","project.json")
+        @config_path =  @me_path.join('config.json')
+        @stacks_path = @base_path.join('stacks')
+        @kube_path=@me_path.join('kube')
+        @kube_config_path=@kube_path.join('config')
+        @kind_config_path=@me_path.join("kind.yaml.erb")
+        @project_minfrarc_path = @base_path.join("config",'minfrarc.rb')
+        require @project_minfrarc_path if @project_minfrarc_path.exist?
+        @me_minfrarc_path = @me_path.join('minfrarc.rb')
+        require @me_minfrarc_path if @me_minfrarc_path.exist?
+        if config_path.exist?
+          @config = Hashie::Mash.new(JSON.parse(Minfra::Cli::Templater.render(File.read(config_path),{}))) 
+        else
+          warn("personal minfra configuration file '#{config_path}' not found, you might have to run 'minfra setup dev'")
+          @config = Hashie::Mash.new({})
+        end
+        @project = Hashie::Mash.new(JSON.parse(Minfra::Cli::Templater.render(File.read(@project_config_path),{})))
+      end
+
+      def load(orch_env)
+        debug( "loading config env: #{orch_env} #{@orch_env}" )
+        return self if defined?(@orch_env)
+        @orch_env = orch_env
+        @orch_env_config = @config.environments[@orch_env] || raise(EnvironmentNotFoundError.new("Configuration for orchestration environment '#{@orch_env}' not found. Available orechstration environments: #{@config.environments.keys.inspect}"))
+        @project= @project.
+                  deep_merge(@project.environments[@orch_env]).
+                  deep_merge(@config).
+                  deep_merge(@orch_env_config)
+        @orch_env_config['env']=@orch_env
+        self
+      end
+
+      def name
+        @project.name
+      end
+
+      def describe(environment)
+          {
+            env: {
+              minfra_name: ENV["MINFRA_NAME"],
+              minfra_path: ENV["MINFRA_PATH"],
+            },
+            base_path: base_path.to_s,
+            me_path: me_path.to_s,
+            kube_path: kube_path.to_s,
+            config_path: config_path.to_s,
+            config: @config.to_h,
+            env_config: @orch_env_config.to_h,
+            project: @project
+          }
+      end
+      def dev?
+        @orch_env=='dev'
+      end
+
+      def email
+        @config.identity.email
+      end
+
+      def api_key
+        @project.account_api_key
+      end
+
+      def endpoint(name)
+        Hashie::Mash.new({"api_key": api_key}).deep_merge(@project.endpoints[name])
+      rescue
+        raise("endpoint #{name} is undefinded please add <env>:endpoints:#{name} to you #{config_path} file ")
+      end
+    end
+  end
+end

data/lib/minfra/cli/document.rb

@@ -0,0 +1,19 @@
+module Minfra
+  module Cli
+    class Document
+      def self.document(config, message)
+        new(config).document(message)
+      end
+
+      def initialize(config)
+        @config = config
+      end
+
+      def document(message)
+        return true if @config.dev?
+        puts "TBD: calling documentation hooks"
+        true
+      end
+    end
+  end
+end

data/lib/minfra/cli/hook.rb

@@ -0,0 +1,65 @@
+# no support for around hooks yet
+
+module Minfra
+  module Cli
+    module Hook
+      class Hook
+        def initialize(type, name, block)
+          @type=type
+          @name=name
+          @block=block
+        end
+
+        def match?(type, name)
+         @type == type && @name == name
+        end
+
+        def exec (obj)
+          obj.instance_eval(&@block)
+        end
+
+      end
+
+      class Hooker
+        def initialize(klass)
+          @klass=klass
+          @hooks=[]
+        end
+
+        def register_before(name, block)
+          @hooks << Hook.new(:before, name, block)
+        end
+
+        def register_after(name, block)
+          @hooks << Hook.new(:after, name, block)
+        end
+
+        def call(obj, name, &block)
+          @hooks.select do |h| h.match?(:before, name) end.each do |h| h.exec(obj) end
+          obj.instance_eval(&block)
+          @hooks.select do |h| h.match?(:after, name) end.each do |h| h.exec(obj) end
+        end
+      end
+
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def hooks
+          @hooker||=Hooker.new(self)
+        end
+        def after_hook(name,&block)
+          hooks.register_after(name, block)
+        end
+        def before_hook(name, &block)
+          hooks.register_before(name, block)
+        end
+      end
+
+      def with_hook(hook_name, &block)
+        self.class.hooks.call(self, hook_name, &block)
+      end
+    end
+  end
+end

data/lib/minfra/cli/logging.rb

@@ -0,0 +1,26 @@
+module Minfra
+  module Cli
+    module Logging
+      def error(str)
+        STDERR.puts "Error: #{str}"
+      end
+
+      def exit_error(str)
+        error str
+        exit 1
+      end
+
+      def info(str)
+        STDOUT.puts str
+      end
+
+      def debug(str)
+        STDOUT.puts "Debug: #{str}"
+      end
+
+      def deprecated(comment)
+        puts "DEPRECATED: #{comment}"
+      end
+    end
+  end
+end

data/lib/minfra/cli/main_command.rb

@@ -0,0 +1,32 @@
+module Minfra
+  module Cli
+    class Main < Command
+
+      desc 'kube', 'kubectl wrapper and other features'
+      long_desc '
+      '
+      option :environment, required: false, aliases: ['-e']
+      option :cluster
+      def kube(*args)
+          kube.kubectl_command(args)
+      end
+
+      # tbd: move this to project
+      desc 'tag', 'tag current commit for deployment - triggers CI'
+      option :message, default: 'release', aliases: ['-m']
+      option :format, required: false, aliases: ['-f']
+      def tag
+        Tag.new.tag_current_commit_for_deploy(options[:message], options[:format])
+      end
+
+      desc 'version', 'prints version of the cli'
+      def version
+        puts Minfra::Cli::VERSION
+      end
+
+      def self.exit_on_failure?
+        true
+      end
+    end
+  end
+end

data/lib/minfra/cli/plugins.rb

@@ -0,0 +1,34 @@
+module Minfra
+  module Cli
+    class Plugins
+      def self.load
+        [Pathname.new(ENV["MINFRA_PATH"]).join("config","minfra_plugins.json"),
+        Pathname.new(ENV["MINFRA_PATH"]).join("me","minfra_plugins.json")].each do |file|
+
+          next unless File.exist?(file)
+
+          plugins=JSON.parse(File.read(file))
+          plugins["plugins"].each do |spec|
+            opts=spec["opts"] || {}
+            opts.merge(require: false)
+            if opts["path"]
+              begin
+                $LOAD_PATH.unshift opts["path"]+"/lib"
+                require spec["name"]
+              rescue Gem::Requirement::BadRequirementError
+                STDERR.puts("Can't load plugin: #{spec["name"]}")
+              end
+            else
+              begin
+                Gem::Specification.find_by_name(spec["name"])
+                gem spec["name"], spec["version"]
+              rescue Gem::MissingSpecError
+                STDERR.puts("Can't load plugin: #{spec["name"]}, #{spec["version"]}; run 'minfra plugin setup'")
+              end
+            end
+          end  
+        end
+      end
+    end
+  end
+end

data/lib/minfra/cli/runner.rb

@@ -0,0 +1,59 @@
+require 'open3'
+
+module Minfra
+  module Cli
+    class Runner
+      class Result
+        attr_reader :stdout, :stderr
+        def initialize(stdout,stderr, status)
+          @stderr=stderr
+          @stdout=stdout
+          @status=status
+        end
+
+        def success?
+          @status.success?
+        end
+
+        def error?
+          !success?
+        end
+
+        def to_s
+          @stdout.to_s
+        end
+      end
+
+      include Logging
+      def self.run(cmd, **args)
+        new(cmd, **args).run
+      end
+
+      attr_reader :exit_on_error
+      def initialize(cmd, exit_on_error: true)
+        @cmd=cmd
+        @exit_on_error = exit_on_error
+      end
+
+      def run
+        debug(@cmd)
+        res=nil
+        begin
+          res=Result.new(*Open3.capture3(@cmd))
+        rescue
+        end  
+        if res&.error?
+          STDERR.puts "command failed: #{@cmd}"
+          STDERR.puts res.stdout
+          STDERR.puts res.stderr
+        end
+        if exit_on_error && res&.error?
+          STDERR.puts "exiting on error"
+          exit 1
+        end
+        res
+      end
+
+    end
+  end
+end

data/lib/minfra/cli/templater.rb

@@ -0,0 +1,63 @@
+require 'erb'
+
+module Minfra
+  module Cli
+    class Templater # not threadsafe!
+      def self.read(path, params: {}, fallback: nil)
+        p=Pathname.new(path)
+        if p.exist?
+          content=File.read(path)
+        else
+          if fallback
+            content=fallback
+          else
+            raise "file #{path} not found"
+          end
+        end  
+        render(template, params)
+      end
+      
+      def self.render(template, params)
+        new(template).render(params)
+      end
+
+      def initialize(template)
+        @erb = ERB.new(template)
+        @check_mode=false
+        @check_missing=[]
+      end
+
+      def missing?
+        !check_missing.empty?
+      end
+
+      def check_missing(&block)
+        begin
+          @check_mode = true
+          @check_block = block
+          @check_missing = []
+          @erb.result(binding)
+        ensure
+          @check_block = nil
+          @check_mode = false
+        end
+        @check_missing
+      end
+
+      def render(params)
+        @erb.result_with_hash(params)
+      end
+
+      def method_missing(name)
+        if @check_mode
+          if @check_block
+            @check_block.call(name)
+          end
+          @check_missing << name
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/minfra/cli/version.rb

@@ -0,0 +1,5 @@
+module Minfra
+  module Cli
+    VERSION = '0.1.0'.freeze
+  end
+end