rack-webdav 0.4.3 → 0.4.4

data/lib/rack-webdav/file_resource.rb

@@ -0,0 +1,247 @@
+require 'digest'
+require 'ffi-xattr'
+
+module RackWebDAV
+  class FileResource < Resource
+    include ::WEBrick::HTTPUtils
+
+    # 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 resource type.
+    #
+    # If this is a collection, return a collection element
+    def resource_type
+      if collection?
+        Nokogiri::XML::fragment('<D:collection xmlns:D="DAV:"/>').children.first
+      end
+    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
+
+    def set_custom_property(name, value)
+      if value.nil? || value.empty?
+        begin
+          xattr.remove("rack-webdav:#{name}")
+        rescue Errno::ENOATTR
+          # If the attribute being deleted doesn't exist, just do nothing
+        end
+      else
+        xattr["rack-webdav:#{name}"] = value
+      end
+    end
+
+    def get_custom_property(name)
+      value = xattr["rack-webdav:#{name}"]
+      raise HTTPStatus::NotFound if value.nil?
+      value
+    end
+
+    def list_custom_properties
+      xattr.list.select { |a| a.start_with?('rack-webdav') }.map { |a| a.sub(/^rack-webdav:/, '') }
+    end
+
+    # HTTP GET request.
+    #
+    # Write the content of the resource to the response.body.
+    def get
+      if stat.directory?
+        content = ""
+        Rack::Directory.new(root).call(@request.env)[2].each { |line| content << line }
+        @response.body = [content]
+        @response['Content-Length'] = (content.respond_to?(:bytesize) ? content.bytesize : content.size).to_s
+      else
+        file = File.open(file_path)
+        @response.body = file
+      end
+    end
+
+    # HTTP PUT request.
+    #
+    # Save the content of the request.body.
+    def put
+      if @request.env['HTTP_CONTENT_MD5']
+        content_md5_pass?(@request.env) or raise HTTPStatus::BadRequest.new('Content-MD5 mismatch')
+      end
+
+      if content_continue_pass?(@request.env)
+        raise HTTPStatus::Continue.new()
+      end
+
+      write(@request.body)
+    end
+
+    # HTTP POST request.
+    #
+    # Usually forbidden.
+    def post
+      raise HTTPStatus::Forbidden
+    end
+
+    # HTTP DELETE request.
+    #
+    # Delete this resource.
+    def delete
+      if stat.directory?
+        Dir.rmdir(file_path)
+      else
+        File.unlink(file_path)
+      end
+    end
+
+    # HTTP COPY request.
+    #
+    # Copy this resource to given destination resource.
+    def copy(dest)
+      if stat.directory?
+        dest.make_collection
+      else
+        open(file_path, "rb") do |file|
+          dest.write(file)
+        end
+
+        list_custom_properties.each do |prop|
+          dest.set_custom_property(prop, get_custom_property(prop))
+        end
+      end
+    end
+
+    # HTTP MOVE request.
+    #
+    # Move this resource to given destination resource.
+    def move(dest)
+      copy(dest)
+      delete
+    end
+
+    # HTTP MKCOL request.
+    #
+    # Create this resource as collection.
+    def make_collection
+      Dir.mkdir(file_path)
+    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
+
+    @@locks = {}
+
+    def lock(token, timeout, scope = nil, type = nil, owner = nil)
+      if scope && type && owner
+        # Create lock
+        @@locks[token] = {
+          :timeout => timeout,
+          :scope   => scope,
+          :type    => type,
+          :owner   => owner
+        }
+        return true
+      else
+        # Refresh lock
+        lock = @@locks[token]
+        return false unless lock
+        return [ lock[:timeout], lock[:scope], lock[:type], lock[:owner] ]
+      end
+    end
+
+    def unlock(token)
+      !!@@locks.delete(token)
+    end
+
+
+    private
+
+      def root
+        @options[:root]
+      end
+
+      def file_path
+        root + '/' + path
+      end
+
+      def stat
+        @stat ||= File.stat(file_path)
+      end
+
+      def xattr
+        @xattr ||= Xattr.new(file_path)
+      end
+
+      def content_md5_pass?(env)
+        expected = env['HTTP_CONTENT_MD5'] or return true
+
+        body   = env['rack.input'].dup
+        digest = Digest::MD5.new.digest(body.read)
+        actual = [ digest ].pack('m').strip
+
+        body.rewind
+
+        expected == actual
+      end
+
+      def content_continue_pass?(env)
+        expected = env['HTTP_EXPECT'] or return false
+
+        expected.downcase == '100-continue'
+      end
+  end
+
+end

data/lib/rack-webdav/handler.rb

@@ -1,62 +1,39 @@
-# encoding: UTF-8
-require 'rack-webdav/logger'
-
 module RackWebDAV
 
   class Handler
-    include RackWebDAV::HTTPStatus
-    def initialize(options={})
-      @options = options.dup
-      unless(@options[:resource_class])
-        require 'rack-webdav/resources/file_resource'
-        @options[:resource_class] = FileResource
-        @options[:root] ||= Dir.pwd
-      end
-      Logger.set(*@options[:log_to])
+
+    # @return [Hash] The hash of options.
+    attr_reader :options
+
+
+    # Initializes a new instance with given options.
+    #
+    # @param  [Hash] options Hash of options to customize the handler behavior.
+    # @option options [Class] :resource_class (FileResource)
+    #         The resource class.
+    # @option options [String] :root (".")
+    #         The root resource folder.
+    #
+    def initialize(options = {})
+      @options = {
+        :resource_class => FileResource,
+        :root => Dir.pwd
+      }.merge(options)
     end
 
     def call(env)
-      begin
-        start = Time.now
-        request = Rack::Request.new(env)
-        response = Rack::Response.new
-
-        Logger.info "Processing WebDAV request: #{request.path} (for #{request.ip} at #{Time.now}) [#{request.request_method}]"
+      request  = Rack::Request.new(env)
+      response = Rack::Response.new
 
-        controller = nil
-        begin
-          controller_class = @options[:controller_class] || Controller
-          controller = controller_class.new(request, response, @options.dup)
-          controller.authenticate
-          res = controller.send(request.request_method.downcase)
-          response.status = res.code if res.respond_to?(:code)
-        rescue HTTPStatus::Unauthorized => status
-          response.body = controller.resource.respond_to?(:authentication_error_msg) ? controller.resource.authentication_error_msg : 'Not Authorized'
-          response['WWW-Authenticate'] = "Basic realm=\"#{controller.resource.respond_to?(:authentication_realm) ? controller.resource.authentication_realm : 'Locked content'}\""
-          response.status = status.code
-        rescue HTTPStatus::Status => status
-          response.status = status.code
-        end
-
-        # Strings in Ruby 1.9 are no longer enumerable.  Rack still expects the response.body to be
-        # enumerable, however.
-
-        response['Content-Length'] = response.body.to_s.length unless response['Content-Length'] || !response.body.is_a?(String)
-        response.body = [response.body] unless response.body.respond_to? :each
-        response.status = response.status ? response.status.to_i : 200
-        response.headers.keys.each{|k| response.headers[k] = response[k].to_s}
-
-        # Apache wants the body dealt with, so just read it and junk it
-        buf = true
-        buf = request.body.read(8192) while buf
+      begin
+        controller = Controller.new(request, response, @options)
+        controller.send(request.request_method.downcase)
 
-        Logger.debug "Response in string form. Outputting contents: \n#{response.body}" if response.body.is_a?(String)
-        Logger.info "Completed in: #{((Time.now.to_f - start.to_f) * 1000).to_i} ms | #{response.status} [#{request.url}]"
-        response
-      rescue Exception => e
-        Logger.error "WebDAV Error: #{e}\n#{e.backtrace.join("\n")}"
-        raise e
+      rescue HTTPStatus::Status => status
+        response.status = status.code
       end
+
+      response.finish
     end
 
   end

data/lib/rack-webdav/http_status.rb

@@ -1,19 +1,19 @@
 module RackWebDAV
 
   module HTTPStatus
-    
+
     class Status < Exception
-      
+
       class << self
         attr_accessor :code, :reason_phrase
         alias_method :to_i, :code
-        
+
         def status_line
           "#{code} #{reason_phrase}"
         end
-        
+
       end
-      
+
       def code
         self.class.code
       end
@@ -21,17 +21,17 @@ module RackWebDAV
       def reason_phrase
         self.class.reason_phrase
       end
-      
+
       def status_line
         self.class.status_line
       end
-      
+
       def to_i
         self.class.to_i
       end
-      
+
     end
-    
+
     StatusMessage = {
       100 => 'Continue',
       101 => 'Switching Protocols',
@@ -71,7 +71,7 @@ module RackWebDAV
       417 => 'Expectation Failed',
       422 => 'Unprocessable Entity',
       423 => 'Locked',
-      424 => 'Failed Dependency',      
+      424 => 'Failed Dependency',
       500 => 'Internal Server Error',
       501 => 'Not Implemented',
       502 => 'Bad Gateway',