heighliner 0.9.0

data/lib/heighliner/cli_options.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Heighliner
+  module CliOptions
+    def option(*option)
+      @options ||= []
+      @options << option
+    end
+
+    def options
+      @options || []
+    end
+  end
+end

data/lib/heighliner/cmds/attach.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Heighliner
+  module Cmds
+    class Attach < Cli
+      def usage
+        <<~EOS
+          Shuts down the application container and starts it up again with the current directory bind mounted inside. This way the application will run from the source code in the current directory and any edits you make will immediately show up inside the container. This is ideal for development.
+
+          Once the attached container exits (through the use of control+c for example) it will be replaced by a regular non-attached version of the app container.
+
+          USAGE: heighliner attach
+        EOS
+      end
+
+      def execute(_opts)
+        ensure_setup
+        attach_app
+        start_app
+      end
+    end
+  end
+end

data/lib/heighliner/cmds/db_load.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Heighliner
+  module Cmds
+    class DbLoad < Cli
+      def usage
+        <<~EOS
+          Shuts down the database docker container, *replaces* the database with the backup provided and brings the container up again.
+
+          The database will be restored from a tarball saved as \`~/.heighliner/<ENV_NAME>/<current_github_branch_name>/<DB_BACKUP_FILENAME>.tar.bz\`
+
+          Alternatively you can also load it from your current directory.
+
+          If no database name was provided, the default database stored at \`~/.heighliner/<ENV_NAME>/<current_github_branch_name>/default.tar.bz\` will be used.
+
+          USAGE: heighliner db_load
+                 heighliner db_load DB_BACKUP_FILENAME
+                 heighliner db_load ./my_database.tar.bz
+        EOS
+      end
+
+      def execute(_opts)
+        ensure_setup
+        name = ARGV.shift || 'default'
+        load_db(name)
+      end
+    end
+  end
+end

data/lib/heighliner/cmds/db_reset.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Heighliner
+  module Cmds
+    class DbReset < Cli
+      def usage
+        <<~EOS
+          Shuts down the database docker container, *replaces* the database with the default database image stored at \`~/.heighliner/<ENV_NAME>/<current_github_branch_name>/default.tar.bz\` and brings the container up again.
+
+          This is the same as running \`heighliner db_load\` with no arguments.
+
+          USAGE: heighliner db_reset
+        EOS
+      end
+
+      def execute(_opts)
+        ensure_setup
+        load_db('default')
+      end
+    end
+  end
+end

data/lib/heighliner/cmds/db_reset_hard.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Heighliner
+  module Cmds
+    class DbResetHard < Cli
+      def usage
+        <<~EOS
+          Shuts down the database docker container, deletes the default database image stored at \`~/.heighliner/<ENV_NAME>/<current_github_branch_name>/default.tar.bz\`, rebuilds the docker volume if needed and the default database image from scratch and then brings the container up again.
+
+          USAGE: heighliner 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/heighliner/cmds/db_save.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Heighliner
+  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 \`~/.heighliner/<ENV_NAME>/<current_github_branch_name>/<DB_BACKUP_FILENAME>.tar.bz\`
+
+          Alternatively you can also save it to your current directory.
+
+          USAGE: heighliner db_save DB_BACKUP_FILENAME
+                 heighliner 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/heighliner/cmds/deinit.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Heighliner
+  module Cmds
+    class Deinit < Cli
+      def usage
+        <<~EOS
+          Removes the Heighliner environment from \`~/.heighliner/config.yml\`. This also runs \`heighliner down\` to stop and delete your app containers and database volume. It does not delete the \`~/.heighliner/databases/<ENV_NAME>\` directory.
+
+          USAGE: heighliner deinit
+        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/heighliner/cmds/down.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Heighliner
+  module Cmds
+    class Down < Cli
+      def usage
+        <<~EOS
+          Stops and removes your app and database containers, and deletes the database volume. This does **not** affect the shared infrastructure (nginx, DNS, Chrome) — use \`heighliner shutdown\` for that.
+
+          USAGE: heighliner down
+        EOS
+      end
+
+      def execute(_opts)
+        stop_db
+        stop_app
+        delete_db_volume
+      end
+    end
+  end
+end

data/lib/heighliner/cmds/init.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Heighliner
+  module Cmds
+    class Init < Cli
+      def usage
+        <<~EOS
+          Initializes a Heighliner environment and assigns ports for it in \`~/.heighliner/config.yml\`. When running \`heighliner up\` later the directory \`~/.heighliner/databases/<ENV_NAME>\` will get created.
+
+          If the current directory is already initialized, you will get an error telling you the existing environment name.
+
+          USAGE: heighliner init ENV_NAME
+        EOS
+      end
+
+      def execute(_opts)
+        return Optimist.die "Already initialized as #{envname}. Use 'heighliner deinit' to remove this environment first." 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/heighliner/cmds/login.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Heighliner
+  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: heighliner 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/heighliner/cmds/logs.rb

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

data/lib/heighliner/cmds/root.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Heighliner
+  module Cmds
+    class Root < Cli
+      def usage
+        <<~USAGE
+          Executes a command on the application docker container as a root user.
+
+          USAGE: heighliner 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/heighliner/cmds/set.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Heighliner
+  module Cmds
+    class Set < Cli
+      def usage
+        <<~EOS
+          This command lets you set up special variables that configure heighliner'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.
+          cert-1password       - Sets up a 1Password item from which HTTPS certificates can be downloaded.
+          cert-1password-fields - Sets custom 1Password field names (JSON object)
+          help-https           - Shows the HTTPS notes.
+
+          USAGE: heighliner set cert-url
+                 heighliner set cert-folder
+                 heighliner set cert-1password
+                 heighliner set cert-1password-fields
+                 heighliner set http-suffix
+                 heighliner set help-https
+        EOS
+      end
+
+      def initialize
+        super
+        @use_steerfile = false
+      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 'cert-1password'
+          handle_cert_1password
+        when 'cert-1password-fields'
+          Config.config[:cert_source]['1password-fields'] = JSON.parse(ARGV.shift)
+        when 'http-suffix'
+          Config.config[:http_suffix] = ARGV.shift
+        when 'help-https'
+          puts help_https
+        else
+          Optimist.die "Unknown subcommand: '#{cmd}'"
+        end
+
+        save_config
+      end
+
+      private
+
+      def handle_cert_1password
+        if ARGV.empty?
+          puts help_1password
+        else
+          Config.config[:cert_source] = { '1password': ARGV.shift }
+        end
+      end
+
+      def help_https
+        <<~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
+      end
+
+      def help_1password
+        <<~SET_HELP
+          Notes on 1Password certificates:
+
+          You need to set suffix and cert-1password to enable HTTPS with 1Password.
+
+          The cert-1password value should be in the format 'Vault/Item'.
+
+          By default, the field names in the 1Password item should match the file extensions:
+            - key   → <suffix>.key
+            - crt   → <suffix>.crt
+            - chain → <suffix>.chain.pem
+
+          You can customize field names with:
+            heighliner set cert-1password-fields '{"key":"private-key","crt":"certificate","chain":"ca-bundle"}'
+
+          Example:
+            heighliner set cert-1password Vault/Dev-Certs
+            heighliner set http-suffix local.mydomain.com
+
+          This will read:
+            op read "op://Vault/Dev-Certs/key"   → local.mydomain.com.key
+            op read "op://Vault/Dev-Certs/crt"   → local.mydomain.com.crt
+            op read "op://Vault/Dev-Certs/chain" → local.mydomain.com.chain.pem
+
+          Make sure the `op` CLI is installed and authenticated on your machine.
+        SET_HELP
+      end
+    end
+  end
+end

data/lib/heighliner/cmds/show.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Heighliner
+  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: heighliner show ports
+                 heighliner show cert-source
+                 heighliner 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 heighliner 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/heighliner/cmds/shutdown.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Heighliner
+  module Cmds
+    class Shutdown < Cli
+      def usage
+        <<~EOS
+          Shuts down the shared infrastructure containers used by Heighliner (nginx reverse proxy, DNS resolver, and Selenium Chrome). This does **not** stop your app or database containers — use \`heighliner down\` for that.
+
+          NOTE: This command is destructive — it removes the shared Docker network and certs volume, which will affect all Heighliner environments on this machine.
+
+          USAGE: heighliner shutdown
+        EOS
+      end
+
+      def initialize
+        super
+        @use_steerfile = false
+      end
+
+      def execute(_opts)
+        Config.load(Dir.pwd, use_steerfile: false)
+
+        shared_names = Config.config[:shared_names] || {}
+        networkname = Config.config[:networkname] || 'heighliner_net'
+
+        shared_names.each_value do |container_name|
+          killrm container_name
+        end
+
+        CommandRunner.run Config.out, "docker network rm #{networkname}"
+        CommandRunner.run Config.out, "docker volume rm #{shared_names[:certs]}"
+      end
+    end
+  end
+end

data/lib/heighliner/cmds/up.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Heighliner
+  module Cmds
+    class Up < Cli
+      option :attach,
+             'Bind mount the current source code directory in the app container',
+             short: '-a'
+
+      def usage
+        <<~EOS
+          Boots up the application in docker as defined in the \`Steerfile\` 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 \`~/.heighliner/<ENV_NAME>/<current_github_branch_name>/default.tar.bz\`. This can be restored at any time using the \`db_reset\` command.
+
+          USAGE: heighliner up
+        EOS
+      end
+
+      def execute(opts)
+        ensure_setup
+        setup_app
+        setup_db
+
+        if opts[:attach]
+          attach_app
+        else
+          start_app
+        end
+      end
+
+      def build_cmd
+        platform_args = ''
+        platform_args = "--platform=#{force_platform}" unless force_platform.empty?
+        build_args = docker_build_args.map { |k, v| "--build-arg #{k}=#{v}" }
+        [
+          'docker build',
+          "-t heighliner:#{envname}-#{current_branch}",
+          "-f #{tmp_dockerfile_name} #{Config.work_dir}",
+          platform_args,
+          build_args.join(' ').to_s
+        ]
+      end
+
+      def setup_app
+        Config.info_out.puts 'Setting up application'
+        File.write(tmp_dockerfile_name, docker_file_contents)
+
+        CommandRunner.run! Config.out, build_cmd.join("\n\t"), env_vars: {
+          'DOCKER_BUILDKIT' => '1',
+          'BUILDKIT_PROGRESS' => 'plain'
+        }
+        FileUtils.rm(tmp_dockerfile_name)
+      end
+    end
+  end
+end

data/lib/heighliner/command_runner.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'pty'
+require 'English'
+
+module Heighliner
+  # This is the command runner
+  # it abstracts away the complicated syntax required to deal with
+  # PTY and to pass the lines programmatically to the host application
+  # as well as to capture the return code at the end.
+  class CommandRunner
+    def self.run(out, cmd, env_vars: {}, &block)
+      out.puts "> #{cmd}"
+      CommandRunner.new(out, cmd, env_vars).run_command(&block)
+    end
+
+    def self.run!(out, cmd, env_vars: {}, &block)
+      status = run(out, cmd, env_vars: env_vars, &block)
+      raise Heighliner::CmdError.new(cmd, status) if status.to_s != '0'
+    end
+
+    def initialize(out, cmd, env_vars)
+      @out = out
+      @cmd = cmd.tr "\n", ' '
+      @env_vars = env_vars
+    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(@env_vars, "#{@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