rack-webdav 0.4.0

data/lib/rack-webdav/file.rb

@@ -0,0 +1,37 @@
+require 'time'
+require 'rack/utils'
+require 'rack/mime'
+
+module RackWebDAV
+  # RackWebDAV::File simply allows us to use Rack::File but with the
+  # specific location we deem appropriate
+  class File < Rack::File
+    attr_accessor :path
+
+    alias :to_path :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def _call(env)
+      begin
+        if F.file?(@path) && F.readable?(@path)
+          serving(env)
+        else
+          raise Errno::EPERM
+        end
+      rescue SystemCallError
+        not_found
+      end
+    end
+
+    def not_found
+      body = "File not found: #{Rack::Utils.unescape(env["PATH_INFO"])}\n"
+      [404, {"Content-Type" => "text/plain",
+         "Content-Length" => body.size.to_s,
+         "X-Cascade" => "pass"},
+       [body]]
+    end
+  end
+end

data/lib/rack-webdav/file_resource_lock.rb

@@ -0,0 +1,169 @@
+require 'pstore'
+
+module RackWebDAV
+  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 implict_locks(path)
+      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 !struct
+          struct = store.transaction(true) {
+            store[:tokens].keys.each { |k| token = k if k.include?(token) }
+            store[:tokens][token]
+          }
+        end
+
+        if struct
+          self.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/rack-webdav'
+      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/rack-webdav/handler.rb

@@ -0,0 +1,63 @@
+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])
+    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}]"
+
+        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
+
+        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
+      end
+    end
+
+  end
+
+end

data/lib/rack-webdav/http_status.rb

@@ -0,0 +1,108 @@
+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
+
+      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',
+      102 => 'Processing',
+      200 => 'OK',
+      201 => 'Created',
+      202 => 'Accepted',
+      203 => 'Non-Authoritative Information',
+      204 => 'No Content',
+      205 => 'Reset Content',
+      206 => 'Partial Content',
+      207 => 'Multi-Status',
+      300 => 'Multiple Choices',
+      301 => 'Moved Permanently',
+      302 => 'Found',
+      303 => 'See Other',
+      304 => 'Not Modified',
+      305 => 'Use Proxy',
+      307 => 'Temporary Redirect',
+      400 => 'Bad Request',
+      401 => 'Unauthorized',
+      402 => 'Payment Required',
+      403 => 'Forbidden',
+      404 => 'Not Found',
+      405 => 'Method Not Allowed',
+      406 => 'Not Acceptable',
+      407 => 'Proxy Authentication Required',
+      408 => 'Request Timeout',
+      409 => 'Conflict',
+      410 => 'Gone',
+      411 => 'Length Required',
+      412 => 'Precondition Failed',
+      413 => 'Request Entity Too Large',
+      414 => 'Request-URI Too Large',
+      415 => 'Unsupported Media Type',
+      416 => 'Request Range Not Satisfiable',
+      417 => 'Expectation Failed',
+      422 => 'Unprocessable Entity',
+      423 => 'Locked',
+      424 => 'Failed Dependency',      
+      500 => 'Internal Server Error',
+      501 => 'Not Implemented',
+      502 => 'Bad Gateway',
+      503 => 'Service Unavailable',
+      504 => 'Gateway Timeout',
+      505 => 'HTTP Version Not Supported',
+      507 => 'Insufficient Storage'
+    }
+
+    StatusMessage.each do |code, reason_phrase|
+      klass = Class.new(Status)
+      klass.code = code
+      klass.reason_phrase = reason_phrase
+      klass_name = reason_phrase.gsub(/[ \-]/,'')
+      const_set(klass_name, klass)
+    end
+
+  end
+
+end
+
+
+module Rack
+  class Response
+    module Helpers
+      RackWebDAV::HTTPStatus::StatusMessage.each do |code, reason_phrase|
+        name = reason_phrase.gsub(/[ \-]/,'_').downcase
+        define_method(name + '?') do
+          @status == code
+        end
+      end
+    end
+  end
+end

data/lib/rack-webdav/interceptor.rb

@@ -0,0 +1,22 @@
+require 'rack-webdav/interceptor_resource'
+module RackWebDAV
+  class Interceptor
+    def initialize(app, args={})
+      @roots = args[:mappings].keys
+      @args = args
+      @app = app
+      @intercept_methods = %w(OPTIONS PROPFIND PROPPATCH MKCOL COPY MOVE LOCK UNLOCK)
+      @intercept_methods -= args[:ignore_methods] if args[:ignore_methods]
+    end
+
+    def call(env)
+      path = env['PATH_INFO'].downcase
+      method = env['REQUEST_METHOD'].upcase
+      app = nil
+      if(@roots.detect{|x| path =~ /^#{Regexp.escape(x.downcase)}\/?/}.nil? && @intercept_methods.include?(method))
+        app = RackWebDAV::Handler.new(:resource_class => InterceptorResource, :mappings => @args[:mappings], :log_to => @args[:log_to])
+      end
+      app ? app.call(env) : @app.call(env)
+    end
+  end
+end

data/lib/rack-webdav/interceptor_resource.rb

@@ -0,0 +1,119 @@
+require 'digest/sha1'
+
+module RackWebDAV
+
+  class InterceptorResource < Resource
+    attr_reader :path, :options
+    
+    def initialize(*args)
+      super
+      @root_paths = @options[:mappings].keys
+      @mappings = @options[:mappings]
+    end
+        
+    def children
+      childs = @root_paths.find_all{|x|x =~ /^#{Regexp.escape(@path)}/}
+      childs = childs.map{|a| child a.gsub(/^#{Regexp.escape(@path)}/, '').split('/').delete_if{|x|x.empty?}.first }.flatten
+    end
+
+    def collection?
+      true if exist?
+    end
+
+    def exist?
+      !@root_paths.find_all{|x| x =~ /^#{Regexp.escape(@path)}/}.empty?
+    end
+    
+    def creation_date
+      Time.now
+    end
+
+    def last_modified
+      Time.now
+    end
+    
+    def last_modified=(time)
+      Time.now
+    end
+
+    def etag
+      Digest::SHA1.hexdigest(@path)
+    end
+
+    def content_type
+      'text/html'
+    end
+
+    def content_length
+      0
+    end
+
+    def get(request, response)
+      raise Forbidden
+    end
+
+    def put(request, response)
+      raise Forbidden
+    end
+    
+    def post(request, response)
+      raise Forbidden
+    end
+    
+    def delete
+      raise Forbidden
+    end
+    
+    def copy(dest)
+      raise Forbidden
+    end
+  
+    def move(dest)
+      raise Forbidden
+    end
+    
+    def make_collection
+      raise Forbidden
+    end
+
+    def ==(other)
+      path == other.path
+    end
+
+    def name
+      ::File.basename(path)
+    end
+
+    def display_name
+      ::File.basename(path.to_s)
+    end
+    
+    def child(name, option={})
+      new_path = path.dup
+      new_path = '/' + new_path unless new_path[0,1] == '/'
+      new_path.slice!(-1) if new_path[-1,1] == '/'
+      name = '/' + name unless name[-1,1] == '/'
+      new_path = "#{new_path}#{name}"
+      new_public = public_path.dup
+      new_public = '/' + new_public unless new_public[0,1] == '/'
+      new_public.slice!(-1) if new_public[-1,1] == '/'
+      new_public = "#{new_public}#{name}"
+      if(key = @root_paths.find{|x| new_path =~ /^#{Regexp.escape(x.downcase)}\/?/})
+        @mappings[key][:resource_class].new(new_public, new_path.gsub(key, ''), request, response, {:root_uri_path => key, :user => @user}.merge(options).merge(@mappings[key]))
+      else
+        self.class.new(new_public, new_path, request, response, {:user => @user}.merge(options))
+      end
+    end
+    
+    def descendants
+      list = []
+      children.each do |child|
+        list << child
+        list.concat(child.descendants)
+      end
+      list
+    end
+
+  end
+
+end