dav4rack 0.2.11 → 0.3.0

data/lib/dav4rack/file.rb

@@ -17,7 +17,7 @@ module DAV4Rack
     def _call(env)
       begin
         if F.file?(@path) && F.readable?(@path)
-          serving
+          serving(env)
         else
           raise Errno::EPERM
         end

data/lib/dav4rack/file_resource_lock.rb

@@ -0,0 +1,159 @@
+require 'pstore'
+
+module DAV4Rack
+  class FileResourceLock
+    attr_accessor :path
+    attr_accessor :token
+    attr_accessor :timeout
+    attr_accessor :depth
+    attr_accessor :user
+    attr_accessor :scope
+    attr_accessor :kind
+    attr_accessor :owner
+    attr_reader :created_at
+    attr_reader :root
+
+    class << self
+      def explicitly_locked?(path, croot=nil)
+        store = init_pstore(croot)
+        !!store.transaction(true){
+          store[:paths][path]
+        }
+      end
+
+      def implicitly_locked?(path, croot=nil)
+        store = init_pstore(croot)
+        !!store.transaction(true){
+          store[:paths].keys.detect do |check|
+            check.start_with?(path)
+          end
+        }
+      end
+
+      def explicit_locks(path, croot, args={})
+      end
+
+      def find_by_path(path, croot=nil)
+        lock = self.class.new(:path => path, :root => croot)
+        lock.token.nil? ? nil : lock
+      end
+
+      def find_by_token(token, croot=nil)
+        store = init_pstore(croot)
+        struct = store.transaction(true){
+          store[:tokens][token]
+        }
+        if(tok)
+          self.class.new(:path => struct[:path], :root => croot)
+        else
+          nil
+        end
+      end
+
+      def generate(path, user, token, croot)
+        lock = self.new(:root => croot)
+        lock.user = user
+        lock.path = path
+        lock.token = token
+        lock.save
+        lock
+      end
+
+      def root=(path)
+        @root = path
+      end
+
+      def root
+        @root || '/tmp/dav4rack'
+      end
+
+      def init_pstore(croot)
+        path = File.join(croot, '.attribs', 'locks.pstore')
+        FileUtils.mkdir_p(File.dirname(path)) unless File.directory?(File.dirname(path))
+        store = IS_18 ? PStore.new(path) : PStore.new(path, true)
+        store.transaction do
+          unless(store[:paths])
+            store[:paths] = {}
+            store[:tokens] = {}
+            store.commit
+          end
+        end
+        store
+      end
+    end
+
+    def initialize(args={})
+      @path = args[:path]
+      @root = args[:root]
+      @owner = args[:owner]
+      @store = init_pstore(@root)
+      @max_timeout = args[:max_timeout] || 86400
+      @default_timeout = args[:max_timeout] || 60
+      load_if_exists!
+      @new_record = true if token.nil?
+    end
+
+    def owner?(user)
+      user == owner
+    end
+
+    def reload
+      load_if_exists
+      self
+    end
+
+    def remaining_timeout
+      t = timeout.to_i - (Time.now.to_i - created_at.to_i)
+      t < 0 ? 0 : t
+    end
+
+    def save
+      struct = {
+        :path => path, 
+        :token => token, 
+        :timeout => timeout, 
+        :depth => depth,
+        :created_at => Time.now,
+        :owner => owner
+      }
+      @store.transaction do
+        @store[:paths][path] = struct
+        @store[:tokens][token] = struct
+        @store.commit
+      end
+      @new_record = false
+      self
+    end
+
+    def destroy
+      @store.transaction do
+        @store[:paths].delete(path)
+        @store[:tokens].delete(token)
+        @store.commit
+      end
+      nil
+    end
+
+    private
+
+    def load_if_exists!
+      struct = @store.transaction do
+        @store[:paths][path]
+      end
+      if(struct)
+        @path = struct[:path]
+        @token = struct[:token]
+        @timeout = struct[:timeout]
+        @depth = struct[:depth]
+        @created_at = struct[:created_at]
+        @owner = struct[:owner]
+      end
+      self
+    end
+
+    def init_pstore(croot=nil)
+      self.class.init_pstore(croot || @root)
+    end
+
+  end
+end

data/lib/dav4rack/handler.rb

@@ -7,7 +7,7 @@ module DAV4Rack
     def initialize(options={})
       @options = options.dup
       unless(@options[:resource_class])
-        require 'dav4rack/file_resource'
+        require 'dav4rack/resources/file_resource'
         @options[:resource_class] = FileResource
         @options[:root] ||= Dir.pwd
       end

data/lib/dav4rack/resource.rb

@@ -117,7 +117,12 @@ module DAV4Rack
       @runner.call(class_sym, :after, orig)
       result
     end
-    
+  
+    # Returns if resource supports locking
+    def supports_locking?
+      false #true
+    end
+
     # If this is a collection, return the child resources.
     def children
       NotImplemented
@@ -138,6 +143,11 @@ module DAV4Rack
       parent.exist?
     end
     
+    # Is the parent resource a collection?
+    def parent_collection?
+      parent.collection?
+    end
+    
     # Return the creation time.
     def creation_date
       raise NotImplemented
@@ -341,14 +351,17 @@ module DAV4Rack
     end
     
     # Available properties
-    def property_names
-      %w(creationdate displayname getlastmodified getetag resourcetype getcontenttype getcontentlength)
+    def properties
+      %w(creationdate displayname getlastmodified getetag resourcetype getcontenttype getcontentlength).collect do |prop|
+        {:name => prop, :ns_href => 'DAV:'}
+      end
     end
     
     # name:: String - Property name
     # Returns the value of the given property
-    def get_property(name)
-      case name
+    def get_property(element)
+      raise NotImplemented if (element[:ns_href] != 'DAV:')
+      case element[:name]
       when 'resourcetype'     then resource_type
       when 'displayname'      then display_name
       when 'creationdate'     then use_ms_compat_creationdate? ? creation_date.httpdate : creation_date.xmlschema 
@@ -356,24 +369,27 @@ module DAV4Rack
       when 'getcontenttype'   then content_type
       when 'getetag'          then etag
       when 'getlastmodified'  then last_modified.httpdate
+      else                    raise NotImplemented
       end
     end
 
     # name:: String - Property name
     # value:: New value
     # Set the property to the given value
-    def set_property(name, value)
-      case name
+    def set_property(element, value)
+      raise NotImplemented if (element[:ns_href] != 'DAV:')
+      case element[:name]
       when 'resourcetype'    then self.resource_type = value
       when 'getcontenttype'  then self.content_type = value
       when 'getetag'         then self.etag = value
       when 'getlastmodified' then self.last_modified = Time.httpdate(value)
+      else                   raise NotImplemented
       end
     end
 
     # name:: Property name
     # Remove the property from the resource
-    def remove_property(name)
+    def remove_property(element)
       Forbidden
     end
 
@@ -463,7 +479,7 @@ module DAV4Rack
       auth = Rack::Auth::Basic::Request.new(request.env)
       auth.provided? && auth.basic? ? auth.credentials : [nil,nil]
     end
-    
+
   end
 
 end

data/lib/dav4rack/resources/file_resource.rb

@@ -0,0 +1,366 @@
+# encoding: UTF-8
+
+require 'pstore'
+require 'webrick/httputils'
+require 'dav4rack/file_resource_lock'
+
+module DAV4Rack
+
+  class FileResource < Resource
+
+    include WEBrick::HTTPUtils
+    include DAV4Rack::Utils
+
+    # If this is a collection, return the child resources.
+    def children
+      Dir[file_path + '/*'].map do |path|
+        child ::File.basename(path)
+      end
+    end
+
+    # Is this resource a collection?
+    def collection?
+      ::File.directory?(file_path)
+    end
+
+    # Does this recource exist?
+    def exist?
+      ::File.exist?(file_path)
+    end
+
+    # Return the creation time.
+    def creation_date
+      stat.ctime
+    end
+
+    # Return the time of last modification.
+    def last_modified
+      stat.mtime
+    end
+
+    # Set the time of last modification.
+    def last_modified=(time)
+      ::File.utime(Time.now, time, file_path)
+    end
+
+    # Return an Etag, an unique hash value for this resource.
+    def etag
+      sprintf('%x-%x-%x', stat.ino, stat.size, stat.mtime.to_i)
+    end
+
+    # Return the mime type of this resource.
+    def content_type
+      if stat.directory?
+        "text/html"
+      else
+        mime_type(file_path, DefaultMimeTypes)
+      end
+    end
+
+    # Return the size in bytes for this resource.
+    def content_length
+      stat.size
+    end
+
+    # HTTP GET request.
+    #
+    # Write the content of the resource to the response.body.
+    def get(request, response)
+      raise NotFound unless exist?
+      if stat.directory?
+        response.body = ""
+        Rack::Directory.new(root).call(request.env)[2].each do |line|
+          response.body << line
+        end
+        response['Content-Length'] = response.body.bytesize.to_s
+      else
+        file = Rack::File.new(root)
+        response.body = file
+      end
+      OK
+    end
+
+    # HTTP PUT request.
+    #
+    # Save the content of the request.body.
+    def put(request, response)
+      write(request.body)
+      Created
+    end
+
+    # HTTP POST request.
+    #
+    # Usually forbidden.
+    def post(request, response)
+      raise HTTPStatus::Forbidden
+    end
+
+    # HTTP DELETE request.
+    #
+    # Delete this resource.
+    def delete
+      if stat.directory?
+        FileUtils.rm_rf(file_path)
+      else
+        ::File.unlink(file_path)
+      end
+      ::File.unlink(prop_path) if ::File.exists?(prop_path)
+      @_prop_hash = nil
+      NoContent
+    end
+
+    # HTTP COPY request.
+    #
+    # Copy this resource to given destination resource.
+    # Copy this resource to given destination resource.
+    def copy(dest, overwrite)
+      if(collection?)
+        if(dest.exist?)
+          if(dest.collection? && overwrite)
+            FileUtils.cp_r(file_path, dest.send(:file_path))
+            Created
+          else
+            if(overwrite)
+              FileUtils.rm(dest.send(:file_path))
+              FileUtils.cp_r(file_path, dest.send(:file_path))
+              NoContent
+            else
+              PreconditionFailed
+            end
+          end
+        else
+          FileUtils.cp_r(file_path, dest.send(:file_path))
+          Created
+        end
+      else
+        if(dest.exist? && !overwrite)
+          PreconditionFailed
+        else
+          if(::File.directory?(::File.dirname(dest.send(:file_path))))
+            new = !dest.exist?
+            if(dest.collection? && dest.exist?)
+              FileUtils.rm_rf(dest.send(:file_path))
+            end
+            FileUtils.cp(file_path, dest.send(:file_path).sub(/\/$/, ''))
+            FileUtils.cp(prop_path, dest.prop_path) if ::File.exist? prop_path
+            new ? Created : NoContent
+          else
+            Conflict
+          end
+        end
+      end
+    end
+
+    # HTTP MOVE request.
+    #
+    # Move this resource to given destination resource.
+    def move(*args)
+      result = copy(*args)
+      delete if [Created, NoContent].include?(result)
+      result
+    end
+
+    # HTTP MKCOL request.
+    #
+    # Create this resource as collection.
+    def make_collection
+      if(request.body.read.to_s == '')
+        if(::File.directory?(file_path))
+          MethodNotAllowed
+        else
+          if(::File.directory?(::File.dirname(file_path)) && !::File.exists?(file_path))
+            Dir.mkdir(file_path)
+            Created
+          else
+            Conflict
+          end
+        end
+      else
+        UnsupportedMediaType
+      end
+    end
+
+    # Write to this resource from given IO.
+    def write(io)
+      tempfile = "#{file_path}.#{Process.pid}.#{object_id}"
+      open(tempfile, "wb") do |file|
+        while part = io.read(8192)
+          file << part
+        end
+      end
+      ::File.rename(tempfile, file_path)
+    ensure
+      ::File.unlink(tempfile) rescue nil
+    end
+
+    # name:: String - Property name
+    # Returns the value of the given property
+    def get_property(name)
+      begin
+        super
+      rescue NotImplemented
+        custom_props(name)
+      end
+    end
+
+    # name:: String - Property name
+    # value:: New value
+    # Set the property to the given value
+    def set_property(name, value)
+      begin
+        super
+      rescue NotImplemented
+        set_custom_props(name,value)
+      end
+    end
+
+    def remove_property(element)
+      prop_hash.transaction do
+        prop_hash.delete(to_element_key(element))
+        prop_hash.commit
+      end
+      val = prop_hash.transaction{ prop_hash[to_element_key(element)] }
+    end
+
+    def lock(args)
+      unless(parent_exists?)
+        Conflict
+      else
+        lock_check(args[:type])
+        lock = FileResourceLock.explicit_locks(@path, root, :scope => args[:scope], :kind => args[:type], :user => @user)
+        unless(lock)
+          token = UUIDTools::UUID.random_create.to_s
+          lock = FileResourceLock.generate(@path, @user, token, root)
+          lock.scope = args[:scope]
+          lock.kind = args[:type]
+          lock.owner = args[:owner]
+          lock.depth = args[:depth]
+          if(args[:timeout])
+            lock.timeout = args[:timeout] <= @max_timeout && args[:timeout] > 0 ? args[:timeout] : @max_timeout
+          else
+            lock.timeout = @default_timeout
+          end
+          lock.save
+        end
+        begin
+          lock_check(args[:type])
+        rescue DAV4Rack::LockFailure => lock_failure
+          lock.destroy
+          raise lock_failure
+        rescue HTTPStatus::Status => status
+          status
+        end
+        [lock.remaining_timeout, lock.token]
+      end
+    end
+
+    def unlock(token)
+      token = token.slice(1, token.length - 2)
+      if(token.nil? || token.empty?)
+        BadRequest
+      else
+        lock = FileResourceLock.find_by_token(token)
+        if(lock.nil? || lock.user_id != @user.id)
+          Forbidden
+        elsif(lock.path !~ /^#{Regexp.escape(@path)}.*$/)
+          Conflict
+        else
+          lock.destroy
+          NoContent
+        end
+      end
+    end
+
+    protected
+
+    def lock_check(lock_type=nil)
+      if(FileResourceLock.explicitly_locked?(@path, root))
+        raise Locked if lock_type && lock_type == 'exclusive'
+        #raise Locked if FileResourceLock.explicit_locks(@path, root).find(:all, :conditions => ["scope = 'exclusive' AND user_id != ?", @user.id]).size > 0
+      elsif(FileResourceLock.implicitly_locked?(@path, root))
+        if(lock_type.to_s == 'exclusive')
+          locks = FileResourceLock.implicit_locks(@path)
+          failure = DAV4Rack::LockFailure.new("Failed to lock: #{@path}")
+          locks.each do |lock|
+            failure.add_failure(@path, Locked)
+          end
+          raise failure
+        else
+          locks = FileResourceLock.implict_locks(@path).find(:all, :conditions => ["scope = 'exclusive' AND user_id != ?", @user.id])
+          if(locks.size > 0)
+            failure = LockFailure.new("Failed to lock: #{@path}")
+            locks.each do |lock|
+              failure.add_failure(@path, Locked)
+            end
+            raise failure
+          end
+        end
+      end
+    end
+
+    def set_custom_props(element, val)
+      prop_hash.transaction do
+        prop_hash[to_element_key(element)] = val
+        prop_hash.commit
+      end
+    end
+
+    def custom_props(element)
+      val = prop_hash.transaction(true) do
+        prop_hash[to_element_key(element)]
+      end
+      raise NotFound unless val
+      val
+    end
+
+    def store_directory
+      path = ::File.join(root, '.attrib_store')
+      unless(::File.directory?(::File.dirname(path)))
+        FileUtils.mkdir_p(::File.dirname(path))
+      end
+      path
+    end
+
+    def prop_path
+      path = ::File.join(store_directory, "#{::File.join(::File.dirname(file_path), ::File.basename(file_path)).gsub('/', '_')}.pstore")
+      unless(::File.directory?(::File.dirname(path)))
+        FileUtils.mkdir_p(::File.dirname(path))
+      end
+      path
+    end
+
+    def lock_path
+      path = ::File.join(store_directory, 'locks.pstore')
+      unless(::File.directory?(::File.dirname(path)))
+        FileUtils.mkdir_p(::File.dirname(path))
+      end
+      path
+    end
+
+    def prop_hash
+      @_prop_hash ||= IS_18 ? PStore.new(prop_path) : PStore.new(prop_path, true)
+    end
+
+    def authenticate(user, pass)
+      if(options[:username])
+        options[:username] == user && options[:password] == pass
+      else
+        true
+      end
+    end
+
+    def root
+      @options[:root]
+    end
+
+    def file_path
+      ::File.join(root, path)
+    end
+
+    def stat
+      @stat ||= ::File.stat(file_path)
+    end
+
+  end
+
+end