nutshell 1.0.0

data/History.txt

@@ -0,0 +1,5 @@
+=== 1.0.0 / 2010-09-28
+ 
+* 1 major enhancement
+ 
+  * First release!

data/Manifest.txt

@@ -0,0 +1,12 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/nutshell.rb
+lib/nutshell/remote_shell.rb
+lib/nutshell/shell.rb
+test/mocks/mock_object.rb
+test/mocks/mock_open4.rb
+test/test_helper.rb
+test/test_remote_shell.rb
+test/test_shell.rb

data/README.txt

@@ -0,0 +1,76 @@
+= Nutshell
+
+* http://github.com/yaksnrainbows/nutshell
+
+== DESCRIPTION:
+
+A light weight ssh client that wraps the ssh and rsync commands.
+
+== SYNOPSIS:
+
+  remote = Nutshell::RemoteShell.new "user@example.com"
+  remote.connected?
+  #=> false
+
+  remote.connect
+  remote.connected?
+  #=> <#ssh pid>
+
+  remote.call "whoami"
+  #=> "user"
+
+  remote.call "whoami", :sudo => true
+  #=> "root"
+
+  remote.upload "myfile.txt", "/tmp/myfile.txt"
+  remote.disconnect
+
+  remote.session do |remote|
+    remote.connected?
+    #=> <#ssh pid>
+
+    remote.tty!
+    # starts an interactive shell session
+  end
+
+  remote.connected?
+  #=> false
+  
+
+== REQUIREMENTS:
+
+* open4 gem
+
+* highline gem
+
+* Unix based OS
+
+== INSTALL:
+
+* gem install nutshell
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 FIX
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Rakefile

@@ -0,0 +1,46 @@
+# -*- ruby -*-
+require 'rubygems'
+require 'hoe'
+require 'rake'
+require 'rake/testtask'
+
+task :manifest do
+  manifest_file = "Manifest.txt"
+
+  gem_files = record_files do |f|
+    next if f =~ /^(tmp|pkg|deploy_scripts)/
+    puts(f)
+    true
+  end
+
+  gem_files.push(manifest_file)
+  gem_files = gem_files.uniq.sort.join("\n")
+
+  File.open(manifest_file, "w+") do |file|
+    file.write gem_files
+  end
+end
+
+def record_files(path="*", file_arr=[], &block)
+  Dir[path].each do |child_path|
+    if File.file?(child_path)
+      next if block_given? && !yield(child_path)
+      file_arr << child_path
+    end
+    record_files(child_path+"/*", file_arr, &block) if
+      File.directory?(child_path)
+  end
+  return file_arr
+end
+
+Hoe.plugin :isolate
+
+Hoe.spec 'nutshell' do |p|
+  developer('Jeremie Castagna', 'yaksnrainbows@gmail.com')
+  self.extra_deps << ['open4',    '>= 1.0.1']
+  self.extra_deps << ['highline', '>= 1.5.1']
+end
+
+# vim: syntax=Ruby
+
+

data/lib/nutshell.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'open4'
+require 'highline'
+
+require 'fileutils'
+require 'tmpdir'
+
+
+module Nutshell
+
+  VERSION = "1.0.0"
+
+  ##
+  # Temp directory used by various nutshell classes
+  # for uploads, checkouts, etc...
+  TMP_DIR = File.join Dir.tmpdir, "nutshell_#{$$}"
+  FileUtils.mkdir_p TMP_DIR
+
+
+  class TimeoutError < Exception; end
+  class CmdError < Exception; end
+  class ConnectionError < Exception; end
+
+
+  def self.config
+    @config ||= {}
+  end
+
+
+  def self.timeout
+    config[:timeout]
+  end
+
+
+  def self.interactive?
+    config[:interactive]
+  end
+
+
+  require 'nutshell/shell'
+  require 'nutshell/remote_shell'
+end

data/lib/nutshell/remote_shell.rb

@@ -0,0 +1,268 @@
+module Nutshell
+
+  ##
+  # 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/nutshell-%r%h:%p
+  #
+  # Setting session-persistant environment variables is supported by
+  # accessing the @env attribute.
+
+  class RemoteShell < Shell
+
+
+    ##
+    # The loop to keep the ssh connection open.
+    LOGIN_LOOP = "echo ok; echo ready; "+
+      "for (( ; ; )); do kill -0 $PPID && sleep 10 || exit; 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, :pid
+    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/nutshell-%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
+      execute build_remote_cmd(command_str, options), &block
+    end
+
+
+    ##
+    # Connect to host via SSH and return process pid
+
+    def connect
+      return true if connected?
+
+      cmd = ssh_cmd quote_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
+      @inn.close rescue nil
+      @out.close rescue nil
+      @err.close rescue nil
+
+      kill_process @pid, "HUP" rescue nil
+
+      @pid = nil
+    end
+
+
+    ##
+    # Download a file via rsync
+
+    def download from_path, to_path, options={}, &block
+      from_path = "#{@host}:#{from_path}"
+      execute rsync_cmd(from_path, to_path, options), &block
+    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
+      syscall "test -f #{filepath}"
+    end
+
+
+    ##
+    # Start an interactive shell with preset permissions and env.
+    # Optionally pass a command to be run first.
+
+    def tty! cmd=nil
+      sync do
+        cmd = [cmd, "sh -il"].compact.join " && "
+        cmd = quote_cmd cmd
+
+        pid = fork do
+          exec \
+            ssh_cmd(sudo_cmd(env_cmd(cmd)), :flags => "-t").to_a.join(" ")
+        end
+        Process.waitpid pid
+      end
+    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
+
+
+    ##
+    # Builds an ssh command with permissions, env, etc.
+
+    def build_remote_cmd cmd, options={}
+      cmd = sh_cmd   cmd
+      cmd = env_cmd  cmd
+      cmd = sudo_cmd cmd, options
+      cmd = ssh_cmd  cmd, options
+    end
+
+
+    ##
+    # Uploads a file via rsync
+
+    def upload from_path, to_path, options={}, &block
+      to_path = "#{@host}:#{to_path}"
+      execute rsync_cmd(from_path, to_path, options), &block
+    end
+
+
+    ##
+    # Figure out which rsync flags to use.
+
+    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
+
+
+    ##
+    # Creates an rsync command.
+
+    def rsync_cmd from_path, to_path, options={}
+      cmd  = ["rsync", build_rsync_flags(options), from_path, to_path]
+      cmd.flatten.compact.join(" ")
+    end
+
+
+    ##
+    # Wraps the command in an ssh call.
+
+    def ssh_cmd cmd, options=nil
+      options ||= {}
+
+      flags = [*options[:flags]].concat @ssh_flags
+
+      ["ssh", flags, @host, cmd].flatten.compact
+    end
+  end
+end
+