tomo 0.1.0

data/lib/tomo/host.rb

@@ -0,0 +1,57 @@
+module Tomo
+  class Host
+    PATTERN = /^(?:(\S+)@)?(\S*?)$/.freeze
+    private_constant :PATTERN
+
+    attr_reader :address, :log_prefix, :user, :port, :roles, :as_privileged
+
+    def self.parse(host, **kwargs)
+      host = host.to_s.strip
+      user, address = host.match(PATTERN).captures
+      raise ArgumentError, "host cannot be blank" if address.empty?
+
+      new(**{ user: user, address: address }.merge(kwargs))
+    end
+
+    def initialize(address:, port: nil, log_prefix: nil, roles: nil,
+                   user: nil, privileged_user: "root")
+      @user = user.freeze
+      @port = (port || 22).to_i.freeze
+      @address = address.freeze
+      @log_prefix = log_prefix.freeze
+      @roles = Array(roles).map(&:freeze).freeze
+      @as_privileged = privileged_copy(privileged_user)
+      freeze
+    end
+
+    def with_log_prefix(prefix)
+      copy = dup
+      copy.instance_variable_set(:@log_prefix, prefix)
+      copy.freeze
+    end
+
+    def to_s
+      str = user ? "#{user}@#{address}" : address
+      str << ":#{port}" unless port == 22
+      str
+    end
+
+    def to_ssh_args
+      args = [user ? "#{user}@#{address}" : address]
+      args.push("-p", port.to_s) unless port == 22
+      args
+    end
+
+    private
+
+    def privileged_copy(priv_user)
+      return self if user == priv_user
+
+      new_prefix = Colors.red([log_prefix, priv_user].compact.join(":"))
+      copy = dup
+      copy.instance_variable_set(:@user, priv_user)
+      copy.instance_variable_set(:@log_prefix, new_prefix)
+      copy.freeze
+    end
+  end
+end

data/lib/tomo/logger/tagged_io.rb

@@ -0,0 +1,38 @@
+module Tomo
+  class Logger
+    class TaggedIO
+      include Colors
+
+      def initialize(io)
+        @io = io
+      end
+
+      def puts(str)
+        io.puts(str.to_s.gsub(/^/, prefix))
+      end
+
+      private
+
+      attr_reader :io
+
+      def prefix
+        host = Runtime::Current.host
+        return "" if host.nil?
+
+        tags = []
+        tags << red("*") if Tomo.dry_run?
+        tags << grayish("[#{host.log_prefix}]") unless host.log_prefix.nil?
+        return "" if tags.empty?
+
+        "#{tags.join(' ')} "
+      end
+
+      def grayish(str)
+        parts = str.split(/(\e.*?\e\[0m)/)
+        parts.map! do |part|
+          part.start_with?("\e") ? part : gray(part)
+        end.join
+      end
+    end
+  end
+end

data/lib/tomo/logger.rb

@@ -0,0 +1,70 @@
+require "forwardable"
+
+module Tomo
+  class Logger
+    autoload :TaggedIO, "tomo/logger/tagged_io"
+
+    extend Forwardable
+    include Tomo::Colors
+
+    def initialize(stdout: $stdout, stderr: $stderr)
+      @stdout = TaggedIO.new(stdout)
+      @stderr = TaggedIO.new(stderr)
+    end
+
+    def script_start(script)
+      return unless script.echo?
+
+      puts yellow(script.echo_string)
+    end
+
+    def script_output(script, output)
+      return if script.silent?
+
+      puts output
+    end
+
+    def script_end(script, result)
+      return unless result.failure?
+      return unless script.silent?
+      return unless script.raise_on_error?
+
+      puts result.output
+    end
+
+    def connect(host)
+      puts gray("→ Connecting to #{host}")
+    end
+
+    def task_start(task)
+      puts blue("• #{task}")
+    end
+
+    def info(message)
+      puts message
+    end
+
+    def error(message)
+      stderr.puts indent("\n" + red("ERROR: ") + message.strip + "\n\n")
+    end
+
+    def warn(message)
+      stderr.puts red("WARNING: ") + message
+    end
+
+    def debug(message)
+      return unless Tomo.debug?
+
+      stderr.puts gray("DEBUG: #{message}")
+    end
+
+    private
+
+    def_delegators :@stdout, :puts
+    attr_reader :stderr
+
+    def indent(message, prefix="  ")
+      message.gsub(/^/, prefix)
+    end
+  end
+end

data/lib/tomo/path.rb

@@ -0,0 +1,19 @@
+require "forwardable"
+require "pathname"
+
+module Tomo
+  class Path < SimpleDelegator
+    def initialize(path)
+      super(path.to_s)
+      freeze
+    end
+
+    def join(*other)
+      self.class.new(Pathname.new(self).join(*other))
+    end
+
+    def dirname
+      self.class.new(Pathname.new(self).dirname)
+    end
+  end
+end

data/lib/tomo/paths.rb

@@ -0,0 +1,36 @@
+module Tomo
+  class Paths
+    def initialize(settings)
+      @settings = settings
+      freeze
+    end
+
+    def deploy_to
+      path(:deploy_to)
+    end
+
+    private
+
+    attr_reader :settings
+
+    def method_missing(method, *args)
+      return super unless setting?(method)
+      raise ArgumentError, "#{method} takes no arguments" unless args.empty?
+
+      path(:"#{method}_path")
+    end
+
+    def respond_to_missing?(method, include_private=false)
+      setting?(method) || super
+    end
+
+    def setting?(name)
+      settings.key?(:"#{name}_path")
+    end
+
+    def path(setting)
+      path = settings.fetch(setting).to_s.gsub(%r{//+}, "/")
+      Path.new(path)
+    end
+  end
+end

data/lib/tomo/plugin/bundler/helpers.rb

@@ -0,0 +1,14 @@
+module Tomo::Plugin::Bundler
+  module Helpers
+    def bundle(*args, **opts)
+      prepend("bundle") do
+        run(*args, **opts.merge(default_chdir: paths.release))
+      end
+    end
+
+    def bundle?(*args, **opts)
+      result = bundle(*args, **opts.merge(raise_on_error: false))
+      result.success?
+    end
+  end
+end

data/lib/tomo/plugin/bundler/tasks.rb

@@ -0,0 +1,57 @@
+module Tomo::Plugin::Bundler
+  class Tasks < Tomo::TaskLibrary
+    def install
+      return if remote.bundle?("check", *check_options) && !dry_run?
+
+      remote.bundle("install", *install_options)
+    end
+
+    def clean
+      remote.bundle("clean")
+    end
+
+    def upgrade_bundler
+      needed_bundler_ver = extract_bundler_ver_from_lockfile
+      return if needed_bundler_ver.nil?
+
+      remote.run(
+        "gem", "install", "bundler",
+        "--conservative", "--no-document",
+        "-v", needed_bundler_ver
+      )
+    end
+
+    private
+
+    def check_options
+      gemfile = settings[:bundler_gemfile]
+      path = paths.bundler
+
+      options = []
+      options.push("--gemfile", gemfile) if gemfile
+      options.push("--path", path) if path
+      options
+    end
+
+    def install_options
+      jobs = settings[:bundler_jobs]
+      without = settings[:bundler_without]
+      flags = settings[:bundler_install_flags]
+
+      options = check_options.dup
+      options.push("--jobs", jobs) if jobs
+      options.push("--without", without) if without
+      options.push(flags) if flags
+
+      options.flatten
+    end
+
+    def extract_bundler_ver_from_lockfile
+      lockfile_tail = remote.capture(
+        "tail", "-n", "10", paths.release.join("Gemfile.lock"),
+        raise_on_error: false
+      )
+      lockfile_tail[/BUNDLED WITH\n   (\S+)$/, 1]
+    end
+  end
+end

data/lib/tomo/plugin/bundler.rb

@@ -0,0 +1,17 @@
+require_relative "bundler/helpers"
+require_relative "bundler/tasks"
+
+module Tomo::Plugin
+  module Bundler
+    extend Tomo::PluginDSL
+
+    tasks Tomo::Plugin::Bundler::Tasks
+    helpers Tomo::Plugin::Bundler::Helpers
+
+    defaults bundler_install_flags: ["--deployment"],
+             bundler_gemfile:       nil,
+             bundler_jobs:          "4",
+             bundler_path:          "%<shared_path>/bundle",
+             bundler_without:       %w[development test]
+  end
+end

data/lib/tomo/plugin/core/helpers.rb

@@ -0,0 +1,65 @@
+require "shellwords"
+
+module Tomo::Plugin::Core
+  module Helpers
+    def capture(*command, **run_opts)
+      result = run(*command, **{ silent: true }.merge(run_opts))
+      result.stdout
+    end
+
+    def run?(*command, **run_opts)
+      result = run(*command, **run_opts.merge(raise_on_error: false))
+      result.success?
+    end
+
+    def write(text:, to:, append: false, **run_opts)
+      message = "Writing #{text.bytesize} bytes to #{to}"
+      run(
+        "echo -n #{text.shellescape} #{append ? '>>' : '>'} #{to.shellescape}",
+        **{ echo: message }.merge(run_opts)
+      )
+    end
+
+    def ln_sf(target, link, **run_opts)
+      run("ln", "-sf", target, link, **run_opts)
+    end
+
+    def ln_sfn(target, link, **run_opts)
+      run("ln", "-sfn", target, link, **run_opts)
+    end
+
+    def mkdir_p(*directories, **run_opts)
+      run("mkdir", "-p", *directories, **run_opts)
+    end
+
+    def rm_rf(*paths, **run_opts)
+      run("rm", "-rf", *paths, **run_opts)
+    end
+
+    def list_files(directory=nil, **run_opts)
+      capture("ls", "-A1", directory, **run_opts).strip.split("\n")
+    end
+
+    def command_available?(command_name, **run_opts)
+      run?("which", command_name, **{ silent: true }.merge(run_opts))
+    end
+
+    def file?(file, **run_opts)
+      flag?("-f", file, **run_opts)
+    end
+
+    def executable?(file, **run_opts)
+      flag?("-x", file, **run_opts)
+    end
+
+    def directory?(directory, **run_opts)
+      flag?("-d", directory, **run_opts)
+    end
+
+    private
+
+    def flag?(flag, path, **run_opts)
+      run?("[ #{flag} #{path.to_s.shellescape} ]", **run_opts)
+    end
+  end
+end

data/lib/tomo/plugin/core/tasks.rb

@@ -0,0 +1,138 @@
+require "json"
+require "securerandom"
+
+module Tomo::Plugin::Core
+  class Tasks < Tomo::TaskLibrary
+    RELEASE_REGEXP = /\d{14}/.freeze
+    private_constant :RELEASE_REGEXP
+
+    # rubocop:disable Metrics/AbcSize
+    def setup_directories
+      dirs = [
+        paths.deploy_to,
+        paths.current.dirname,
+        paths.releases,
+        paths.revision_log.dirname,
+        paths.shared
+      ].map(&:to_s).uniq
+
+      remote.mkdir_p(*dirs)
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def symlink_shared
+      return if linked_dirs.empty? && linked_files.empty?
+
+      remote.mkdir_p(*shared_directories, *link_dirnames)
+      symlink_shared_directories
+      symlink_shared_files
+    end
+
+    def symlink_current
+      return if paths.release == paths.current
+
+      tmp_link = "#{paths.current}-#{SecureRandom.hex(8)}"
+      remote.ln_sf paths.release, tmp_link
+      remote.run "mv", "-fT", tmp_link, paths.current
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def clean_releases
+      desired_count = settings[:keep_releases].to_i
+      return if desired_count < 1
+
+      current = read_current_release
+
+      remote.chdir(paths.releases) do
+        releases = remote.list_files.grep(/^#{RELEASE_REGEXP}$/).sort
+        desired_count -= 1 if releases.delete(current)
+        return if releases.length <= desired_count
+
+        remote.rm_rf(*releases.take(releases.length - desired_count))
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def write_release_json
+      json = JSON.pretty_generate(remote.release)
+      remote.write(text: json, to: paths.release_json)
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def log_revision
+      message = remote.release[:deploy_date].to_s
+      message << " - #{remote.release[:revision] || '<unknown>'}"
+      message << " (#{remote.release[:branch] || '<unknown>'})"
+      message << " deployed by #{remote.release[:deploy_user] || '<unknown>'}"
+      message << "\n"
+
+      remote.write(text: message, to: paths.revision_log, append: true)
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    private
+
+    def linked_dirs
+      settings[:linked_dirs] || []
+    end
+
+    def linked_files
+      settings[:linked_files] || []
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def shared_directories
+      result = linked_dirs.map { |name| paths.shared.join(name) }
+      linked_files.each do |name|
+        result << paths.shared.join(name).dirname
+      end
+      result.map(&:to_s).uniq - [paths.shared.to_s]
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def symlink_shared_files
+      return if linked_files.empty?
+
+      linked_files.each do |file|
+        remote.ln_sfn paths.shared.join(file), paths.release.join(file)
+      end
+    end
+
+    def symlink_shared_directories
+      return if linked_dirs.empty?
+
+      remove_existing_link_targets
+      linked_dirs.each do |dir|
+        remote.ln_sf paths.shared.join(dir), paths.release.join(dir)
+      end
+    end
+
+    def link_dirnames
+      parents = (linked_dirs + linked_files).map do |target|
+        paths.release.join(target).dirname
+      end
+
+      parents.map(&:to_s).uniq - [paths.release.to_s]
+    end
+
+    def remove_existing_link_targets
+      return if linked_dirs.empty?
+
+      remote.chdir(paths.release) do
+        remote.rm_rf(*linked_dirs)
+      end
+    end
+
+    def read_current_release
+      result = remote.run(
+        "readlink",
+        paths.current,
+        raise_on_error: false,
+        silent: true
+      )
+      return nil if result.failure?
+
+      result.stdout.strip[%r{/(#{RELEASE_REGEXP})$}, 1]
+    end
+  end
+end

data/lib/tomo/plugin/core.rb

@@ -0,0 +1,31 @@
+require_relative "core/helpers"
+require_relative "core/tasks"
+
+module Tomo::Plugin
+  module Core
+    extend Tomo::PluginDSL
+
+    helpers Tomo::Plugin::Core::Helpers
+    tasks Tomo::Plugin::Core::Tasks
+
+    defaults application:                  "default",
+             concurrency:                  10,
+             current_path:                 "%<deploy_to>/current",
+             deploy_to:                    "/var/www/%<application>",
+             keep_releases:                10,
+             linked_dirs:                  [],
+             linked_files:                 [],
+             release_json_path:            "%<release_path>/.tomo_release.json",
+             releases_path:                "%<deploy_to>/releases",
+             revision_log_path:            "%<deploy_to>/revisions.log",
+             shared_path:                  "%<deploy_to>/shared",
+             tmp_path:                     "/tmp/tomo",
+             run_args:                     [],
+             ssh_connect_timeout:          5,
+             ssh_executable:               "ssh",
+             ssh_extra_opts:               %w[-o PasswordAuthentication=no],
+             ssh_forward_agent:            true,
+             ssh_reuse_connections:        true,
+             ssh_strict_host_key_checking: "accept-new"
+  end
+end

data/lib/tomo/plugin/env/tasks.rb

@@ -0,0 +1,113 @@
+require "monitor"
+
+module Tomo::Plugin::Env
+  class Tasks < Tomo::TaskLibrary
+    include MonitorMixin
+
+    def show
+      env = read_existing
+      logger.info env.gsub(/^export /, "").strip
+    end
+
+    def setup
+      update
+      modify_bashrc
+    end
+
+    def update
+      return if settings[:env_vars].empty?
+
+      modify_env_file do |env|
+        settings[:env_vars].each do |name, value|
+          next if value == :prompt && contains_entry?(env, name)
+
+          value = prompt_for(name) if value == :prompt
+          replace_entry(env, name, value)
+        end
+      end
+    end
+
+    def set
+      return if settings[:run_args].empty?
+
+      modify_env_file do |env|
+        settings[:run_args].each do |arg|
+          name, value = arg.split("=", 2)
+          value ||= prompt_for(name)
+          replace_entry(env, name, value)
+        end
+      end
+    end
+
+    def unset
+      return if settings[:run_args].empty?
+
+      modify_env_file do |env|
+        settings[:run_args].each do |name|
+          remove_entry(env, name)
+        end
+      end
+    end
+
+    private
+
+    def modify_env_file
+      env = read_existing
+      original = env.dup
+      yield(env)
+      return if env == original
+
+      remote.mkdir_p(paths.env.dirname) if original.empty?
+      remote.write(text: env, to: paths.env)
+    end
+
+    def read_existing
+      remote.capture(
+        "cat", paths.env,
+        raise_on_error: false, echo: false, silent: true
+      )
+    end
+
+    def replace_entry(text, name, value)
+      remove_entry(text, name)
+      prepend_entry(text, name, value)
+    end
+
+    def remove_entry(text, name)
+      text.gsub!(/^export #{Regexp.quote(name.to_s.shellescape)}=.*\n/, "")
+    end
+
+    def prepend_entry(text, name, value)
+      text.prepend("\n") unless text.start_with?("\n")
+      text.prepend("export #{name.to_s.shellescape}=#{value.shellescape}")
+    end
+
+    def contains_entry?(text, name)
+      return true if dry_run?
+
+      text.match?(/^export #{Regexp.quote(name.to_s.shellescape)}=/)
+    end
+
+    def prompt_for(name)
+      synchronize do
+        @answers ||= {}
+        next @answers[name] if @answers.key?(name)
+
+        @answers[name] = Tomo::Console.prompt("#{name}? ")
+      end
+    end
+
+    def modify_bashrc
+      env_path = paths.env.shellescape
+      existing_rc = remote.capture("cat", paths.bashrc, raise_on_error: false)
+      return if existing_rc.include?(". #{env_path}")
+
+      remote.write(text: <<~BASHRC + existing_rc, to: paths.bashrc)
+        if [ -f #{env_path} ]; then
+          . #{env_path}
+        fi
+
+      BASHRC
+    end
+  end
+end

data/lib/tomo/plugin/env.rb

@@ -0,0 +1,13 @@
+require_relative "env/tasks"
+
+module Tomo::Plugin
+  module Env
+    extend Tomo::PluginDSL
+
+    tasks Tomo::Plugin::Env::Tasks
+
+    defaults bashrc_path: ".bashrc",
+             env_path: "%<deploy_to>/envrc",
+             env_vars: {}
+  end
+end

data/lib/tomo/plugin/git/helpers.rb

@@ -0,0 +1,11 @@
+module Tomo::Plugin::Git
+  module Helpers
+    def git(*args, **opts)
+      env(settings[:git_env]) do
+        prepend("git") do
+          run(*args, **opts)
+        end
+      end
+    end
+  end
+end