minfra-cli 1.13.3 → 2.0.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'pathname'
 
 module Minfra
@@ -7,29 +9,29 @@ module Minfra
         include ::Minfra::Cli::Logging
 
         attr_reader :content, :path
+
         def initialize(stack_name, client_name, config)
           @stack_name  = stack_name
           @client_name = client_name
           @config      = OpenStruct.new
-          @path       = config.stacks_path.join(stack_name, "fxnet-client-#{client_name}-#{config.orch_env}.json")
+          @path = config.stacks_path.join(stack_name, "fxnet-client-#{client_name}-#{config.orch_env}.json")
           read
         end
 
         def exist?
           @path.exist?
         end
-          
+
         def read
-          if exist?
-            t=Minfra::Cli::Templater.new(File.read(@path))
-            @content = Hashie::Mash.new(JSON.parse(t.render({})))
-          end
+          return unless exist?
+
+          t = Minfra::Cli::Templater.new(File.read(@path))
+          @content = Hashie::Mash.new(JSON.parse(t.render({})))
         end
 
         def to_s
-          JSON.generate(@content, {indent: "  ", object_nl: "\n"})
+          JSON.generate(@content, { indent: '  ', object_nl: "\n" })
         end
-
       end
     end
   end

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

@@ -1,75 +1,73 @@
+# frozen_string_literal: true
+
 require 'pathname'
 module Minfra
   module Cli
     module StackM
       class KubeStackTemplate
-      include ::Minfra::Cli::Logging
+        include ::Minfra::Cli::Logging
 
-      attr_reader :name, :env, :deployment, :config_path
-      def initialize(name, config, deployment: '', cluster:)
-        @name       = name
-        @config_path = config.stacks_path.join(name)
-        @errors     = []
-        @config     = config
-        @env        = config.orch_env
-        @deployment = deployment.freeze
-        @cluster    = cluster.freeze || l!("cluster").id
-        @result_path = config.status_path.join('stacks', @cluster, name)
-        debug "Stack selection: #{@name}, #{@config_path}, #{@cluster}, #{@result_path}"
-      end
+        attr_reader :name, :env, :deployment, :config_path
 
-      def cluster_name
-        @cluster
-      end
+        def initialize(name, config, cluster:, deployment: '')
+          @name = name
+          @config_path = config.stacks_path.join(name)
+          @errors     = []
+          @config     = config
+          @env        = config.orch_env
+          @deployment = deployment.freeze
+          @cluster    = cluster.freeze || l!('cluster').id
+          @result_path = config.status_path.join('stacks', @cluster, name)
+          debug "Stack selection: #{@name}, #{@config_path}, #{@cluster}, #{@result_path}"
+        end
 
-      def mixin_env
-        "#{@env}#{dashed(@deployment)}"
-      end
+        def cluster_name
+          @cluster
+        end
 
-      def valid?
-        unless @config_path.exist?
-          @errors << "stack path #{@config_path} doesn't exist"
+        def mixin_env
+          "#{@env}#{dashed(@deployment)}"
         end
 
-        unless stack_rb_path.exist?
-          @errors << "stack.rb file #{stack_rb_path} doesn't exist"
+        def valid?
+          @errors << "stack path #{@config_path} doesn't exist" unless @config_path.exist?
+
+          @errors << "stack.rb file #{stack_rb_path} doesn't exist" unless stack_rb_path.exist?
+          @errors.empty?
         end
-        @errors.empty?
-      end
 
-      def stack_rb_path
-        config_path.join('stack.rb')
-      end
+        def stack_rb_path
+          config_path.join('stack.rb')
+        end
 
-      def compose_path(blank: false)
-        if blank
-          release_path.join("compose.yaml")
-        elsif @cluster
-          release_path.join("compose#{dashed(@cluster)}.yaml")
-        else
-          release_path.join("compose#{dashed(@env)}#{dashed(@deployment)}.yaml")
+        def compose_path(blank: false)
+          if blank
+            release_path.join('compose.yaml')
+          elsif @cluster
+            release_path.join("compose#{dashed(@cluster)}.yaml")
+          else
+            release_path.join("compose#{dashed(@env)}#{dashed(@deployment)}.yaml")
+          end
         end
-      end
 
-      def error_message
-        @errors.join(";\n")
-      end
+        def error_message
+          @errors.join(";\n")
+        end
 
-      def release_path
-        @result_path
-      end
+        def release_path
+          @result_path
+        end
 
+        def check_plan
+          []
+        end
 
-      def check_plan
-        errors = []
-        errors
-      end
+        private
 
-      private
-      def dashed(sth,set=nil)
-        sth.nil? || sth.empty? ? '' : "-#{set||sth}"
+        def dashed(sth, set = nil)
+          sth.nil? || sth.empty? ? '' : "-#{set || sth}"
+        end
       end
     end
   end
 end
-end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 require_relative 'stack/app_template'
 require_relative 'stack/client_template'
@@ -6,24 +8,23 @@ require_relative 'stack/kube_stack_template'
 module Minfra
   module Cli
     class Stack < Command
-
-      desc "describe","get information about a stack"
+      desc 'describe', 'get information about a stack'
       option :environment, aliases: ['-e']
       def describe
-        pp minfra_config.describe(options["environment"])
+        pp minfra_config.describe(options['environment'])
       end
 
-      desc "dashboard <stack_name>", "openening a dashboard for a stack"
+      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')
+      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"
+      desc "deploy <stack_name> '<message> (optional)'", 'deploy a complete stack'
       option :environment, aliases: ['-e']
-#      option :deployment, aliases: ['-d']
+      #      option :deployment, aliases: ['-d']
       option :cluster, aliases: ['-c']
       option :dev, type: :boolean # currently, about to be changed
       option :explain, type: :boolean
@@ -31,45 +32,52 @@ module Minfra
       option :test, type: :boolean
       option :opts
       option :force, type: :boolean
-      def deploy(stack_name, message='')
-        kube.deploy(stack_name, message)
+      def deploy(stack_name, message = '')
+        stacks = l('env.roles') || l('env.stacks') || []
+        default_stacks = minfra_config.project.default_stacks || []
+        stacks = stacks.concat(default_stacks)
+        if stacks.include?(stack_name) || options[:force] || options[:test]
+          kube.deploy(stack_name, message)
+        else
+          exit_error("project:default_stacks or hiera:env.roles or hiera:env.stacks has to include '#{stack_name}' or use --force or --test")
+        end  
       end
 
-      desc "rollback <extraargs>", "rollback a deployment"
+      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"
+      def rollback(*_args)
+        warn 'needs implementation'
         exit 1
-        #kube.rollback(stack_name, options[:environment], options[:deployment], options[:cluster], args)
+        # kube.rollback(stack_name, options[:environment], options[:deployment], options[:cluster], args)
       end
 
-      desc "destroy", "remove the whole stack"
+      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"
+      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"
+      desc 'app', 'show the app a stack provides'
       option :environment, aliases: ['-e']
       def app(stack_name)
-        cluster=nil
-        deployment=nil
+        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
+        puts "Template: #{template.app_path}\n#{template}"
+        apps = AppResource.all(filter: { identifier: template.app.identifier }).data
         if apps.empty?
-          puts "Auth: app uninstalled"
+          puts 'Auth: app uninstalled'
           atts = {
             identifier: template.app.identifier,
             name: template.app.name,
@@ -79,43 +87,44 @@ module Minfra
             start_url: template.app.start_url,
             public: template.app.public
           }
-          app_res=AppResource.build( {data: {attributes: atts, type: 'apps'}} )
+          app_res = AppResource.build({ data: { attributes: atts, type: 'apps' } })
           app_res.save
           app = app_res.data
         else
-          app = apps.first  
-        end    
+          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}"
+        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
-          
+        client_template = Minfra::Cli::StackM::ClientTemplate.new(stack_name, client.name, minfra_config)
+        return if client_template.exist?
+
+        File.write(client_template.path.to_s,
+                   { name: client.name, identifier: client.identifier, secret: client.secret }.to_json)
 
         # TODO: create app configuration
         # TODO: create provider
       end
 
-       private
-       def kube
-         Kube.new(options, minfra_config)
-       end
+      private
+
+      def kube
+        Kube.new(options, minfra_config)
+      end
     end
   end
 end
 
-Minfra::Cli.register("stack", "dealing wit stacks", Minfra::Cli::Stack)
+Minfra::Cli.register('stack', 'dealing wit stacks', Minfra::Cli::Stack)

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Minfra
   module Cli
     class Tag
@@ -22,10 +23,10 @@ module Minfra
         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
+        return unless output.empty?
+
+        exit_error "The current commit is not present on the remote.\n" \
+                   'Please push your changes to origin and try again.'
       end
 
       def cmd_ensure_commit_is_pushed
@@ -45,7 +46,7 @@ module Minfra
       end
 
       def cmd_push
-        "git push"
+        'git push'
       end
 
       def cmd_push_tag
@@ -55,8 +56,8 @@ module Minfra
       def git_current_branch
         `git rev-parse --abbrev-ref HEAD`.strip
       end
-      
-      #TBD: this should be more flexible
+
+      # TBD: this should be more flexible
       def tag_name
         "#{git_current_branch}-REL-#{@now.strftime(@format)}"
       end
@@ -68,4 +69,4 @@ module Minfra
   end
 end
 
-#Minfra::Cli.register("tag", "creating tags", Minfra::Cli::Tag)
+# Minfra::Cli.register("tag", "creating tags", Minfra::Cli::Tag)

data/lib/minfra/cli/common.rb

@@ -1,13 +1,11 @@
+# frozen_string_literal: true
+
 require 'pathname'
 
 module Minfra
   module Cli
     module Common
-
-      def exit_error(msg)
-        STDERR.puts("ERROR: #{msg}" )
-        exit 1
-      end
+      include Minfra::Cli::Logging
 
       def run_cmd(cmd, type = :non_system, silence: false)
         debug(cmd)
@@ -15,12 +13,12 @@ module Minfra
         when :exec
           Kernel.exec(cmd)
         when :bash
-          res = system(%{bash -c "#{Array.new(cmd).join(' && ')}"})
-          exit_error("failed!") unless res
+          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
+          exit_error('failed!') unless res
           nil # no output!
         else
           `#{cmd}` # with output!
@@ -28,14 +26,13 @@ module Minfra
       end
 
       def parse_cmd(cmd, silence: false)
-        reply = JSON.parse(run_cmd(cmd, silence: silence))
+        reply = JSON.parse(run_cmd(cmd, 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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'pathname'
 require 'hashie/mash'
 require 'json'
@@ -8,90 +10,61 @@ module Minfra
     class Config
       class ConfigNotFoundError < StandardError
       end
+
       class EnvironmentNotFoundError < StandardError
       end
 
-      attr_reader :base_path
-      attr_reader :config_path
-      attr_reader :stacks_path
-      attr_reader :status_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
+      attr_reader :base_path, :config_path, :stacks_path, :status_path, :me_path, :kube_path, :kube_config_path,
+                  :kind_config_path, :orch_env, :orch_env_config, :config, :project
 
-      def self.load(orch_env, base_path_str = nil)
-        new(base_path_str).load(orch_env)
+      def initialize(base_path_str, orch_env)
+        init!(base_path_str, orch_env)
       end
 
-      def initialize(base_path_str=nil)
-        init!(base_path_str)
-      end
-      
-      def init!(base_path_str=nil)
-        @base_path = Pathname.new(base_path_str || ENV["MINFRA_PATH"]).expand_path
+      def init!(base_path_str, orch_env)
+        @orch_env = orch_env
+        @base_path = Pathname.new(base_path_str).expand_path
         @me_path = @base_path.join('me')
-        @project_config_path=@base_path.join("config","project.json")
-        @config_path =  @me_path.join('config.json')
+        @project_config_path = @base_path.join('config', 'project.json')
+        @config_path = @me_path.join('config.json')
         @stacks_path = @base_path.join('stacks')
         @status_path = @base_path.join('state')
-        @kube_path=@me_path.join('kube')
-        @kube_config_path=@kube_path.join('config')
-        @kind_config_path=@me_path.join("kind.yaml")
-
-#        @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?
+        @kube_path = @me_path.join('kube')
+        @kube_config_path = @kube_path.join('config')
+        @kind_config_path = @me_path.join('kind.yaml')
 
         if config_path.exist?
-          @config = Hashie::Mash.new(JSON.parse(Minfra::Cli::Templater.render(File.read(config_path),{}))) 
+          @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),{})))
-        @project= @project.
-           deep_merge(@config)
-#           deep_merge(@project.environments[@orch_env]).
-#           deep_merge(@orch_env_config)
-
-      end
-
-      def load(orch_env)
-        return self if defined?(@orch_env)
-        @orch_env = orch_env
-        @orch_env_config=Hashie::Mash.new
-        @orch_env_config['env']=@orch_env
-        self
+        @project = Hashie::Mash.new(JSON.parse(Minfra::Cli::Templater.render(File.read(@project_config_path), {})))
+        @project = @project
+                   .deep_merge(@config)
       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
-          }
+      def describe(_environment)
+        {
+          env: {
+            minfra_name: ENV.fetch('MINFRA_NAME', nil),
+            minfra_path: ENV.fetch('MINFRA_PATH', nil)
+          },
+          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,
+          project: @project
+        }
       end
+
       def dev?
-        @orch_env=='dev'
+        @orch_env == 'dev'
       end
 
       def email
@@ -103,8 +76,8 @@ module Minfra
       end
 
       def endpoint(name)
-        Hashie::Mash.new({"api_key": api_key}).deep_merge(@project.endpoints[name])
-      rescue
+        Hashie::Mash.new({ api_key: }).deep_merge(@project.endpoints[name])
+      rescue StandardError
         raise("endpoint #{name} is undefinded please add <env>:endpoints:#{name} to you #{config_path} file ")
       end
     end

data/lib/minfra/cli/core_ext.rb

@@ -0,0 +1,7 @@
+# this is for ruby 3.2
+
+class File
+  def self.exists?(file)
+    exist?(file)
+  end
+end

data/lib/minfra/cli/document.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Minfra
   module Cli
     class Document
@@ -9,9 +11,10 @@ module Minfra
         @config = config
       end
 
-      def document(message)
+      def document(_message)
         return true if @config.dev?
-        puts "TBD: calling documentation hooks"
+
+        puts 'TBD: calling documentation hooks'
         true
       end
     end

data/lib/minfra/cli/env.rb

@@ -0,0 +1,24 @@
+module Minfra
+  module Cli
+    class Env
+      attr_reader :name, :hiera
+      def initialize(name:, hiera_root:,   hiera_env_path:)
+        @name = name            
+        @hiera = HieraLooker.new( 
+          root: hiera_root,
+          env_name: name,
+          env_path: hiera_env_path
+        )
+      end
+      
+      def l(key, value = nil)
+        @hiera.l(key,value)
+      end
+      
+      def l!(key, value = nil)
+        @hiera.l!(key, value)
+      end
+      
+    end
+  end
+end

data/lib/minfra/cli/errors.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Minfra
+  module Cli
+    module Errors
+      class ExitError < StandardError
+      end
+    end
+  end
+end

data/lib/minfra/cli/helm_runner.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Minfra
   module Cli
     class HelmRunner < Runner
       def initialize(cmd, **args)
-        insecure_flag = l("infra::allow_insecure_k8s_connections") ? "--kube-insecure-skip-tls-verify" : ""
+        insecure_flag = l('infra::allow_insecure_k8s_connections') ? '--kube-insecure-skip-tls-verify' : ''
         cmd = "helm #{insecure_flag} #{cmd}"
         super(cmd, **args)
       end