kaiser 0.0.0 → 0.4.5

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,19 @@
+# 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)
+        down
+      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,70 @@
+# 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
+        if cmd == 'cert-url'
+          Config.config[:cert_source] = {
+            url: ARGV.shift
+          }
+        elsif cmd == 'cert-folder'
+          Config.config[:cert_source] = {
+            folder: ARGV.shift
+          }
+        elsif cmd == 'http-suffix'
+          Config.config[:http_suffix] = ARGV.shift
+        elsif cmd == '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,39 @@
+# 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
+
+        if cmd == 'ports'
+          Config.info_out.puts "app: #{app_port}"
+          Config.info_out.puts "db: #{db_port}"
+        elsif cmd == '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
+        elsif cmd == '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,42 @@
+# 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,66 @@
+# frozen_string_literal: true
+
+module Kaiser
+  class Config
+    class << self
+      attr_reader :work_dir,
+                  :config_dir,
+                  :config_file,
+                  :kaiserfile,
+                  :config,
+                  :out,
+                  :info_out
+
+      attr_writer :out,
+                  :info_out
+
+      def load(work_dir)
+        @work_dir = work_dir
+        @config_dir = "#{ENV['HOME']}/.kaiser"
+
+        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
+
+      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/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,18 @@
+# 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
+
+    def respond_to_missing?(name)
+      super
+    end
+  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

data/lib/kaiser/kaiserfile.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Kaiser
+  # This class is responsible for parsing the Kaiserfile
+  class Kaiserfile
+    attr_accessor :docker_file_contents,
+                  :docker_build_args,
+                  :database,
+                  :port,
+                  :database_reset_command,
+                  :attach_mounts,
+                  :server_type
+
+    def initialize(filename)
+      Optimist.die 'No Kaiserfile in current directory' unless File.exist? filename
+
+      @databases = {}
+      @attach_mounts = []
+      @params_array = []
+      @server_type = :unknown
+
+      instance_eval File.read(filename), filename
+    end
+
+    def plugin(name)
+      raise "Plugin #{name} is not loaded." unless Plugin.loaded?(name)
+
+      Plugin.all_plugins[name].new(self).on_init
+    end
+
+    def dockerfile(name, options = {})
+      @docker_file_contents = File.read(name)
+      @docker_build_args = options[:args] || {}
+    end
+
+    def attach_mount(from, to)
+      attach_mounts << [from, to]
+    end
+
+    def db(image,
+           data_dir:,
+           port:,
+           params: '',
+           commands: '',
+           waitscript: nil,
+           waitscript_params: '')
+      @database = {
+        image: image,
+        port: port,
+        data_dir: data_dir,
+        params: params,
+        commands: commands,
+        waitscript: waitscript,
+        waitscript_params: waitscript_params
+      }
+    end
+
+    def expose(port)
+      @port = port
+    end
+
+    def app_params(value)
+      @params_array << value
+    end
+
+    def params
+      @params_array.join(' ')
+    end
+
+    def db_reset_command(value)
+      @database_reset_command = value
+    end
+
+    def type(value)
+      raise 'Valid server types are: [:http]' if value != :http
+
+      @server_type = value
+    end
+  end
+end

data/lib/kaiser/plugin.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Kaiser
+  # To implement a Kaiser plugin you must inherit from this class.
+  # For example,
+  #
+  #   class MyPlugin < Plugin
+  #     def on_init
+  #       puts 'My plugin is loaded!'
+  #     end
+  #   end
+  #
+  # Then in your Kasierfile
+  #
+  #   plugin :my_plugin
+  #
+  # Plugins has access the Kaiserfile DSL. For example,
+  #
+  #   class Ruby < Plugin
+  #     def on_init
+  #       attach_mount 'Gemfile', '/usr/app/Gemfile'
+  #       attach_mount 'Gemfile.lock', '/usr/app/Gemfile.lock'
+  #     end
+  #   end
+  #
+  class Plugin
+    def initialize(kaiserfile)
+      @kaiserfile = kaiserfile
+    end
+
+    def self.loaded?(name)
+      Plugin.all_plugins.key?(name)
+    end
+
+    def self.inherited(plugin)
+      # underscore class name
+      name = plugin.to_s.split('::').last
+                   .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                   .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                   .gsub(/([a-z])(\d)/, '\1_\2')
+                   .tr('-', '_').downcase
+
+      Plugin.all_plugins[name.to_sym] = plugin
+    end
+
+    def self.all_plugins
+      @all_plugins ||= {}
+    end
+
+    def on_init
+      raise 'Please implement #on_init'
+    end
+
+    def method_missing(method_sym, *arguments, &block) # rubocop:disable all
+      @kaiserfile.send(method_sym, *arguments, &block)
+    end
+  end
+end

data/lib/kaiser/plugins/git_submodule.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Kaiser
+  class GitSubmodule < Plugin
+    def on_init
+      `git submodule status`.lines.each do |line|
+        # The git-submodule man page says uninitialized submodules are prefixed with a -
+        # but I found this unreliable. While testing I pressed Control-C in the middle of
+        # the update command so some submodule would be initialized and others wouldn't.
+        # After that, the status command had removed the - for every submodule.
+        # Therefore we just check if there's files in the directory instead.
+        dir = line.strip.split(' ')[1]
+        if !Dir.exist?(dir) || Dir.empty?(dir) # rubocop:disable Style/Next
+          puts "Found uninitialized git submodule '#{dir}'"
+          system 'git submodule update --init --recursive'
+        end
+      end
+    end
+  end
+end

data/lib/kaiser/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Kaiser
+  VERSION = '0.4.5'
+end