spiderfw 0.5

data/apps/webdav/lib/locking.rb

@@ -0,0 +1,193 @@
+require 'rubygems'
+require 'uuid'
+require 'spiderfw/utils/shared_store'
+
+module Locking
+	module ClassMethods; end
+	
+	def Locking.included(other)
+		other.extend(ClassMethods)
+	end
+	
+	class Lock
+		attr_reader :resource, :properties, :token, :created
+		
+		def initialize(resource, properties)
+			@resource = resource
+			@properties = properties
+			@created = Time.now
+			
+			@token = UUID.new.generate
+		end
+		
+		def [](key)
+			@properties[key]
+		end
+		
+		def method_missing(meth, *args)
+			@properties.include?(meth.to_sym) ? @properties[meth.to_sym] : nil
+		end
+		
+		# Overload type, because ruby already defines it
+		def type
+			@properties[:type]
+		end
+		
+		# Overload private timeout, who defines it, we don't know
+		def timeout
+			@properties[:timeout]
+		end
+		
+		def timeout=(val)
+		    @properties[:timeout] = val
+	    end
+	end
+	
+	module ClassMethods
+	    
+	    def lockstore
+			@lockstore ||= Spider::Utils::SharedStore.get(nil, :name => 'dav_locks')
+		end
+	    
+		def locking?
+			true
+		end
+		
+	end
+	
+	def locking?
+	    true
+    end
+
+    def lockstore
+        self.class.lockstore
+    end
+		
+		
+	def timeout=(timeout)
+		@timeout = timeout
+	end
+	
+	def locked?(resource, uid = nil)
+		resource = "/#{resource}" unless resource[0] == ?/
+		
+		# Check if resource is directly locked
+		return lockstore[resource] if lockstore.include?(resource)
+		
+		item = resource
+		depth = 0
+		
+		# Check if resource is indirectly locked
+		while true
+			item = File.split(item).first
+			
+			if lockstore.include?(item)
+				locks = check_timeout(item)
+				
+				locks.each do |lock|
+					return lock if (lock.depth == 'infinite' or lock.depth == depth)
+				end
+			end
+
+			break if item == '/'
+			depth += 1
+		end
+		
+		return nil
+	end
+	
+	def check_timeout(resource)
+		lockstore[resource].delete_if do |lock|
+		    if (lock.timeout && lock.timeout)
+		        if (lock.timeout =~ /Second-(\d+)/)
+		            t = Time.now
+		            t += $1.to_i
+		            return true if (Time.now - lock.created) < $1.to_i
+	            end
+            end
+            return false
+		end
+		
+		if lockstore[resource].empty?
+			lockstore.delete(resource)
+			[]
+		else
+			lockstore[resource]
+		end
+	end
+	
+	def child_locked?(resource, exclusive)
+		# This method checks if some child in resource is locked
+		lockstore.each_key do |key|
+			next unless key.index(resource) == 0
+
+			return true if exclusive
+			
+			
+			lockstore[key].each do |lock|
+				return true if lock.scope == 'exclusive'
+			end
+		end
+		
+		false
+	end
+	
+	def lock(resource, properties)
+		# Check for direct locks of #resource
+		locks = locked?(resource)
+		
+		if locks
+			locks.each do |lock|
+				return nil if (lock.scope == 'exclusive' || properties[:scope] == 'exclusive')
+			end
+		end
+		
+		# Check if something within #resource is already locked
+		return nil if child_locked?(resource, properties[:scope])
+		
+		if @timeout and not properties.include?(:timeout)
+			properties[:timeout] = @timeout
+		end
+		
+		touch(resource) if (!exists?(resource))
+		lock = Lock.new(resource, properties)
+		lockstore[resource] = [lock, lockstore[resource]].flatten.compact
+
+		lock
+	end
+	
+	def unlock_all(resource)
+		lockstore.delete(resource)
+	end
+	
+	def refresh(lock)
+		return if !lock.timeout || lock.timeout.downcase == 'infinite' || !@timeout
+		
+		lock.timeout += @timeout
+	end
+	
+	def unlock(resource, token, uid = nil)
+		locks = locked?(resource)
+		Spider::Logger.debug("UNLOCKING #{resource} WITH TOKEN #{token} AND UID #{uid}")
+		Spider::Logger.debug(locks)
+		match = nil
+
+		if locks
+			locks.each do |lock|
+				if lock.token == token and lock.uid == uid
+					match = lock
+					break
+				end
+			end
+		end
+		
+		Spider::Logger.error("NO MATCH FOR UNLOCK!") unless match
+		return false unless match
+		locks.delete(match)
+		
+		lockstore.delete(match.resource) if locks.empty?
+
+		true
+	end
+	
+end

data/apps/webdav/lib/vfs/abstract.rb

@@ -0,0 +1,78 @@
+require 'apps/webdav/lib/vfs/properties'
+require 'mime/types'
+
+module Spider; module WebDAV; module VFS
+    
+    class Abstract
+       
+       def self.locking?
+           false
+       end
+       
+       def self.config
+           {:MimeTypes => ::MIME::Types}
+       end
+       
+       def locking?
+           self.class.locking?
+       end
+       
+       def map_path(path)
+           path
+       end
+       
+       def stream(filename, acc)
+           raise NotImplementedError
+       end
+       
+		def iostream(filename)
+			stream(filename, "w+") {|f| yield f}
+		end
+		
+		def ostream(filename)
+			stream(filename, "w") {|f| yield f}
+		end
+		
+		def istream(filename)
+			stream(filename, "r") {|f| yield f}
+		end
+		
+		def directory?(path)
+		    raise NotImplementedError
+	    end
+	    
+	    def mkdir(path)
+	        raise NotImplementedError
+        end
+        
+        def rm(path)
+            raise NotImplementedError
+        end
+        
+        def copy(src, dest, recursive=true)
+            raise NotImplementedError
+        end
+        
+        def mv(src, dst)
+            raise NotImplementedError
+        end
+        
+        def exists?(filename)
+            raise NotImplementedError
+        end
+        
+        def ls(path)
+            raise NotImplementedError
+        end
+        
+        def filtered?(path)
+            return false
+        end
+        
+		def properties(path)
+			Properties.new(self, map_path(path))
+		end 
+        
+    end
+    
+end; end; end

data/apps/webdav/lib/vfs/local.rb

@@ -0,0 +1,126 @@
+require 'apps/webdav/lib/vfs/abstract'
+require 'apps/webdav/lib/locking'
+
+module Spider; module WebDAV; module VFS
+
+    class Local < Abstract
+        include Locking
+        
+        class Properties < VFS::Properties
+			def initialize(vfs, filename)
+				super
+                
+				@stat = File.exist?(@filename) ? File.lstat(@filename) : OpenStruct.new
+			end
+			
+			def ctime
+				@stat.ctime || Time.now
+			end
+			
+			def mtime
+				@stat.mtime || Time.now
+			end
+			
+			def etag
+				sprintf('%x-%x-%x', @stat.ino, self.size, self.mtime.to_i)
+			end
+			
+			def content_type
+				File.directory?(@filename) ? "httpd/unix-directory" : MIME::Types.type_for(@filename)[0].to_s
+			end
+			
+			def size
+				File.file?(@filename) or return 0
+				@stat.size
+			end
+			
+			def to_s
+			    "file #{@filename}, ctime #{ctime}, mtime #{mtime}"
+		    end
+		    
+		    def apache_org_executable
+		        raise PropertyNotFound.new(@filename) unless File.file?(@filename)
+		        return @stat.executable? ? 'T' : 'F'
+	        end
+		end
+
+        def initialize(path)
+            @base_path = path
+        end
+
+        def map_path(path)
+            path = '/' + path unless path[0].chr == '/'
+            res = @base_path+path
+            res
+        end
+
+        def stream(path, acc)
+            full_path = map_path(path)
+            File.touch(full_path) unless File.exist?(full_path)
+            File.open(full_path, acc){ |f| yield f } 
+        end
+        
+        def directory?(path)
+            File.directory?(map_path(path))
+        end
+        
+        def mkdir(path)
+            Dir.mkdir(map_path(path))
+        end
+        
+        def touch(path)
+            File.new(map_path(path), 'w').close
+        end
+        
+        def rm(path)
+            FileUtils.rm_rf(map_path(path))
+        end
+        
+        def cp(src, dst, recursive=true)
+            real_src = map_path(src)
+            real_dst = map_path(dst)
+            if directory?(src)
+				if recursive
+					FileUtils.cp_r(real_src, real_dest, {:preserve => true})
+				else
+					mkdir(real_dst)
+				
+					st = File.stat(real_src)
+				
+					begin
+						# Make sure that the new directory has the same
+						# access and modified time
+						File.utime(st.atime, st.mtime, real_dst)
+					rescue
+						# simply ignore
+					end
+				end
+			else
+				FileUtils.cp(real_src, real_dst, {:preserve => true})
+			end
+        end
+        
+        def mv(src, dst)
+            File.rename(map_path(src), map_path(dst))
+        end
+        
+        def exists?(path)
+            File.exists?(map_path(path))
+        end
+        
+        def ls(dirname)
+            Dir.entries(map_path(dirname)).each do |f|
+				next if f == ".." || f == "."
+				next if filtered?(f)
+		
+				yield f
+			end
+		end
+		
+		def properties(path)
+		    Properties.new(self, map_path(path))
+	    end
+
+    end
+
+end; end; end

data/apps/webdav/lib/vfs/mapped.rb

@@ -0,0 +1,235 @@
+require 'apps/webdav/lib/vfs/abstract'
+require 'apps/webdav/lib/locking'
+
+module Spider; module WebDAV; module VFS
+
+    class Mapped < Abstract
+        include Locking
+        attr_reader :name, :props
+
+        def initialize(name=nil)
+            @entries = {}
+            @name = name || '/'
+            @props = {
+                :ctime => Time.now,
+                :mtime => Time.now,
+                :size => 0,
+                :executable => false
+            }
+        end
+
+        def get(path)
+            return self unless path
+            path = path.sub(/^\/+/, '')
+            return self if (path.empty?)
+            first, rest = path.split('/', 2)
+            raise Errno::ENOENT unless self[first]
+            return [self[first], rest]
+        end
+
+        def [](name)
+            @entries[name]
+        end
+
+        def []=(name, value)
+            @entries[name] = value
+        end
+
+        def stream(path, acc)
+            return Errno::ENOENT if directory?(path)
+            vfs, rest = get(path)
+            vfs.stream(rest, acc){ |f| yield f }
+            # if (vfs.is_a?(MappedFile))
+            #     return File.open(vfs.real_path, acc){ |f| yield f } 
+            # else
+            #     
+            # end
+        end
+
+        def directory?(path)
+            vfs, rest = get(path)
+            return vfs.directory?(rest) if rest
+            return true if (vfs.is_a?(Mapped))
+            return false
+        end
+
+        def mkdir(path)
+            vfs, rest = get(path)
+            if (rest)
+                return vfs.mkdir(rest) if rest
+            end
+            return self[path] = Mapped.new(path)
+        end
+
+        def touch(path)
+            begin
+                vfs, rest = get(path)
+                return vfs.touch(rest)
+            rescue Errno::ENOENT
+                return self[path] = VirtualFile.new(path)
+            end
+        end
+
+        def rm(path)
+            vfs, rest = get(path)
+            return vfs.rm(rest) if rest
+            return @entries.delete(path)
+        end
+
+        def cp(src, dst, recursive=true)
+            raise Forbidden
+        end
+
+        def mv(src, dst)
+            raise Forbidden
+        end
+
+        def exists?(path)
+            begin
+                vfs, rest = get(path)
+            rescue Errno::ENOENT
+                return false
+            end
+            return vfs.exists?(rest) if rest
+            return true
+        end
+
+        def ls(path)
+            vfs, rest = get(path)
+            if (vfs == self)
+                do_ls { |f| yield f }
+                return
+            end
+            return vfs.ls(rest){ |f| yield f }
+        end
+
+        def do_ls
+            @entries.each do |f|
+                yield f
+            end
+        end
+
+        def properties(path)
+            vfs, rest = get(path)
+            return vfs.properties(rest) if rest
+            return MappedProperties.new(self, vfs) if (vfs.is_a?(Mapped))
+            return MappedFileProperties.new(self, vfs) if (vfs.is_a?(MappedFile))
+            return VirtualFileProperties.new(self, vfs) if (vfs.is_a?(VirtualFile))
+            raise Errno::ENOENT
+        end
+
+
+
+
+        class MappedProperties
+
+            def initialize(vfs, mapped)
+                @vfs = vfs
+                @mapped = mapped
+            end
+
+            def ctime
+                @mapped.props[:ctime]
+            end
+
+            def mtime
+                @mapped.props[:mtime]
+            end
+
+            def size
+                @mapped.props[:size]
+            end
+
+            def etag
+                sprintf('%x-%x-%x', 0, size, mtime.to_i)
+            end
+
+            def content_type
+                "httpd/unix-directory"
+            end
+            
+            def displayname
+                @mapped.name
+            end
+
+            def to_s
+                "file #{@filename}, ctime #{ctime}, mtime #{mtime}"
+            end
+
+            def apache_org_executable
+                return @mapped.props[:executable] ? 'T' : 'F'
+            end
+
+        end
+
+
+        class MappedFileProperties < VFS::Local::Properties
+
+            def initialize(vfs, mapped)
+                super(vfs, mapped.real_path)
+            end
+
+        end
+
+        class VirtualFileProperties < MappedProperties
+
+            def content_type
+                @mapped.props[:mime_type]
+            end
+
+        end
+
+
+    end
+
+    class MappedFile
+        attr_reader :name, :real_path, :props
+
+        def initialize(real_path, name='')
+            @name ||= File.basename(real_path)
+            @real_path = real_path
+            @props = {
+                :ctime => Time.now,
+                :mtime => Time.now,
+                :size => 0,
+                :executable => false
+            }
+        end
+
+        def stream(dummy_path, acc)
+            File.open(@real_path, acc){ |f| yield f }
+        end
+
+        def touch(dummy_path)
+            File.new(@real_path, 'w').close
+        end
+        
+        def rm
+            File.unlink(@real_path)
+        end
+
+    end
+
+    class VirtualFile
+        attr_reader :name, :props
+
+        def initialize(name)
+            @name = name
+            @props = {
+                :ctime => Time.now,
+                :mtime => Time.now,
+                :size => 0,
+                :executable => false
+            }
+        end
+
+        def stream
+        end
+
+        def touch
+            @props[:mtime] = Time.now
+        end 
+
+    end
+
+end; end; end

data/apps/webdav/lib/vfs/properties.rb

@@ -0,0 +1,41 @@
+module Spider; module WebDAV; module VFS
+    
+    class Properties
+		attr_reader :filename
+		
+		def initialize(vfs, filename)
+			@filename = filename
+			@vfs = vfs
+		end
+		
+		def displayname
+			File.basename(@filename)
+		end
+		
+		def ctime
+		end
+		
+		def mtime
+		end
+		
+		def etag
+		end
+		
+		def content_type
+			@vfs.directory?(@filename) ? "httpd/unix-directory" : "text/plain"
+		end
+		
+		def size
+			0
+		end
+		
+	end
+	
+	class PropertyNotFound < RuntimeError
+	    attr_reader :file
+	    def initialize(file=nil)
+	        @file = file
+        end
+    end
+	
+end; end; end

data/apps/worker/_init.rb

@@ -0,0 +1,13 @@
+module Spider
+
+    module Worker
+        @description = ""
+        @version = 0.1
+        @short_name = 'worker'
+        @path = File.dirname(__FILE__)
+        include Spider::App
+        @gem_dependencies = ['rufus-scheduler >2.0.0']
+    end
+    
+end
+