vfs 0.0.4 → 0.1.0

data/lib/old/ssh.rb

@@ -1,11 +0,0 @@
-class Ssh
-  attr_reader :config
-  
-  
-  def setstat(path, options)
-    remote do |sh, sftp|
-      sftp.setstat! path, options
-    end
-  end
-  
-end

data/lib/rsh.rb

@@ -1,19 +0,0 @@
-raise 'ruby 1.9.2 or higher required!' if RUBY_VERSION < '1.9.2'
-
-require 'rsh/gems'
-
-require 'open3'
-
-require 'net/ssh'
-require 'net/sftp'
-
-%w(
-  support
-
-  drivers/abstract
-  drivers/local
-  drivers/ssh
-
-  box/marks
-  box
-).each{|f| require "rsh/#{f}"}

data/lib/rsh/box.rb

@@ -1,182 +0,0 @@
-module Rsh
-  class Box
-    include Marks
-    
-    attr_accessor :options
-    
-    def initialize options = {}
-      @options = options
-      options[:host] ||= 'localhost'
-    end
-    
-    def driver
-      unless @driver
-        klass = options[:host] == 'localhost' ? Drivers::Local : Drivers::Ssh
-        @driver = klass.new options
-      end
-      @driver
-    end
-    
-    def local_driver
-      @local_driver ||= Drivers::Local.new
-    end
-    
-    def bulk &b
-      driver.bulk &b
-    end
-    
-    def upload_file from_local_path, to_remote_path, options = {}
-      bulk do
-        raise "file '#{from_local_path}' not exists!" unless local_driver.file_exist? from_local_path
-        if driver.file_exist?(to_remote_path)
-          if options[:override]
-            driver.remove_file to_remote_path
-          else
-            raise "file '#{to_remote_path}' already exists!"
-          end
-        end        
-        driver.upload_file from_local_path, to_remote_path
-      end
-    end
-    
-    def download_file from_remote_path, to_local_path, options = {}
-      bulk do
-        raise "file #{from_remote_path} not exists!" unless driver.file_exist?(from_remote_path)
-        if local_driver.file_exist? to_local_path
-          if options[:override]
-            local_driver.remove_file to_local_path
-          else
-            raise "file #{to_local_path} already exists!" 
-          end
-        end
-        driver.download_file from_remote_path, to_local_path
-      end
-    end
-    
-    def remove_file remote_file_path, options = {}
-      bulk do
-        if driver.file_exist? remote_file_path
-          driver.remove_file remote_file_path
-        else
-          raise "file #{remote_file_path} not exists!" unless options[:silent]
-        end        
-      end
-    end
-    
-    def exist? remote_path
-      driver.exist? remote_path
-    end
-    
-    def file_exist? remote_file_path
-      driver.file_exist? remote_file_path
-    end
-    
-    def remove_directory remote_directory_path, options = {}
-      bulk do
-        if driver.directory_exist? remote_directory_path
-          driver.remove_directory remote_directory_path
-        else
-          raise "directory #{remote_directory_path} not exists!" unless options[:silent]
-        end
-      end
-    end
-    
-    def create_directory remote_path, options = {}
-      bulk do
-        if driver.directory_exist?(remote_path)
-          if options[:override]
-            driver.remove_directory remote_path
-            driver.create_directory remote_path
-          elsif options[:silent]
-            # do nothing
-          else
-            raise "directory '#{remote_path}' already exists!"
-          end
-        else
-          driver.create_directory remote_path
-        end        
-      end
-    end
-    
-    def directory_exist? remote_path
-      driver.directory_exist? remote_path
-    end
-    
-    def upload_directory from_local_path, to_remote_path, options = {}
-      bulk do
-        raise "directory '#{from_local_path}' not exists!" unless local_driver.directory_exist? from_local_path
-        if driver.directory_exist?(to_remote_path)
-          if options[:override]
-            driver.remove_directory to_remote_path
-          else
-            raise "directory '#{to_remote_path}' already exists!"
-          end
-        end        
-        driver.upload_directory from_local_path, to_remote_path
-      end
-    end
-    
-    def download_directory from_remote_path, to_local_path, options = {}
-      bulk do
-        raise "directory #{from_remote_path} not exists!" unless driver.directory_exist?(from_remote_path)
-        if local_driver.directory_exist? to_local_path
-          if options[:override]
-            local_driver.remove_directory to_local_path
-          else
-            raise "directory #{to_local_path} already exists!" 
-          end
-        end
-        driver.download_directory from_remote_path, to_local_path
-      end
-    end
-    
-    def with_tmp_dir &block
-      bulk do
-        tmp_dir = driver.generate_tmp_dir_name
-        begin   
-          remove_directory tmp_dir if directory_exist? tmp_dir
-          create_directory tmp_dir
-          block.call
-        ensure
-          remove_directory tmp_dir if directory_exist? tmp_dir
-        end
-      end
-    end
-    
-    def bash cmd, options = {}
-      ignore_stderr = options.delete :ignore_stderr
-      raise "invalid options :#{options.keys.join(', :')}" unless options.empty?
-      
-      code, stdout, stderr = exec cmd
-      unless code == 0
-        puts stdout
-        puts stderr
-        raise "can't execute '#{cmd}'!" 
-      end
-      unless stderr.empty? or ignore_stderr
-        puts stderr
-        raise "stderr not empty for '#{cmd}'!"
-      end
-      stdout + stderr
-    end
-    
-    def exec cmd
-      driver.exec cmd
-    end
-    
-    def home path = nil
-      @home ||= bash('cd ~; pwd').gsub("\n", '')    
-      "#{@home}#{path}"
-    end    
-    
-    def inspect
-      "<Box: #{options[:host]}>"
-    end
-    alias_method :to_s, :inspect
-
-    protected
-      def method_missing m, *a, &b
-        driver.send m, *a, &b
-      end
-  end
-end

data/lib/rsh/box/marks.rb

@@ -1,29 +0,0 @@
-module Rsh
-  module Marks
-    def mark key
-      ensure_mark_requrements!
-      bash "touch #{marks_dir}/#{key}"
-    end
-
-    def has_mark? key
-      ensure_mark_requrements!
-      file_exist? "#{marks_dir}/#{key}"
-    end
-    
-    def clear_marks
-      bash "rm -r #{marks_dir}"
-    end
-    
-    protected
-      def marks_dir
-        home "/.marks"
-      end
-
-      def ensure_mark_requrements!
-        unless @ensure_mark_requrements
-          create_directory marks_dir unless directory_exist? marks_dir
-          @ensure_mark_requrements = true
-        end
-      end
-  end
-end

data/lib/rsh/drivers/abstract.rb

@@ -1,15 +0,0 @@
-module Rsh
-  module Drivers
-    class Abstract
-      attr_reader :options
-    
-      def initialize options = {}
-        @options = options
-      end
-        
-      def generate_tmp_dir_name
-        "/tmp/ssh_tmp_dir_#{rand(10**6)}"
-      end
-    end
-  end
-end

data/lib/rsh/drivers/local.rb

@@ -1,48 +0,0 @@
-module Rsh
-  module Drivers
-    class Local < Abstract    
-      def upload_file from_local_path, to_remote_path
-        FileUtils.copy from_local_path, to_remote_path
-      end
-    
-      def download_file from_remote_path, to_local_path
-        FileUtils.copy from_remote_path, to_local_path
-      end
-    
-      def exist? remote_file_path
-        File.exist? remote_file_path
-      end
-    
-      alias_method :directory_exist?, :exist?
-      alias_method :file_exist?, :exist?
-    
-      def remove_file remote_file_path
-        File.delete remote_file_path
-      end    
-    
-      def create_directory path
-        Dir.mkdir path
-      end
-    
-      def remove_directory path
-        FileUtils.rm_r path
-      end
-      
-      def upload_directory from_local_path, to_remote_path
-        FileUtils.cp_r from_local_path, to_remote_path
-      end
-      
-      def download_directory from_remote_path, to_local_path
-        FileUtils.cp_r from_remote_path, to_local_path
-      end
-    
-      def exec command        
-        code, stdout, stderr = Open3.popen3 command do |stdin, stdout, stderr, waitth|  
-          [waitth.value.to_i, stdout.read, stderr.read]
-        end
-      
-        return code, stdout, stderr
-      end
-    end
-  end
-end

data/lib/rsh/drivers/ssh.rb

@@ -1,147 +0,0 @@
-module Rsh
-  module Drivers
-    class Ssh < Abstract
-      def initialize options = {}
-        super
-        raise "ssh options not provided!" unless options[:ssh]
-        raise "invalid ssh options!" unless options[:ssh].is_a?(Hash)
-      end
-    
-      def upload_file from_local_path, to_remote_path
-        sftp.upload! from_local_path, fix_path(to_remote_path)
-      end
-
-      def download_file from_remote_path, to_local_path
-        File.open to_local_path, "w" do |out|
-          sftp.download! fix_path(from_remote_path), out #, :recursive => true          
-        end
-      end
-
-      def exist? remote_file_path
-        begin
-          fattrs = sftp.stat! fix_path(remote_file_path)
-          fattrs.directory? or fattrs.file? or fattrs.symlink?
-        rescue Net::SFTP::StatusException
-          false
-        end
-      end
-      alias_method :directory_exist?, :exist?
-      alias_method :file_exist?, :exist?
-
-      def remove_file remote_file_path
-        sftp.remove! fix_path(remote_file_path)
-      end
-
-      def exec command
-        remote do |ssh, sftp|
-          # somehow net-ssh doesn't executes ~/.profile, so we need to execute it manually
-          # command = ". ~/.profile && #{command}"
-
-          stdout, stderr, code, signal = hacked_exec! ssh, command
-
-          return code, stdout, stderr
-        end
-      end    
-    
-      def open      
-        ssh_options = self.options[:ssh].clone
-        host = options[:host] || raise('host not provided!')
-        user = ssh_options.delete(:user) || raise('user not provied!')
-        @ssh = Net::SSH.start(host, user, ssh_options)
-        @sftp = @ssh.sftp.connect
-      end
-    
-      def close
-        @ssh.close
-        # @sftp.close not needed
-        @ssh, @sftp = nil
-      end
-        
-      def create_directory path
-        remote do |ssh, sftp|          
-          sftp.mkdir! path
-          # exec "mkdir #{path}"
-        end        
-      end
-    
-      def remove_directory path
-        exec "rm -r #{path}"
-      end
-      
-      def upload_directory from_local_path, to_remote_path
-        remote do |ssh, sftp|
-          sftp.upload! from_local_path, fix_path(to_remote_path)
-        end
-      end
-      
-      def download_directory from_remote_path, to_local_path
-        remote do |ssh, sftp|
-          sftp.download! fix_path(from_remote_path), to_local_path, :recursive => true
-        end
-      end
-    
-      protected
-        def fix_path path
-          path.sub(/^\~/, home)
-        end
-        
-        def home
-          unless @home
-            command = 'cd ~; pwd'
-            code, stdout, stderr = exec command
-            raise "can't execute '#{command}'!" unless code == 0
-            @home = stdout.gsub("\n", '')    
-          end
-          @home
-        end
-      
-        # taken from here http://stackoverflow.com/questions/3386233/how-to-get-exit-status-with-rubys-netssh-library/3386375#3386375
-        def hacked_exec!(ssh, command, &block)
-          stdout_data = ""
-          stderr_data = ""
-          exit_code = nil
-          exit_signal = nil
-        
-          channel = ssh.open_channel do |channel|
-            channel.exec(command) do |ch, success|
-              raise "could not execute command: #{command.inspect}" unless success
-
-              channel.on_data{|ch2, data| stdout_data << data}
-              channel.on_extended_data{|ch2, type, data| stderr_data << data}
-              channel.on_request("exit-status"){|ch,data| exit_code = data.read_long}
-              channel.on_request("exit-signal"){|ch, data| exit_signal = data.read_long}
-            end          
-          end  
-        
-          channel.wait      
-        
-          [stdout_data, stderr_data, exit_code, exit_signal]
-        end
-    
-        def remote(&block)
-          if @ssh
-            block.call @ssh, @sftp
-          else            
-            # Rails.logger.info "Connecting to remote Hadoop #{options[:user]}@#{options[:host]}"          
-            begin
-              open
-              block.call @ssh, @sftp
-            ensure
-              close
-            end
-                              
-            # Net::SSH.start options[:host], options[:user], :config => true do |ssh|
-            #   ssh.sftp.connect do |sftp|
-            #     begin
-            #       @ssh, @sftp = ssh, sftp
-            #       block.call @ssh, @sftp
-            #     ensure
-            #       @ssh, @sftp = nil
-            #     end
-            #   end
-            # end
-          end
-        end
-    end
-  end
-end