shuttle-deploy 0.2.0.beta1

data/lib/shuttle/runner.rb

@@ -0,0 +1,153 @@
+module Shuttle
+  class Runner
+    attr_reader :options
+    attr_reader :config_path
+    attr_reader :config, :target
+
+    def initialize(options)
+      @options     = options
+      @config_path = File.expand_path(options[:path])
+      @target      = options[:target]
+
+      if !File.exists?(config_path)
+        raise ConfigError, "Config file #{config_path} does not exist"
+      end
+
+      @config_path = config_path
+      @target = target
+    end
+
+    def load_config
+      data = File.read(config_path)
+
+      if config_path =~ /\.toml$/
+        parse_toml_data(data)
+      else
+        parse_yaml_data(data)
+      end
+    end
+
+    def parse_yaml_data(data)
+      Hashr.new(YAML.safe_load(data))
+    end
+
+    def parse_toml_data(data)
+      Hashr.new(TOML::Parser.new(data).parsed)
+    end
+
+    def validate_target(target)
+      if target.host.nil?
+        raise ConfigError, "Target host required"
+      end
+
+      if target.user.nil?
+        raise ConfigError, "Target user required"
+      end
+
+      if target.deploy_to.nil?
+        raise ConfigError, "Target deploy path required"
+      end
+    end
+
+    def execute(command)
+      @config = load_config
+
+      strategy = config.app.strategy || 'static'
+      if strategy.nil?
+        raise ConfigError, "Invalid strategy: #{strategy}"
+      end
+
+      if @config.target
+        server = @config.target
+      else
+        if @config.targets.nil?
+          raise ConfigError, "Please define deployment target"
+        end
+
+        server = @config.targets[target]
+        if server.nil?
+          raise ConfigError, "Target #{target} does not exist"
+        end
+      end
+
+      validate_target(server)
+
+      ssh = Net::SSH::Session.new(server.host, server.user, server.password)
+
+      if options[:log]
+        ssh.logger = Logger.new(STDOUT)
+      end
+
+      ssh.open
+
+      klass = Shuttle.const_get(strategy.capitalize) rescue nil
+
+      if klass.nil?
+        STDERR.puts "Invalid strategy: #{strategy}"
+        exit 1
+      end
+
+      integration = klass.new(config, ssh, server, target) 
+
+      command.gsub!(/:/,'_')
+      exit_code = 0
+      puts "\n"
+
+      puts "Shuttle v#{Shuttle::VERSION}\n"
+      puts "\n"
+      integration.log "Connected to #{server.user}@#{server.host}"
+      
+      if integration.respond_to?(command)
+        time_start = Time.now
+
+        begin
+          if integration.deploy_running?
+            deployer = ssh.read_file("#{integration.deploy_path}/.lock").strip
+            message = "Another deployment is running."
+            message << " Deployer: #{deployer}" if deployer.size > 0
+
+            integration.error(message)
+          end
+
+          integration.write_lock
+          integration.export_environment
+          integration.send(command.to_sym)
+          integration.write_revision
+
+        rescue DeployError => err
+          integration.cleanup_release
+          exit_code = 1
+        rescue SystemExit
+          # NOOP
+          exit_code = 0
+        rescue Interrupt
+          STDERR.puts "Interrupted by user. Aborting deploy..."
+          exit_code = 1
+        rescue Exception => err
+          integration.cleanup_release
+          integration.log("ERROR: #{err.message}", 'error')
+          exit_code = 1
+        ensure
+          integration.release_lock
+        end
+
+        if exit_code == 0
+          diff = (Float(Time.now - time_start) * 100).round / 100
+          duration = ChronicDuration.output(diff, :format => :short)
+          puts "\nExecution time: #{duration}\n"
+        end
+
+        puts "\n"
+        exit(exit_code)
+
+      else
+        raise ConfigError, "Invalid command: #{command}"
+      end
+
+      ssh.close
+    rescue Net::SSH::AuthenticationFailed
+      STDERR.puts "Authentication failed"
+      exit 1
+    end
+  end
+end

data/lib/shuttle/session.rb

@@ -0,0 +1,52 @@
+module Shuttle
+  class Session
+    attr_reader :config, :target
+
+    # Initialize a new session
+    # @param [Hashr] deploy config
+    # @param [String] deploy target
+    def initialize(config, target)
+      @config = config
+      @target = target
+    end
+
+    def validate
+      if config.app.strategy.nil?
+        raise ConfigError, "Deployment strategy is required"
+      end
+
+      if config.targets[target].nil?
+        raise ConfigError, "Target does not exist"
+      end
+    end
+
+    def run(command)
+      strategy = config.app.strategy
+      server = config.targets[target]
+
+      ssh = Net::SSH::Session.new(server.host, server.user, server.password)
+      ssh.open
+
+      klass = Shuttle.const_get(strategy.capitalize)
+      integration = klass.new(config, ssh, server, target)
+
+      if integration.deploy_running?
+        raise DeployError, "Another deployment is running"
+      end
+
+      begin
+        integration.write_lock
+        integration.send(command.to_sym)
+        integration.write_revision
+      rescue DeployError => err
+        integration.cleanup_release
+      rescue Exception => err
+        integration.cleanup_release
+      ensure
+        integration.release_lock
+      end
+
+      ssh.close
+    end
+  end
+end

data/lib/shuttle/support/bundler.rb

@@ -0,0 +1,45 @@
+module Shuttle
+  module Support
+    module Bundler
+      def bundle_path
+        shared_path('bundle')
+      end
+
+      def bundler_installed?
+        ssh.run("which bundle").success?
+      end
+
+      def bundler_version
+        ssh.capture("bundle --version").split(' ').last
+      end
+
+      def install_bundler
+        res = ssh.run("gem install bundler")
+
+        if res.success?
+          log "Bundler installed: #{bundler_version}"
+        else
+          error "Bundler install failed: #{res.output}"
+        end
+      end
+
+      def bundle_install
+        log "Installing dependencies with Bundler"
+
+        cmd = [
+          "bundle install",
+          "--quiet",
+          "--path #{bundle_path}",
+          "--binstubs",
+          "--deployment"
+        ].join(' ')
+
+        res = ssh.run("cd #{release_path} && #{cmd}", &method(:stream_output))
+
+        unless res.success?
+          error "Unable to run bundle: #{res.output}"
+        end
+      end
+    end
+  end
+end

data/lib/shuttle/support/foreman.rb

@@ -0,0 +1,7 @@
+module Shuttle
+  module Support::Foreman
+    def foreman_installed?
+      ssh.run("which foreman").success?
+    end
+  end
+end

data/lib/shuttle/support/thin.rb

@@ -0,0 +1,59 @@
+module Shuttle
+  module Support::Thin
+    def thin_config
+      config.thin || Hashr.new
+    end
+
+    def thin_host
+      thin_config.host || "127.0.0.1"
+    end
+
+    def thin_port
+      thin_config.port || "9000"
+    end
+
+    def thin_servers
+      thin_config.servers || 1
+    end
+
+    def thin_env
+      environment
+    end
+
+    def thin_options
+      [
+        "-a #{thin_host}",
+        "-p #{thin_port}",
+        "-e #{thin_env}",
+        "-s #{thin_servers}",
+        "-l #{shared_path('log/thin.log')}",
+        "-P #{shared_path('pids/thin.pid')}",
+        "-d"
+      ].join(' ')
+    end
+
+    def thin_start
+      log "Starting thin"
+
+      res = ssh.run("cd #{release_path} && ./bin/thin #{thin_options} start")
+
+      unless res.success?
+        error "Unable to start thin: #{res.output}"
+      end
+    end
+
+    def thin_stop
+      log "Stopping thin"
+
+      ssh.run("cd #{release_path} && ./bin/thin #{thin_options} stop")
+    end
+
+    def thin_restart
+      if ssh.file_exists?(shared_path("pids/thin.#{thin_port}.pid"))
+        thin_stop
+      end
+
+      thin_start
+    end
+  end
+end

data/lib/shuttle/target.rb

@@ -0,0 +1,23 @@
+module Shuttle
+  class Target
+    attr_reader :host, :user, :password
+    attr_reader :deploy_to
+
+    def initialize(hash)
+      @host      = hash[:host]
+      @user      = hash[:user]
+      @password  = hash[:password]
+      @deploy_to = hash[:deploy_to]
+    end
+
+    def connection
+      @connection ||= Net::SSH::Session.new(host, user, password)
+    end
+
+    def validate!
+      raise Shuttle::ConfigError, "Host required" if host.nil?
+      raise Shuttle::ConfigError, "User required" if user.nil?
+      raise Shuttle::ConfigError, "Deploy path required" if deploy_to.nil?
+    end
+  end
+end

data/lib/shuttle/tasks.rb

@@ -0,0 +1,264 @@
+require 'uri'
+
+module Shuttle
+  module Tasks
+    def setup
+      log "Preparing application structure"
+
+      execute_hook(:before_setup)
+
+      ssh.run "mkdir -p #{deploy_path}"
+      ssh.run "mkdir -p #{deploy_path('releases')}"
+      ssh.run "mkdir -p #{deploy_path('backups')}"
+      ssh.run "mkdir -p #{deploy_path('shared')}"
+      ssh.run "mkdir -p #{shared_path('tmp')}"
+      ssh.run "mkdir -p #{shared_path('pids')}"
+      ssh.run "mkdir -p #{shared_path('log')}"
+
+      execute_hook(:after_setup)
+    end
+
+    def deploy
+      setup
+      update_code
+      checkout_code
+      link_release
+      cleanup_releases
+    end
+
+    def keep_releases
+      config.app.keep_releases || 10
+    end
+
+    def update_code
+      if config.app.svn
+        return update_code_svn
+      end
+
+      error "Git is not installed" if !git_installed?
+      error "Git source url is not defined. Please define :git option first" if config.app.git.nil?
+
+      if ssh.directory_exists?(scm_path)
+        # Check if git remote has changed
+        current_remote = git_remote
+        
+        if current_remote != config.app.git
+          log("Git remote change detected. Using #{config.app.git}", 'warning')
+
+          res = ssh.run("cd #{scm_path} && git remote rm origin && git remote add origin #{config.app.git}")
+          if res.failure?
+            error("Failed to change git remote: #{res.output}")
+          end
+        end
+
+        log "Fetching latest code"
+        res = ssh.run "cd #{scm_path} && git pull origin master"
+
+        if res.failure?
+          error "Unable to fetch latest code: #{res.output}"
+        end
+      else
+        log "Cloning repository #{config.app.git}"
+        res = ssh.run "cd #{deploy_path} && git clone --depth 25 --recursive --quiet #{config.app.git} scm"
+
+        if res.failure?
+          error "Failed to clone repository: #{res.output}"
+        end
+      end
+
+      branch = config.app.branch || 'master'
+
+      ssh.run("cd #{scm_path} && git fetch")
+
+      log "Using branch '#{branch}'"
+      result = ssh.run("cd #{scm_path} && git checkout -m #{branch}")
+
+      if result.failure?
+        error "Failed to checkout #{branch}: #{result.output}"
+      end
+
+      if ssh.file_exists?("#{scm_path}/.gitmodules")
+        log "Updating git submodules"
+        result = ssh.run("cd #{scm_path} && git submodule update --init --recursive")
+
+        if result.failure?
+          error "Failed to update submodules: #{result.output}"
+        end
+      end
+    end
+
+    def update_code_svn
+      error "Subversion is not installed" if !svn_installed?
+      error "Subversion source is not defined. Please define :svn option first" if config.app.svn.nil?
+
+      url = URI.parse(config.app.svn)
+      repo_url = "#{url.scheme}://#{url.host}#{url.path}"
+
+      opts = ["--non-interactive", "--quiet"]
+
+      if url.user
+        opts << "--username #{url.user}"
+        opts << "--password #{url.password}" if url.password
+      end
+
+      if ssh.directory_exists?(scm_path)
+        log "Fetching latest code"
+
+        res = ssh.run("cd #{scm_path} && svn up #{opts.join(' ')}")
+        if res.failure?
+          error "Unable to fetch latest code: #{res.output}"
+        end
+      else
+        log "Cloning repository #{config.app.svn}"
+        res = ssh.run("cd #{deploy_path} && svn checkout #{opts.join(' ')} #{repo_url} scm")
+
+        if res.failure?
+          error "Failed to clone repository: #{res.output}"
+        end
+      end
+    end
+
+    def checkout_code(path=nil)
+      checkout_path = [release_path, path].compact.join('/')
+      res = ssh.run("cp -a #{scm_path} #{checkout_path}")
+      
+      if res.failure?
+        error "Failed to checkout code. Reason: #{res.output}"
+      else
+        ssh.run("cd #{release_path} && rm -rf $(find . | grep .git)")
+        ssh.run("cd #{release_path} && rm -rf $(find . -name .svn)")
+      end
+    end
+
+    def link_release
+      if !release_exists?
+        error "Release does not exist"
+      end
+
+      # Execute before link_release hook
+      execute_hook(:before_link_release)
+
+      log "Linking release"
+
+      # Check if `current` is a directory first
+      if ssh.run("unlink #{current_path}").failure?
+        ssh.run("rm -rf #{current_path}")
+      end
+
+      if ssh.run("ln -s #{release_path} #{current_path}").failure?
+        error "Unable to create symlink to current path"
+      end
+
+      ssh.run "echo #{version} > #{version_path}"
+
+      log "Release v#{version} has been deployed"
+
+      # Execute after link_release hook
+      execute_hook(:after_link_release)
+    end
+
+    def write_lock
+      ssh.run(%{echo #{deployer_hostname} > #{deploy_path}/.lock})
+    end
+
+    def release_lock
+      ssh.run("rm #{deploy_path}/.lock")
+    end
+
+    # Delete current session release
+    def cleanup_release
+      if ssh.directory_exists?(release_path)
+        ssh.run("rm -rf #{release_path}")
+      end
+    end
+
+    def cleanup_releases
+      ssh.run("cd #{deploy_path('releases')}")
+      ssh.run("count=`ls -1d [0-9]* | sort -rn | wc -l`")
+
+      count = ssh.capture("echo $count")
+
+      unless count.empty?
+        num = Integer(count) - Integer(keep_releases)
+
+        if num > 0
+          log "Cleaning up old releases: #{num}"
+
+          ssh.run("remove=$((count > #{keep_releases} ? count - #{keep_releases} : 0))")
+          ssh.run("ls -1d [0-9]* | sort -rn | tail -n $remove | xargs rm -rf {}")
+        end
+      end
+    end
+
+    def write_revision
+      if ssh.directory_exists?(deploy_path('scm'))
+        command = nil
+
+        if config.app.git
+          command = "git log --format='%H' -n 1"
+        elsif config.app.svn
+          command = "svn info |grep Revision: |cut -c11-"
+        end
+
+        if command
+          ssh.run("cd #{scm_path} && #{command} > #{release_path}/REVISION")
+        end
+      end
+    end
+
+    def export_environment
+      ssh.export_hash(
+        'DEPLOY_APPLICATION'  => config.app.name,
+        'DEPLOY_USER'         => target.user,
+        'DEPLOY_PATH'         => deploy_path,
+        'DEPLOY_RELEASE_PATH' => release_path,
+        'DEPLOY_CURRENT_PATH' => current_path,
+        'DEPLOY_SHARED_PATH'  => shared_path,
+        'DEPLOY_SCM_PATH'     => scm_path
+      )
+
+      if config.env?
+        log "Exporting environment variables"
+
+        config.env.each_pair do |k, v|
+          ssh.export(k, v)
+        end
+      end
+    end
+
+    def execute_hook(name)
+      if config.hooks && config.hooks[name]
+        execute_commands(config.hooks[name])
+      end
+    end
+
+    def deploy_running?
+      ssh.file_exists?("#{deploy_path}/.lock")
+    end
+
+    def connect
+      exec("ssh #{target.user}@#{target.host}")
+    end
+
+    def changes_at?(path)
+      result = ssh.run(%{diff -r #{current_path}/#{path} #{release_path}/#{path} 2>/dev/null})
+      result.success? ? false : true
+    end
+
+    def execute_commands(commands=[])
+      commands.flatten.compact.uniq.each do |cmd|
+        log %{Executing "#{cmd.strip}"}
+        command = cmd
+        command = "cd #{release_path} && #{command}" if ssh.directory_exists?(release_path)
+
+        result = ssh.run(command)
+
+        if result.failure?
+          error "Failed: #{result.output}"
+        else
+          stream_output(result.output)
+        end
+      end
+    end
+  end
+end

data/lib/shuttle/version.rb

@@ -0,0 +1,3 @@
+module Shuttle
+  VERSION = '0.2.0.beta1'
+end

data/lib/shuttle.rb

@@ -0,0 +1,35 @@
+require 'terminal_helpers'
+require 'net/ssh/session'
+require 'chronic_duration'
+require 'toml'
+require 'hashr'
+require 'yaml'
+require 'safe_yaml'
+require 'toml'
+require 'digest/sha1'
+require 'logger'
+
+require 'shuttle/version'
+require 'shuttle/errors'
+
+module Shuttle
+  autoload :Session,   'shuttle/session'
+  autoload :Runner,    'shuttle/runner'
+  autoload :Deploy,    'shuttle/deploy'
+  autoload :Tasks,     'shuttle/tasks'
+  autoload :Target,    'shuttle/target'
+  autoload :Helpers,   'shuttle/helpers'
+
+  autoload :Static,    'shuttle/deployment/static'
+  autoload :Php,       'shuttle/deployment/php'
+  autoload :Wordpress, 'shuttle/deployment/wordpress'
+  autoload :Ruby,      'shuttle/deployment/ruby'
+  autoload :Rails,     'shuttle/deployment/rails'
+  autoload :Nodejs,    'shuttle/deployment/nodejs'
+
+  module Support
+    autoload :Bundler, 'shuttle/support/bundler'
+    autoload :Foreman, 'shuttle/support/foreman'
+    autoload :Thin,    'shuttle/support/thin'
+  end
+end

data/shuttle-deploy.gemspec

@@ -0,0 +1,28 @@
+require File.expand_path('../lib/shuttle/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "shuttle-deploy"
+  s.version     = Shuttle::VERSION
+  s.summary     = "Minimalistic deployment tool"
+  s.description = "Minimalistic deployment tool for small and one-server applications"
+  s.homepage    = "https://github.com/sosedoff/shuttle"
+  s.authors     = ["Dan Sosedoff"]
+  s.email       = ["dan.sosedoff@gmail.com"]
+  
+  s.add_development_dependency 'rake',      '~> 10'
+  s.add_development_dependency 'rspec',     '~> 2.13'
+  s.add_development_dependency 'simplecov', '~> 0.7'
+
+  s.add_dependency 'net-ssh',          '~> 2.6'
+  s.add_dependency 'net-ssh-session',  '~> 0.1'
+  s.add_dependency 'terminal_helpers', '~> 0.1'
+  s.add_dependency 'chronic_duration', '~> 0.9'
+  s.add_dependency 'hashr',            '~> 0.0.22'
+  s.add_dependency 'safe_yaml',        '~> 0.9'
+  s.add_dependency 'toml',             '~> 0.0'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f)}
+  s.require_paths = ["lib"]
+end

data/spec/deploy_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Shuttle::Deploy do
+end

data/spec/fixtures/static.yml

@@ -0,0 +1,11 @@
+app:
+  name: application
+  git: git@hostname.com:repo.git
+  strategy: static
+
+targets:
+  staging:
+    host: localhost
+    user: deployer
+    password: password
+    deploy_to: /home/deployer