tomo 0.1.0

data/lib/tomo/commands/help.rb

@@ -0,0 +1,9 @@
+module Tomo
+  module Commands
+    class Help
+      def self.parse(argv)
+        Default.parse([*argv, "--help"])
+      end
+    end
+  end
+end

data/lib/tomo/commands/init.rb

@@ -0,0 +1,92 @@
+require "erb"
+
+module Tomo
+  module Commands
+    class Init < CLI::Command
+      include CLI::CommonOptions
+
+      arg "[APP]"
+
+      def summary
+        "Start a new tomo project with a sample config"
+      end
+
+      def banner
+        <<~BANNER
+          Usage: #{green('tomo init')} #{yellow('[APP]')}
+
+          Set up a new tomo project named #{yellow('APP')}. If #{yellow('APP')} is not specified, the
+          name of the current directory will be used.
+
+          This command creates a #{DEFAULT_CONFIG_PATH} file relative the current
+          directory containing some example configuration.
+        BANNER
+      end
+
+      def call(*args, _options)
+        assert_can_create_tomo_directory!
+        assert_no_tomo_project!
+
+        app = args.first || current_dir_name || "default"
+        app = app.gsub(/([^\w\-]|_)+/, "_").downcase
+        FileUtils.mkdir_p(".tomo/plugins")
+
+        # TODO: use a template for this file
+        FileUtils.touch(".tomo/plugins/#{app}.rb")
+
+        IO.write(DEFAULT_CONFIG_PATH, config_rb_template(app))
+
+        logger.info(green("✔ Created #{DEFAULT_CONFIG_PATH}"))
+      end
+
+      private
+
+      def assert_can_create_tomo_directory!
+        return if Dir.exist?(".tomo")
+        return unless File.exist?(".tomo")
+
+        logger.error("Can't create .tomo directory; a file already exists")
+        exit(1)
+      end
+
+      def assert_no_tomo_project!
+        return unless File.exist?(DEFAULT_CONFIG_PATH)
+
+        logger.error("A #{DEFAULT_CONFIG_PATH} file already exists")
+        exit(1)
+      end
+
+      def current_dir_name
+        File.basename(File.expand_path("."))
+      end
+
+      def git_origin_url
+        return unless File.file?(".git/config")
+        return unless `git remote -v` =~ /^origin/
+
+        url = `git remote get-url origin`.chomp
+        url.empty? ? nil : url
+      rescue SystemCallError
+        nil
+      end
+
+      def node_version
+        `node --version`.chomp.sub(/^v/i, "")
+      rescue SystemCallError
+        nil
+      end
+
+      def yarn_version
+        `yarn --version`.chomp
+      rescue SystemCallError
+        nil
+      end
+
+      def config_rb_template(app)
+        path = File.expand_path("../templates/config.rb.erb", __dir__)
+        template = IO.read(path)
+        ERB.new(template).result(binding)
+      end
+    end
+  end
+end

data/lib/tomo/commands/run.rb

@@ -0,0 +1,76 @@
+module Tomo
+  module Commands
+    class Run < CLI::Command
+      include CLI::DeployOptions
+
+      option :privileged,
+             "--[no-]privileged",
+             "Run the task using a privileged user (e.g. root)"
+
+      include CLI::ProjectOptions
+      include CLI::CommonOptions
+
+      arg "TASK", values: :task_names
+      arg "[ARGS...]"
+
+      def summary
+        "Run a specific remote task from the current project"
+      end
+
+      def banner
+        <<~BANNER
+          Usage: #{green('tomo run')} #{yellow('[--dry-run] [options] [--] TASK [ARGS...]')}
+
+          Remotely run one specified #{yellow('TASK')}, optionally passing #{yellow('ARGS')} to that task.
+          For example, if this project uses the "rails" plugin, you could run:
+
+            #{blue('tomo run -- rails:console --sandbox')}
+
+          This will run the #{blue('rails:console')} task on the host specified in
+          #{DEFAULT_CONFIG_PATH}, and will pass the #{blue('--sandbox')} argument to that task.
+          The #{blue('--')} is used to separate tomo options from options that are passed
+          to the task. If a task does not accept options, the #{blue('--')} can be omitted,
+          like this:
+
+            #{blue('tomo run core:clean_releases')}
+
+          You can run any task defined by plugins loaded in #{DEFAULT_CONFIG_PATH}.
+          To see a list of available tasks, run #{blue('tomo tasks')}.
+
+          Tomo will auto-complete this command’s options, including the #{yellow('TASK')} name,
+          if you are using bash and have tomo’s completion script installed. For
+          installation instructions, run #{blue('tomo completion-script')}.
+
+          For more documentation and examples, visit:
+
+            #{blue('https://tomo-deploy.com/commands/run')}
+        BANNER
+      end
+
+      def call(task, *args, options)
+        logger.info "tomo run v#{Tomo::VERSION}"
+
+        runtime = configure_runtime(options)
+        plan = runtime.run!(task, *args, privileged: options[:privileged])
+        log_completion(task, plan)
+      end
+
+      private
+
+      def log_completion(task, plan)
+        target = "#{task} on #{plan.applicable_hosts_sentence}"
+
+        if dry_run?
+          logger.info(green("* Simulated #{target} (dry run)"))
+        else
+          logger.info(green("✔ Ran #{target}"))
+        end
+      end
+
+      def task_names(*, options)
+        runtime = configure_runtime(options, strict: false)
+        runtime.tasks
+      end
+    end
+  end
+end

data/lib/tomo/commands/setup.rb

@@ -0,0 +1,54 @@
+module Tomo
+  module Commands
+    class Setup < CLI::Command
+      include CLI::DeployOptions
+      include CLI::ProjectOptions
+      include CLI::CommonOptions
+
+      def summary
+        "Prepare the current project for its first deploy"
+      end
+
+      def banner
+        <<~BANNER
+          Usage: #{green('tomo setup')} #{yellow('[--dry-run] [options]')}
+
+          Prepare the remote host for its first deploy by sequentially running the
+          "setup" list of tasks specified in #{DEFAULT_CONFIG_PATH}. These tasks typically
+          create directories, initialize data stores, install prerequisite tools,
+          and perform other one-time actions that are necessary before a deploy can
+          take place.
+
+          Use the #{blue('--dry-run')} option to quickly simulate the setup without actually
+          connecting to the host.
+
+          More documentation and examples can be found here:
+
+            #{blue('https://tomo-deploy.com/commands/setup')}
+        BANNER
+      end
+
+      def call(options)
+        logger.info "tomo setup v#{Tomo::VERSION}"
+
+        runtime = configure_runtime(options)
+        plan = runtime.setup!
+
+        log_completion(plan)
+      end
+
+      private
+
+      def log_completion(plan)
+        app = plan.settings[:application]
+        target = "#{app} on #{plan.applicable_hosts_sentence}"
+
+        if dry_run?
+          logger.info(green("* Simulated setup of #{target} (dry run)"))
+        else
+          logger.info(green("✔ Performed setup of #{target}"))
+        end
+      end
+    end
+  end
+end

data/lib/tomo/commands/tasks.rb

@@ -0,0 +1,32 @@
+module Tomo
+  module Commands
+    class Tasks < CLI::Command
+      include CLI::ProjectOptions
+      include CLI::CommonOptions
+
+      def summary
+        "List all tasks that can be used with the #{yellow('run')} command"
+      end
+
+      def banner
+        <<~BANNER
+          Usage: #{green('tomo tasks')}
+
+          List all tomo tasks (i.e. those that can be used with #{blue('tomo run')}).
+
+          Available tasks are those defined by plugins loaded in #{DEFAULT_CONFIG_PATH}.
+        BANNER
+      end
+
+      def call(options)
+        runtime = configure_runtime(options, strict: false)
+        tasks = runtime.tasks
+
+        groups = tasks.group_by { |task| task[/^([^:]+):/, 1].to_s }
+        groups.keys.sort.each do |group|
+          puts groups[group].sort.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/tomo/commands/version.rb

@@ -0,0 +1,23 @@
+module Tomo
+  module Commands
+    class Version < CLI::Command
+      include CLI::CommonOptions
+
+      def summary
+        "Display tomo’s version"
+      end
+
+      def banner
+        <<~BANNER
+          Usage: #{green('tomo version')}
+
+          Display tomo’s version information.
+        BANNER
+      end
+
+      def call(_options)
+        puts "tomo/#{Tomo::VERSION} #{RUBY_DESCRIPTION}"
+      end
+    end
+  end
+end

data/lib/tomo/commands.rb

@@ -0,0 +1,13 @@
+module Tomo
+  module Commands
+    autoload :CompletionScript, "tomo/commands/completion_script"
+    autoload :Default, "tomo/commands/default"
+    autoload :Deploy, "tomo/commands/deploy"
+    autoload :Help, "tomo/commands/help"
+    autoload :Init, "tomo/commands/init"
+    autoload :Run, "tomo/commands/run"
+    autoload :Setup, "tomo/commands/setup"
+    autoload :Tasks, "tomo/commands/tasks"
+    autoload :Version, "tomo/commands/version"
+  end
+end

data/lib/tomo/configuration/dsl/batch_block.rb

@@ -0,0 +1,17 @@
+module Tomo
+  class Configuration
+    module DSL
+      class BatchBlock
+        def initialize(batch)
+          @batch = batch
+        end
+
+        def run(task, privileged: false)
+          task.extend(Runtime::PrivilegedTask) if privileged
+          @batch << task
+          self
+        end
+      end
+    end
+  end
+end

data/lib/tomo/configuration/dsl/config_file.rb

@@ -0,0 +1,39 @@
+module Tomo
+  class Configuration
+    module DSL
+      class ConfigFile
+        include HostsAndSettings
+
+        def initialize(config)
+          @config = config
+        end
+
+        def plugin(name)
+          @config.plugins << name.to_s
+          self
+        end
+
+        def role(name, runs:)
+          @config.task_filter.add_role(name, runs)
+          self
+        end
+
+        def environment(name, &block)
+          environment = @config.environments[name.to_s] ||= Environment.new
+          EnvironmentBlock.new(environment).instance_eval(&block)
+          self
+        end
+
+        def deploy(&block)
+          TasksBlock.new(@config.deploy_tasks).instance_eval(&block)
+          self
+        end
+
+        def setup(&block)
+          TasksBlock.new(@config.setup_tasks).instance_eval(&block)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/tomo/configuration/dsl/environment_block.rb

@@ -0,0 +1,13 @@
+module Tomo
+  class Configuration
+    module DSL
+      class EnvironmentBlock
+        include HostsAndSettings
+
+        def initialize(config)
+          @config = config
+        end
+      end
+    end
+  end
+end

data/lib/tomo/configuration/dsl/error_formatter.rb

@@ -0,0 +1,75 @@
+module Tomo
+  class Configuration
+    module DSL
+      module ErrorFormatter
+        def self.decorate(error, path, lines)
+          if error.backtrace[0..1].grep(/^#{Regexp.quote(path)}:/).empty?
+            return error
+          end
+
+          error.extend(self)
+          error.dsl_lines = lines || []
+          error.dsl_path = path
+          error
+        end
+
+        include Colors
+
+        attr_accessor :dsl_lines, :dsl_path
+
+        def to_console
+          <<~ERROR
+            Configuration syntax error in #{yellow(dsl_path)} at line #{yellow(error_line_no)}.
+
+            #{highlighted_lines}
+            #{Colors.red([self.class, message].join(': '))}
+
+            Visit #{Colors.blue('https://tomo-deploy.com/configuration')} for syntax reference.
+            #{trace_hint}
+          ERROR
+        end
+
+        private
+
+        def trace_hint
+          return "" if CLI.show_backtrace
+
+          <<~HINT
+            You can run this command again with #{Colors.blue('--trace')} for a full backtrace.
+          HINT
+        end
+
+        def error_line_no
+          @_error_line_no ||= begin
+            pattern = /^#{Regexp.quote(dsl_path)}:(\d+):/
+            backtrace.each do |entry|
+              match = pattern.match(entry)
+              break match[1].to_i if match
+            end
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
+        def highlighted_lines
+          first = [1, error_line_no - 1].max
+          last = [dsl_lines.length, error_line_no + 1].min
+          width = last.to_s.length
+
+          (first..last).each_with_object("") do |line_no, result|
+            line = dsl_lines[line_no - 1]
+            line_no_prefix = line_no.to_s.rjust(width)
+
+            result << if line_no == error_line_no
+                        yellow("→ #{line_no_prefix}: #{line}")
+                      else
+                        "  #{line_no_prefix}: #{line}"
+                      end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/MethodLength
+      end
+    end
+  end
+end

data/lib/tomo/configuration/dsl/hosts_and_settings.rb

@@ -0,0 +1,24 @@
+module Tomo
+  class Configuration
+    module DSL
+      module HostsAndSettings
+        def set(settings)
+          @config.settings.merge!(settings)
+          self
+        end
+
+        def host(address, port: 22, roles: [],
+                 log_prefix: nil, privileged_user: "root")
+          @config.hosts << Host.parse(
+            address,
+            privileged_user: privileged_user,
+            port: port,
+            roles: roles,
+            log_prefix: log_prefix
+          )
+          self
+        end
+      end
+    end
+  end
+end

data/lib/tomo/configuration/dsl/tasks_block.rb

@@ -0,0 +1,24 @@
+module Tomo
+  class Configuration
+    module DSL
+      class TasksBlock
+        def initialize(tasks)
+          @tasks = tasks
+        end
+
+        def batch(&block)
+          batch = []
+          BatchBlock.new(batch).instance_eval(&block)
+          @tasks << batch unless batch.empty?
+          self
+        end
+
+        def run(task, privileged: false)
+          task.extend(Runtime::PrivilegedTask) if privileged
+          @tasks << task
+          self
+        end
+      end
+    end
+  end
+end

data/lib/tomo/configuration/dsl.rb

@@ -0,0 +1,12 @@
+module Tomo
+  class Configuration
+    module DSL
+      autoload :BatchBlock, "tomo/configuration/dsl/batch_block"
+      autoload :ConfigFile, "tomo/configuration/dsl/config_file"
+      autoload :EnvironmentBlock, "tomo/configuration/dsl/environment_block"
+      autoload :ErrorFormatter, "tomo/configuration/dsl/error_formatter"
+      autoload :HostsAndSettings, "tomo/configuration/dsl/hosts_and_settings"
+      autoload :TasksBlock, "tomo/configuration/dsl/tasks_block"
+    end
+  end
+end

data/lib/tomo/configuration/environment.rb

@@ -0,0 +1,12 @@
+module Tomo
+  class Configuration
+    class Environment
+      attr_accessor :hosts, :settings
+
+      def initialize
+        @hosts = []
+        @settings = {}
+      end
+    end
+  end
+end

data/lib/tomo/configuration/glob.rb

@@ -0,0 +1,26 @@
+module Tomo
+  class Configuration
+    class Glob
+      def initialize(spec)
+        @spec = spec.to_s.freeze
+        regexp_parts = @spec.split(/(\*)/).map do |part|
+          part == "*" ? ".*" : Regexp.quote(part)
+        end
+        @regexp = Regexp.new(regexp_parts.join).freeze
+        freeze
+      end
+
+      def match?(str)
+        regexp.match?(str)
+      end
+
+      def to_s
+        spec
+      end
+
+      private
+
+      attr_reader :regexp, :spec
+    end
+  end
+end

data/lib/tomo/configuration/plugin_file_not_found_error.rb

@@ -0,0 +1,14 @@
+module Tomo
+  class Configuration
+    class PluginFileNotFoundError < Error
+      attr_accessor :path
+
+      def to_console
+        <<~ERROR
+          A plugin specified by this project could not be loaded.
+          File does not exist: #{yellow(path)}
+        ERROR
+      end
+    end
+  end
+end

data/lib/tomo/configuration/plugin_resolver.rb

@@ -0,0 +1,63 @@
+module Tomo
+  class Configuration
+    class PluginResolver
+      PLUGIN_PREFIX = "tomo/plugin".freeze
+      private_constant :PLUGIN_PREFIX
+
+      def self.resolve(name)
+        new(name).plugin_module
+      end
+
+      def initialize(name)
+        @name = name
+      end
+
+      def plugin_module
+        plugin_path = [PLUGIN_PREFIX, name.tr("-", "/")].join("/")
+        require plugin_path
+
+        plugin = constantize(plugin_path)
+        assert_compatible_api(plugin)
+
+        plugin
+      rescue LoadError => e
+        raise unless e.message.match?(/\s#{Regexp.quote(plugin_path)}$/)
+
+        raise_unknown_plugin_error(e)
+      end
+
+      private
+
+      attr_reader :name
+
+      def assert_compatible_api(plugin)
+        return if plugin.is_a?(::Tomo::PluginDSL)
+
+        raise "#{plugin} does not extend Tomo::PluginDSL"
+      end
+
+      def constantize(path)
+        parts = path.split("/")
+        parts.reduce(Object) do |parent, part|
+          child = part.gsub(/^[a-z]|_[a-z]/) { |str| str.chars.last.upcase }
+          parent.const_get(child, false)
+        end
+      end
+
+      def raise_unknown_plugin_error(error)
+        UnknownPluginError.raise_with(
+          error.message,
+          name: name,
+          gem_name: "#{PLUGIN_PREFIX}/#{name}".tr("/", "-"),
+          known_plugins: scan_for_plugins
+        )
+      end
+
+      def scan_for_plugins
+        Gem.find_latest_files("#{PLUGIN_PREFIX}/*.rb").map do |file|
+          file[%r{#{PLUGIN_PREFIX}/(.+).rb$}, 1].tr("/", "-")
+        end.uniq.sort
+      end
+    end
+  end
+end

data/lib/tomo/configuration/plugins_registry/file_resolver.rb

@@ -0,0 +1,43 @@
+module Tomo
+  class Configuration
+    class PluginsRegistry::FileResolver
+      def self.resolve(path)
+        new(path).plugin_module
+      end
+
+      def initialize(path)
+        @path = path
+      end
+
+      def plugin_module
+        raise_file_not_found(path) unless File.file?(path)
+
+        Tomo.logger.debug("Loading plugin from #{path.inspect}")
+        script = IO.read(path)
+        plugin = define_anonymous_plugin_class
+        plugin.class_eval(script, path.to_s, 1)
+
+        plugin
+      end
+
+      private
+
+      attr_reader :path
+
+      def raise_file_not_found(path)
+        PluginFileNotFoundError.raise_with(path: path)
+      end
+
+      def define_anonymous_plugin_class
+        name = path.to_s
+        plugin = Class.new(TaskLibrary)
+        plugin.extend(PluginDSL)
+        plugin.send(:tasks, plugin)
+        plugin.define_singleton_method(:to_s) do
+          super().sub(/>$/, "(#{name})>")
+        end
+        plugin
+      end
+    end
+  end
+end