minfra-cli 0.1.0

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

@@ -0,0 +1,279 @@
+require 'yaml'
+module Minfra
+  module Cli
+    class Kube
+      include Minfra::Cli::Common
+      include Logging
+
+      attr_reader :options, :env_config, :config
+
+      def initialize(options, config)
+        @options = options
+        @config=config
+        @env_config=config.orch_env_config
+      end
+
+      def dashboard(stack_name,env,deployment,cluster)
+        stack = init(stack_name,env,deployment,cluster)
+        exec("k9s --kubeconfig #{kube_config_path} --context #{stack.cluster_name} --namespace #{stack_name} --command pod")
+      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"}
+      end
+
+      def create
+        STDOUT.sync
+
+        network_mask = @config.project.kind.network.mask
+        gateway_ip = @config.project.kind.network.gateway
+        panel_ip = @config.project.kind.panel.ip
+
+        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 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
+        info 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)
+        File.write(@config.kube_config_path, YAML.dump(existing_config))
+
+        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}
+
+#        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}}
+      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) 
+      end
+
+      def deploy(stack_name, reason_message)
+        #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"
+        File.open(stack.compose_path(blank: true),"w") do |f|
+          Orchparty.print(cluster_name: cluster, 
+                          application_name: stack.name, 
+                          force_variable_definition: false, 
+                          file_name: stack.stack_rb_path.to_s, 
+                          method: method,
+                          options: options,
+                          out_io: f)
+        end
+        #run_cmd(generate_cmd, :bash)
+        bash_cmd = ["cd #{stack.release_path}"]
+        bash_cmd << "cp #{stack.compose_path(blank: true)} #{stack.compose_path}"
+        run_cmd(bash_cmd, :bash)
+
+
+        run_cmd(["cd #{stack.release_path}",
+                 "git --no-pager diff #{stack.compose_path}",
+        ], :bash, silence: true)
+
+        errors = stack.check_plan
+        unless errors.empty?
+          if config['force_mem']
+            exit_error(errors.join("\n"))
+          else
+            warn(errors.join("\n"))
+          end
+        end
+
+        unless test
+          unless @config.dev?
+            unless Ask.boolean("Are the changes ok?")
+              exit_error("Deployment aborted!")
+            end
+          end
+
+#          deploy_cmd = bash_cmd
+#          deploy_cmd << "#{env_cmd} orchparty #{method} -c #{cluster} -f #{stack.stack_rb_path}  -a #{stack.name}"
+
+          reason_message = tag_changed_to(release_path: stack.release_path) if reason_message.blank?
+
+          message =  "deploying stack #{stack.name}: #{reason_message}."
+          Minfra::Cli::Document.document(@config,"started #{message}")
+          Orchparty.send(method, cluster_name: cluster, application_name: stack.name, force_variable_definition: false, file_name: stack.stack_rb_path.to_s, options: options)
+          Minfra::Cli::Document.document(@config,"finished #{message}")
+        end
+      end
+
+      def rollback(stack_name, env, deployment, cluster)
+        stack = init(stack_name,
+                     env,
+                     deployment,
+                     cluster)
+
+        cluster = stack.cluster_name
+
+        extra_args = args.dup
+        extra_args.delete("rollback")
+
+        extra_args = extra_args.join(' ')
+
+        cmd = "helm --kube-context #{cluster} rollback #{options[:stack]} #{extra_args}"
+        #puts cmd
+        run_cmd(cmd, :exec)
+      end
+
+      def list
+        puts run_helm(%{list --all-namespaces})
+      end
+
+      def destroy(stack_name)
+        stack = init(stack_name,
+                     options[:environment],
+                     options[:deployment],
+                     options[:cluster])
+        # Our convention is that our stack name is the namespace in helm.
+        # Sometimes the helm release name can be the same as the stack name (usually in the normal stacks).
+        # However, stacks that combine multiple helm charts have the release name different from the stack name, that's why we have to list them all in a sub-command.
+        run_helm(%{uninstall --namespace #{stack_name} --kube-context #{stack.cluster_name} $(helm list --namespace #{stack_name} --kube-context #{stack.cluster_name} --short)})
+      end
+
+      def kubectl_command(args)
+        unless options['stack']
+          exit_error("You must specify a stack name (--stack).")
+        end
+
+        subcommand = args.shift
+
+        if ['exec', 'logs'].include?(subcommand)
+          resource = nil
+          implicit_resource = 'pod'
+        else
+          resource = args.shift
+        end
+
+        stack = init(options[:stack],
+                     options[:environment],
+                     options[:deployment],
+                     options[:cluster])
+
+        cluster = stack.cluster_name
+
+        if [resource, implicit_resource].include?('pod') && ['delete', 'describe', 'exec', 'logs'].include?(subcommand)
+          cmd_get_pods = "kubectl --kubeconfig #{kube_config_path} --context #{cluster} --namespace #{options[:stack]} get pod -o jsonpath='{range .items[*]}{.metadata.name}{\"\\n\"}'"
+
+          pods_list = run_cmd(cmd_get_pods).split("\n")
+
+          fuzzy_pod_name = args.shift
+
+          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
+
+          position = 0
+          if options[:position]
+            p = options[:position].to_i
+            if p <= matching_pods.size
+              position = p - 1
+            else
+              exit_error("You specified '--position #{options[:position]} but only #{matching_pods.size} pods matched the name.")
+            end
+          end
+
+          pod_name = matching_pods[position]
+        end
+
+        extra_args = args.dup
+
+        if subcommand == 'exec'
+          subcommand = 'exec -ti'
+          extra_args << '--' << 'bash'
+        end
+
+        extra_args = extra_args.join(' ')
+
+        cmd = "kubectl --kubeconfig #{kube_config_path} --context #{cluster} --namespace #{options[:stack]} #{subcommand} #{resource} #{pod_name} #{extra_args}"
+        # puts cmd
+        run_cmd(cmd, :exec)
+      end
+
+      private
+
+      def tag_changed_to(release_path:)
+        return '' if @config.dev? # We don't use messages in dev
+
+        diff = run_cmd("cd #{release_path} && git --no-pager diff --unified=0 tags.json").split %r{(\d{4}_\d{2}_\d{2}T\d{2}_\d{2}_\d{2}Z)}
+
+        raise ArgumentError.new "#{release_path}/tags.json has not changed - supply message" if diff.empty?
+
+        diff[3]
+      end
+
+      def init(stack_name, env, deployment, explicit_cluster)
+        template = Minfra::Cli::StackM::KubeStackTemplate.new(stack_name,
+                                                        config,
+                                                        deployment: deployment,
+                                                        cluster: explicit_cluster)
+
+#        exit_error(template.error_message) unless template.valid?
+        template
+      end
+
+      def kube_config_path
+        @config.kube_config_path
+      end
+
+      def run_kubectl(cmd)
+        #        run(%{kubectl --kubeconfig #{kube_config_path} #{cmd}})
+        run(%{kubectl #{cmd}})
+      end
+
+      def run_helm(cmd)
+#        run(%{helm --kubeconfig #{kube_config_path} --home #{helm_path} #{cmd}})
+        run(%{helm #{cmd}})
+      end
+
+      def helm_path
+        @config.me_path.join('helm')
+      end
+
+      def kind_name
+        @config.name
+      end
+
+      def run(cmd, **args)
+        Runner.run(cmd, **args)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Minfra
+  module Cli
+    class Project < Command
+      class Branch < Command
+
+        desc "create 'story desc'", 'create branch'
+        def create(story_desc)
+          story_desc = story_desc.gsub(/[^0-9a-z]/i, '_')
+          email = `git config user.email`
+          fullname = email.split('@').first
+          name = fullname[0] + fullname.split('.').last
+          Runner.run("git checkout -b #{name}_#{story_desc}_$(date +%Y%m%d)")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Minfra
+  module Cli
+    class Project < Command
+      class Tag < Command
+
+        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)
+
+          tags[options[:environment]][domain] = new_tag
+          pretty_tags = JSON.pretty_unparse(tags)
+          File.write(tags_path, pretty_tags + "\n")
+          puts "#{tags_path} - UPDATED"
+          puts pretty_tags
+        end
+
+        private
+
+        def tags_path
+          apps_path.join('stacks', stack_name, 'tags.json')
+        end
+
+        def apps_path
+          minfra_config.base_path
+        end
+
+        def stack_name
+          current_directory.split('/').last.gsub('_', '-')
+        end
+
+        def current_directory
+          Dir.getwd
+        end
+      end
+    end  
+  end
+end

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

@@ -0,0 +1,113 @@
+require_relative 'project/branch'
+require_relative 'project/tag'
+
+module Minfra
+  module Cli
+    class Project < Command
+      class ProjectInfo
+        def self.load(app_dir)
+          new(app_dir)
+        end
+        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)))
+        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
+      end
+
+      desc 'branch', 'manage branches'
+      subcommand 'branch', Branch
+
+      desc 'tag', 'manage tags'
+      subcommand 'tag', Tag
+
+      desc "test", 'run tests'
+      def test
+        ARGV.delete('project') # ARGV is passed along to `rspec` call
+        ARGV.delete('test')
+
+        if File.exists?('./bin/run_tests')
+          # config = Config.load('staging')
+          project = ProjectInfo.load(Pathname.pwd)
+          # Minfra::Cli::Document.document(config, "Using project specific ./bin/run_tests in #{project.name}")
+          debug "Using project specific ./bin/run_tests in #{project.name}"
+          system('./bin/run_tests', out: $stdout, err: :out)
+        else
+          require_relative '../../generic/bin/run_tests'
+        end
+      end
+
+      desc "build","build a local build"
+      option "noload", aliases: ['-n']
+      option "target", aliases: ['-t'] 
+      def build
+        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}}
+        # Runner.run(cmd) # this gives us no output ... don't like that
+        puts "running: #{cmd}"
+        `#{cmd}` || exit(1)
+        unless options[:noload]
+          debug("loading int KIND")
+          Runner.run(%{kind load docker-image #{p.repo_name}:latest --name #{@minfra_config.name}})
+        end  
+      end
+
+      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  -v #{p.app_dir}:/code #{p.repo_name}:latest #{cmd}})
+      end
+
+      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)
+
+        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
+
+
+
+      private
+      def run_pre_repo
+        Runner.run(%{#{@minfra_config.base_path.join('hooks','pre_repo.sh')}})
+      end
+    end
+  end
+end
+
+
+Minfra::Cli.register("project", "dealing wit projects", Minfra::Cli::Project)

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

@@ -0,0 +1,49 @@
+require 'fileutils'
+module Minfra
+  module Cli
+    class Setup < Thor # not from command! # Dev
+      include Logging
+      include Hook
+
+      desc "setup", "creates a default config file on the host"
+      def dev
+        setup_config
+      end
+
+      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.init!
+        config.load('dev')
+        templates_path=Minfra::Cli.root_path.join("templates")
+        ensure_path_and_template(config.kube_config_path, templates_path.join('kube_config.yaml.erb'))
+        ensure_path_and_template(config.kind_config_path, config.base_path.join('config','kind.yaml.erb'),
+                                 {ip: config.project.kind.panel.ip,
+                                  name: config.project.name,
+                                  host_path: config.base_path
+                                 })
+      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
+          end
+        else
+          info "SETUP CONFIG: checked #{dest_path}"
+        end
+      end
+    end
+  end
+end
+
+Minfra::Cli.register("setup", "Manage your dev setup.", Minfra::Cli::Setup)

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

@@ -0,0 +1,65 @@
+require 'pathname'
+
+module Minfra
+  module Cli
+    module StackM
+      class AppTemplate
+        include ::Minfra::Cli::Logging
+
+        attr_reader :name, :env, :deployment, :app_path
+        def initialize(name, config)
+          @name       = name
+          @path       = config.stacks_path.join(name)
+          @app_path   = @path.join('fxnet-app.json')
+          @errors     = []
+          @config     = config
+          @env        = config.orch_env
+          @content    = {}
+        end
+
+        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
+          unless @cluster_name
+            error "Cluster name unknown (not given explicitly and '#{cluster_path}' missing)"
+            exit 1
+          end
+          @cluster_name
+        end
+
+        def valid?
+          unless @path.exist?
+            @errors << "stack path #{@path} doesn't exist"
+          end
+
+          unless @app_path.exist?
+            @errors << "stack.rb file #{@app_path} doesn't exist"
+          end
+          @errors.empty?
+        end
+
+        def read
+          t=Minfra::Cli::Templater.new(File.read(@app_path))
+          @content = Hashie::Mash.new(JSON.parse(t.render({})))
+        end
+
+        def app
+          @content.app
+        end
+
+        def client
+          @content.client
+        end
+        
+        def to_s
+          JSON.generate(@content, {indent: "  ", object_nl: "\n"})
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'pathname'
+
+module Minfra
+  module Cli
+    module StackM
+      class ClientTemplate
+        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")
+          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
+        end
+
+        def to_s
+          JSON.generate(@content, {indent: "  ", object_nl: "\n"})
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+require 'pathname'
+module Minfra
+  module Cli
+    module StackM
+      class KubeStackTemplate
+      include ::Minfra::Cli::Logging
+
+      attr_reader :name, :env, :deployment
+      def initialize(name, config, deployment: '', cluster:)
+        @name       = name
+        @path       = config.stacks_path.join(name)
+        @errors     = []
+        @config     = config
+        @env        = config.orch_env
+        @deployment = deployment.freeze
+        @cluster    = cluster.freeze
+        puts "Stack selection: #{@name}, #{@path}, #{@cluster}"
+      end
+
+      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 ||= env
+        @cluster_name
+      end
+
+      def mixin_env
+        "#{@env}#{dashed(@deployment)}"
+      end
+
+      def valid?
+        unless @path.exist?
+          @errors << "stack path #{@path} doesn't exist"
+        end
+
+        unless stack_rb_path.exist?
+          @errors << "stack.rb file #{stack_rb_path} doesn't exist"
+        end
+        @errors.empty?
+      end
+
+      def stack_rb_path
+        release_path.join('stack.rb')
+      end
+
+      def cluster_path
+        release_path.join("cluster.yaml")
+      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")
+        end
+      end
+
+      def error_message
+        @errors.join(";\n")
+      end
+
+      # we use a special file to flag the this stack is releasable to an environment
+      def releasable?
+        switch_path.exist?
+      end
+
+      def switch_path
+        release_path.join("#{@env}_#{rancher_stack_name}.sh")
+      end
+
+      def release_path
+        @path
+      end
+
+
+      def check_plan
+        errors = []
+        errors
+      end
+
+      private
+      def dashed(sth,set=nil)
+        sth.nil? || sth.empty? ? '' : "-#{set||sth}"
+      end
+    end
+  end
+end
+end