minfra-cli 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fdef57265500c1ab2f82470de61a21d1d604d4cdbc198f2acbcafdab9cb37548
+  data.tar.gz: f7a25a0c65239ccaa49331a0e94d14494b92a44927df112c2258d6b42ef51420
+SHA512:
+  metadata.gz: e2875bcf474cbed4017f6fb5e7188745b04357e0181a9ab1d8641d041d880e3152624e21f4fed4317a9c4a24c1c1e3d00c552f4fcaf558324a78d74d08de8930
+  data.tar.gz: f6ae3c0c3a82ca453a886a8d1bfc6ea2170a967f42094a482d769cbb40f60706416f2592465202afc2e04f7bd957068730d8da1420b14b6c13c331864770e1ca

data/.dockerignore

@@ -0,0 +1,12 @@
+tmp/*
+log/*
+deploy/*
+.codeqa/*
+.dockerignore
+.git/*
+.gitignore
+.idea/*
+.rubocop.yml
+public/javascripts/*
+*~
+vendor

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/examples.txt
+/spec/reports/
+/tmp/
+vendor
+
+*~
+.byebug_history
+spec/docker-compose.run.yml
+
+minfra-cli-*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--format progress
+--color

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+# 0.1.0 Initial
+ * opensourcing a base state, still WIP!

data/Dockerfile

@@ -0,0 +1,12 @@
+FROM ruby:2.7.1
+
+ENV APP_DIR /code
+WORKDIR $APP_DIR
+
+ADD Gemfile $APP_DIR
+#ADD Gemfile.lock $APP_DIR
+RUN bundle install --jobs 4 --retry 3
+ADD . $APP_DIR
+
+CMD /bin/bash
+

data/bin/build

@@ -0,0 +1,20 @@
+#!/bin/bash
+set -e
+
+app_dir=`pwd`
+prj_file="$app_dir/project.json"
+
+repo=`jq -r ".docker.repo" "$prj_file"`
+project=`jq -r ".docker.name" "$prj_file"`
+path=`jq -r ".path" "$prj_file"`
+
+ACTION=${1:-local}
+
+case "$ACTION" in
+  "local" )
+    docker build -t $repo/$project:latest $app_dir
+    ;;
+  * )
+    echo "unknown action: '$ACTION'"
+  ;;
+esac

data/bin/console

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.expand_path('../lib', __dir__)
+
+require "bundler/setup"
+require "minfra/cli"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/container_exec

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+app_dir=`pwd`
+prj_file="$app_dir/project.json"
+
+repo=`jq -r ".docker.repo" "$prj_file"`
+project=`jq -r ".docker.name" "$prj_file"`
+
+docker run -ti --rm  -v `pwd`:/code $repo/$project:latest /bin/bash

data/bin/run_tests

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+require 'erb'
+require 'json'
+require 'pathname'
+
+root=Pathname.new(File.expand_path('..', __dir__))
+project_info=JSON.parse(File.read(root.join('project.json')))
+
+def pull_base_image
+  dockerfile = File.read(File.expand_path('../Dockerfile', __dir__))
+  base_image = dockerfile.match(/^FROM .+$/).to_s.gsub(/^FROM /, '')
+  run("docker pull #{base_image}")
+end
+
+def run(command, exit_on_error=true)
+  puts "running: #{command}"
+  system(command, out: $stdout, err: :out)
+  exit_status=$?.exitstatus
+  if exit_status.nonzero? && exit_on_error
+    exit(exit_status)
+  end
+  exit_status
+end
+
+if ENV["INSIDE_CONTAINER"] == "true" then
+  puts 'setting up test and running rspec'
+  run("bundle exec rspec --colour --tty #{ARGV.join(' ')}")
+  exit(0)
+end
+
+def pull_base_image
+  dockerfile = File.read(File.expand_path('../Dockerfile', __dir__))
+  base_image = dockerfile.match(/^FROM .+$/).to_s.gsub(/^FROM /, '')
+  run("docker pull #{base_image}")
+end
+
+# We always pull the latest base image, to ensure that we don't build with
+# an old base image that is already present on the Jenkins worker.
+pull_base_image
+
+@project_name  = project_info["docker"]["name"] # used in docker-compose.yml
+
+build_tag= ENV["BUILD_NUMBER"] || Time.now.strftime("%Y%m%d%H%M")
+
+cache_tag_code = "git describe --abbrev=0 --tags `git rev-list HEAD --skip=1 --max-count=1 2>/dev/null` 2>/dev/null"
+cache_tag = `#{cache_tag_code}`
+
+unless $?.exitstatus == 0
+  puts ("getting cache tag failed, fallback to 'latest'")
+  cache_tag = "latest"
+end
+cache_tag = false unless ENV["BUILD_ID"]
+
+volumes = []
+
+volumes << "..:/code" unless ENV["BUILD_ID"]
+
+@tag = build_tag
+@cache_tag = nil #cache_tag
+@volumes = volumes
+
+# Run docker pull on cache
+if @cache_tag
+  run("docker pull 858049876441.dkr.ecr.eu-west-1.amazonaws.com/#{@project_name}:#{@cache_tag}")
+end
+
+erb = ERB.new(File.open("#{__dir__}/../spec/docker-compose.yml").read, 0, '>')
+File.write("#{__dir__}/../spec/docker-compose.run.yml", erb.result)
+
+run("sudo docker-compose -f #{__dir__}/../spec/docker-compose.run.yml build")
+envs=["-e 'INSIDE_CONTAINER=true'"]
+exit_status=run("sudo docker-compose -f #{__dir__}/../spec/docker-compose.run.yml run --rm #{envs.join(' ')} tester bin/run_tests #{ARGV.join(' ')}", false)
+run("sudo docker-compose -f #{__dir__}/../spec/docker-compose.run.yml down --remove-orphans") unless ENV["KEEP_SPEC_CONTAINERS"]
+exit(exit_status)

data/bin/setup.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+PROJ_NAME=$1
+PROJ_PATH=`pwd`/$PROJ_NAME
+
+echo "Setting up your project $PROJ_NAME"
+
+mkdir $PROJ_NAME
+
+mkdir $PROJ_NAME/stacks
+mkdir $PROJ_NAME/me
+mkdir $PROJ_NAME/apps
+mkdir $PROJ_NAME/infra
+mkdir $PROJ_NAME/host
+mkdir $PROJ_NAME/secrets
+mkdir $PROJ_NAME/bin
+
+cd $PROJ_NAME
+
+echo "KUBECONFIG=$PROJ_NAME/me/kube/config" > me/dev.env
+echo "HELM_HOME=$PROJ_NAME/me/helm" >> me/dev.env
+echo "MINFRA_HOST_PATH=$PROJ_PATH" >> me/dev.env

data/exe/minfra

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.expand_path('../lib', __dir__)
+require 'minfra/cli'
+Minfra::Cli::Main.start(ARGV)
+

data/lib/deep_merge.rb

@@ -0,0 +1,149 @@
+module Hashie
+  module Extensions
+    module DeepMergeConcat
+
+      def transform_values
+        result = self.class.new
+        each do |key, value|
+          result[key] = yield(value)
+        end
+        result
+      end
+
+      def transform_values!
+        each do |key, value|
+          self[key] = yield(value)
+        end
+      end
+
+      def transform_keys
+        result = self.class.new
+        each_key do |key|
+          result[yield(key)] = self[key]
+        end
+        result
+      end
+
+      def transform_keys!
+        keys.each do |key|
+          self[yield(key)] = delete(key)
+        end
+        self
+      end
+
+      def deep_sort_by_key_and_sort_array(exclusions = [], &block)
+        self.keys.sort(&block).reduce({}) do |seed, key|
+          seed[key] = self[key]
+          unless exclusions.include?(key.to_s)
+            if seed[key].is_a?(Hash)
+              seed[key] = seed[key].deep_sort_by_key_and_sort_array(exclusions, &block)
+            elsif seed[key].is_a?(Hashie::Array)
+              seed[key] = seed[key].sort(&block)
+            end
+          end
+          seed
+        end
+      end
+
+      # Returns a new hash with +self+ and +other_hash+ merged recursively.
+      def deep_sort(&block)
+        copy = dup
+        copy.extend(Hashie::Extensions::DeepMergeConcat) unless copy.respond_to?(:deep_sort!)
+        copy.deep_sort!(&block)
+      end
+
+      # Returns a new hash with +self+ and +other_hash+ merged recursively.
+      # Modifies the receiver in place.
+      def deep_sort!(&block)
+        _recursive_sort(self, &block)
+        self
+      end
+
+      # Returns a new hash with +self+ and +other_hash+ merged recursively.
+      def deep_merge_concat(other_hash, &block)
+        copy = dup
+        copy.extend(Hashie::Extensions::DeepMergeConcat) unless copy.respond_to?(:deep_merge_concat!)
+        copy.deep_merge_concat!(other_hash, &block)
+      end
+
+      # Returns a new hash with +self+ and +other_hash+ merged recursively.
+      # Modifies the receiver in place.
+      def deep_merge_concat!(other_hash, &block)
+        return self unless other_hash.is_a?(::Hash)
+        _recursive_merge_concat(self, other_hash, &block)
+        self
+      end
+
+      def deep_transform_values(&block)
+        _deep_transform_values_in_object(self, &block)
+      end
+
+      def deep_transform_values!(&block)
+        _deep_transform_values_in_object!(self, &block)
+      end
+
+      private
+
+      def _deep_transform_values_in_object(object, &block)
+        case object
+        when Hash
+          object.each_with_object({}) do |arg, result|
+            key = arg.first
+            value = arg.last
+            result[key] = _deep_transform_values_in_object(value, &block)
+          end
+        when Array
+          object.map {|e| _deep_transform_values_in_object(e, &block) }
+        else
+          yield(object)
+        end
+      end
+
+      def _deep_transform_values_in_object!(object, &block)
+        case object
+        when Hash
+          object.each do |key, value|
+            object[key] = _deep_transform_values_in_object!(value, &block)
+          end
+        when Array
+          object.map! {|e| _deep_transform_values_in_object!(e, &block) }
+        else
+          yield(object)
+        end
+      end
+
+      def _recursive_sort(object, &block)
+        case object
+        when Hash
+          object = Orchparty::AST::Node.new(object.sort {|a, b| block.call(a[0], b[0]) }.to_h)
+          object.each do |key, value|
+            object[key] = _recursive_sort(value, &block)
+          end
+          object
+        when Array
+          object.map! {|e| _recursive_sort(e, &block) }.sort(&block)
+        else
+          yield(object)
+        end
+      end
+
+
+      def _recursive_merge_concat(hash, other_hash, &block)
+        other_hash.each do |k, v|
+          hash[k] = if hash.key?(k) && hash[k].is_a?(::Hash) && v.is_a?(::Hash)
+                      _recursive_merge(hash[k], v, &block)
+                    elsif hash.key?(k) && hash[k].is_a?(::Array) && v.is_a?(::Array)
+                      hash[k].concat(v).uniq
+                    else
+                      if hash.key?(k) && block_given?
+                        block.call(k, hash[k], v)
+                      else
+                        v.respond_to?(:deep_dup) ? v.deep_dup : v
+                      end
+                    end
+        end
+        hash
+      end
+    end
+  end
+end

data/lib/hash.rb

@@ -0,0 +1,28 @@
+class HashUtils
+  def self.transform_hash(original, options={}, &block)
+    original.inject({}){|result, (key,value)|
+      value = if (options[:deep] && Hash === value)
+                transform_hash(value, options, &block)
+              else
+                if Array === value
+                  value.map{|v|
+                    if Hash === v
+                      transform_hash(v, options, &block)
+                    else
+                      v
+                    end}
+                else
+                  value
+                end
+              end
+      block.call(result,key,value)
+      result
+    }
+  end
+  # Convert keys to strings, recursively
+  def self.deep_stringify_keys(hash)
+    transform_hash(hash, :deep => true) {|hash, key, value|
+      hash[key.to_s] = value
+    }
+  end
+end

data/lib/minfra/cli/ask.rb

@@ -0,0 +1,43 @@
+module Minfra
+  module Cli
+    module Ask
+      def self.boolean(question)
+        answered = false
+        until answered
+          STDOUT.write "#{question} (y/n)"
+          answer = STDIN.gets.chomp
+          if ['y', 'n'].include?(answer)
+            answered = true
+          else
+            STDOUT.write("I just understand 'y' and 'n', again: ")
+          end
+        end
+        answer == 'y'
+      end
+
+      def self.text(question, default=nil)
+        begin
+          message = format('%s%s: ', question, default && " (#{default})")
+          STDOUT.write message
+          answer = STDIN.gets.chomp
+          answer = default if answer == ''
+        end while answer.nil?
+        answer
+      end
+
+      def self.placeholders(templater,placeholders={})
+        templater.check_missing do |name|
+          placeholders[name]=self.text("I need a value for: #{name}") unless placeholders[name]
+        end
+        placeholders
+      end
+
+      def self.interactive_template(template_file, out_file, placeholders={})
+        templater=Templater.new(File.read(template_file))
+        params=self.placeholders(templater,placeholders)
+        File.write(out_file,templater.render(params))
+
+      end
+    end
+  end
+end

data/lib/minfra/cli/command.rb

@@ -0,0 +1,35 @@
+module Minfra
+  module Cli
+    class Command < Thor
+      include Common
+      include Logging
+      include Hook
+
+      attr_reader :minfra_config
+      no_commands do
+        def invoke_command(*args)
+            begin
+              subcommand_name = args.first.name.to_sym
+              with_hook(subcommand_name) do
+                @minfra_config = Minfra::Cli.config
+                @minfra_config.load(options['environment']) if options['environment']
+                @cli_args = args[1]
+               super(*args)
+              end
+            rescue Minfra::Cli::Config::ConfigNotFoundError => err
+              STDERR.puts(err.message)
+              STDERR.puts "please run 'minfra setup dev'"
+              exit 1
+            rescue Minfra::Cli::Config::EnvironmentNotFoundError => err
+              STDERR.puts(err.message)
+              exit 1
+            end
+        end
+        def cli_args
+          @args
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'fileutils'
+module Minfra
+  module Cli
+    class Dev < Command
+
+      desc "describe", "get some info about your config (if it's setup)"
+      option :environment, required: false, aliases: ['-e']
+      def describe
+        pp @minfra_config.describe(options[:environment])
+      end
+
+      desc "create", "create your development cluster"
+      def create
+        kube.create
+      end
+
+      desc "upgrade", "upgrade kind (moves previous configs and recreates the cluster; use it if you made changes to config/kind.yaml.erb)"
+      def upgrade
+        info "Destroying existing dev cluster.."
+        destroy
+        Runner.run("mv #{@minfra_config.base_path.join('me','kind.yaml.erb')} #{@minfra_config.base_path.join('me','kind_old_' + Time.now.strftime("%Y_%m_%dT%H_%M_%SZ") + '.yaml.erb')}", print_stdout: true)
+        Runner.run("mv #{@minfra_config.base_path.join('me', 'kube', 'config')} #{@minfra_config.base_path.join('me', 'kube', 'config_old_' + Time.now.strftime("%Y_%m_%dT%H_%M_%SZ"))}", print_stdout: true)
+        Runner.run('yes | minfra setup dev', print_stdout: true) # On an existing cluster this should only ask for recreating the files that we moved previously
+        info "Creating a new dev cluster.."
+        create
+        info "I am done upgrading the dev cluster! 🎉"
+      end
+
+      desc "restart", "restart your development cluster"
+      def restart
+        kube.restart
+      end
+
+      desc "start", "start your development cluster"
+      def start
+        restart
+      end
+
+      desc "destroy", "tear down your development cluster"
+      def destroy
+        kube.destroy_dev_cluster
+      end
+
+      private
+
+      def kube
+        @kube ||= Kube.new(options,minfra_config)
+      end
+
+    end
+  end
+end
+
+Minfra::Cli.register("dev", "Manage your dev cluster.", Minfra::Cli::Dev)