sabat-rudy 0.8.0

data/lib/rudy/scm.rb

@@ -0,0 +1,75 @@
+
+
+module Rudy
+  module SCM
+    
+    class NotAWorkingCopy < Rudy::Error
+      def message
+        "Not the root directory of a #{@obj} working copy"
+      end
+    end
+    class CannotCreateTag < Rudy::Error
+      def message
+        "There was an unknown problem creating a release tag (#{@obj})"
+      end
+    end
+    class DirtyWorkingCopy < Rudy::Error
+      def message
+        "Please commit local #{@obj} changes"
+      end
+    end
+    class RemoteError < Rudy::Error; end
+    class NoRemoteURI < Rudy::Error; end
+    class TooManyTags < Rudy::Error
+      def message; "Too many tag creation attempts!"; end
+    end
+    class NoRemotePath < Rudy::Error
+      def message 
+        "Add a path for #{@obj} in your routines config"
+      end
+    end
+    
+    
+    module ObjectBase
+      
+      
+      def raise_early_exceptions; raise "override raise_early_exceptions"; end
+      
+      # copied from routines/helper.rb
+      def execute_rbox_command(ret=nil, &command)
+        begin
+          ret = command.call
+          puts '  ' << ret.stdout.join("#{$/}  ") if !ret.stdout.empty?
+          print_response(ret)
+        rescue Rye::CommandError => ex
+          print_response(ex)
+          exit 12 unless keep_going?
+        rescue Rye::CommandNotFound => ex
+          STDERR.puts "  CommandNotFound: #{ex.message}".color(:red)
+          STDERR.puts ex.backtrace
+          exit 12 unless keep_going?
+        end
+
+        ret
+      end
+      
+      
+      private 
+        def keep_going?
+          Annoy.pose_question("  Keep going?\a ", /yes|y|ya|sure|you bet!/i, STDERR)
+        end
+      
+        def print_response(rap)
+          [:stderr].each do |sumpin|
+            next if rap.send(sumpin).empty?
+            STDERR.puts "  #{sumpin}: #{rap.send(sumpin).join("#{$/}  ")}".color(:red)
+          end
+          STDERR.puts "  Exit code: #{rap.exit_code}".color(:red) if rap.exit_code != 0
+        end
+        
+    end
+    
+  end
+end
+
+Rudy::Utils.require_glob(RUDY_LIB, 'rudy', 'scm', '*.rb')

data/lib/rudy/scm/git.rb

@@ -0,0 +1,217 @@
+
+require 'date'
+
+  
+module Rudy
+  module SCM
+    class GIT
+      require 'grit'
+      include Rudy::SCM::ObjectBase
+      include Grit
+      
+      attr_accessor :base_uri
+      attr_accessor :remote
+      attr_accessor :branch
+      attr_reader :repo
+      attr_reader :rbox
+      attr_reader :rtag
+      attr_reader :user
+      attr_reader :pkey
+      attr_reader :changes
+      
+      # * +args+ a hash of params from the git block in the routines config
+      # 
+      def initialize(args={})
+        args = {
+          :privatekey => nil,
+          :remote => :origin,
+          :branch => :master,
+          :user => :root,
+          :changes => :enforce,
+          :path => nil
+        }.merge(args)
+        @remote, @branch, @path = args[:remote], args[:branch], args[:path]
+        @user, @pkey, @changes = args[:user], args[:privatekey], args[:changes]
+        @repo = Repo.new(Dir.pwd) if GIT.working_copy?
+      end
+      
+      def engine; :git; end
+      
+      def liner_note
+        "%-40s  (git:%s:%s)" % [@rtag, @remote, @branch]
+      end
+      
+      def create_release(username=nil, msg=nil)
+        @rtag = find_next_rtag(username)
+        msg ||= 'Another Release by Rudy!'
+        msg.tr!("'", "''")
+        ret = Rye.shell(:git, "tag", @rtag)  # Use annotated? -a -m '#{msg}' 
+        raise ret.stderr.join($/) if ret.exit_code > 0
+        ret = Rye.shell(:git, "push") if @remote
+        raise ret.stderr.join($/) if ret.exit_code > 0
+        ret = Rye.shell(:git, "push #{@remote} #{rtag}") if @remote
+        raise ret.stderr.join($/) if ret.exit_code > 0
+        @rtag
+      end
+      
+      # rel-2009-03-05-user-rev
+      def find_next_rtag(username=nil)
+        now = Time.now
+        mon = now.mon.to_s.rjust(2, '0')
+        day = now.day.to_s.rjust(2, '0')
+        rev = "01"
+        criteria = ['rel', now.year, mon, day, rev]
+        criteria.insert(-2, username) if username
+        rev.succ! while valid_rtag?(criteria.join(Rudy::DELIM)) && rev.to_i < 50
+        raise TooManyTags if rev.to_i >= 50
+        criteria.join(Rudy::DELIM)
+      end
+      
+      def delete_rtag(rtag=nil)
+        rtag ||= @rtag
+        ret = execute_rbox_command { Rye.shell(:git, 'tag', :d, rtag) }
+        raise ret.stderr.join($/) if ret.exit_code > 0 # TODO: retest
+        # Equivalent to: "git push origin :tag-name" which deletes a remote tag
+        ret = execute_rbox_command { Rye.shell(:git, "push #{@remote} :#{rtag}") } if @remote
+        raise ret.stderr.join($/) if ret.exit_code > 0
+        true
+      end
+      
+      def create_remote_checkout(rbox)
+        
+        # Make sure the directory above the clone path exists 
+        # and that it's owned by the request user. 
+        rbox.mkdir(:p, File.dirname(@path)) 
+        rbox.chown(@user, File.dirname(@path)) 
+        
+        begin
+          original_user = rbox.user
+          rbox.switch_user(@user)
+          
+          if @pkey
+            # Try when debugging: ssh -vi path/2/pkey git@github.com
+            key = File.basename(@pkey)
+            homedir = rbox.getenv['HOME']
+            rbox.mkdir(:p, :m, '700', '.ssh') rescue nil # :p says keep quiet if it exists              
+            if rbox.file_exists?(".ssh/#{key}")
+              puts "  Remote private key #{key} already exists".colour(:red)
+            else
+              rbox.upload(@pkey, ".ssh/#{key}")
+            end
+            
+            ## NOTE: The following are two attempts at telling git which 
+            ## private key to use. Both fail. The only thing I could get
+            ## to work is modifying the ~/.ssh/config file. 
+            ##
+            ## This runs fine, but "git clone" doesn't care. 
+            ## git config --global --replace-all http.sslKey /home/delano/.ssh/id_rsa
+            ## rbox.git('config', '--global', '--replace-all', 'http.sslKey', "#{homedir}/.ssh/#{key}")
+            ##
+            ## "git clone" doesn't care about this either. Note that both these
+            ## config attempts come directly from the git-config man page:
+            ## http://www.kernel.org/pub/software/scm/git/docs/git-config.html
+            ## export GIT_SSL_KEY=/home/delano/.ssh/id_rsa
+            ## rbox.setenv("GIT_SSL_KEY", "#{homedir}/.ssh/#{key}")
+            
+            if rbox.file_exists?('.ssh/config')
+              rbox.cp('.ssh/config', ".ssh/config-previous")
+              ssh_config = rbox.download('.ssh/config')
+            end
+            
+            ssh_config ||= StringIO.new
+            ssh_config.puts $/, "IdentityFile #{homedir}/.ssh/#{key}"
+            puts "  Adding IdentityFile #{key} to #{homedir}/.ssh/config"
+            
+            rbox.upload(ssh_config, '.ssh/config')
+            rbox.chmod('0600', '.ssh/config')
+            
+          end
+          
+          # We need to add the host keys to the user's known_hosts file
+          # to prevent the git commands from failing when it raises the
+          # "Host key verification failed." messsage.
+          if rbox.file_exists?('.ssh/known_hosts')
+            rbox.cp('.ssh/known_hosts', ".ssh/known_hosts-previous")
+            known_hosts = rbox.download('.ssh/known_hosts')
+          end
+          known_hosts ||= StringIO.new
+          remote = get_remote_uri
+          host = URI.parse(remote).host rescue nil
+          host ||= remote.scan(/\A.+?@(.+?)\:/).flatten.first
+          known_hosts.puts $/, Rye.remote_host_keys(host)
+          puts "  Adding host key for #{host} to .ssh/known_hosts"
+
+          rbox.upload(known_hosts, '.ssh/known_hosts')
+          rbox.chmod('0600', '.ssh/known_hosts')
+
+          execute_rbox_command {
+            rbox.git('clone', get_remote_uri, @path)
+          }
+          rbox.cd(@path)
+          execute_rbox_command {
+            rbox.git('checkout', :b, @rtag)
+          }
+        rescue Rye::CommandError => ex
+          puts ex.message
+        ensure
+          # Return to the original user and directory
+          rbox.switch_user(original_user)
+          rbox.cd
+        end
+        
+      end
+      
+      
+      def get_remote_uri
+        ret = Rye.shell(:git, "config", "remote.#{@remote}.url")
+        ret.stdout.first
+      end
+      
+      # Check if the given remote is valid. 
+      #def has_remote?(remote)
+      #  success = false
+      #  (@repo.remotes || []).each do |r|
+      #  end
+      #  success
+      #end
+      
+      def valid_rtag?(tag)
+        # git tag -l tagname returns a 0 exit code and stdout is empty
+        # when a tag does not exit. When it does exist, the exit code
+        # is 0 and stdout contains the tagname. 
+        ret = Rye.shell(:git, 'tag', :l, tag)  
+        # change :l to :d for quick deleting above and return true
+        # OR: just change to :d to always recreate the same tag
+        (ret.exit_code == 0 && ret.stdout.to_s == tag)
+      end
+      
+      # Are all local changes committed?
+      def self.clean_working_copy?(path=Dir.pwd)
+        Rye.shell(:git, 'diff').stdout == []
+      end
+      def clean_working_copy?; GIT.clean_working_copy?; end
+      
+      def self.working_copy?(path=Dir.pwd)
+        (File.exists?(File.join(path, '.git')))
+      end
+      def working_copy?; GIT.working_copy?; end
+      
+      def raise_early_exceptions
+        raise NotAWorkingCopy, :git unless working_copy?
+        raise DirtyWorkingCopy, :git unless @changes.to_s == 'ignore' || clean_working_copy?
+        raise NoRemoteURI, "remote.#{@remote}.url not set" if get_remote_uri.nil?
+        raise NoRemotePath, :git if @path.nil?
+        raise PrivateKeyNotFound, @pkey if @pkey && !File.exists?(@pkey)
+        find_next_rtag # will raise exception is there's a problem
+        
+        # We can't check stuff that requires access to the machine b/c the 
+        # machine may not be running yet. These include:
+        # * Remote checkout path already exists
+        # * No git available
+        # ...
+        # If create_remote_checkout should fail, it should print a message
+        # about the release that was created and how to install it manually
+      end
+    end
+  end
+end

data/lib/rudy/scm/svn.rb

@@ -0,0 +1,110 @@
+
+require 'date'
+
+module Rudy
+  module SCM
+    class SVN
+      attr_accessor :base_uri
+      
+      attr_reader :changes
+      
+      def initialize(args={})
+        args = {
+          :privatekey => nil,
+          :base_uri => nil,
+          :user => :root,
+          :changes => :enforce,
+          :path => nil
+        }.merge(args)
+        @base_uri, @path = args[:base_uri], args[:path]
+        @user, @pkey, @changes = args[:user], args[:privatekey], args[:changes]
+      end
+      
+      def engine; :svn; end
+      
+      def liner_note
+        "%-40s  (svn:%s:%s)" % [@rtag, @base_uri, @branch]
+      end
+      
+      def create_release(username=nil, msg=nil)
+        local_uri, local_revision = local_info
+        rtag = find_next_rtag(username)
+        release_uri = "#{@base_uri}/#{rtag}"
+        msg ||= 'Another Release by Rudy!'
+        msg.tr!("'", "\\'")
+        cmd = "svn copy -m '#{msg}' #{local_uri} #{release_uri}"
+        
+        `#{cmd} 2>&1`
+        
+        release_uri
+      end
+      
+      def switch_working_copy(tag)
+        raise "Invalid release tag (#{tag})." unless valid_rtag?(tag)
+        `svn switch #{tag}`
+      end
+      
+      # rel-2009-03-05-user-rev
+      def find_next_rtag(username=nil)
+        now = Time.now
+        mon = now.mon.to_s.rjust(2, '0')
+        day = now.day.to_s.rjust(2, '0')
+        rev = "01"
+        criteria = ['rel', now.year, mon, day, rev]
+        criteria.insert(-2, username) if username
+        tag = criteria.join(Rudy::DELIM)
+        # Keep incrementing the revision number until we find the next one.
+        tag.succ! while (valid_rtag?("#{@base_uri}/#{tag}"))
+        tag
+      end
+      
+      def local_info
+        ret = Rye.shell(:svn, "info").join
+        # URL: http://some/uri/path
+        # Repository Root: http://some/uri
+        # Repository UUID: c5abe49d-53e4-4ea3-9314-89e1e25aa7e1
+        # Revision: 921
+        ret.scan(/URL: (http:.+?)\s*\n.+Revision: (\d+)/m).flatten
+      end
+      
+      def working_copy?(path)
+        (File.exists?(File.join(path, '.svn')))
+      end
+      
+      def valid_rtag?(uri)
+        ret = `svn info #{uri} 2>&1` || '' # Valid SVN URIs will return some info
+        (ret =~ /Repository UUID/) ? true : false
+      end
+      
+      # Are all local changes committed?
+      def self.clean_working_copy?(path=Dir.pwd)
+        Rye.shell(:svn, 'diff', '.').stdout == []
+      end
+      def clean_working_copy?; SVN.clean_working_copy?; end
+      
+      def self.working_copy?(path=Dir.pwd)
+        (File.exists?(File.join(path, '.svn')))
+      end
+      def working_copy?; SVN.working_copy?; end
+      
+      
+      def raise_early_exceptions
+        raise NotAWorkingCopy, :svn unless working_copy?
+        raise DirtyWorkingCopy, :svn unless @changes.to_s == 'ignore' || clean_working_copy?
+        #raise NoRemoteURI, "remote.#{@remote}.url not set" if get_remote_uri.nil?
+        raise NoRemotePath, :svn if @path.nil?
+        raise PrivateKeyNotFound, @pkey if @pkey && !File.exists?(@pkey)
+        find_next_rtag # will raise exception is there's a problem
+        
+        # We can't check stuff that requires access to the machine b/c the 
+        # machine may not be running yet. These include:
+        # * Remote checkout path already exists
+        # * No git available
+        # ...
+        # If create_remote_checkout should fail, it should print a message
+        # about the release that was created and how to install it manually
+      end
+      
+    end
+  end
+end

data/lib/rudy/utils.rb

@@ -0,0 +1,365 @@
+
+#require 'drydock/mixins'
+require 'socket'
+require 'open-uri'
+require 'date'
+
+require 'timeout'
+
+module Rudy
+  
+  # A motley collection of methods that Rudy loves to call!
+  module Utils
+    extend self
+    include Socket::Constants
+    
+    # Return the external IP address (the one seen by the internet)
+    def external_ip_address
+      ip = nil
+      begin
+        %w{solutious.com/ip/ myip.dk/ whatismyip.com }.each do |sponge| # w/ backup
+          ipstr = Net::HTTP.get(URI.parse("http://#{sponge}")) || ''
+          ip = /([0-9]{1,3}\.){3}[0-9]{1,3}/.match(ipstr).to_s
+          break if ip && !ip.empty?
+        end
+      rescue SocketError, Errno::ETIMEDOUT => ex
+        STDERR.puts "Connection Error. Check your internets!"
+      end
+      ip += "/32" if ip
+      ip
+    end
+    
+    # Return the local IP address which receives external traffic
+    # from: http://coderrr.wordpress.com/2008/05/28/get-your-local-ip-address/
+    # NOTE: This <em>does not</em> open a connection to the IP address. 
+    def internal_ip_address
+      # turn off reverse DNS resolution temporarily 
+      orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true   
+      ip = UDPSocket.open {|s| s.connect('75.101.137.7', 1); s.addr.last } # Solutious IP
+      ip += "/24" if ip
+      ip
+    ensure  
+      Socket.do_not_reverse_lookup = orig
+    end
+    
+    # Generates a canonical tag name in the form:
+    #     rudy-2009-12-31-01
+    # where r1 refers to the revision number that day
+    def generate_tag(revision=1)
+      n = DateTime.now
+      y = n.year.to_s.rjust(4, "20")
+      m = n.month.to_s.rjust(2, "0")
+      d = n.mday.to_s.rjust(2, "0")
+      "rudy-%4s-%2s-%2s-r%s" % [y, m, d, revision.to_s.rjust(2, "0")] 
+    end
+    
+    
+    
+    
+    # Determine if we're running directly on EC2 or
+    # "some other machine". We do this by checking if
+    # the file /etc/ec2/instance-id exists. This
+    # file is written by /etc/init.d/rudy-ec2-startup. 
+    # NOTE: Is there a way to know definitively that this is EC2?
+    # We could make a request to the metadata IP addresses. 
+    def Rudy.in_situ?
+      File.exists?('/etc/ec2/instance-id')
+    end
+
+
+    # Wait for something to happen. 
+    # * +duration+ seconds to wait between tries (default: 2).
+    # * +max+ maximum time to wait (default: 120). Throws an exception when exceeded.
+    # * +logger+ IO object to print +dot+ to.
+    # * +msg+ the message to print before executing the block. 
+    # * +bells+ number of terminal bells to ring. Set to nil or false to keep the waiter silent
+    #
+    # The +check+ block must return false while waiting. Once it returns true
+    # the waiter will return true too.
+    def waiter(duration=2, max=120, logger=STDOUT, msg=nil, bells=0, &check)
+      # TODO: Move to Drydock. [ed-why?]
+      raise "The waiter needs a block!" unless check
+      duration = 1 if duration < 1
+      max = duration*2 if max < duration
+      dot = '.'
+      begin
+        if msg && logger
+          logger.print msg 
+          logger.flush
+        end
+        Timeout::timeout(max) do
+          while !check.call
+            sleep duration
+            logger.print dot if logger.respond_to?(:print)
+            logger.flush if logger.respond_to?(:flush)
+          end
+        end
+      rescue Timeout::Error => ex
+        retry if Annoy.pose_question(" Keep waiting?\a ", /yes|y|ya|sure|you bet!/i, logger)
+        return false
+      end
+      
+      if msg && logger
+        logger.puts " done"
+        logger.flush
+      end
+      
+      Rudy::Utils.bell(bells, logger)
+      true
+    end
+
+    # Make a terminal bell chime
+    def bell(chimes=1, logger=nil)
+      chimes ||= 0
+      return unless logger
+      chimed = chimes.to_i
+      logger.print "\a"*chimes if chimes > 0 && logger
+      true # be like Rudy.bug()
+    end
+
+    # Have you seen that episode of The Cosby Show where Dizzy Gillespie... ah nevermind.
+    def bug(bugid, logger=STDERR)
+      logger.puts "You have found a bug! If you want, you can email".color(:red)
+      logger.puts 'rudy@solutious.com'.color(:red).bright << " about it. It's bug ##{bugid}.".color(:red)          
+      logger.puts "Continuing...".color(:red)
+      true # so we can string it together like: bug('1') && next if ...
+    end
+
+    # Is the given string +str+ an ID of type +identifier+? 
+    # * +identifier+ is expected to be a key from ID_MAP
+    # * +str+ is a string you're investigating
+    def is_id?(identifier, str)
+      return false unless identifier && str && known_type?(identifier)
+      identifier &&= identifier.to_sym
+      str &&= str.to_s.strip
+      str.split('-').first == Rudy::ID_MAP[identifier].to_s
+    end
+
+    # Returns the object type associated to +str+ or nil if unknown. 
+    # * +str+ is a string you're investigating
+    def id_type(str)
+      return false unless str
+      str &&= str.to_s.strip
+      (Rudy::ID_MAP.detect { |n,v| v == str.split('-').first } || []).first
+    end
+
+    # Is the given +key+ a known type of object?
+    def known_type?(key)
+      return false unless key
+      key &&= key.to_s.to_sym
+      Rudy::ID_MAP.has_key?(key)
+    end
+
+    # Returns the string identifier associated to this +key+
+    def identifier(key)
+      key &&= key.to_sym
+      return unless Rudy::ID_MAP.has_key?(key)
+      Rudy::ID_MAP[key]
+    end
+
+    # Return a string ID without the identifier. i.e. key-stage-app-root => stage-app-root
+    def noid(str)
+      el = str.split('-')
+      el.shift
+      el.join('-')
+    end
+    
+
+    # +msg+ The message to return as a banner
+    # +size+ One of: :normal (default), :huge
+    # +colour+ a valid 
+    # Returns a string with styling applying
+    def banner(msg, size = :normal, colour = :black)
+      return unless msg
+      banners = {
+        :huge => Rudy::Utils.without_indent(%Q(
+        =======================================================
+        =======================================================
+        !!!!!!!!!   %s   !!!!!!!!!
+        =======================================================
+        =======================================================)),
+        :normal => %Q(============  %s  ============)
+      }
+      size = :normal unless banners.has_key?(size)
+      #colour = :black unless Drydock::Console.valid_colour?(colour)
+      size, colour = size.to_sym, colour.to_sym
+      sprintf(banners[size], msg).bright.att(:reverse)
+    end
+
+    
+    # <tt>require</tt> a glob of files. 
+    # * +path+ is a list of path elements which is sent to File.join 
+    # and then to Dir.glob. The list of files found are sent to require. 
+    # Nothing is returned but LoadError exceptions are caught. The message
+    # is printed to STDERR and the program exits with 7. 
+    def require_glob(*path)
+      begin
+        # TODO: Use autoload
+        Dir.glob(File.join(*path.flatten)).each do |path|
+          require path
+        end
+      rescue LoadError => ex
+        puts "Error: #{ex.message}"
+        exit 7
+      end
+    end
+
+    # Checks whether something is listening to a socket. 
+    # * +host+ A hostname
+    # * +port+ The port to check
+    # * +wait+ The number of seconds to wait for before timing out. 
+    #
+    # Returns true if +host+ allows a socket connection on +port+. 
+    # Returns false if one of the following exceptions is raised:
+    # Errno::EAFNOSUPPORT, Errno::ECONNREFUSED, SocketError, Timeout::Error
+    #
+    def service_available?(host, port, wait=3)
+      begin
+        status = Timeout::timeout(wait) do
+          socket = Socket.new( AF_INET, SOCK_STREAM, 0 )
+          sockaddr = Socket.pack_sockaddr_in( port, host )
+          socket.connect( sockaddr )
+        end
+        true
+      rescue Errno::EAFNOSUPPORT, Errno::ECONNREFUSED, SocketError, Timeout::Error => ex
+        false
+      end
+    end
+    
+    
+    
+    # Capture STDOUT or STDERR to prevent it from being printed. 
+    #
+    #    capture(:stdout) do
+    #      ...
+    #    end
+    #
+    def capture(stream)
+      #raise "We can only capture STDOUT or STDERR" unless stream == :stdout || stream == :stderr
+      begin
+        stream = stream.to_s
+        eval "$#{stream} = StringIO.new"
+        yield
+        result = eval("$#{stream}").read
+      ensure
+        eval("$#{stream} = #{stream.upcase}")
+      end
+
+      result
+    end
+
+    # A basic file writer
+    def write_to_file(filename, content, mode, chmod=600)
+      mode = (mode == :append) ? 'a' : 'w'
+      f = File.open(filename,mode)
+      f.puts content
+      f.close
+      return unless Rudy.sysinfo.os == :unix
+      raise "Provided chmod is not a Fixnum (#{chmod})" unless chmod.is_a?(Fixnum)
+      File.chmod(chmod, filename)
+    end
+
+    # 
+    # Generates a string of random alphanumeric characters.
+    # * +len+ is the length, an Integer. Default: 8
+    # * +safe+ in safe-mode, ambiguous characters are removed (default: true):
+    #       i l o 1 0
+    def strand( len=8, safe=true )
+       chars = ("a".."z").to_a + ("0".."9").to_a
+       chars.delete_if { |v| %w(i l o 1 0).member?(v) } if safe
+       str = ""
+       1.upto(len) { |i| str << chars[rand(chars.size-1)] }
+       str
+    end
+    
+    # Returns +str+ with the leading indentation removed. 
+    # Stolen from http://github.com/mynyml/unindent/ because it was better.
+    def without_indent(str)
+      indent = str.split($/).each {|line| !line.strip.empty? }.map {|line| line.index(/[^\s]/) }.compact.min
+      str.gsub(/^[[:blank:]]{#{indent}}/, '')
+    end
+      
+    
+    
+    
+    ######### Everything below here is TO BE REMOVED. 
+    
+    # (TO BE REMOVED)
+    # TODO: This is old and nasty.
+    def scp_command(host, keypair, user, paths, to_path, to_local=false, verbose=false, printonly=false)
+
+      paths = [paths] unless paths.is_a?(Array)
+      from_paths = ""
+      if to_local
+        paths.each do |path|
+          from_paths << "#{user}@#{host}:#{path} "
+        end  
+        #puts "Copying FROM remote TO this machine", $/
+
+      else
+        to_path = "#{user}@#{host}:#{to_path}"
+        from_paths = paths.join(' ')
+        #puts "Copying FROM this machine TO remote", $/
+      end
+
+
+      cmd = "scp -r "
+      cmd << "-i #{keypair}" if keypair
+      cmd << " #{from_paths} #{to_path}"
+
+      puts cmd if verbose
+      printonly ? (puts cmd) : system(cmd)
+    end
+
+  end
+end
+
+# = RSSReader
+#
+# A rudimentary way to read an RSS feed as a hash.
+# Adapted from: http://snippets.dzone.com/posts/show/68
+#
+module Rudy::Utils::RSSReader
+  extend self
+  require 'net/http'
+  require 'rexml/document'
+  
+  # Returns a feed as a hash. 
+  # * +uri+ to RSS feed
+  def run(uri)
+    begin
+      xmlstr = Net::HTTP.get(URI.parse(uri))
+    rescue SocketError, Errno::ETIMEDOUT
+      STDERR.puts "Connection Error. Check your internets!"
+    end
+    
+    xml = REXML::Document.new xmlstr
+    
+    data = { :items => [] }
+    xml.elements.each '//channel' do |item|
+      item.elements.each do |e| 
+        n = e.name.downcase.gsub(/^dc:(\w)/,"\1").to_sym
+        next if n == :item
+        data[n] = e.text
+      end
+    end
+    
+    #data = {
+    #  :title    => xml.root.elements['channel/title'].text,
+    #  :link => xml.root.elements['channel/link'].text,
+    #  :updated => xml.root.elements['channel/lastBuildDate'].text,
+    #  :uri  => uri,
+    #  :items    => []
+    #}
+    #data[:updated] &&= DateTime.parse(data[:updated])
+    
+    xml.elements.each '//item' do |item|
+      new_items = {} and item.elements.each do |e| 
+        n = e.name.downcase.gsub(/^dc:(\w)/,"\1").to_sym
+        new_items[n] = e.text
+      end
+      data[:items] << new_items
+    end
+    data
+  end
+end