sunshine 1.0.0.pre

data/lib/sunshine/remote_shell.rb

@@ -0,0 +1,241 @@
+module Sunshine
+
+  ##
+  # Keeps an SSH connection open to a server the app will be deployed to.
+  # Deploy servers use the ssh command and support any ssh feature.
+  # By default, deploy servers use the ControlMaster feature to share
+  # socket connections, with the ControlPath = ~/.ssh/sunshine-%r%h:%p
+  #
+  # Setting session-persistant environment variables is supported by
+  # accessing the @env attribute.
+
+  class RemoteShell < Shell
+
+    class ConnectionError < FatalDeployError; end
+
+    ##
+    # The loop to keep the ssh connection open.
+    LOGIN_LOOP = "echo connected; echo ready; for (( ; ; )); do sleep 10; done"
+
+    LOGIN_TIMEOUT = 30
+
+
+    ##
+    # Closes all remote shell connections.
+
+    def self.disconnect_all
+      return unless defined?(@remote_shells)
+      @remote_shells.each{|rs| rs.disconnect}
+    end
+
+
+    ##
+    # Registers a remote shell for global access from the class.
+    # Handled automatically on initialization.
+
+    def self.register remote_shell
+      (@remote_shells ||= []) << remote_shell
+    end
+
+
+    attr_reader :host, :user
+    attr_accessor :ssh_flags, :rsync_flags
+
+
+    ##
+    # Remote shells essentially need a host and optional user.
+    # Typical instantiation is done through either of these methods:
+    #   RemoteShell.new "user@host"
+    #   RemoteShell.new "host", :user => "user"
+    #
+    # The constructor also supports the following options:
+    # :env:: hash - hash of environment variables to set for the ssh session
+    # :password:: string - password for ssh login; if missing the deploy server
+    #                      will attempt to prompt the user for a password.
+
+    def initialize host, options={}
+      super $stdout, options
+
+      @host, @user = host.split("@").reverse
+
+      @user ||= options[:user]
+
+      @rsync_flags = ["-azP"]
+      @rsync_flags.concat [*options[:rsync_flags]] if options[:rsync_flags]
+
+      @ssh_flags = [
+        "-o ControlMaster=auto",
+        "-o ControlPath=~/.ssh/sunshine-%r@%h:%p"
+      ]
+      @ssh_flags.concat ["-l", @user] if @user
+      @ssh_flags.concat [*options[:ssh_flags]] if options[:ssh_flags]
+
+      @pid, @inn, @out, @err = nil
+
+      self.class.register self
+    end
+
+
+    ##
+    # Runs a command via SSH. Optional block is passed the
+    # stream(stderr, stdout) and string data
+
+    def call command_str, options={}, &block
+      Sunshine.logger.info @host, "Running: #{command_str}" do
+        execute ssh_cmd(command_str, options), &block
+      end
+    end
+
+
+    ##
+    # Connect to host via SSH and return process pid
+
+    def connect
+      return @pid if connected?
+
+      cmd = ssh_cmd LOGIN_LOOP, :sudo => false
+
+      @pid, @inn, @out, @err = popen4(cmd.join(" "))
+      @inn.sync = true
+
+      data  = ""
+      ready = nil
+      start_time = Time.now.to_i
+
+      until ready || @out.eof?
+        data << @out.readpartial(1024)
+        ready = data =~ /ready/
+
+        raise TimeoutError if timed_out?(start_time, LOGIN_TIMEOUT)
+      end
+
+      unless connected?
+        disconnect
+        host_info = [@user, @host].compact.join("@")
+        raise ConnectionError, "Can't connect to #{host_info}"
+      end
+
+      @inn.close
+      @pid
+    end
+
+
+    ##
+    # Check if SSH session is open and returns process pid
+
+    def connected?
+      Process.kill(0, @pid) && @pid rescue false
+    end
+
+
+    ##
+    # Disconnect from host
+
+    def disconnect
+      return unless connected?
+
+      @inn.close rescue nil
+      @out.close rescue nil
+      @err.close rescue nil
+
+      kill_process @pid, "HUP"
+
+      @pid = nil
+    end
+
+
+    ##
+    # Download a file via rsync
+
+    def download from_path, to_path, options={}, &block
+      from_path = "#{@host}:#{from_path}"
+      Sunshine.logger.info @host, "Downloading #{from_path} -> #{to_path}" do
+        execute rsync_cmd(from_path, to_path, options), &block
+      end
+    end
+
+
+    ##
+    # Expand a path:
+    #   shell.expand_path "~user/thing"
+    #   #=> "/home/user/thing"
+
+    def expand_path path
+      dir = File.dirname path
+      full_dir = call "cd #{dir} && pwd"
+      File.join full_dir, File.basename(path)
+    end
+
+
+    ##
+    # Checks if the given file exists
+
+    def file? filepath
+      call("test -f #{filepath}") && true rescue false
+    end
+
+
+    ##
+    # Create a file remotely
+
+    def make_file filepath, content, options={}
+
+      temp_filepath =
+        "#{TMP_DIR}/#{File.basename(filepath)}_#{Time.now.to_i}#{rand(10000)}"
+
+      File.open(temp_filepath, "w+"){|f| f.write(content)}
+
+      self.upload temp_filepath, filepath, options
+
+      File.delete(temp_filepath)
+    end
+
+
+    ##
+    # Uploads a file via rsync
+
+    def upload from_path, to_path, options={}, &block
+      to_path = "#{@host}:#{to_path}"
+      Sunshine.logger.info @host, "Uploading #{from_path} -> #{to_path}" do
+        execute rsync_cmd(from_path, to_path, options), &block
+      end
+    end
+
+
+    private
+
+    def build_rsync_flags options
+      flags = @rsync_flags.dup
+
+      remote_rsync = 'rsync'
+      rsync_sudo = sudo_cmd remote_rsync, options
+
+      unless rsync_sudo == remote_rsync
+        flags << "--rsync-path='#{ rsync_sudo.join(" ") }'"
+      end
+
+      flags << "-e \"ssh #{@ssh_flags.join(' ')}\"" if @ssh_flags
+
+      flags.concat [*options[:flags]] if options[:flags]
+
+      flags
+    end
+
+
+    def rsync_cmd from_path, to_path, options={}
+      cmd  = ["rsync", build_rsync_flags(options), from_path, to_path]
+      cmd.flatten.compact.join(" ")
+    end
+
+
+    def ssh_cmd string, options={}
+      cmd = sh_cmd string
+      cmd = env_cmd cmd
+      cmd = sudo_cmd cmd, options
+
+      flags = [*options[:flags]].concat @ssh_flags
+
+      ["ssh", flags, @host, cmd].flatten.compact
+    end
+  end
+end

data/lib/sunshine/repo.rb

@@ -0,0 +1,128 @@
+module Sunshine
+
+  class RepoError < Exception; end
+
+  ##
+  # An abstract class to wrap simple basic scm features. The primary function
+  # of repo objects is to get information about the scm branch that is being
+  # deployed and to check it out on remote deploy servers:
+  #   svn = SvnRepo.new "svn://path/to/repo", :flags => "--ignore-externals"
+  #
+  # The :flags option can be a String or an Array and supports any scm
+  # checkout (or clone for git) options.
+
+  class Repo
+
+    ##
+    # Creates a new repo subclass object:
+    #   Repo.new_of_type :svn, "https://path/to/repo/tags/releasetag"
+    #   Repo.new_of_type :git, "user@gitbox.com:repo/path"
+
+    def self.new_of_type repo_type, url, options={}
+      repo = "#{repo_type.to_s.capitalize}Repo"
+      Sunshine.const_get(repo).new(url, options)
+    end
+
+
+    ##
+    # Looks for .git and .svn directories and determines if the passed path
+    # is a recognized repo. Does not check for RsyncRepo since it's a
+    # special case. Returns the appropriate repo object:
+    #   Repo.detect "path/to/svn/repo/dir"
+    #     #=> <SvnRepo @url="svn://url/of/checked/out/repo">
+    #   Repo.detect "path/to/git/repo/dir"
+    #     #=> <GitRepo, @url="git://url/of/git/repo", @branch="master">
+    #   Repo.detect "invalid/repo/path"
+    #     #=> nil
+
+    def self.detect path=".", shell=nil
+
+      if SvnRepo.valid? path, shell
+        info = SvnRepo.get_info path, shell
+        SvnRepo.new info[:url], info
+
+      elsif GitRepo.valid? path, shell
+        info = GitRepo.get_info path, shell
+        GitRepo.new info[:url], info
+      end
+    end
+
+
+    ##
+    # Gets repo information for the specified dir - Implemented by subclass
+
+    def self.get_info path=".", shell=nil
+      raise RepoError,
+        "The 'get_info' method must be implemented by child classes"
+    end
+
+
+    attr_reader :url
+
+    def initialize url, options={}
+      @scm = self.class.name.split("::").last.sub('Repo', '').downcase
+
+      @url   = url
+      @flags = [*options[:flags]].compact
+    end
+
+
+    ##
+    # Checkout code to a shell and return an info log hash:
+    #   repo.chekout_to server, "some/path"
+    #   #=> {:revision => 123, :committer => 'someone', :date => time_obj ...}
+
+    def checkout_to path, shell=nil
+      shell ||= Sunshine.shell
+
+      Sunshine.logger.info @scm,
+        "Checking out to #{shell.host} #{path}" do
+
+        Sunshine.dependencies.install @scm, :call => shell if
+          Sunshine.dependencies.exist? @scm
+
+        shell.call "test -d #{path} && rm -rf #{path} || echo false"
+        shell.call "mkdir -p #{path}"
+
+        do_checkout   path, shell
+        get_repo_info path, shell
+      end
+    end
+
+
+    ##
+    # Checkout the repo - implemented by subclass
+
+    def do_checkout path, shell
+      raise RepoError,
+        "The 'do_checkout' method must be implemented by child classes"
+    end
+
+
+    ##
+    # Get the name of the specified repo - implemented by subclass
+
+    def name
+      raise RepoError,
+        "The 'name' method must be implemented by child classes"
+    end
+
+
+    ##
+    # Returns the set scm flags as a string
+
+    def scm_flags
+      @flags.join(" ")
+    end
+
+
+    ##
+    # Returns the repo information as a hash.
+
+    def get_repo_info path=".", shell=nil
+      defaults = {:type => @scm, :url => @url, :path => path}
+
+      defaults.merge self.class.get_info(path, shell)
+    end
+  end
+end

data/lib/sunshine/repos/git_repo.rb

@@ -0,0 +1,122 @@
+module Sunshine
+
+  ##
+  # Simple wrapper for git repos. Constructor supports :tree option to
+  # specify either a branch or tree-ish to checkout:
+  #   git = GitRepo.new "git://mygitrepo.git", :tree => "tags/release001"
+
+  class GitRepo < Repo
+
+    LOG_FORMAT = [
+      ":revision: %H",
+      ":committer: %cn",
+      ":date: %cd",
+      ":message: %s",
+      ":refs: '%d'",
+      ":tree: %t"
+    ].join("%n")
+
+
+    ##
+    # Check if this is an svn repo
+
+    def self.valid? path="."
+       File.exist? File.join(path, ".git")
+    end
+
+
+    ##
+    # Get the repo info from the path to a checked out git repo
+
+    def self.get_info path=".", shell=nil
+      shell ||= Sunshine.shell
+
+      info = YAML.load git_log(path, shell)
+
+      info[:date]   = Time.parse info[:date]
+      info[:branch] = parse_branch info
+      info[:url]    = git_origin path, shell
+
+      info
+    rescue => e
+      raise RepoError, e
+    end
+
+
+    ##
+    # Returns the git logs for a path, formatted as yaml.
+
+    def self.git_log path, shell
+      git_options = "-1 --no-color --format=\"#{LOG_FORMAT}\""
+      shell.call "cd #{path} && git log #{git_options}"
+    end
+
+
+    ##
+    # Returns the fetch origin of the current git repo. Returns the path to a
+    # public git repo by default:
+    #   GitRepo.git_origin "/some/path", Sunshine.shell
+    #     #=> "git://myrepo/path/to/repo.git"
+    #   GitRepo.git_origin "/some/path", Sunshine.shell, false
+    #     #=> "user@myrepo:path/to/repo.git"
+
+    def self.git_origin path, shell, public_url=true
+      get_origin_cmd = "cd #{path} && git remote -v | grep \\(fetch\\)"
+
+      origin = shell.call get_origin_cmd
+      origin = origin.split(/\t|\s/)[1]
+
+      origin = make_public_url origin if public_url
+
+      origin
+    end
+
+
+    ##
+    # Returns the git url for a public checkout
+
+    def self.make_public_url git_url
+      url, protocol = git_url.split("://").reverse
+      url, user     = url.split("@").reverse
+
+      url.gsub!(":", "/") if !protocol
+
+      "git://#{url}"
+    end
+
+
+    attr_accessor :tree
+
+    def initialize url, options={}
+      super
+      @tree = options[:branch] || options[:tree] || "master"
+    end
+
+
+    def do_checkout path, shell
+      cmd = "cd #{path} && git clone #{@url} #{scm_flags} . && "+
+        "git checkout #{@tree}"
+      shell.call cmd
+    end
+
+
+    NAME_MATCH = /\/([^\/]+)\.git/
+
+    def name
+      @url.match(NAME_MATCH)[1]
+    rescue
+      raise RepoError, "Git url must match #{NAME_MATCH.inspect}"
+    end
+
+
+    private
+
+    def self.parse_branch response
+      refs = response[:refs]
+      return response[:tree] unless refs && !refs.strip.empty?
+
+      ref_names = refs.delete('()').gsub('/', '_')
+      ref_names.split(',').last.strip
+    end
+  end
+end

data/lib/sunshine/repos/rsync_repo.rb

@@ -0,0 +1,29 @@
+module Sunshine
+
+  ##
+  # Allows uploading code directly using rsync, instead of a scm.
+
+  class RsyncRepo < Repo
+
+    def self.get_info path=".", shell=nil
+      {}
+    end
+
+
+    def initialize url, options={}
+      super
+      @flags << "-r"
+    end
+
+
+    def do_checkout path, shell
+      shell.upload @url, path, :flags => @flags
+    end
+
+
+    def name
+      File.basename @url
+    end
+  end
+end
+

data/lib/sunshine/repos/svn_repo.rb

@@ -0,0 +1,78 @@
+module Sunshine
+
+  ##
+  # Simple scm wrapper for subversion control.
+
+  class SvnRepo < Repo
+
+    ##
+    # Check if this is an svn repo
+
+    def self.valid? path="."
+       git_svn?(path) || File.exist?(File.join(path, ".svn"))
+    end
+
+
+    ##
+    # Get the repo info from the path to a checked out svn repo
+
+    def self.get_info path=".", shell=nil
+      shell ||= Sunshine.shell
+
+      svn_url  = get_svn_url path, shell
+      response = svn_log svn_url, shell
+
+      info = {}
+
+      info[:url]       = svn_url
+      info[:revision]  = response.match(/revision="(.*)">/)[1]
+      info[:committer] = response.match(/<author>(.*)<\/author>/)[1]
+      info[:date]      = Time.parse response.match(/<date>(.*)<\/date>/)[1]
+      info[:message]   = response.match(/<msg>(.*)<\/msg>/m)[1]
+      info[:branch]    = svn_url.split("/").last
+
+      info
+    rescue => e
+      raise RepoError, e
+    end
+
+
+    ##
+    # Returns the svn logs as xml.
+
+    def self.svn_log path, shell
+      shell.call "svn log #{path} --limit 1 --xml"
+    end
+
+
+    ##
+    # Check if this is a git-svn repo.
+
+    def self.git_svn? path="."
+      File.exist? File.join(path, ".git/svn")
+    end
+
+
+    ##
+    # Get the svn url from a svn or git-svn checkout.
+
+    def self.get_svn_url path, shell
+      cmd = git_svn?(path) ? "git svn" : "svn"
+      shell.call("cd #{path} && #{cmd} info | grep ^URL:").split(" ")[1]
+    end
+
+
+    def do_checkout path, shell
+      shell.call "svn checkout #{scm_flags} #{@url} #{path}"
+    end
+
+
+    NAME_MATCH = /([^\/]+\/)+([^\/]+)\/(trunk|branches|tags)/
+
+    def name
+      @url.match(NAME_MATCH)[2]
+    rescue
+      raise RepoError, "Svn url must match #{NAME_MATCH.inspect}"
+    end
+  end
+end