kaiser 0.0.0 → 0.6.4

data/lib/kaiser/cmds/db_reset_hard.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Kaiser
+  module Cmds
+    class DbResetHard < Cli
+      def usage
+        <<~EOS
+          Shuts down the database docker container, deletes the docker volume on which the db was stored, deletes the default database image stored at \`~/.kaiser/<ENV_NAME>/<current_github_branch_name>/default.tar.bz\`, rebuilds the docker volume and the default database image from scratch and then brings the container up again.
+
+          USAGE: kaiser db_reset_hard
+        EOS
+      end
+
+      def execute(_opts)
+        ensure_setup
+        FileUtils.rm db_image_path('default') if File.exist?(db_image_path('default'))
+        setup_db
+      end
+    end
+  end
+end

data/lib/kaiser/cmds/db_save.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Kaiser
+  module Cmds
+    class DbSave < Cli
+      def usage
+        <<~EOS
+          Shuts down the database docker container, backs up the database and brings the container back up.
+
+          The database will be saved as a tarball to \`~/.kaiser/<ENV_NAME>/<current_github_branch_name>/<DB_BACKUP_FILENAME>.tar.bz\`
+
+          Alternatively you can also save it to your current directory.
+
+          USAGE: kaiser db_save DB_BACKUP_FILENAME
+                 kaiser db_save ./my_database.tar.bz
+        EOS
+      end
+
+      def execute(_opts)
+        ensure_setup
+        name = ARGV.shift || 'default'
+        save_db(name)
+      end
+    end
+  end
+end

data/lib/kaiser/cmds/deinit.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Kaiser
+  module Cmds
+    class Deinit < Cli
+      def usage
+        <<~EOS
+          Removes the Kaiser environment from \`~/.kaiser/.config.yml\`. This however does not delete the \`~/.kaiser/databases/<ENV_NAME>\` directory.
+
+          USAGE: kaiser init ENV_NAME
+        EOS
+      end
+
+      def execute(_opts)
+        down
+        Config.config[:envs].delete(envname)
+        Config.config[:envnames].delete(Config.work_dir)
+        save_config
+      end
+    end
+  end
+end

data/lib/kaiser/cmds/down.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Kaiser
+  module Cmds
+    class Down < Cli
+      def usage
+        <<~EOS
+          Shuts down and *deletes* the containers that were started using \`kaiser up\`.
+
+          USAGE: kaiser down
+        EOS
+      end
+
+      def execute(_opts)
+        stop_db
+        stop_app
+        delete_db_volume
+      end
+    end
+  end
+end

data/lib/kaiser/cmds/init.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Kaiser
+  module Cmds
+    class Init < Cli
+      # TODO: Add explanation for the Already initialized error.
+      def usage
+        <<~EOS
+          Initializes a Kaiser environment and assigns ports for it in \`~/.kaiser/.config.yml\`. When running \`kaiser up\` later the directory \`~/.kaiser/databases/<ENV_NAME>\`  will get created.
+
+          USAGE: kaiser init ENV_NAME
+        EOS
+      end
+
+      def execute(_opts)
+        return Optimist.die "Already initialized as #{envname}" if envname
+
+        name = ARGV.shift
+        return Optimist.die 'Needs environment name' if name.nil?
+
+        init_config_for_env(name)
+        save_config
+      end
+
+      def init_config_for_env(name)
+        Config.config[:envnames][Config.work_dir] = name
+        Config.config[:envs][name] = {
+          app_port: (largest_port + 1).to_s,
+          db_port: (largest_port + 2).to_s
+        }
+        Config.config[:largest_port] = Config.config[:largest_port] + 2
+      end
+
+      def largest_port
+        Config.config[:largest_port]
+      end
+    end
+  end
+end

data/lib/kaiser/cmds/login.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Kaiser
+  module Cmds
+    class Login < Cli
+      def usage
+        <<~EOS
+          Executes a command on the application docker container. By executing the command \`sh\` you can get a login shell.
+
+          USAGE: kaiser login COMMAND
+        EOS
+      end
+
+      def execute(_opts)
+        ensure_setup
+        cmd = (ARGV || []).join(' ')
+        exec "docker exec -ti #{app_container_name} #{cmd}"
+      end
+    end
+  end
+end

data/lib/kaiser/cmds/logs.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kaiser
+  module Cmds
+    class Logs < Cli
+      def usage
+        <<~EOS
+          Continuously monitors the application container's logs.
+
+          USAGE: kaiser logs
+        EOS
+      end
+
+      def execute(_opts)
+        exec "docker logs -f #{app_container_name}"
+      end
+    end
+  end
+end

data/lib/kaiser/cmds/root.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Kaiser
+  module Cmds
+    class Root < Cli
+      def usage
+        <<~USAGE
+          Executes a command on the application docker container as a root user.
+
+          USAGE: kaiser root COMMAND
+        USAGE
+      end
+
+      def execute(_opts)
+        ensure_setup
+        cmd = (ARGV || []).join(' ')
+        exec "docker exec -ti --user root #{app_container_name} #{cmd}"
+      end
+    end
+  end
+end

data/lib/kaiser/cmds/set.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Kaiser
+  module Cmds
+    class Set < Cli
+      def usage
+        <<~EOS
+          This command lets you set up special variables that configure kaiser's behavior for you.
+
+          Available subcommands:
+
+          http-suffix - Sets the domain suffix for the reverse proxy to use (defaults to lvh.me)
+          cert-url    - Sets up a URL from which HTTPS certificates can be downloaded.
+          cert-folder - Sets up a folder from which HTTPS certificates can be copied.
+          help-https  - Shows the HTTPS notes.
+
+          USAGE: kaiser set cert-url
+                 kaiser set cert-folder
+                 kaiser set http-suffix
+                 kaiser set help-https
+        EOS
+      end
+
+      def execute(_opts)
+        cmd = ARGV.shift
+
+        case cmd
+        when 'cert-url'
+          Config.config[:cert_source] = {
+            url: ARGV.shift
+          }
+        when 'cert-folder'
+          Config.config[:cert_source] = {
+            folder: ARGV.shift
+          }
+        when 'http-suffix'
+          Config.config[:http_suffix] = ARGV.shift
+        when 'help-https'
+          puts <<~SET_HELP
+            Notes on HTTPS:
+
+            You need to set suffix and either cert-url or cert-folder to enable HTTPS.
+
+            cert-url and cert-folder are mutually exclusive. If you set one of them the other will be erased.
+
+            The cert-url and cert-folder must satisfy the following requirements to work:
+
+            The strings must be the root of certificates named after the suffix. For example,
+
+              if cert-url is https://mydomain.com/certs and your suffix is local.mydomain.com, the following
+              url need to be the certificate files:
+
+              https://mydomain.com/certs/local.mydomain.com.chain.pem
+              https://mydomain.com/certs/local.mydomain.com.crt
+              https://mydomain.com/certs/local.mydomain.com.key
+
+            Another example:
+
+              If you use suffix of localme.com and cert-folder is /home/me/https, The following files need to exist:
+
+              /home/me/https/localme.com.chain.pem
+              /home/me/https/localme.com.crt
+              /home/me/https/localme.com.key
+          SET_HELP
+        else
+          Optimist.die "Unknown subcommand: '#{cmd}'"
+        end
+
+        save_config
+      end
+    end
+  end
+end

data/lib/kaiser/cmds/show.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Kaiser
+  module Cmds
+    class Show < Cli
+      def usage
+        <<~EOS
+          Subcommand that shows information about the environment such as the TCP ports or the certificate used for HTTPS.
+
+          USAGE: kaiser show ports
+                 kaiser show cert-source
+                 kaiser show http-suffix
+        EOS
+      end
+
+      def execute(_opts)
+        ensure_setup
+        cmd = ARGV.shift
+        valid_cmds = 'ports cert-source http-suffix'
+        return Optimist.die "Available things to show: #{valid_cmds}" unless cmd
+
+        case cmd
+        when 'ports'
+          Config.info_out.puts "app: #{app_port}"
+          Config.info_out.puts "db: #{db_port}"
+        when 'cert-source'
+          unless Config.config[:cert_source]
+            Optimist.die 'No certificate source set.
+              see kaiser set help'
+          end
+
+          source = Config.config[:cert_source][:url] || Config.config[:cert_source][:folder]
+          Config.info_out.puts source
+        when 'http-suffix'
+          Config.info_out.puts http_suffix
+        end
+      end
+    end
+  end
+end

data/lib/kaiser/cmds/shutdown.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Kaiser
+  module Cmds
+    class Shutdown < Cli
+      def usage
+        # TODO: Explain a bit more about what these containers do and what shutting
+        #      them down really means for an end user.
+        <<~EOS
+          Shuts down all the containers used internally by Kaiser.
+
+          USAGE: kaiser shutdown
+        EOS
+      end
+
+      def execute(_opts)
+        Config.config[:shared_names].each do |_, container_name|
+          killrm container_name
+        end
+
+        CommandRunner.run Config.out, "docker network rm #{Config.config[:networkname]}"
+        CommandRunner.run Config.out, "docker volume rm #{Config.config[:shared_names][:certs]}"
+      end
+    end
+  end
+end

data/lib/kaiser/cmds/up.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Kaiser
+  module Cmds
+    class Up < Cli
+      option :attach,
+             "Bind mount the current source code directory in the app container (as the \`kaiser attach\` command would)", short: '-a'
+
+      def usage
+        <<~EOS
+          Boots up the application in docker as defined in the \`Kaiserfile\` in its source code. Usually this will create two docker containers \`<ENV_NAME>-db\` and \`<ENV_NAME>-app\` running your database and application respectively.
+
+          A backup of the default database is created and saved to \`~/.kaiser/<ENV_NAME>/<current_github_branch_name>/default.tar.bz\`. This can be restored at any time using the \`db_reset\` command.
+
+          USAGE: kaiser up
+        EOS
+      end
+
+      def execute(opts)
+        ensure_setup
+        setup_app
+        setup_db
+
+        if opts[:attach]
+          attach_app
+        else
+          start_app
+        end
+      end
+
+      def setup_app
+        Config.info_out.puts 'Setting up application'
+        File.write(tmp_dockerfile_name, docker_file_contents)
+        build_args = docker_build_args.map { |k, v| "--build-arg #{k}=#{v}" }
+        CommandRunner.run! Config.out, "docker build
+          -t kaiser:#{envname}-#{current_branch}
+          -f #{tmp_dockerfile_name} #{Config.work_dir}
+          #{build_args.join(' ')}"
+        FileUtils.rm(tmp_dockerfile_name)
+      end
+    end
+  end
+end

data/lib/kaiser/command_runner.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'English'
+
+# This is the command runner
+module Kaiser
+  # Make running easy
+  class CommandRunner
+    def self.run(out, cmd, &block)
+      out.puts "> #{cmd}"
+      CommandRunner.new(out, cmd).run_command(&block)
+    end
+
+    def self.run!(out, cmd, &block)
+      status = run(out, cmd, &block)
+      raise Kaiser::CmdError.new(cmd, status) if status.to_s != '0'
+    end
+
+    def initialize(out, cmd)
+      @out = out
+      @cmd = cmd.tr "\n", ' '
+    end
+
+    def print_and_return_status(status = 0)
+      @out.puts "$? = #{status}"
+      @out.flush
+      status
+    end
+
+    def print_lines(lines)
+      lines.each do |line|
+        @out.print line
+        @out.flush
+        yield line.chomp if block_given?
+      end
+    rescue Errno::EIO
+      # Happens when `lines` stream is closed
+    end
+
+    def run_command(&block)
+      PTY.spawn("#{@cmd} 2>&1") do |stdout, _stdin, pid|
+        print_lines(stdout, &block)
+        Process.wait(pid)
+      end
+      print_and_return_status $CHILD_STATUS.exitstatus
+    rescue PTY::ChildExited => e
+      print_and_return_status(e.status)
+    end
+  end
+end

data/lib/kaiser/config.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Kaiser
+  class Config
+    class << self
+      attr_accessor :out,
+                    :info_out
+
+      attr_reader :work_dir,
+                  :config_dir,
+                  :config_file,
+                  :kaiserfile,
+                  :config
+
+      def load(work_dir)
+        @work_dir = work_dir
+        @config_dir = "#{ENV['HOME']}/.kaiser"
+
+        migrate_dotted_config_files
+
+        FileUtils.mkdir_p @config_dir
+        @config_file = "#{@config_dir}/config.yml"
+        @kaiserfile = Kaiserfile.new("#{@work_dir}/Kaiserfile")
+
+        @config = {
+          envnames: {},
+          envs: {},
+          networkname: 'kaiser_net',
+          shared_names: {
+            redis: 'kaiser-redis',
+            nginx: 'kaiser-nginx',
+            chrome: 'kaiser-chrome',
+            dns: 'kaiser-dns',
+            certs: 'kaiser-certs'
+          },
+          largest_port: 9000,
+          always_verbose: false
+        }
+
+        load_config
+
+        alt_kaiserfile = "#{ENV['HOME']}/kaiserfiles/Kaiserfile.#{@config[:envnames][work_dir]}"
+        @kaiserfile = Kaiserfile.new(alt_kaiserfile) if File.exist?(alt_kaiserfile)
+
+        @config
+      end
+
+      def always_verbose?
+        @config[:always_verbose]
+      end
+
+      # Up until version 0.5.1, kaiser used dotfiles for all of it configuration.
+      # It makes sense of hide the configuration directory itself but hiding the files
+      # inside of it just causes confusion.
+      #
+      # Kaiser 0.5.2 started using non-dotted files instead. This method renames the old
+      # files in case you have just upgraded from an older version.
+      def migrate_dotted_config_files
+        return unless File.exist?("#{@config_dir}/.config.yml")
+
+        Dir["#{@config_dir}/**/.*"].each do |x|
+          dest = x.sub(%r{/\.([a-z.]+)$}, '/\1')
+          FileUtils.mv x, dest
+        end
+      end
+
+      def load_config
+        loaded = YAML.load_file(@config_file) if File.exist?(@config_file)
+
+        config_shared_names = @config[:shared_names] if @config
+        loaded_shared_names = loaded[:shared_names] if loaded
+
+        @config = {
+          **(@config || {}),
+          **(loaded || {}),
+          shared_names: { **(config_shared_names || {}), **(loaded_shared_names || {}) }
+        }
+      end
+    end
+  end
+end

data/lib/kaiser/databases/mysql.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Kaiser
+  module Databases
+    class Mysql
+      def initialize(options)
+        @options = options
+      end
+
+      def options_hash
+        testpass = @options[:root_password] || 'testpassword'
+        parameters = @options[:parameters] || ''
+        port = @options[:port] || 3306
+
+        {
+          port: port,
+          data_dir: '/var/lib/mysql',
+          params: "-e MYSQL_ROOT_PASSWORD=#{testpass}",
+          commands: parameters,
+          waitscript_params: "
+            -e MYSQL_ADDR=<%= db_container_name %>
+            -e MYSQL_PORT=#{port}
+            -e MYSQL_ROOT_PASSWORD=#{testpass}",
+          waitscript: <<~SCRIPT
+            #!/bin/bash
+
+            echo "Waiting for mysql to start."
+            until mysql -h"$MYSQL_ADDR" -P"$MYSQL_PORT" -uroot -p"$MYSQL_ROOT_PASSWORD" -e "SELECT 1"
+            do
+              printf "."
+              sleep 1
+            done
+
+            echo -e "\nmysql started."
+          SCRIPT
+        }
+      end
+
+      def image_name
+        version = @options[:version] || '5.6'
+        "mysql:#{version}"
+      end
+    end
+  end
+end

data/lib/kaiser/databases/postgres.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Kaiser
+  module Databases
+    class Postgres
+      def initialize(options)
+        @options = options
+      end
+
+      def options_hash
+        testpass = @options[:root_password] || 'testpassword'
+        parameters = @options[:parameters] || ''
+        port = @options[:port] || 3306
+        platform = @options[:platform] || 'linux/amd64'
+
+        {
+          port: port,
+          data_dir: '/var/lib/postgresql/data',
+          params: "-e POSTGRES_PASSWORD=#{testpass}",
+          commands: parameters,
+          platform: platform,
+          waitscript_params: "
+            -e PG_HOST=<%= db_container_name %>
+            -e PG_USER=postgres
+            -e PGPASSWORD=#{testpass}
+            -e PG_DATABASE=postgres",
+          waitscript: <<~SCRIPT
+            #!/bin/sh
+
+            RETRIES=5
+
+            until psql -h $PG_HOST -U $PG_USER -d $PG_DATABASE -c "select 1" > /dev/null 2>&1 || [ $RETRIES -eq 0 ]; do
+             echo "Waiting for postgres server, $((RETRIES--)) remaining attempts..."
+             sleep 1
+            done
+          SCRIPT
+        }
+      end
+
+      def image_name
+        version = @options[:version] || 'alpine'
+        "postgres:#{version}"
+      end
+    end
+  end
+end

data/lib/kaiser/docker_control.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Kaiser
+  # Docker control
+  class DockerControl
+    def initialize
+      @docker
+    end
+  end
+end

data/lib/kaiser/dotter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Kaiser
+  # Prints dots for every line printed
+  class Dotter
+    attr_accessor :dotted
+
+    def method_missing(name, *value)
+      $stderr.print '.'
+      @dotted = true
+      super unless @dotted
+    end
+
+    # rubocop:disable Lint/UselessMethodDefinition
+    # If we remove this method rubocop complains about it not existing instead.
+    def respond_to_missing?(name)
+      super
+    end
+    # rubocop:enable Lint/UselessMethodDefinition
+  end
+end

data/lib/kaiser/error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Kaiser
+  # Base class for Kaiser-related errors.
+  class Error < StandardError
+  end
+
+  # Raised when a command exits with non-zero exit status.
+  class CmdError < Error
+    def initialize(cmd, status)
+      super "ERROR\n#{cmd}\n- exited with code #{status}"
+    end
+  end
+end