redcar-dev 0.12.17dev

data/plugins/project/lib/project/adapters/local.rb

@@ -0,0 +1,82 @@
+module Redcar
+  class Project
+    module Adapters
+      class Local
+        def touch(new_file_path)
+          FileUtils.touch(new_file_path)
+        end
+
+        def mkdir(new_dir_path)
+          FileUtils.mkdir(new_dir_path)
+        end
+
+        def mv(path, new_path)
+          FileUtils.mv(path, new_path)
+          new_path = File.join(new_path, File.basename(path)) unless File.file?(new_path)
+          Manager.update_tab_for_path(path,new_path)
+        end
+
+        def file?(path)
+          File.file?(path)
+        end
+
+        def directory?(path)
+          # JRuby's File.directory? seems to have a problem with multi-byte strings
+          f = java.io.File.new(path.to_java)
+          f.directory?
+        end
+
+        def empty_directory?(path)
+          Dir.glob("#{path}/*", File::FNM_DOTMATCH).length <= 2
+        end
+
+        def fetch_contents(path, force=false)
+          Dir.glob("#{path}/*", File::FNM_DOTMATCH).map do |fn|
+            is_dir = directory?(fn)
+            hash = {
+              :fullname => fn,
+              :type => (is_dir ? :dir : :file),
+            }
+            if is_dir
+              hash[:empty] = empty_directory?(fn)
+            end
+            hash
+          end
+        end
+
+        def load(file)
+          File.open(file, 'rb') do |f|; f.read; end
+        end
+
+        def save(file, contents)
+          File.open(file, "wb") {|f| f.print contents }
+        end
+
+        def mtime(file)
+          File.mtime(file)
+        end
+
+        def exists?(file)
+          File.exists?(file)
+        end
+
+        def delete(file)
+          FileUtils.rm_rf(file) unless Trash.recycle(file)
+          Manager.update_tab_for_path(file)
+        end
+
+        def load_contents(file)
+          File.open(file, 'rb') do |f|; f.read; end
+        end
+
+        def save_contents(file)
+          File.open(file, "wb") {|f| f.print contents }
+        end
+
+        def refresh_operation(tree)
+          yield
+        end
+      end
+    end
+  end
+end

data/plugins/project/lib/project/adapters/remote.rb

@@ -0,0 +1,96 @@
+
+module Redcar
+  class Project
+    module Adapters
+      class Remote
+        class PathDoesNotExist < StandardError; end
+
+        PROTOCOLS = {
+          :ftp  => RemoteProtocols::FTP,
+          :sftp => RemoteProtocols::SFTP
+        }
+
+        attr_accessor :protocol, :host, :user, :password, :private_key_files
+
+        def initialize(protocol, host, user, password, private_key_files)
+          @protocol = protocol
+          @host = host
+          @user = user
+          @password = password
+          @private_key_files = private_key_files
+          target
+        end
+
+        def target
+          @target ||= PROTOCOLS[protocol].new(host, user, password, private_key_files)
+        end
+
+        def touch(file)
+          target.touch(file)
+        end
+
+        def mkdir(new_dir_path)
+          target.mkdir(new_dir_path)
+        end
+
+        def mv(path, new_path)
+          target.mv(path, new_path)
+          Manager.update_tab_for_path(path,new_path)
+        end
+
+        def mtime(file)
+          target.mtime(file)
+        end
+
+        def file?(path)
+          target.file?(path)
+        end
+
+        def directory?(path)
+          target.directory?(path)
+        end
+
+        def fetch_contents(path)
+          target.fetch_contents(path)
+        end
+
+        def load(file)
+          target.load(file)
+        end
+
+        def save(file, contents)
+          target.save(file)
+        end
+
+        def stat(file)
+          target.stat(file)
+        end
+
+        def delete(file)
+          target.delete(file)
+          Manager.update_tab_for_path(file)
+        end
+
+        def exists?(path)
+          target.exists?(path)
+        end
+
+        def load(file)
+          target.load(file)
+        end
+
+        def save(file, contents)
+          target.save(file, contents)
+        end
+
+        def refresh_operation(tree)
+          visible_paths = tree.visible_nodes.map {|n| n.path}
+          visible_dirs = visible_paths.map {|path| File.dirname(path) }.uniq
+          target.with_cached_directories(visible_dirs) do
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/project/lib/project/adapters/remote_protocols/ftp.rb

@@ -0,0 +1,93 @@
+
+module Redcar
+  class Project
+    module Adapters
+      module RemoteProtocols
+        class FTP < Protocol
+          class << self
+            def handle_error(e, host, user)
+              return "Authentication failed for user #{user} in ftp://#{host}" if e.is_a?(Net::FTPPermError)
+            end
+          end
+          
+          def connection
+            require 'net/ftp'
+            gem "net-ftp-list"
+            require 'net/ftp/list'
+            @connection ||= Net::FTP.open(host, user, password)
+          end
+          
+          def touch(file)
+            local_path, local_file = split_paths(file)
+
+            FileUtils.mkdir_p local_path
+            FileUtils.touch local_file
+
+            upload local_file, file
+          end
+
+          def mkdir(new_dir_path)
+            exec :mkdir, new_dir_path
+          end
+
+          def mv(path, new_path)
+            target = "#{new_path}/#{File.basename(path)}"
+            exec :rename, path, target
+          end
+          
+          def mtime(file)
+            if e = entry(file)
+              e[:mtime]
+            end
+          end
+          
+          def download(remote, local)
+            exec :get, remote, local
+          end
+          
+          def upload(local, remote)
+            exec :put, local, remote
+          end
+
+          def dir_listing(path)
+            contents = []
+            exec(:list, path) do |e|
+              entry = Net::FTP::List.parse(e)
+              name = entry.basename
+              type = "unknown"
+              type = "file" if entry.file?
+              type = "dir" if entry.dir?
+              
+              unless ['.', '..'].include?(name)
+                contents << { :fullname => "#{path}/#{name}", :name => "#{name}", :type => type, :mtime => entry.mtime }
+              end
+            end
+            
+            contents
+          end
+          
+          def is_folder(path)
+            exec(:chdir, path)
+            exec(:pwd) == path
+          end
+          
+          def with_cached_directories
+            yield
+          end
+          
+          private
+          
+          def exec(method, *args, &block)
+            begin
+              Redcar.timeout(10) do
+                connection.send(method, *args, &block)
+              end
+            rescue Redcar::TimeoutError
+              raise "#{host} connection timed out"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/project/lib/project/adapters/remote_protocols/protocol.rb

@@ -0,0 +1,94 @@
+
+module Redcar
+  class Project
+    module Adapters
+      module RemoteProtocols
+        class Protocol
+          attr_accessor :host, :user, :password, :private_key_files
+          
+          def initialize(host, user, password, private_key_files)
+            @host     = host
+            @user     = user
+            @password = password
+            @cache    = {}
+            @private_key_files = private_key_files
+            connection
+          end
+          
+          def exists?(path)
+            !!entry(path)
+          end
+          
+          def directory?(path)
+            return false unless entry = entry(path)
+            entry[:type] == :dir
+          end
+          
+          def file?(path)
+            return false unless entry = entry(path)
+            entry[:type] == :file
+          end
+          
+          def fetch_contents(path)
+            fetch(path)
+          end
+          
+          def load(file)
+            local_path, local_file = split_paths(file)
+
+            FileUtils.mkdir_p local_path
+            download file, local_file
+            File.open(local_file, 'rb') do |f|; f.read; end
+          end
+          
+          def save(file, contents)
+            local_path, local_file = split_paths(file)
+
+            ret = File.open(local_file, "wb") {|f| f.print contents }
+            upload local_file, file
+            
+            ret
+          end
+
+          private
+          
+          def cache(path)
+            @cache[path]
+          end
+
+          def check_folder(path)
+            parent = File.dirname(path)
+            if contents = cache(parent)
+              result = contents.find { |f| f[:fullname] == path }
+              return false unless result
+              result[:type] == :dir
+            else
+              is_folder(path)
+            end
+          end
+          
+          def split_paths(file)
+            base_temp = '/tmp'
+            file_name = File.basename(file)
+            path = File.dirname(file)
+
+            local_path = "#{base_temp}/#{host}#{path}"
+            local_file = "#{local_path}/#{file_name}"
+
+            [local_path, local_file]
+          end
+
+          def entry(file)
+            path = File.dirname(file)
+            contents = fetch(path)
+            contents.detect { |f| f[:fullname] == file }
+          end
+
+          def fetch(path)
+            dir_listing(path)
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/project/lib/project/adapters/remote_protocols/sftp.rb

@@ -0,0 +1,181 @@
+
+module Redcar
+  class Project
+    module Adapters
+      module RemoteProtocols
+        class SFTP < Protocol
+          class << self
+            def handle_error(e, host, user)
+              return "Authentication failed for user #{user} in sftp://#{host}" if e.is_a?(Net::SSH::AuthenticationFailed)
+            end
+          end
+
+          def connection
+            gem "net-ssh"
+            gem "net-sftp"
+            require 'net/ssh'
+            require 'net/sftp'
+            Redcar.timeout(10) do
+              @connection ||= Net::SSH.start(host, user, :password => password, :keys => private_key_files)
+            end
+          rescue OpenSSL::PKey::DSAError => error
+            puts "*** Warning, DSA keys not supported."
+            # Error with DSA key. Throw us back to a password input. Think this is because jopenssl bugs
+            # out on valid dsa keys.
+            raise Net::SSH::AuthenticationFailed, "DSA key-based authentication failed."
+          rescue Redcar::TimeoutError
+            raise "connection to #{host} timed out"
+          end
+          
+          def touch(file)
+            exec "touch \"#{escape(file)}\""
+          end
+
+          def mkdir(new_dir_path)
+            exec "mkdir -p \"#{escape(new_dir_path)}\""
+          end
+
+          def mv(path, new_path)
+            exec "mv \"#{escape(path)}\" \"#{escape(new_path)}\""
+          end
+          
+          def mtime(file)
+            sftp_exec(:stat!, file).mtime
+          end
+          
+          def download(remote, local)
+            sftp_exec(:download!, remote, local)
+          end
+          
+          def upload(local, remote)
+            sftp_exec(:upload!, local, remote)
+          end
+          
+          def delete(file)
+            sftp_exec(:remove, file)
+          end
+          
+          def use_cache?
+            @use_cache
+          end
+          
+          def dir_listing(path)
+            if use_cache?
+              if @cached_dirs[path]
+                return @cached_dirs[path]
+              end
+            end
+            
+            return [] unless result = retrieve_dir_listing(path)
+            process_dir_listing_response(result)
+          end
+          
+          def retrieve_dir_listing(path)
+            raise Adapters::Remote::PathDoesNotExist, "Path #{path} does not exist" unless check_folder(path)
+
+            exec %Q(
+              for file in #{path}/*; do 
+                test -f "$file" && echo "file|na|$file"
+                test -d "$file" && test $(find $file -maxdepth 1 | wc -l) -eq 1 && echo "dir|0|$file"
+                test -d "$file" && test $(find $file -maxdepth 1 | wc -l) -gt 1 && echo "dir|1|$file"
+              done
+            )
+          end
+          
+          def process_dir_listing_response(response)
+            contents = []
+            response.each do |line|
+              next unless line.include?('|')
+              type, empty_flag, name = line.chomp.split('|')
+              unless ['.', '..'].include?(name)
+                hash = { :fullname => name, :name => File.basename(name), :type => type.to_sym }
+                if type == "dir"
+                  hash[:empty] = (empty_flag == "0")
+                end
+                contents << hash
+              end
+            end
+            contents
+          end
+          
+          def exists?(path)
+            is_file(path) or is_folder(path)
+          end
+          
+          def is_folder(path)
+            result = exec(%Q(
+              test -d "#{path}" && echo y
+            )) 
+
+            result =~ /^y/ ? true : false
+          end
+          
+          def is_file(path)
+            result = exec(%Q(
+              test -f "#{path}" && echo y
+            )) 
+
+            result =~ /^y/ ? true : false
+          end
+          
+          def with_cached_directories(dirs)
+            @cached_dirs = list_dirs(dirs)
+            @use_cache = true
+            yield
+          ensure
+            @use_cache = false
+          end
+          
+          def list_dirs(dirs)
+            cmd = ""
+            dirs.each do |dir|
+              cmd << <<-SH
+                for file in #{dir}/*; do 
+                  test -f "$file" && echo "file|na|$file"
+                  test -d "$file" && test $(find "$file" -maxdepth 1 | wc -l) -eq 1 && echo "dir|0|$file"
+                  test -d "$file" && test $(find "$file" -maxdepth 1 | wc -l) -gt 1 && echo "dir|1|$file"
+                done
+              SH
+            end
+            response = exec(cmd)
+            listings = process_dir_listing_response(response)
+            hash = {}
+            listings.each do |listing|
+              (hash[File.dirname(listing[:fullname])] ||= []) << listing
+            end
+            hash
+          end
+          
+          private
+          
+          def escape(path)
+            path.gsub("\\", "\\\\").gsub("\"", "\\\"")
+          end
+          
+          def exec(what)
+            puts "exec: #{what.inspect}"
+            begin
+              Redcar.timeout(10) do
+                connection.exec!(what)
+              end
+            rescue Redcar::TimeoutError => e
+              connection.shutdown!
+              raise "#{host} connection timed out"
+            end
+          end
+          
+          def sftp_exec(method, *args)
+            begin
+              Redcar.timeout(10) do
+                connection.sftp.send(method, *args)
+              end
+            rescue Redcar::TimeoutError
+              connection.shutdown!
+              raise "#{host} connection timed out"
+            end
+          end
+        end
+      end
+    end
+  end
+end