capistrano-sbt 0.0.7 → 0.1.0

data/README.md

@@ -26,29 +26,29 @@ This recipes will try to do following things during Capistrano `deploy:setup` an
 
 To build you sbt projects during Capistrano `deploy` tasks, add following in you `config/deploy.rb`. By default, sbt build will run after the Capistrano's `deploy:finalize_update`.
 
-    # in "config/deploy.rb"
-    require 'capistrano-sbt'
-    set(:sbt_version, '0.11.2') # sbt version to build project
+    # config/deploy.rb
+    require "capistrano-sbt"
 
 Following options are available to manage your sbt build.
 
- * `:sbt_use_extras` - Use [sbt-extras](https://github.com/paulp/sbt-extras) to manage sbt. `false` by default.
- * `:sbt_version` - Project sbt version. This value may be discarded if `sbt_use_extras` is turned `true`.
- * `:sbt_archive_url` - Download URL for specified sbt version. This value may be discarded if `sbt_use_extras` is turned `true`.
- * `:sbt_compile_locally` - compile project on localhost. false by default.
- * `:sbt_goals` - sbt commands and tasks to execute. default is "reload clean package".
- * `:sbt_update_settings` - update `*.sbt` or not. false by default.
- * `:sbt_update_settings_locally` - udate `*.sbt` or not on local compilation. false by default.
- * `:sbt_settings` - list of your optional `*.sbt` files
- * `:sbt_settings_local` - list of your optional `*.sbt` files in on local compilation.
- * `:sbt_settings_path` - the destination path of the optional `*.sbt` files.
- * `:sbt_settings_path_local` - the destination path of the optional `*.sbt` files.
- * `:sbt_template_path` - specify ERB template path for `*.sbt`.
- * `:sbt_java_home` - optional `JAVA_HOME` settings for sbt commands.
- * `:sbt_java_home_local` - optional `JAVA_HOME` settings for sbt commands in localhost.
- * `:sbt_extras_url` - Download URL of `sbt` script of sbt-extras.
- * `:sbt_extras_check_interval` - Check updates of sbt-extras every specified seconds. `86400` by default.
- * `:sbt_log_noformat` - Do not colorize sbt outputs. `true` by default.
+ * `:sbt_use_extras` - Use [sbt-extras](https://github.com/paulp/sbt-extras) to manage sbt. `true` by default.
+ * `:sbt_extras_url` - The download url of sbt-extras.
+ * `:sbt_version` - If `:sbt_use_extras` was set as `false`, download specified version of `sbt-launch.jar` and set it up as `sbt`. If no version was given, try loading version from `project/build.properties`.
+ * `:sbt_setup_remotely` - Setup `sbt` on remote servers. As same value as `:sbt_update_remotely` by default.
+ * `:sbt_setup_locally` - Setup `sbt` on local server. Asa same value as `:sbt_update_locally` by default.
+ * `:sbt_update_remotely` - Run `sbt` on remote servers. `true` by default.
+ * `:sbt_update_locally` - Run `sbt` on local server. `false` by default.
+ * `:sbt_goals` - The `sbt` commands and tasks to be be executed. Run `reload clean package` by default.
+ * `:sbt_project_path` - The project path to be built on remote servers.
+ * `:sbt_project_path_local` - The project path to be built on local server.
+ * `:sbt_settings` - List of optional `*.sbt` files for remote servers.
+ * `:sbt_settings_local` - List of optional `*.sbt` files for local server.
+ * `:sbt_template_path` - The local path where the templates of `*.sbt` are in. By default, searches from `config/templates`.
+ * `:sbt_settings_path` - The destination path of the optional `*.sbt` files.
+ * `:sbt_settings_path_local` - The destination path of the optional `*.sbt` files.
+ * `:sbt_java_home` - Optional `JAVA_HOME` settings for `sbt` on remote servers.
+ * `:sbt_java_home_local` - Optional `JAVA_HOME` settings for `sbt` on local server.
+ * `:sbt_log_noformat` - Do not colorize `sbt` outputs. `true` by default.
  * `:sbt_release_build` - Skip building on SNAPSHOT version. `false` by default.
 
 ## Contributing

data/capistrano-sbt.gemspec

@@ -13,9 +13,13 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "capistrano-sbt"
   gem.require_paths = ["lib"]
-  gem.version       = Capistrano::Sbt::VERSION
+  gem.version       = Capistrano::SBT::VERSION
 
   gem.add_dependency("capistrano")
-  gem.add_dependency("capistrano-file-resources", "~> 0.0.1")
-  gem.add_dependency("capistrano-file-transfer-ext", "~> 0.0.3")
+  gem.add_dependency("capistrano-file-resources", "~> 0.1.0")
+  gem.add_dependency("capistrano-file-transfer-ext", "~> 0.1.0")
+  gem.add_development_dependency("capistrano-jdk-installer", "~> 0.1.0")
+  gem.add_development_dependency("net-scp", "~> 1.0.4")
+  gem.add_development_dependency("net-ssh", "~> 2.2.2")
+  gem.add_development_dependency("vagrant", "~> 1.0.6")
 end

data/lib/capistrano-sbt.rb

@@ -2,267 +2,480 @@ require "capistrano-sbt/version"
 require "capistrano"
 require "capistrano/configuration/actions/file_transfer_ext"
 require "capistrano/configuration/resources/file_resources"
+require "tempfile"
 require "uri"
 
 module Capistrano
-  module Sbt
+  module SBT
     def self.extended(configuration)
       configuration.load {
         namespace(:sbt) {
-          _cset(:sbt_version, '0.12.2')
-          _cset(:sbt_group_id) {
-            case sbt_version
-            when /^0\.(?:7|10)\.\d+$/, /^0\.11\.[0-2]$/
-              'org.scala-tools.sbt'
+          _cset(:sbt_roles, [:app])
+          _cset(:sbt_tools_path) { File.join(shared_path, "tools", "sbt") }
+          _cset(:sbt_tools_path_local) { File.expand_path("tools/sbt") }
+          _cset(:sbt_archive_path) { sbt_tools_path }
+          _cset(:sbt_archive_path_local) { sbt_tools_path_local }
+          _cset(:sbt_path) {
+            if sbt_use_extras
+              File.join(sbt_tools_path, "sbt-extras")
             else
-              'org.scala-sbt'
+              File.join(sbt_tools_path, "sbt-#{sbt_version}")
             end
           }
-          _cset(:sbt_jar_url) {
-            "http://typesafe.artifactoryonline.com/typesafe/ivy-releases/#{sbt_group_id}/sbt-launch/#{sbt_version}/sbt-launch.jar"
-          }
-          _cset(:sbt_jar_file) {
-            File.join(shared_path, 'tools', 'sbt', "sbt-#{sbt_version}", File.basename(URI.parse(sbt_jar_url).path))
-          }
-          _cset(:sbt_jar_file_local) {
-            File.join(File.expand_path('.'), 'tools', 'sbt', "sbt-#{sbt_version}", File.basename(URI.parse(sbt_jar_url).path))
+          _cset(:sbt_path_local) {
+            if sbt_use_extras
+              File.join(sbt_tools_path_local, "sbt-extras")
+            else
+              File.join(sbt_tools_path_local, "sbt-#{sbt_version}")
+            end
           }
-          _cset(:sbt_use_extras, false)
+          _cset(:sbt_bin_path) { sbt_path }
+          _cset(:sbt_bin_path_local) { sbt_path_local }
+          _cset(:sbt_bin) { File.join(sbt_bin_path, "sbt") }
+          _cset(:sbt_bin_local) { File.join(sbt_bin_path_local, "sbt") }
+          _cset(:sbt_project_path) { release_path }
+          _cset(:sbt_project_path_local) { File.expand_path(".") }
+          _cset(:sbt_target_path) { File.join(sbt_project_path, "target") }
+          _cset(:sbt_target_path_local) { File.join(sbt_project_path_local, "target") }
+          _cset(:sbt_template_path) { File.expand_path("config/templates") }
+
+          ## sbt-extras
+          _cset(:sbt_use_extras, true)
           _cset(:sbt_extras_url, "https://raw.github.com/paulp/sbt-extras/master/sbt")
-          _cset(:sbt_extras_file) { File.join(shared_path, 'tools', 'sbt', 'sbt') }
-          _cset(:sbt_extras_file_local) { File.join(File.expand_path('.'), 'tools', 'sbt', 'sbt') }
-          _cset(:sbt_extras_check_interval, 86400)
-          _cset(:sbt_extras_check_timestamp) { (Time.now - sbt_extras_check_interval).strftime('%Y%m%d%H%M') }
-          _cset(:sbt_cmd) {
-            if fetch(:sbt_java_home, nil)
-              env = "env JAVA_HOME=#{sbt_java_home.dump}"
-              java = "#{sbt_java_home}/bin/java"
+          _cset(:sbt_extras_file) { File.join(sbt_tools_path, "sbt") }
+          _cset(:sbt_extras_file_local) { File.join(sbt_tools_path_local, "sbt") }
+          _cset(:sbt_extras_update_interval) {
+            if exists?(:sbt_extras_check_interval)
+              logger.info(":sbt_extras_check_interval has been deprecated. use :sbt_extras_update_interval instead.")
+              fetch(:sbt_extras_check_interval)
             else
-              env = ""
-              java = "java"
+              86400
             end
-            if sbt_use_extras
-              "#{env} #{sbt_extras_file} #{sbt_options.join(' ')}".strip
+          }
+          _cset(:sbt_extras_update_timestamp) { (Time.now - sbt_extras_update_interval).strftime("%Y%m%d%H%M") }
+
+          ## sbt-launch.jar
+          _cset(:sbt_project_sbt_version) {
+            begin
+              tempfile = Tempfile.new("capistrano-sbt")
+              download(File.join(sbt_project_path, "project", "build.properties"), tempfile.path)
+              tempfile.rewind()
+              tempfile.read().scan(/^sbt\.version=(.*)$/).map { |x| x.last }.last
+            rescue
+              nil
+            ensure
+              tempfile.close()
+            end
+          }
+          _cset(:sbt_project_sbt_version_local) {
+            begin
+              properties = File.read(File.join(sbt_project_path_local, "project", "build.properties"))
+              properties.scan(/^sbt\.version=(.*)$/).map { |x| x.last }.last
+            rescue
+              nil
+            end
+          }
+          _cset(:sbt_version) {
+            version ||= sbt_project_sbt_version if sbt_update_remotely
+            version ||= sbt_project_sbt_version_local if sbt_update_locally
+            version ||= "0.12.2"
+            logger.debug("Detected sbt version #{version}")
+            version
+          }
+          _cset(:sbt_group_id) {
+            case sbt_version
+            when /^0\.(?:7|10)\.\d+$/, /^0\.11\.[0-2]$/
+              "org.scala-tools.sbt"
             else
-              "#{env} #{java} -jar #{sbt_jar_file} #{sbt_options.join(' ')}".strip
+              "org.scala-sbt"
             end
           }
-          _cset(:sbt_cmd_local) {
-            if fetch(:sbt_java_home_local, nil)
-              env = "env JAVA_HOME=#{sbt_java_home_local.dump}"
-              java = "#{sbt_java_home_local}/bin/java"
+          _cset(:sbt_launch_jar_url) {
+            if exists?(:sbt_jar_url)
+              logger.info(":sbt_jar_url has been deprecated. use :sbt_launch_jar_url instead.")
+              fetch(:sbt_jar_url)
+            else
+              "http://typesafe.artifactoryonline.com/typesafe/ivy-releases/#{sbt_group_id}/sbt-launch/#{sbt_version}/sbt-launch.jar"
             end
-            if sbt_use_extras
-              "#{env} #{sbt_extras_file_local} #{sbt_options_local.join(' ')}".strip
+          }
+          _cset(:sbt_launch_jar) {
+            if exists?(:sbt_jar_file)
+              logger.info(":sbt_jar_file has been deprecated. use :sbt_launch_jar instead.")
+              fetch(:sbt_jar_file)
             else
-              "#{env} #{java} -jar #{sbt_jar_file_local} #{sbt_options_local.join(' ')}".strip
+              File.join(sbt_path, "sbt-launch.jar")
             end
           }
-          _cset(:sbt_project_path) {
-            release_path
+          _cset(:sbt_launch_jar_local) {
+            if exists?(:sbt_jar_file_local)
+              logger.info(":sbt_jar_file_local has been deprecated. use :sbt_launch_jar_local instead.")
+              fetch(:sbt_jar_file_local)
+            else
+              File.join(sbt_path_local, "sbt-launch.jar")
+            end
           }
-          _cset(:sbt_project_path_local) {
-            Dir.pwd
+          _cset(:sbt_launch_jar_script) {
+            (<<-EOS).gsub(/^\s*/, "")
+              #!/bin/sh -e
+              java -Xms512M -Xmx1536M -Xss1M -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=384M -jar `dirname $0`/sbt-launch.jar "$@"
+            EOS
           }
-          _cset(:sbt_target_path) {
-            File.join(sbt_project_path, 'target')
+
+          ## SBT environment
+          _cset(:sbt_common_environment, {})
+          _cset(:sbt_default_environment) {
+            environment = {}
+            environment["JAVA_HOME"] = fetch(:sbt_java_home) if exists?(:sbt_java_home)
+            environment["PATH"] = [ sbt_bin_path, "$PATH" ].join(":") if sbt_setup_remotely
+            _merge_environment(sbt_common_environment, environment)
           }
-          _cset(:sbt_target_path_local) {
-            File.join(sbt_project_path_local, File.basename(sbt_target_path))
+          _cset(:sbt_default_environment_local) {
+            environment = {}
+            environment["JAVA_HOME"] = fetch(:sbt_java_home_local) if exists?(:sbt_java_home_local)
+            environment["PATH"] = [ sbt_bin_path, "$PATH" ].join(":") if sbt_setup_locally
+            _merge_environment(sbt_common_environment, environment)
           }
-          _cset(:sbt_template_path, File.join(File.dirname(__FILE__), 'templates'))
-          _cset(:sbt_update_settings, false)
-          _cset(:sbt_update_settings_locally, false)
-          _cset(:sbt_settings_path) { File.join(sbt_project_path, 'sbt') }
-          _cset(:sbt_settings_path_local) { File.join(sbt_project_path_local, 'sbt') }
-          _cset(:sbt_settings, [])
-          _cset(:sbt_settings_local, [])
-          _cset(:sbt_cleanup_settings, [])
-          _cset(:sbt_cleanup_settings_local, [])
-          _cset(:sbt_compile_locally, false) # perform precompilation on localhost
+          _cset(:sbt_environment) { _merge_environment(sbt_default_environment, fetch(:sbt_extra_environment, {})) }
+          _cset(:sbt_environment_local) { _merge_environment(sbt_default_environment_local, fetch(:sbt_extra_environment_local, {})) }
+          def _command(cmdline, options={})
+            environment = options.fetch(:env, {})
+            if environment.empty?
+              cmdline
+            else
+              env = (["env"] + environment.map { |k, v| "#{k}=#{v.dump}" }).join(" ")
+              "#{env} #{cmdline}"
+            end
+          end
+          def command(cmdline, options={})
+            _command(cmdline, :env => sbt_environment.merge(options.fetch(:env, {})))
+          end
+          def command_local(cmdline, options={})
+            _command(cmdline, :env => sbt_environment_local.merge(options.fetch(:env, {})))
+          end
+          _cset(:sbt_cmd) { command("#{sbt_bin.dump} #{sbt_options.map { |x| x.dump }.join(" ")}") }
+          _cset(:sbt_cmd_local) { command_local("#{sbt_bin_local.dump} #{sbt_options_local.map { |x| x.dump }.join(" ")}") }
           _cset(:sbt_goals, %w(reload clean package))
           _cset(:sbt_common_options) {
             options = []
             if fetch(:sbt_log_noformat, true)
-              options << if sbt_use_extras
-                           "-no-colors"
-                         else
-                           "-Dsbt.log.noformat=true"
-                         end
+              if sbt_use_extras
+                options << "-no-colors"
+              else
+                options << "-Dsbt.log.noformat=true"
+              end
             end
             options
           }
-          _cset(:sbt_options) {
-            options = sbt_common_options + fetch(:sbt_extra_options, [])
+          _cset(:sbt_default_options) {
+            options = sbt_common_options.dup
             if sbt_update_settings
-              options << if sbt_use_extras
-                           "-sbt-dir #{sbt_settings_path}"
-                         else
-                           "-Dsbt.global.base=#{sbt_settings_path}"
-                         end
+              if sbt_use_extras
+                options += ["-sbt-dir", sbt_settings_path]
+              else
+                options << "-Dsbt.global.base=#{sbt_settings_path}"
+              end
             end
             options
           }
-          _cset(:sbt_options_local) {
-            options = sbt_common_options + fetch(:sbt_extra_options_local, [])
+          _cset(:sbt_default_options_local) {
+            options = sbt_common_options.dup
             if sbt_update_settings_locally
-              options << if sbt_use_extras
-                           "-sbt-dir #{sbt_settings_path_local}"
-                         else
-                           "-Dsbt.global.base=#{sbt_settings_path_local}"
-                         end
+              if sbt_use_extras
+                options += ["-sbt-dir", sbt_settings_path_local]
+              else
+                options << "-Dsbt.global.base=#{sbt_settings_path_local}"
+              end
             end
             options
           }
+          _cset(:sbt_options) { sbt_default_options + fetch(:sbt_extra_options, []) }
+          _cset(:sbt_options_local) { sbt_default_options_local + fetch(:sbt_extra_options_local, []) }
 
-          desc("Setup sbt.")
-          task(:setup, :roles => :app, :except => { :no_release => true }) {
-            transaction {
-              install
-              update_settings if sbt_update_settings
-              setup_locally if sbt_compile_locally
-            }
+          _cset(:sbt_setup_remotely) { sbt_update_remotely }
+          _cset(:sbt_setup_locally) { sbt_update_locally }
+          _cset(:sbt_update_remotely) { not(sbt_update_locally) }
+          _cset(:sbt_update_locally) { # perform update on localhost
+            if exists?(:sbt_compile_locally)
+              logger.info(":sbt_compile_locally has been deprecated. use :sbt_update_locally instead.")
+              fetch(:sbt_compile_locally, false)
+            else
+              false
+            end
           }
-          after 'deploy:setup', 'sbt:setup'
 
-          desc("Setup sbt locally.")
-          task(:setup_locally, :except => { :no_release => true }) {
-            transaction {
-              install_locally
-              update_settings_locally if sbt_update_settings_locally
+          if top.namespaces.key?(:multistage)
+            after "multistage:ensure", "sbt:setup_default_environment"
+          else
+            on :start do
+              if top.namespaces.key?(:multistage)
+                after "multistage:ensure", "sbt:setup_default_environment"
+              else
+                setup_default_environment
+              end
+            end
+          end
+
+          _cset(:sbt_environment_join_keys, %w(DYLD_LIBRARY_PATH LD_LIBRARY_PATH MANPATH PATH))
+          def _merge_environment(x, y)
+            x.merge(y) { |key, x_val, y_val|
+              if sbt_environment_join_keys.include?(key)
+                ( y_val.split(":") + x_val.split(":") ).uniq.join(":")
+              else
+                y_val
+              end
             }
+          end
+
+          task(:setup_default_environment, :roles => sbt_roles, :except => { :no_release => true }) {
+            if fetch(:sbt_setup_default_environment, true)
+              set(:default_environment, _merge_environment(default_environment, sbt_environment))
+            end
           }
 
-          def _install(options={})
+          def _invoke_command(cmdline, options={})
+            if options[:via] == :run_locally
+              run_locally(cmdline)
+            else
+              invoke_command(cmdline, options)
+            end
+          end
+
+          def _download_extras(uri, filename, options={})
             execute = []
-            if sbt_use_extras
-              extras_file = options.delete(:extras_file)
-              execute << "mkdir -p #{File.dirname(extras_file)}"
-              x = "/tmp/sbt-extras.#{$$}"
-              execute << "touch -t #{sbt_extras_check_timestamp} #{x}"
-              execute << "( test #{extras_file} -nt #{x} || wget --no-verbose -O #{extras_file} #{sbt_extras_url} )"
-              execute << "touch #{extras_file}"
-              execute << "rm -f #{x}"
-              execute << "( test -x #{extras_file} || chmod a+x #{extras_file} )"
+            execute << "mkdir -p #{File.dirname(filename).dump}"
+            if fetch(:sbt_update_extras, true)
+              execute << %{t=$(mktemp /tmp/sbt.XXXXXXXXXX)}
+              execute << %{touch -t #{sbt_extras_update_timestamp.dump} "$t"}
+              execute << %{( test #{filename.dump} -nt "$t" || wget --no-verbose -O #{filename.dump} #{uri.dump}; rm -f "$t" )}
+            else
+              execute << %{( test -f #{filename.dump} || wget --no-verbose -O #{filename.dump} #{uri.dump} )}
+            end
+            execute << %{( test -x #{filename.dump} || chmod 755 #{filename.dump} )}
+            _invoke_command(execute.join(" && "), options)
+          end
+
+          def _download_launch_jar(uri, filename, options={})
+            execute = []
+            execute << "mkdir -p #{File.dirname(filename).dump}"
+            execute << "( test -f #{filename.dump} || wget --no-verbose -O #{filename.dump} #{uri.dump} )"
+            _invoke_command(execute.join(" && "), options)
+          end
+
+          def _upload(filename, remote_filename, options={})
+            mode = options.delete(:mode)
+            _invoke_command("mkdir -p #{File.dirname(remote_filename).dump}", options)
+            transfer_if_modified(:up, filename, remote_filename, fetch(:sbt_upload_options, {}).merge(options))
+            if mode
+              mode = mode.is_a?(Numeric) ? mode.to_s(8) : mode.to_s
+              _invoke_command("chmod #{mode.dump} #{remote_filename.dump}", options)
+            end
+          end
+
+          def _install_extras(filename, options={})
+            # nop
+          end
+
+          def _install_launch_jar(jar, sbt, options={})
+            via = options.delete(:via)
+            if via == :run_locally
+              run_locally("mkdir -p #{File.dirname(sbt).dump}")
+              File.write(sbt, sbt_launch_jar_script)
+              run_locally("( test -x #{sbt.dump} || chmod 755 #{sbt.dump} )")
             else
-              jar_file = options.delete(:jar_file)
-              execute << "mkdir -p #{File.dirname(jar_file)}"
-              execute << "( test -f #{jar_file} || wget --no-verbose -O #{jar_file} #{sbt_jar_url} )"
-              execute << "test -f #{jar_file}"
+              safe_put(sbt_launch_jar_script, sbt, {:mode => "755", :run_method => via}.merge(options))
             end
-            execute.join(' && ')
           end
 
-          task(:install, :roles => :app, :except => { :no_release => true }) {
-            run(_install(:jar_file => sbt_jar_file, :extras_file => sbt_extras_file))
+          def _installed?(destination, options={})
+            sbt = File.join(destination, "sbt")
+            cmdline = "test -d #{destination.dump} && test -x #{sbt.dump}"
+            _invoke_command(cmdline, options)
+            true
+          rescue
+            false
+          end
+
+          ## setup
+          desc("Setup sbt.")
+          task(:setup, :roles => sbt_roles, :except => { :no_release => true }) {
+            transaction {
+              setup_remotely if sbt_setup_remotely
+              setup_locally if sbt_setup_locally
+            }
           }
+          after "deploy:setup", "sbt:setup"
 
-          task(:install_locally, :except => { :no_release => true }) {
-            run_locally(_install(:jar_file => sbt_jar_file_local, :extras_file => sbt_extras_file_local))
+          task(:setup_remotely, :roles => sbt_roles, :except => { :no_release => true }) {
+            if sbt_use_extras
+              _download_extras(sbt_extras_url, sbt_bin_local, :via => :run_locally)
+              _upload(sbt_bin_local, sbt_bin, :mode => "755")
+              unless _installed?(sbt_path)
+                _install_extras(sbt_bin)
+              end
+            else
+              _download_launch_jar(sbt_launch_jar_url, sbt_launch_jar_local, :via => :run_locally)
+              _upload(sbt_launch_jar_local, sbt_launch_jar, :mode => "644")
+              unless _installed?(sbt_path)
+                _install_launch_jar(sbt_launch_jar, sbt_bin)
+              end
+            end
+            _installed?(sbt_path)
+            update_settings if sbt_update_settings
+          }
+
+          desc("Setup sbt locally.")
+          task(:setup_locally, :roles => sbt_roles, :except => { :no_release => true }) {
+            if sbt_use_extras
+              _download_extras(sbt_extras_url, sbt_bin_local, :via => :run_locally)
+              unless _installed?(sbt_path_local, :via => :run_locally)
+                _install_extras(sbt_bin_local, :via => :run_locally)
+              end
+            else
+              _download_launch_jar(sbt_launch_jar_url, sbt_launch_jar_local, :via => :run_locally)
+              unless _installed?(sbt_path_local, :via => :run_locally)
+                _install_launch_jar(sbt_launch_jar_local, sbt_bin_local, :via => :run_locally)
+              end
+            end
+            _installed?(sbt_path_local, :via => :run_locally)
+            update_settings_locally if sbt_update_settings_locally
           }
 
-          task(:update_settings, :roles => :app, :except => { :no_release => true }) {
-            sbt_settings.each do |f|
-              safe_put(template(f, :path => sbt_template_path), File.join(sbt_settings_path, f))
+          _cset(:sbt_update_settings) { sbt_setup_remotely and not(sbt_settings.empty?) }
+          _cset(:sbt_update_settings_locally) { sbt_setup_locally and not(sbt_settings_local.empty?) }
+          _cset(:sbt_settings_path) { File.join(sbt_project_path, "sbt") } # sbt.global.base
+          _cset(:sbt_settings_path_local) { File.join(sbt_project_path_local, "sbt") } # sbt.global.base
+          _cset(:sbt_settings, [])
+          _cset(:sbt_settings_local) { sbt_settings }
+          task(:update_settings, :roles => sbt_roles, :except => { :no_release => true }) {
+            sbt_settings.each do |file|
+              safe_put(template(file, :path => sbt_template_path), File.join(sbt_settings_path, file))
             end
-            run("rm -f #{sbt_cleanup_settings.map { |x| x.dump }.join(' ')}") unless sbt_cleanup_settings.empty?
           }
 
-          task(:update_settings_locally, :except => { :no_release => true }) {
-            sbt_settings_local.each do |f|
-              File.write(File.join(sbt_settings_path_local, f), template(f, :path => sbt_template_path))
+          task(:update_settings_locally, :rols => sbt_roles, :except => { :no_release => true }) {
+            sbt_settings_local.each do |file|
+              destination = File.join(sbt_settings_path_local, file)
+              run_locally("mkdir -p #{File.dirname(destination).dump}")
+              File.write(destination, template(file, :path => sbt_template_path))
             end
-            run_locally("rm -f #{sbt_cleanup_settings_local.map { |x| x.dump }.join(' ')}") unless sbt_cleanup_settings_local.empty?
           }
 
+          ## update
           desc("Update sbt build.")
-          task(:update, :roles => :app, :except => { :no_release => true }) {
+          task(:update, :roles => sbt_roles, :except => { :no_release => true }) {
             transaction {
-              if sbt_compile_locally
-                update_locally
-              else
-                execute
-              end
+              update_remotely if sbt_update_remotely
+              update_locally if sbt_update_locally
             }
           }
-          after 'deploy:finalize_update', 'sbt:update'
+          _cset(:sbt_update_hook_type, :after)
+          _cset(:sbt_update_hook, "deploy:finalize_update")
+          on(:start) do
+            [ sbt_update_hook ].flatten.each do |hook|
+              send(sbt_update_hook_type, hook, "sbt:update") if hook
+            end
+          end
 
-          desc("Update sbt build locally.")
-          task(:update_locally, :except => { :no_release => true }) {
-            transaction {
-              execute_locally
-              upload_locally
-            }
+          task(:update_remotely, :roles => sbt_roles, :except => { :no_release => true }) {
+            execute_remotely
           }
 
-          def _sbt(cmd, path, goals=[])
-            "cd #{path.dump} && #{cmd} #{goals.map { |s| s.dump }.join(' ')}"
-          end
+          desc("Update sbt build locally.")
+          task(:update_locally, :roles => sbt_roles, :except => { :no_release => true }) {
+            execute_locally
+            upload_locally
+          }
 
-          def _sbt_parse_version(s)
+          def _parse_project_version(s)
             # FIXME: is there any better way to get project version?
             lastline = s.split(/(?:\r?\n)+/)[-1]
             lastline.split[-1]
           end
 
-          _cset(:sbt_release_build, false)
-          _cset(:sbt_snapshot_pattern, /-SNAPSHOT$/i)
           _cset(:sbt_project_version) {
-            _sbt_parse_version(capture(_sbt(sbt_cmd, sbt_project_path, ["show version"])))
+            _parse_project_version(sbt.exec(["show version"], :via => :capture))
           }
           _cset(:sbt_project_version_local) {
-            _sbt_parse_version(run_locally(_sbt(sbt_cmd_local, sbt_project_path_local, ["show version"])))
+            _parse_project_version(sbt.exec_locally(["show version"], :via => :capture_locally))
           }
-
-          def _validate_project_version(version_key)
-            if sbt_release_build
-              version = fetch(version_key)
-              if sbt_snapshot_pattern === version
-                abort("Skip to build project since \`#{version}' is a SNAPSHOT version.")
-              end
+          _cset(:sbt_snapshot_pattern, /-SNAPSHOT$/i)
+          def _validate_project_version(key)
+            if fetch(:sbt_release_build, false)
+              version = fetch(key)
+              abort("Skip to build project since \`#{version}' is a SNAPSHOT version.") if sbt_snapshot_pattern === version
             end
           end
 
           desc("Perform sbt build.")
-          task(:execute, :roles => :app, :except => { :no_release => true }) {
-            on_rollback {
-              run(_sbt(sbt_cmd, sbt_project_path, %w(clean)))
-            }
+          task(:execute, :roles => sbt_roles, :except => { :no_release => true }) {
+            execute_remotely
+          }
+
+          task(:execute_remotely, :roles => sbt_roles, :except => { :no_release => true }) {
+            on_rollback do
+              sbt.exec("clean")
+            end
             _validate_project_version(:sbt_project_version)
-            run(_sbt(sbt_cmd, sbt_project_path, sbt_goals))
+            sbt.exec(sbt_goals)
           }
 
           desc("Perform sbt build locally.")
-          task(:execute_locally, :roles => :app, :except => { :no_release => true }) {
+          task(:execute_locally, :roles => sbt_roles, :except => { :no_release => true }) {
             on_rollback {
-              run_locally(_sbt(sbt_cmd_local, sbt_project_path_local, %w(clean)))
+              sbt.exec_locally("clean")
             }
             _validate_project_version(:sbt_project_version_local)
-            cmdline = _sbt(sbt_cmd_local, sbt_project_path_local, sbt_goals)
-            logger.info(cmdline)
-            abort("execution failure") unless system(cmdline)
+            sbt.exec_locally(sbt_goals)
           }
 
-          _cset(:sbt_tar, 'tar')
-          _cset(:sbt_tar_local, 'tar')
-          _cset(:sbt_target_archive) {
-            "#{sbt_target_path}.tar.gz"
-          }
-          _cset(:sbt_target_archive_local) {
-            "#{sbt_target_path_local}.tar.gz"
-          }
-          task(:upload_locally, :roles => :app, :except => { :no_release => true }) {
-            on_rollback {
-              run("rm -rf #{sbt_target_path} #{sbt_target_archive}")
-            }
+          task(:upload_locally, :rolse => sbt_roles, :except => { :no_release => true }) {
+            on_rollback do
+              run("rm -rf #{sbt_target_path.dump}")
+            end
+            filename = "#{sbt_target_path_local}.tar.gz"
+            remote_filename = "#{sbt_target_path}.tar.gz"
             begin
-              run_locally("cd #{File.dirname(sbt_target_path_local)} && #{sbt_tar_local} chzf #{sbt_target_archive_local} #{File.basename(sbt_target_path_local)}")
-              upload(sbt_target_archive_local, sbt_target_archive)
-              run("cd #{File.dirname(sbt_target_path)} && #{sbt_tar} xzf #{sbt_target_archive} && rm -f #{sbt_target_archive}")
+              run_locally("cd #{File.dirname(sbt_target_path_local).dump} && tar chzf #{filename.dump} #{File.basename(sbt_target_path_local).dump}")
+              run("mkdir -p #{File.dirname(sbt_target_path).dump}")
+              top.upload(filename, remote_filename)
+              run("cd #{File.dirname(sbt_target_path).dump} && tar xzf #{remote_filename.dump}")
             ensure
-              run_locally("rm -f #{sbt_target_archive_local}")
+              run("rm -f #{remote_filename.dump}") rescue nil
+              run_locally("rm -f #{filename.dump}") rescue nil
             end
           }
+
+          def _exec_command(args=[], options={})
+            args = [ args ].flatten
+            sbt = options.fetch(:sbt, "sbt")
+            execute = []
+            execute << "cd #{options[:path].dump}" if options.key?(:path)
+            execute << "#{sbt} #{args.map { |x| x.dump }.join(" ")}"
+            execute.join(" && ")
+          end
+
+          ## public methods
+          def exec(args=[], options={})
+            cmdline = _exec_command(args, { :path => sbt_project_path, :sbt => sbt_cmd, :via => :run }.merge(options))
+            _invoke_command(cmdline, options)
+          end
+
+          def exec_locally(args=[], options={})
+            via = options.delete(:via)
+            cmdline = _exec_command(args, { :path => sbt_project_path_local, :sbt => sbt_cmd_local, :via => :run_locally }.merge(options))
+            if via == :capture_locally
+              _invoke_command(cmdline, options.merge(:via => :run_locally))
+            else
+              logger.trace("executing locally: #{cmdline.dump}")
+              elapsed = Benchmark.realtime do
+                system(cmdline)
+              end
+              if $?.to_i > 0 # $? is command exit code (posix style)
+                raise Capistrano::LocalArgumentError, "Command #{cmd} returned status code #{$?}"
+              end
+              logger.trace "command finished in #{(elapsed * 1000).round}ms"
+            end
+          end
         }
       }
     end
@@ -270,7 +483,7 @@ module Capistrano
 end
 
 if Capistrano::Configuration.instance
-  Capistrano::Configuration.instance.extend(Capistrano::Sbt)
+  Capistrano::Configuration.instance.extend(Capistrano::SBT)
 end
 
 # vim:set ft=ruby :