tomo 0.1.0

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

@@ -0,0 +1,78 @@
+require "shellwords"
+require "time"
+
+module Tomo::Plugin::Git
+  class Tasks < Tomo::TaskLibrary
+    # rubocop:disable Metrics/AbcSize
+    def clone
+      require_setting :git_url
+
+      if remote.directory?(paths.git_repo) && !dry_run?
+        set_origin_url
+      else
+        remote.mkdir_p(paths.git_repo.dirname)
+        remote.git(
+          "clone", "--mirror", settings[:git_url], paths.git_repo
+        )
+      end
+    end
+
+    def create_release
+      configure_git_attributes
+      remote.chdir(paths.git_repo) do
+        remote.git("remote update --prune")
+        remote.mkdir_p(paths.release)
+        remote.git(
+          "archive #{branch.shellescape} | "\
+          "tar -x -f - -C #{paths.release.shellescape}"
+        )
+      end
+      store_release_info
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    private
+
+    def branch
+      settings[:git_branch]
+    end
+
+    def set_origin_url
+      remote.chdir(paths.git_repo) do
+        remote.git("remote", "set-url", "origin", settings[:git_url])
+      end
+    end
+
+    def configure_git_attributes
+      exclusions = settings[:git_exclusions] || []
+      attributes = exclusions.map { |excl| "#{excl} export-ignore" }.join("\n")
+
+      remote.write(
+        text: attributes,
+        to: paths.git_repo.join("info/attributes")
+      )
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    def store_release_info
+      log = remote.chdir(paths.git_repo) do
+        remote.git(
+          'log -n1 --date=iso --pretty=format:"%H/%cd/%ae" '\
+          "#{branch.shellescape}",
+          silent: true
+        ).stdout.strip
+      end
+
+      sha, date, email = log.split("/", 3)
+      remote.release[:branch] = branch
+      remote.release[:author] = email
+      remote.release[:revision] = sha
+      remote.release[:revision_date] = date
+      remote.release[:deploy_date] = Time.now.to_s
+      remote.release[:deploy_user] = ENV["USER"] || ENV["USERNAME"]
+    end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
+  end
+end

data/lib/tomo/plugin/git.rb

@@ -0,0 +1,19 @@
+require_relative "git/helpers"
+require_relative "git/tasks"
+
+module Tomo::Plugin
+  module Git
+    extend Tomo::PluginDSL
+
+    helpers Tomo::Plugin::Git::Helpers
+    tasks Tomo::Plugin::Git::Tasks
+
+    # rubocop:disable Metrics/LineLength
+    defaults git_branch:     "master",
+             git_repo_path:  "%<deploy_to>/git_repo",
+             git_exclusions: [],
+             git_env:        { GIT_SSH_COMMAND: "ssh -o PasswordAuthentication=no -o StrictHostKeyChecking=no" },
+             git_url:        nil
+    # rubocop:enable Metrics/LineLength
+  end
+end

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

@@ -0,0 +1,61 @@
+require "shellwords"
+
+module Tomo::Plugin::Nvm
+  class Tasks < Tomo::TaskLibrary
+    def install
+      remote.mkdir_p raw("$HOME/.nvm")
+      modify_bashrc
+      run_installer
+      install_node
+      install_yarn
+    end
+
+    private
+
+    def run_installer
+      require_setting :nvm_version
+
+      nvm_version = settings[:nvm_version]
+      install_url = "https://raw.githubusercontent.com/creationix/nvm/"\
+                    "v#{nvm_version}/install.sh"
+      remote.run("curl -o- #{install_url.shellescape} | bash")
+    end
+
+    def modify_bashrc
+      existing_rc = remote.capture("cat", paths.bashrc, raise_on_error: false)
+      return if existing_rc.include?("nvm.sh")
+
+      remote.write(text: <<~BASHRC + existing_rc, to: paths.bashrc)
+        export NVM_DIR="$HOME/.nvm"
+        [ -s "$NVM_DIR/nvm.sh" ] && \\. "$NVM_DIR/nvm.sh"
+
+      BASHRC
+    end
+
+    def install_node
+      require_setting :nvm_node_version
+      node_version = settings[:nvm_node_version]
+
+      unless node_installed?(node_version)
+        remote.run "nvm", "install", node_version
+      end
+      remote.run "nvm", "alias", "default", node_version
+    end
+
+    def install_yarn
+      version = settings[:nvm_yarn_version]
+      return remote.run "npm i -g yarn@#{version.shellescape}" if version
+
+      logger.info "No :nvm_yarn_version specified; skipping yarn installation."
+    end
+
+    def node_installed?(version)
+      versions = remote.capture("nvm ls", raise_on_error: false)
+      if versions.include?("v#{version}")
+        logger.info("Node #{version} is already installed.")
+        return true
+      end
+      false
+    end
+  end
+end

data/lib/tomo/plugin/nvm.rb

@@ -0,0 +1,14 @@
+require_relative "nvm/tasks"
+
+module Tomo::Plugin
+  module Nvm
+    extend Tomo::PluginDSL
+
+    defaults bashrc_path: ".bashrc",
+             nvm_version: "0.34.0",
+             nvm_node_version: nil,
+             nvm_yarn_version: nil
+
+    tasks Tomo::Plugin::Nvm::Tasks
+  end
+end

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

@@ -0,0 +1,38 @@
+module Tomo::Plugin::Puma
+  class Tasks < Tomo::TaskLibrary
+    def restart
+      return if try_restart
+
+      remote.chdir(paths.current) do
+        logger.info "Puma is not running. Starting it now."
+        remote.bundle("exec", "puma", "--daemon", *control_options)
+      end
+    end
+
+    private
+
+    def try_restart
+      ctl_result = remote.chdir(paths.current) do
+        ctl_result = remote.bundle(
+          "exec", "pumactl", *control_options, "restart",
+          raise_on_error: false,
+          silent: true
+        )
+      end
+
+      return false if dry_run? || ctl_result.failure?
+
+      logger.info(ctl_result.output)
+      true
+    end
+
+    def control_options
+      require_settings :puma_control_token, :puma_control_url
+
+      [
+        "--control-url", settings[:puma_control_url],
+        "--control-token", settings[:puma_control_token]
+      ]
+    end
+  end
+end

data/lib/tomo/plugin/puma.rb

@@ -0,0 +1,12 @@
+require_relative "puma/tasks"
+
+module Tomo::Plugin
+  module Puma
+    extend Tomo::PluginDSL
+
+    tasks Tomo::Plugin::Puma::Tasks
+
+    defaults puma_control_token: "tomo",
+             puma_control_url: "tcp://127.0.0.1:9293"
+  end
+end

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

@@ -0,0 +1,20 @@
+module Tomo::Plugin::Rails
+  module Helpers
+    def rails(*args, **opts)
+      prepend("exec", "rails") do
+        bundle(*args, **opts)
+      end
+    end
+
+    def rake(*args, **opts)
+      prepend("exec", "rails") do
+        bundle(*args, **opts)
+      end
+    end
+
+    def rake?(*args, **opts)
+      result = rake(*args, **opts.merge(raise_on_error: false))
+      result.success?
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module Tomo::Plugin::Rails
+  class Tasks < Tomo::TaskLibrary
+    def assets_precompile
+      remote.rake("assets:precompile")
+    end
+
+    def console
+      remote.rails("console", settings[:run_args], attach: true)
+    end
+
+    def db_migrate
+      remote.rake("db:migrate")
+    end
+
+    def db_seed
+      remote.rake("db:seed")
+    end
+
+    def db_create
+      return remote.rake("db:create") unless database_exists?
+
+      logger.info "Database already exists; skipping db:create."
+    end
+
+    def db_setup
+      return remote.rake("db:setup") unless database_exists?
+
+      logger.info "Database already exists; skipping db:setup."
+    end
+
+    def db_schema_load
+      if !schema_rb_present?
+        logger.warn "db/schema.rb is not present; skipping schema:load."
+      elsif database_schema_loaded?
+        logger.info "Database schema already loaded; skipping db:schema:load."
+      else
+        remote.rake("db:schema:load")
+      end
+    end
+
+    def db_structure_load
+      if !structure_sql_present?
+        logger.warn "db/structure.sql is not present; "\
+                    "skipping db:structure:load."
+      elsif database_schema_loaded?
+        logger.info "Database structure already loaded; "\
+                    "skipping db:structure:load."
+      else
+        remote.rake("db:structure:load")
+      end
+    end
+
+    def log_tail
+      log_path = raw("#{paths.release.to_s.shellescape}/log/${RAILS_ENV}.log")
+      remote.run("tail", settings[:run_args], log_path)
+    end
+
+    private
+
+    def database_exists?
+      remote.rake?("db:version", silent: true) && !dry_run?
+    end
+
+    def database_schema_loaded?
+      result = remote.rake("db:version", silent: true, raise_on_error: false)
+      schema_version = result.output[/version:\s*(\d+)$/i, 1].to_i
+
+      result.success? && schema_version.positive? && !dry_run?
+    end
+
+    def schema_rb_present?
+      remote.file?(paths.release.join("db/schema.rb"))
+    end
+
+    def structure_sql_present?
+      remote.file?(paths.release.join("db/structure.sql"))
+    end
+  end
+end

data/lib/tomo/plugin/rails.rb

@@ -0,0 +1,11 @@
+require_relative "rails/helpers"
+require_relative "rails/tasks"
+
+module Tomo::Plugin
+  module Rails
+    extend Tomo::PluginDSL
+
+    helpers Tomo::Plugin::Rails::Helpers
+    tasks Tomo::Plugin::Rails::Tasks
+  end
+end

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

@@ -0,0 +1,55 @@
+require "shellwords"
+
+module Tomo::Plugin::Rbenv
+  class Tasks < Tomo::TaskLibrary
+    def install
+      run_installer
+      modify_bashrc
+      compile_ruby
+    end
+
+    private
+
+    def run_installer
+      install_url = "https://github.com/rbenv/rbenv-installer/raw/master/bin/rbenv-installer"
+      remote.env PATH: raw("$HOME/.rbenv/bin:$HOME/.rbenv/shims:$PATH") do
+        remote.run("curl -fsSL #{install_url.shellescape} | bash")
+      end
+    end
+
+    def modify_bashrc
+      existing_rc = remote.capture("cat", paths.bashrc, raise_on_error: false)
+      return if existing_rc.include?("rbenv init")
+
+      remote.write(text: <<~BASHRC + existing_rc, to: paths.bashrc)
+        if [ -d $HOME/.rbenv ]; then
+          export PATH="$HOME/.rbenv/bin:$PATH"
+          eval "$(rbenv init -)"
+        fi
+
+      BASHRC
+    end
+
+    def compile_ruby
+      require_setting :rbenv_ruby_version
+      ruby_version = settings[:rbenv_ruby_version]
+
+      unless ruby_installed?(ruby_version)
+        logger.info(
+          "Installing ruby #{ruby_version} -- this may take several minutes"
+        )
+        remote.run "CFLAGS=-O3 rbenv install #{ruby_version.shellescape}"
+      end
+      remote.run "rbenv global #{ruby_version.shellescape}"
+    end
+
+    def ruby_installed?(version)
+      versions = remote.capture("rbenv versions", raise_on_error: false)
+      if versions.include?(version)
+        logger.info("Ruby #{version} is already installed.")
+        return true
+      end
+      false
+    end
+  end
+end

data/lib/tomo/plugin/rbenv.rb

@@ -0,0 +1,12 @@
+require_relative "rbenv/tasks"
+
+module Tomo::Plugin
+  module Rbenv
+    extend Tomo::PluginDSL
+
+    defaults bashrc_path: ".bashrc",
+             rbenv_ruby_version: nil
+
+    tasks Tomo::Plugin::Rbenv::Tasks
+  end
+end

data/lib/tomo/plugin/testing.rb

@@ -0,0 +1,16 @@
+unless defined?(Tomo::Testing)
+  raise "The testing plugin cannot be used outside of unit tests"
+end
+
+module Tomo::Plugin
+  class Testing < Tomo::TaskLibrary
+    extend Tomo::PluginDSL
+    tasks self
+
+    def call_helper
+      helper, args, kwargs = settings[:run_args]
+      value = remote.public_send(helper, *args, **(kwargs || {}))
+      remote.host.helper_values << value
+    end
+  end
+end

data/lib/tomo/plugin.rb

@@ -0,0 +1,4 @@
+module Tomo
+  module Plugin
+  end
+end

data/lib/tomo/plugin_dsl.rb

@@ -0,0 +1,23 @@
+module Tomo
+  module PluginDSL
+    def self.extended(mod)
+      mod.instance_variable_set(:@helper_modules, [])
+      mod.instance_variable_set(:@default_settings, {})
+      mod.instance_variable_set(:@tasks_classes, [])
+    end
+
+    attr_reader :helper_modules, :default_settings, :tasks_classes
+
+    def helpers(mod, *more_mods)
+      @helper_modules.push(mod, *more_mods)
+    end
+
+    def defaults(settings)
+      @default_settings.merge!(settings)
+    end
+
+    def tasks(tasks_class, *more_tasks_classes)
+      @tasks_classes.push(tasks_class, *more_tasks_classes)
+    end
+  end
+end

data/lib/tomo/remote.rb

@@ -0,0 +1,55 @@
+require "forwardable"
+
+module Tomo
+  class Remote
+    extend Forwardable
+    def_delegators :ssh, :close, :host
+    def_delegators :shell_builder, :chdir, :env, :prepend, :umask
+
+    attr_reader :release
+
+    def initialize(ssh, context, helper_modules)
+      @ssh = ssh
+      @context = context
+      @release = {}
+      @shell_builder = ShellBuilder.new
+      helper_modules.each { |mod| extend(mod) }
+      freeze
+    end
+
+    def attach(*command, default_chdir: nil, **command_opts)
+      full_command = shell_builder.build(*command, default_chdir: default_chdir)
+      ssh.ssh_exec(
+        Script.new(full_command, { pty: true }.merge(**command_opts))
+      )
+    end
+
+    def run(*command, attach: false, default_chdir: nil, **command_opts)
+      attach(*command, default_chdir: default_chdir, **command_opts) if attach
+
+      full_command = shell_builder.build(*command, default_chdir: default_chdir)
+      ssh.ssh_subprocess(Script.new(full_command, **command_opts))
+    end
+
+    private
+
+    def_delegators :context, :paths, :settings
+    attr_reader :context, :ssh, :shell_builder
+
+    def dry_run?
+      Tomo.dry_run?
+    end
+
+    def logger
+      Tomo.logger
+    end
+
+    def raw(str)
+      ShellBuilder.raw(str)
+    end
+
+    def remote
+      self
+    end
+  end
+end

data/lib/tomo/result.rb

@@ -0,0 +1,28 @@
+module Tomo
+  class Result
+    def self.empty_success
+      new(stdout: "", stderr: "", exit_status: 0)
+    end
+
+    attr_reader :stdout, :stderr, :exit_status
+
+    def initialize(stdout:, stderr:, exit_status:)
+      @stdout = stdout
+      @stderr = stderr
+      @exit_status = exit_status
+      freeze
+    end
+
+    def success?
+      exit_status.zero?
+    end
+
+    def failure?
+      !success?
+    end
+
+    def output
+      [stdout, stderr].compact.join
+    end
+  end
+end

data/lib/tomo/runtime/concurrent_ruby_load_error.rb

@@ -0,0 +1,26 @@
+module Tomo
+  class Runtime
+    class ConcurrentRubyLoadError < Tomo::Error
+      attr_accessor :version
+
+      def to_console
+        <<~ERROR
+          Running tasks on multiple hosts requires the #{yellow('concurrent-ruby')} gem.
+          To install it, #{install_instructions}
+        ERROR
+      end
+
+      private
+
+      def install_instructions
+        if Tomo.bundled?
+          gem_entry = %Q(gem "concurrent-ruby", "#{version}")
+          "add this entry to your Gemfile:\n\n  #{blue(gem_entry)}"
+        else
+          gem_install = "gem install concurrent-ruby -v '#{version}'"
+          "run:\n\n  #{blue(gem_install)}"
+        end
+      end
+    end
+  end
+end

data/lib/tomo/runtime/concurrent_ruby_thread_pool.rb

@@ -0,0 +1,50 @@
+concurrent_ver = "~> 1.1"
+
+begin
+  gem "concurrent-ruby", concurrent_ver
+  require "concurrent"
+rescue LoadError => e
+  Tomo::Runtime::ConcurrentRubyLoadError.raise_with(
+    e.message,
+    version: concurrent_ver
+  )
+end
+
+module Tomo
+  class Runtime
+    class ConcurrentRubyThreadPool
+      include ::Concurrent::Promises::FactoryMethods
+
+      def initialize(size)
+        @executor = ::Concurrent::FixedThreadPool.new(size)
+        @promises = []
+      end
+
+      def post(*args, &block)
+        return if failure?
+
+        promises << future_on(executor, *args, &block)
+                    .on_rejection_using(executor) do |reason|
+                      self.failure = reason
+                    end
+        nil
+      end
+
+      def run_to_completion
+        promises_to_wait = promises.dup
+        promises.clear
+        zip_futures_on(executor, *promises_to_wait).value
+        raise failure if failure?
+      end
+
+      def failure?
+        !!failure
+      end
+
+      private
+
+      attr_accessor :failure
+      attr_reader :executor, :promises
+    end
+  end
+end

data/lib/tomo/runtime/context.rb

@@ -0,0 +1,21 @@
+module Tomo
+  class Runtime
+    class Context
+      attr_reader :paths, :settings
+
+      def initialize(settings)
+        @paths = Paths.new(settings)
+        @settings = settings.freeze
+        freeze
+      end
+
+      def current_remote
+        Current.remote
+      end
+
+      def current_task
+        Current.task
+      end
+    end
+  end
+end

data/lib/tomo/runtime/current.rb

@@ -0,0 +1,41 @@
+module Tomo
+  class Runtime
+    module Current
+      class << self
+        def host
+          fiber_locals[:host] || remote&.host
+        end
+
+        def remote
+          fiber_locals[:remote]
+        end
+
+        def task
+          fiber_locals[:task]
+        end
+
+        def with(new_locals)
+          old_locals = slice(*new_locals.keys)
+          fiber_locals.merge!(new_locals)
+          yield
+        ensure
+          fiber_locals.merge!(old_locals)
+        end
+
+        def variables
+          fiber_locals.dup.freeze
+        end
+
+        private
+
+        def slice(*keys)
+          Hash[keys.map { |key| [key, fiber_locals[key]] }]
+        end
+
+        def fiber_locals
+          Thread.current["Tomo::Runtime::Current"] ||= {}
+        end
+      end
+    end
+  end
+end