minfra-cli 1.13.3 → 2.0.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 module Minfra
   module Cli
@@ -9,27 +11,27 @@ module Minfra
 
       def initialize(options, config)
         @options = options
-        @config=config
-        @env_config=config.orch_env_config
+        @config = config
+        @env_config = config.orch_env_config
       end
 
-      def dashboard(stack_name,env,deployment,cluster)
-        stack = init(stack_name,env,deployment,cluster)
-        insecure_flag = l("infra::allow_insecure_k8s_connections") ? "--insecure-skip-tls-verify" : ""
+      def dashboard(stack_name, env, deployment, cluster)
+        stack = init(stack_name, env, deployment, cluster)
+        insecure_flag = l('infra::allow_insecure_k8s_connections') ? '--insecure-skip-tls-verify' : ''
         cmd = "k9s #{insecure_flag} --kubeconfig #{kube_config_path} --context #{stack.cluster_name} --namespace #{stack_name} --command pod"
         debug(cmd)
         exec(cmd)
       end
 
       def restart
-        run %{docker start #{kind_name}-control-plane}
-        run %{docker exec  #{kind_name}-control-plane bash -c "sed -e '/nameserver 127.0.0.11/ s/^#*/#/'  /etc/resolv.conf | cat - >> /etc/resolv.conf"}
-        run %{docker exec  #{kind_name}-control-plane bash -c "echo nameserver 8.8.8.8 >> /etc/resolv.conf"}
-        run %{docker exec  #{kind_name}-control-plane bash -c "echo nameserver 8.8.4.4 >> /etc/resolv.conf"}
+        run %(docker start #{kind_name}-control-plane)
+        run %(docker exec  #{kind_name}-control-plane bash -c "sed -e '/nameserver 127.0.0.11/ s/^#*/#/'  /etc/resolv.conf | cat - >> /etc/resolv.conf")
+        run %(docker exec  #{kind_name}-control-plane bash -c "echo nameserver 8.8.8.8 >> /etc/resolv.conf")
+        run %(docker exec  #{kind_name}-control-plane bash -c "echo nameserver 8.8.4.4 >> /etc/resolv.conf")
       end
 
       def create
-        STDOUT.sync
+        $stdout.sync
 
         network_mask = @config.project.kind.network.mask
         gateway_ip = @config.project.kind.network.gateway
@@ -37,82 +39,98 @@ module Minfra
 
         info "step: creating network #{kind_name} #{network_mask} gw #{gateway_ip}"
         # run(%{docker network inspect kind | grep "Subnet"}, exit_on_error: false).success?
-        run(%{docker network rm #{kind_name}}, exit_on_error: false)
+        run(%(docker network rm #{kind_name}), exit_on_error: false)
 
-        run(%{docker network create --gateway #{gateway_ip} --subnet=#{network_mask} #{kind_name}}, exit_on_error: true)
+        run(%(docker network create --gateway #{gateway_ip} --subnet=#{network_mask} #{kind_name}), exit_on_error: true)
 
         info "step: creating '#{kind_name}' kind cluster (can take some minutes)"
-        kind_kube_path=Runner.run('echo $KUBECONFIG').to_s.strip
-        kind_config=Templater.read(config.base_path.join('config','kind.yaml.erb'), params: {config: config})
+        kind_kube_path = Runner.run('echo $KUBECONFIG').to_s.strip
+        kind_config = Templater.read(config.base_path.join('config', 'kind.yaml.erb'), params: { config: })
         File.write(config.kind_config_path, kind_config)
-                                 
-        run(%{KIND_EXPERIMENTAL_DOCKER_NETWORK=#{kind_name} kind create cluster --name "#{kind_name}" --config #{@config.kind_config_path}})
-
-        info "step: configuring kind"
-        run %{docker exec #{kind_name}-control-plane bash -c "sed -e '/nameserver 127.0.0.11/ s/^#*/#/'  /etc/resolv.conf | cat - >> /etc/resolv.conf"}
-        run %{docker exec #{kind_name}-control-plane bash -c "echo nameserver 8.8.8.8 >> /etc/resolv.conf"}
-        run %{docker exec #{kind_name}-control-plane bash -c "echo nameserver 8.8.4.4 >> /etc/resolv.conf"}
-
-        configs = [YAML.load(File.read(kind_kube_path))]
-
-        existing_config = YAML.load(File.read(kube_config_path))
 
-        existing_config["clusters"] = existing_config["clusters"].reject { |c| configs.map { |k| k["clusters"] }.flatten.map { |n| n["name"] }.include?(c["name"]) }.concat(configs.map { |k| k["clusters"] }.flatten)
-        existing_config["users"] = existing_config["users"].reject { |c| configs.map { |k| k["users"] }.flatten.map { |n| n["name"] }.include?(c["name"]) }.concat(configs.map{ |k| k["users"] }.flatten).uniq { |k| k["name"] }
-        existing_config["contexts"] = existing_config["contexts"].reject { |c| configs.map { |k| k["contexts"] }.flatten.map{ |n| n["name"] }.include?(c["name"]) }.concat(configs.map { |k| k["contexts"] }.flatten)
+        run(%(KIND_EXPERIMENTAL_DOCKER_NETWORK=#{kind_name} kind create cluster --name "#{kind_name}" --config #{@config.kind_config_path}))
+
+        info 'step: configuring kind'
+        run %(docker exec #{kind_name}-control-plane bash -c "sed -e '/nameserver 127.0.0.11/ s/^#*/#/'  /etc/resolv.conf | cat - >> /etc/resolv.conf")
+        run %(docker exec #{kind_name}-control-plane bash -c "echo nameserver 8.8.8.8 >> /etc/resolv.conf")
+        run %(docker exec #{kind_name}-control-plane bash -c "echo nameserver 8.8.4.4 >> /etc/resolv.conf")
+
+        configs = [YAML.safe_load(File.read(kind_kube_path))]
+
+        existing_config = YAML.safe_load(File.read(kube_config_path))
+
+        existing_config['clusters'] = existing_config['clusters'].reject do |c|
+          configs.map do |k|
+            k['clusters']
+          end.flatten.map { |n| n['name'] }.include?(c['name'])
+        end.concat(configs.map do |k|
+                     k['clusters']
+                   end.flatten)
+        existing_config['users'] = existing_config['users'].reject do |c|
+                                     configs.map do |k|
+                                       k['users']
+                                     end.flatten.map { |n| n['name'] }.include?(c['name'])
+                                   end.concat(configs.map do |k|
+                                                k['users']
+                                              end.flatten).uniq { |k| k['name'] }
+        existing_config['contexts'] = existing_config['contexts'].reject do |c|
+          configs.map do |k|
+            k['contexts']
+          end.flatten.map { |n| n['name'] }.include?(c['name'])
+        end.concat(configs.map do |k|
+                     k['contexts']
+                   end.flatten)
         File.write(@config.kube_config_path, YAML.dump(existing_config))
 
-        info "step: starting kind"
-        run_kubectl %{ config use-context kind-#{kind_name} }
+        info 'step: starting kind'
+        run_kubectl %( config use-context kind-#{kind_name} )
 
-        run_kubectl %{create clusterrolebinding default-admin --serviceaccount=kube-system:default --clusterrole=cluster-admin}
+        run_kubectl %(create clusterrolebinding default-admin --serviceaccount=kube-system:default --clusterrole=cluster-admin)
 
-#        info "step: attaching newly created kind cluster to its own docker network"
-#        info run(%{docker network connect #{kind_name} #{kind_name}-control-plane --ip #{panel_ip}})
+        #        info "step: attaching newly created kind cluster to its own docker network"
+        #        info run(%{docker network connect #{kind_name} #{kind_name}-control-plane --ip #{panel_ip}})
       end
 
       def push(image)
-        run %{kind load docker-image --name #{kind_name} #{image}}
+        run %(kind load docker-image --name #{kind_name} #{image})
       end
 
       def destroy_dev_cluster
         run %(kind delete cluster --name #{kind_name})
         run(%(docker rm -f #{kind_name}-control-plane), exit_on_error: false)
-        run(%(docker network rm #{kind_name}), exit_on_error: false) 
+        run(%(docker network rm #{kind_name}), exit_on_error: false)
       end
 
       def deploy(stack_name, reason_message)
-        #TBD: options is global, avoid it!
-        
-        test=options[:test]
+        # TBD: options is global, avoid it!
+
+        test = options[:test]
         stack = init(stack_name,
                      options[:environment],
                      options[:deployment],
                      options[:cluster])
         cluster = stack.cluster_name
 
-        method = options["install"] ? "install" : "upgrade"
+        method = options['install'] ? 'install' : 'upgrade'
 
         stack.release_path.mkpath
-        
-        File.open(stack.compose_path,"w") do |f|
-          Orchparty::App.new(cluster_name: cluster, 
-                        application_name: stack.name, 
-                        force_variable_definition: false, 
-                        file_name: stack.stack_rb_path.to_s,
-                        status_dir: stack.release_path,
-                        options: options
-                        ).
-                        print( method: method, out_io: f)
+
+        File.open(stack.compose_path, 'w') do |f|
+          Orchparty::App.new(cluster_name: cluster,
+                             application_name: stack.name,
+                             force_variable_definition: false,
+                             file_name: stack.stack_rb_path.to_s,
+                             status_dir: stack.release_path,
+                             options:)
+                        .print(method:, out_io: f)
         end
-        #run_cmd(generate_cmd, :bash)
+        # run_cmd(generate_cmd, :bash)
         bash_cmd = ["cd #{stack.release_path}"]
         run_cmd(bash_cmd, :bash)
 
-
         run_cmd(["cd #{stack.release_path}",
-                 "git --no-pager diff #{stack.release_path}",
-        ], :bash, silence: true)
+                 "git --no-pager diff #{stack.release_path}"], :bash, silence: true)
+        # run_cmd("helm diff upgrade --allow-unreleased ccs-integration-service state/stacks/development-staging-1/ccs-integration-service/helm -n ccs-integration-service", :bash, silence: true)
 
         errors = stack.check_plan
         unless errors.empty?
@@ -123,25 +141,20 @@ module Minfra
           end
         end
 
-        unless test
-          unless @config.dev? || options[:force]==true
-            unless Ask.boolean("Are the changes ok?")
-              exit_error("Deployment aborted!")
-            end
-          end
+        return if test
 
-          message =  "deploying stack #{stack.name}: #{reason_message}."
-          Minfra::Cli::Document.document(@config,"started #{message}")
-          orch=Orchparty::App.new(cluster_name: cluster, 
-                        application_name: stack.name, 
-                        force_variable_definition: false, 
-                        file_name: stack.stack_rb_path.to_s,
-                        status_dir: stack.release_path,
-                        options: options
-                        )
-          orch.send(method)
-          Minfra::Cli::Document.document(@config,"finished #{message}")
-        end
+        exit_error('Deployment aborted!') if !(@config.dev? || options[:force] == true) && !Ask.boolean('Are the changes ok?')
+
+        message = "deploying stack #{stack.name}: #{reason_message}."
+        Minfra::Cli::Document.document(@config, "started #{message}")
+        orch = Orchparty::App.new(cluster_name: cluster,
+                                  application_name: stack.name,
+                                  force_variable_definition: false,
+                                  file_name: stack.stack_rb_path.to_s,
+                                  status_dir: stack.release_path,
+                                  options:)
+        orch.send(method)
+        Minfra::Cli::Document.document(@config, "finished #{message}")
       end
 
       def rollback(stack_name, env, deployment, cluster)
@@ -153,7 +166,7 @@ module Minfra
         cluster = stack.cluster_name
 
         extra_args = args.dup
-        extra_args.delete("rollback")
+        extra_args.delete('rollback')
 
         extra_args = extra_args.join(' ')
 
@@ -161,7 +174,7 @@ module Minfra
       end
 
       def list
-        puts run_helm(%{list --all-namespaces})
+        puts run_helm(%(list --all-namespaces))
       end
 
       def destroy(stack_name)
@@ -176,13 +189,11 @@ module Minfra
       end
 
       def kubectl_command(args)
-        unless options['stack']
-          exit_error("You must specify a stack name (--stack).")
-        end
+        exit_error('You must specify a stack name (--stack).') unless options['stack']
 
         subcommand = args.shift
 
-        if ['exec', 'logs','port-forward'].include?(subcommand)
+        if %w[exec logs port-forward].include?(subcommand)
           resource = nil
           implicit_resource = 'pod'
         else
@@ -195,7 +206,8 @@ module Minfra
                      options[:cluster])
 
         cluster = stack.cluster_name
-        if [resource, implicit_resource].include?('pod') && ['delete', 'describe', 'exec', 'logs', 'port-forward'].include?(subcommand)
+        if [resource,
+            implicit_resource].include?('pod') && %w[delete describe exec logs port-forward].include?(subcommand)
           cmd_get_pods = "--kubeconfig #{kube_config_path} --context #{cluster} --namespace #{options[:stack]} get pod -o jsonpath='{range .items[*]}{.metadata.name}{\"\\n\"}'"
 
           pods_list = run_kubectl(cmd_get_pods).stdout_lines
@@ -204,9 +216,7 @@ module Minfra
 
           matching_pods = pods_list.select { |p| p.include?(fuzzy_pod_name) }
 
-          if matching_pods.empty?
-            exit_error("Could not find any pods that have '#{fuzzy_pod_name}' in their name.")
-          end
+          exit_error("Could not find any pods that have '#{fuzzy_pod_name}' in their name.") if matching_pods.empty?
 
           position = 0
           if options[:position]
@@ -237,14 +247,13 @@ module Minfra
 
       private
 
-      def init(stack_name, env, deployment, explicit_cluster)
-        template = Minfra::Cli::StackM::KubeStackTemplate.new(stack_name,
-                                                        config,
-                                                        deployment: deployment,
-                                                        cluster: explicit_cluster)
+      def init(stack_name, _env, deployment, explicit_cluster)
+        Minfra::Cli::StackM::KubeStackTemplate.new(stack_name,
+                                                   config,
+                                                   deployment:,
+                                                   cluster: explicit_cluster)
 
-#        exit_error(template.error_message) unless template.valid?
-        template
+        #        exit_error(template.error_message) unless template.valid?
       end
 
       def kube_config_path

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

@@ -1,21 +1,22 @@
+# frozen_string_literal: true
+
 module Minfra
   module Cli
     class Plugin < Command
-
-      desc "describe","describe plugins"
+      desc 'describe', 'describe plugins'
       def describe
-        Minfra::Cli.plugins.each do |plugin|
+        Minfra::Cli.cli.plugins.each do |plugin|
           puts "#{plugin.name} (#{plugin.version})"
         end
       end
-      desc "install", "install plugins"
+      desc 'install', 'install plugins'
       def install
-        Minfra::Cli.plugins.each do |plugin|
+        Minfra::Cli.cli.plugins.each do |plugin|
           puts "setup: #{plugin.name}"
           plugin.install
         end
       end
-    end  
-  end    
+    end
+  end
 end
-Minfra::Cli.register("plugin", "dealing wit plugins", Minfra::Cli::Plugin)
+Minfra::Cli.register('plugin', 'dealing wit plugins', Minfra::Cli::Plugin)

data/lib/minfra/cli/commands/project/branch.rb

@@ -1,18 +1,20 @@
+# frozen_string_literal: true
+
 module Minfra
   module Cli
     class Project < Command
       class Branch < Command
-
         desc "create 'story desc'", 'create branch'
-        option :prefix, type: :string, desc: "don't use your git email address or project.branch.create.prefix or identity.email"
+        option :prefix, type: :string,
+                        desc: "don't use your git email address or project.branch.create.prefix or identity.email"
         def create(story_desc)
-          story_desc = story_desc.gsub(/[^0-9a-z\-]/i, '_')
-          prefix = options[:prefix] || Minfra::Cli.config.project.dig('project','branch', 'create', 'prefix')
+          story_desc = story_desc.gsub(/[^0-9a-z-]/i, '_')
+          prefix = options[:prefix] || Minfra::Cli.config.project.dig('project', 'branch', 'create', 'prefix')
           unless prefix
             email = Minfra::Cli.config.project.dig('identity', 'email') || `git config user.email`
             fullname = email.split('@').first
             prefix = fullname[0] + fullname.split('.').last
-          end  
+          end
           Runner.run("git checkout -b #{prefix}_#{story_desc}_$(date +%Y%m%d)")
         end
       end

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

@@ -1,18 +1,19 @@
+# frozen_string_literal: true
+
 module Minfra
   module Cli
     class Project < Command
       class Tag < Command
-
-        desc "update", 'update stack tag file'
-        option "environment", aliases: ['-e'], required: true
+        desc 'update', 'update stack tag file'
+        option 'environment', aliases: ['-e'], required: true
         def update(domain, new_tag)
           tags = JSON.parse(File.read(tags_path))
 
-          raise ArgumentError.new "#{path} doesn't contain #{domain}" unless tags[options[:environment]].has_key?(domain)
+          raise ArgumentError, "#{path} doesn't contain #{domain}" unless tags[options[:environment]].key?(domain)
 
           tags[options[:environment]][domain] = new_tag
           pretty_tags = JSON.pretty_unparse(tags)
-          File.write(tags_path, pretty_tags + "\n")
+          File.write(tags_path, "#{pretty_tags}\n")
           puts "#{tags_path} - UPDATED"
           puts pretty_tags
         end
@@ -35,6 +36,6 @@ module Minfra
           Dir.getwd
         end
       end
-    end  
+    end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'project/branch'
 require_relative 'project/tag'
 
@@ -11,19 +13,23 @@ module Minfra
         attr_reader :app_dir
 
         def initialize(app_dir)
-          @app_dir=app_dir
-          @project_file_path=app_dir.join('project.json')
-          @info=Hashie::Mash.new(JSON.parse(File.read(@project_file_path)))
+          @app_dir = app_dir
+          @project_file_path = app_dir.join('project.json')
+          @info = Hashie::Mash.new(JSON.parse(File.read(@project_file_path)))
         end
+
         def repo_name
           "#{docker.repo}/#{docker.name}"
         end
+
         def name
           @info['project']
         end
+
         def method_missing(method)
           @info.send(method)
         end
+
         def inspect
           @info.inspect
         end
@@ -35,7 +41,7 @@ module Minfra
       desc 'tag', 'manage tags'
       subcommand 'tag', Tag
 
-      desc "test", 'run tests'
+      desc 'test', 'run tests'
       def test
         ARGV.delete('project') # ARGV is passed along to `rspec` call
         ARGV.delete('test')
@@ -51,63 +57,57 @@ module Minfra
         end
       end
 
-      desc "build","build a local build"
-      option "noload", aliases: ['-n']
-      option "target", aliases: ['-t'] 
+      desc 'build', 'build a local build'
+      option 'noload', aliases: ['-n']
+      option 'target', aliases: ['-t']
       def build
-        p=ProjectInfo.load(Pathname.pwd)
+        p = ProjectInfo.load(Pathname.pwd)
         run_pre_repo
-        if options[:target]
-          target = options[:target]
-        else
-          target = p.docker.dev_target
-        end
-          
-        cmd = %{docker build #{"--target #{target}" if target} -t #{p.repo_name}:latest #{p.app_dir}}
+        target = options[:target] || p.docker.dev_target
+
+        cmd = %(docker build #{"--target #{target}" if target} -t #{p.repo_name}:latest #{p.app_dir})
         res = Runner.run(cmd)
         exit(1) if res.error?
-        
-        unless options[:noload]
-          debug("loading image into KIND's registry")
-          Runner.run(%{kind load docker-image #{p.repo_name}:latest --name #{minfra_config.name}})
-        end  
+
+        return if options[:noload]
+
+        debug("loading image into KIND's registry")
+        Runner.run(%(kind load docker-image #{p.repo_name}:latest --name #{minfra_config.name}))
       end
 
-      desc "exec","execute a command (bash is default in the container)"
-      def exec(cmd='/bin/bash')
-        p=ProjectInfo.load(Pathname.pwd)
+      desc 'exec', 'execute a command (bash is default in the container)'
+      def exec(cmd = '/bin/bash')
+        p = ProjectInfo.load(Pathname.pwd)
         run_pre_repo
-        Kernel.exec(%{docker run -ti --rm  #{p.exec_params} -v #{p.app_dir}:/code #{p.repo_name}:latest #{cmd}})
+        Kernel.exec(%(docker run -ti --rm  #{p.exec_params} -v #{p.app_dir}:/code #{p.repo_name}:latest #{cmd}))
       end
 
-      desc "push", "push directly to the repo"
+      desc 'push', 'push directly to the repo'
       option 'tag', aliases: ['-t']
       option 'registry', aliases: ['-r']
       def push
         tag = options[:tag] || `date +%Y%m%d%H%M`
-        p=ProjectInfo.load(Pathname.pwd)
+        p = ProjectInfo.load(Pathname.pwd)
 
         repo_name = if options[:registry]
-            "#{options[:registry]}/#{p.repo_name}"
-          else
-            p.repo_name
-          end
-          
-        Runner.run(%{docker build -t #{p.repo_name}:latest #{p.app_dir}})
-#        Runner.run(%{docker push #{p.repo_name}})
-        Runner.run(%{docker tag #{p.repo_name}:latest #{repo_name}:#{tag}})
-        Runner.run(%{docker push #{repo_name}:#{tag}})
-      end
-
+                      "#{options[:registry]}/#{p.repo_name}"
+                    else
+                      p.repo_name
+                    end
 
+        Runner.run(%(docker build -t #{p.repo_name}:latest #{p.app_dir}))
+        #        Runner.run(%{docker push #{p.repo_name}})
+        Runner.run(%(docker tag #{p.repo_name}:latest #{repo_name}:#{tag}))
+        Runner.run(%(docker push #{repo_name}:#{tag}))
+      end
 
       private
+
       def run_pre_repo
-        Runner.run(%{#{minfra_config.base_path.join('hooks','pre_repo.sh')}})
+        Runner.run(minfra_config.base_path.join('hooks', 'pre_repo.sh').to_s)
       end
     end
   end
 end
 
-
-Minfra::Cli.register("project", "dealing wit projects", Minfra::Cli::Project)
+Minfra::Cli.register('project', 'dealing wit projects', Minfra::Cli::Project)

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

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 module Minfra
   module Cli
-    class Setup < Thor # not from command! # Dev
+    # not from command! # Dev
+    class Setup < Thor
       include Logging
       include Hook
 
-      desc "dev", "creates a default config file on the host"
+      desc 'dev', 'creates a default config file on the host'
       def dev
         setup_config
       end
@@ -13,31 +16,28 @@ module Minfra
       private
 
       def setup_config
-        config= Minfra::Cli.config
-        ensure_path_and_template(config.config_path, config.base_path.join('config','me_config.json.erb'))
+        config = Minfra::Cli.config
+        ensure_path_and_template(config.config_path, config.base_path.join('config', 'me_config.json.erb'))
         config.init!
         config.load('dev')
-        
       end
 
-      def ensure_path_and_template(dest_path, template_path, params={})
-        unless dest_path.exist?
-          if Ask.boolean("missing configuration at: #{dest_path}, should I create it?")
-            unless dest_path.dirname.exist?
-              info "Generated directory '#{dest_path.dirname}'"
-              FileUtils.mkdir_p(dest_path.dirname)
-            end
-            template=Ask.interactive_template(template_path,dest_path,params)
-          else
-            error "Leaving your filesystem untouched! But I have to stop!"
-            exit 1
+      def ensure_path_and_template(dest_path, template_path, params = {})
+        if dest_path.exist?
+          info "SETUP CONFIG: checked #{dest_path}"
+        elsif Ask.boolean("missing configuration at: #{dest_path}, should I create it?")
+          unless dest_path.dirname.exist?
+            info "Generated directory '#{dest_path.dirname}'"
+            FileUtils.mkdir_p(dest_path.dirname)
           end
+          template = Ask.interactive_template(template_path, dest_path, params)
         else
-          info "SETUP CONFIG: checked #{dest_path}"
+          error 'Leaving your filesystem untouched! But I have to stop!'
+          exit 1
         end
       end
     end
   end
 end
 
-Minfra::Cli.register("setup", "Manage your dev setup.", Minfra::Cli::Setup)
+Minfra::Cli.register('setup', 'Manage your dev setup.', Minfra::Cli::Setup)

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'pathname'
 
 module Minfra
@@ -7,6 +9,7 @@ module Minfra
         include ::Minfra::Cli::Logging
 
         attr_reader :name, :env, :deployment, :app_path
+
         def initialize(name, config)
           @name       = name
           @path       = config.stacks_path.join(name)
@@ -19,11 +22,10 @@ module Minfra
 
         def cluster_name
           return @cluster_name if defined?(@cluster_name)
+
           @cluster_name = @cluster
           @cluster_name ||= "kind-#{@config.name}" if @config.dev?
-          if cluster_path.exist? && (@cluster_name.nil? || @cluster_name.empty?)
-            @cluster_name = YAML.load(File.read(cluster_path))[env.to_s]
-          end
+          @cluster_name = YAML.safe_load(File.read(cluster_path))[env.to_s] if cluster_path.exist? && (@cluster_name.nil? || @cluster_name.empty?)
           unless @cluster_name
             error "Cluster name unknown (not given explicitly and '#{cluster_path}' missing)"
             exit 1
@@ -32,18 +34,14 @@ module Minfra
         end
 
         def valid?
-          unless @path.exist?
-            @errors << "stack path #{@path} doesn't exist"
-          end
+          @errors << "stack path #{@path} doesn't exist" unless @path.exist?
 
-          unless @app_path.exist?
-            @errors << "stack.rb file #{@app_path} doesn't exist"
-          end
+          @errors << "stack.rb file #{@app_path} doesn't exist" unless @app_path.exist?
           @errors.empty?
         end
 
         def read
-          t=Minfra::Cli::Templater.new(File.read(@app_path))
+          t = Minfra::Cli::Templater.new(File.read(@app_path))
           @content = Hashie::Mash.new(JSON.parse(t.render({})))
         end
 
@@ -54,11 +52,10 @@ module Minfra
         def client
           @content.client
         end
-        
+
         def to_s
-          JSON.generate(@content, {indent: "  ", object_nl: "\n"})
+          JSON.generate(@content, { indent: '  ', object_nl: "\n" })
         end
-
       end
     end
   end