tilia-dav 3.1.0.pre.alpha2

data/lib/tilia/dav/mk_col.rb

@@ -0,0 +1,47 @@
+module Tilia
+  module Dav
+    # This class represents a MKCOL operation.
+    #
+    # MKCOL creates a new collection. MKCOL comes in two flavours:
+    #
+    # 1. MKCOL with no body, signifies the creation of a simple collection.
+    # 2. MKCOL with a request body. This can create a collection with a specific
+    #    resource type, and a set of properties that should be set on the new
+    #    collection. This can be used to create caldav calendars, carddav address
+    #    books, etc.
+    #
+    # Property updates must always be atomic. This means that a property update
+    # must either completely succeed, or completely fail.
+    class MkCol < PropPatch
+      # A list of resource-types in clark-notation.
+      #
+      # @var array
+      attr_accessor :resource_type
+
+      # Creates the MKCOL object.
+      #
+      # @param string[] resource_type List of resourcetype values.
+      # @param array mutations List of new properties values.
+      def initialize(resource_type, mutations)
+        @resource_type = resource_type
+        super(mutations)
+      end
+
+      # Returns the resourcetype of the new collection.
+      #
+      # @return string[]
+      attr_reader :resource_type
+
+      # Returns true or false if the MKCOL operation has at least the specified
+      # resource type.
+      #
+      # If the resourcetype is specified as an array, all resourcetypes are
+      # checked.
+      #
+      # @param string|string[] resource_type
+      def resource_type?(resource_type)
+        ([resource_type].flatten - @resource_type).size == 0
+      end
+    end
+  end
+end

data/lib/tilia/dav/mount.rb

@@ -0,0 +1,7 @@
+module Tilia
+  module Dav
+    module Mount
+      require 'tilia/dav/mount/plugin'
+    end
+  end
+end

data/lib/tilia/dav/mount/plugin.rb

@@ -0,0 +1,62 @@
+require 'cgi'
+
+module Tilia
+  module Dav
+    module Mount
+      # This plugin provides support for RFC4709: Mounting WebDAV servers
+      #
+      # Simply append ?mount to any collection to generate the davmount response.
+      class Plugin < ServerPlugin
+        # Reference to Server class
+        #
+        # @var Sabre\DAV\Server
+        # RUBY: attr_accessor :server
+
+        # Initializes the plugin and registers event handles
+        #
+        # @param DAV\Server server
+        # @return void
+        def setup(server)
+          @server = server
+          @server.on('method:GET', method(:http_get), 90)
+        end
+
+        # 'beforeMethod' event handles. This event handles intercepts GET requests ending
+        # with ?mount
+        #
+        # @param RequestInterface request
+        # @param ResponseInterface response
+        # @return bool
+        def http_get(request, response)
+          query_params = request.query_parameters
+          return true unless query_params.include?('mount')
+
+          current_uri = request.absolute_url
+
+          # Stripping off everything after the ?
+          current_uri = current_uri.split('?').first
+
+          dav_mount(response, current_uri)
+
+          # Returning false to break the event chain
+          false
+        end
+
+        # Generates the davmount response
+        #
+        # @param ResponseInterface response
+        # @param string uri absolute uri
+        # @return void
+        def dav_mount(response, uri)
+          response.status = 200
+          response.update_header('Content-Type', 'application/davmount+xml')
+          body = "<?xml version=\"1.0\"?>\n"
+          body << "<dm:mount xmlns:dm=\"http://purl.org/NET/webdav/mount\">\n"
+          body << "  <dm:url>#{CGI.escapeHTML(uri)}</dm:url>\n"
+          body << '</dm:mount>'
+          response.body = body
+        end
+      end
+    end
+  end
+end

data/lib/tilia/dav/node.rb

@@ -0,0 +1,36 @@
+module Tilia
+  module Dav
+    # Node class
+    #
+    # This is a helper class, that should aid in getting nodes setup.
+    class Node
+      include INode
+
+      # Returns the last modification time as a unix timestamp.
+      #
+      # If the information is not available, return null.
+      #
+      # @return int
+      def last_modified
+        nil
+      end
+
+      # Deletes the current node
+      #
+      # @throws Sabre\DAV\Exception\Forbidden
+      # @return void
+      def delete
+        fail Exception::Forbidden, 'Permission denied to delete node'
+      end
+
+      # Renames the node
+      #
+      # @throws Sabre\DAV\Exception\Forbidden
+      # @param string name The new name
+      # @return void
+      def name=(_name)
+        fail Exception::Forbidden, 'Permission denied to rename file'
+      end
+    end
+  end
+end

data/lib/tilia/dav/partial_update.rb

@@ -0,0 +1,8 @@
+module Tilia
+  module Dav
+    module PartialUpdate
+      require 'tilia/dav/partial_update/i_patch_support'
+      require 'tilia/dav/partial_update/plugin'
+    end
+  end
+end

data/lib/tilia/dav/partial_update/i_patch_support.rb

@@ -0,0 +1,40 @@
+module Tilia
+  module Dav
+    module PartialUpdate
+      # This interface provides a way to modify only part of a target resource
+      # It may be used to update a file chunk, upload big a file into smaller
+      # chunks or resume an upload
+      module IPatchSupport
+        include IFile
+
+        # Updates the file based on a range specification.
+        #
+        # The first argument is the data, which is either a readable stream
+        # resource or a string.
+        #
+        # The second argument is the type of update we're doing.
+        # This is either:
+        # * 1. append
+        # * 2. update based on a start byte
+        # * 3. update based on an end byte
+        #
+        # The third argument is the start or end byte.
+        #
+        # After a successful put operation, you may choose to return an ETag. The
+        # etag must always be surrounded by double-quotes. These quotes must
+        # appear in the actual string you're returning.
+        #
+        # Clients may use the ETag from a PUT request to later on make sure that
+        # when they update the file, the contents haven't changed in the mean
+        # time.
+        #
+        # @param resource|string data
+        # @param int range_type
+        # @param int offset
+        # @return string|null
+        def patch(_data, _range_type, _offset = nil)
+        end
+      end
+    end
+  end
+end

data/lib/tilia/dav/partial_update/plugin.rb

@@ -0,0 +1,179 @@
+module Tilia
+  module Dav
+    module PartialUpdate
+      # Partial update plugin (Patch method)
+      #
+      # This plugin provides a way to modify only part of a target resource
+      # It may bu used to update a file chunk, upload big a file into smaller
+      # chunks or resume an upload.
+      #
+      # patch_plugin = new \Sabre\DAV\PartialUpdate\Plugin
+      # server.add_plugin(patch_plugin)
+      class Plugin < ServerPlugin
+        RANGE_APPEND = 1
+        RANGE_START = 2
+        RANGE_END = 3
+
+        # Reference to server
+        #
+        # @var Sabre\DAV\Server
+        # RUBY: attr_accessor :server
+
+        # Initializes the plugin
+        #
+        # This method is automatically called by the Server class after addPlugin.
+        #
+        # @param DAV\Server server
+        # @return void
+        def setup(server)
+          @server = server
+          server.on('method:PATCH', method(:http_patch))
+        end
+
+        # Returns a plugin name.
+        #
+        # Using this name other plugins will be able to access other plugins
+        # using DAV\Server::getPlugin
+        #
+        # @return string
+        def plugin_name
+          'partialupdate'
+        end
+
+        # Use this method to tell the server this plugin defines additional
+        # HTTP methods.
+        #
+        # This method is passed a uri. It should only return HTTP methods that are
+        # available for the specified uri.
+        #
+        # We claim to support PATCH method (partirl update) if and only if
+        #     - the node exist
+        #     - the node implements our partial update interface
+        #
+        # @param string uri
+        # @return array
+        def http_methods(uri)
+          tree = @server.tree
+
+          if tree.node_exists(uri)
+            node = tree.node_for_path(uri)
+            return ['PATCH'] if node.is_a?(IPatchSupport)
+          end
+          []
+        end
+
+        # Returns a list of features for the HTTP OPTIONS Dav: header.
+        #
+        # @return array
+        def features
+          ['sabredav-partialupdate']
+        end
+
+        # Patch an uri
+        #
+        # The WebDAV patch request can be used to modify only a part of an
+        # existing resource. If the resource does not exist yet and the first
+        # offset is not 0, the request fails
+        #
+        # @param RequestInterface request
+        # @param ResponseInterface response
+        # @return void
+        def http_patch(request, response)
+          path = request.path
+
+          # Get the node. Will throw a 404 if not found
+          node = @server.tree.node_for_path(path)
+          unless node.is_a?(IPatchSupport)
+            fail Exception::MethodNotAllowed, 'The target resource does not support the PATCH method.'
+          end
+
+          range = http_update_range(request)
+
+          unless range
+            fail Exception::BadRequest, 'No valid "X-Update-Range" found in the headers'
+          end
+
+          content_type = request.header('Content-Type').to_s.downcase
+
+          unless content_type == 'application/x-sabredav-partialupdate'
+            fail Exception::UnsupportedMediaType, "Unknown Content-Type header \"#{content_type}\""
+          end
+
+          len = @server.http_request.header('Content-Length').to_i
+          if len == 0
+            fail Exception::LengthRequired, 'A Content-Length header is required'
+          end
+
+          case range[0]
+          when RANGE_START
+            # Calculate the end-range if it doesn't exist.
+            if range[2].blank?
+              range[2] = range[1] + len - 1
+            else
+              if range[2] < range[1]
+                fail Exception::RequestedRangeNotSatisfiable, "The end offset (#{range[2]}) is lower than the start offset (#{range[1]})"
+              end
+              if range[2] - range[1] + 1 != len
+                fail Exception::RequestedRangeNotSatisfiable, "Actual data length (#{len}) is not consistent with begin (#{range[1]}) and end (#{range[2]}) offsets"
+              end
+            end
+          end
+
+          unless @server.emit('beforeWriteContent', [path, node, nil, nil])
+            return nil
+          end
+
+          body = @server.http_request.body
+
+          etag = node.patch(body, range[0], range[1])
+
+          @server.emit('afterWriteContent', [path, node])
+
+          response.update_header('Content-Length', '0')
+          response.update_header('ETag', etag) if etag
+
+          response.status = 204
+
+          # Breaks the event chain
+          false
+        end
+
+        # Returns the HTTP custom range update header
+        #
+        # This method returns null if there is no well-formed HTTP range request
+        # header. It returns array(1) if it was an append request, array(2,
+        # start, end) if it's a start and end range, lastly it's array(3,
+        # endoffset) if the offset was negative, and should be calculated from
+        # the end of the file.
+        #
+        # Examples:
+        #
+        # null - invalid
+        # [1] - append
+        # [2,10,15] - update bytes 10, 11, 12, 13, 14, 15
+        # [2,10,null] - update bytes 10 until the end of the patch body
+        # [3,-5] - update from 5 bytes from the end of the file.
+        #
+        # @param RequestInterface request
+        # @return array|null
+        def http_update_range(request)
+          range = request.header('X-Update-Range')
+          return nil unless range
+
+          # Matching "Range: bytes=1234-5678: both numbers are optional
+
+          matches = /^(append)|(?:bytes=([0-9]+)-([0-9]*))|(?:bytes=(-[0-9]+))$/i.match(range)
+          return nil unless matches
+
+          if matches[1] == 'append'
+            return [RANGE_APPEND]
+          elsif matches[2].to_s.size > 0
+            return [RANGE_START, matches[2].to_i, matches[3].blank? ? nil : matches[3].to_i]
+          else
+            return [RANGE_END, matches[4].to_i]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tilia/dav/prop_find.rb

@@ -0,0 +1,262 @@
+module Tilia
+  module Dav
+    # This class holds all the information about a PROPFIND request.
+    #
+    # It contains the type of PROPFIND request, which properties were requested
+    # and also the returned items.
+    class PropFind
+      # A normal propfind
+      NORMAL = 0
+
+      # An allprops request.
+      #
+      # While this was originally intended for instructing the server to really
+      # fetch every property, because it was used so often and it's so heavy
+      # this turned into a small list of default properties after a while.
+      #
+      # So 'all properties' now means a hardcoded list.
+      ALLPROPS = 1
+
+      # A propname request. This just returns a list of properties that are
+      # defined on a node, without their values.
+      PROPNAME = 2
+
+      # Creates the PROPFIND object
+      #
+      # @param string path
+      # @param array properties
+      # @param int depth
+      # @param int request_type
+      def initialize(path, properties, depth = 0, request_type = NORMAL)
+        @path = path
+        @properties = properties
+        @depth = depth
+        @request_type = request_type
+        @result = {}
+
+        if request_type == ALLPROPS
+          @properties = [
+            '{DAV:}getlastmodified',
+            '{DAV:}getcontentlength',
+            '{DAV:}resourcetype',
+            '{DAV:}quota-used-bytes',
+            '{DAV:}quota-available-bytes',
+            '{DAV:}getetag',
+            '{DAV:}getcontenttype'
+          ]
+        end
+
+        @properties.each do |property_name|
+          # Seeding properties with 404's.
+          @result[property_name] = [404, nil]
+        end
+        @items_left = result.size
+      end
+
+      # Handles a specific property.
+      #
+      # This method checks wether the specified property was requested in this
+      # PROPFIND request, and if so, it will call the callback and use the
+      # return value for it's value.
+      #
+      # Example:
+      #
+      # $propFind->handle('{DAV:}displayname', function() {
+      #      return 'hello';
+      # });
+      #
+      # Note that handle will only work the first time. If null is returned, the
+      # value is ignored.
+      #
+      # It's also possible to not pass a callback, but immediately pass a value
+      #
+      # @param string property_name
+      # @param mixed value_or_callback
+      # @return void
+      def handle(property_name, value_or_callback)
+        if @items_left > 0 && @result.key?(property_name) && @result[property_name][0] == 404
+          if value_or_callback.is_a?(Proc) || value_or_callback.is_a?(Method)
+            value = value_or_callback.call
+          else
+            value = value_or_callback
+          end
+
+          unless value.nil?
+            @items_left -= 1
+            @result[property_name] = [200, value]
+          end
+        end
+      end
+
+      # Sets the value of the property
+      #
+      # If status is not supplied, the status will default to 200 for non-null
+      # properties, and 404 for null properties.
+      #
+      # @param string property_name
+      # @param mixed value
+      # @param int status
+      # @return void
+      def set(property_name, value, status = nil)
+        status = value.nil? ? 404 : 200 if status.nil?
+
+        # If this is an ALLPROPS request and the property is
+        # unknown, add it to the result; else ignore it:
+        unless @result.key?(property_name)
+          @result[property_name] = [status, value] if @request_type == ALLPROPS
+          return
+        end
+
+        if status != 404 && @result[property_name][0] == 404
+          @items_left -= 1
+        elsif status == 404 && @result[property_name][0] != 404
+          @items_left += 1
+        end
+
+        @result[property_name] = [status, value]
+      end
+
+      # Returns the current value for a property.
+      #
+      # @param string property_name
+      # @return mixed
+      def get(property_name)
+        @result.key?(property_name) ? @result[property_name][1] : nil
+      end
+
+      # Returns the current status code for a property name.
+      #
+      # If the property does not appear in the list of requested properties,
+      # null will be returned.
+      #
+      # @param string property_name
+      # @return int|null
+      def status(property_name)
+        @result.key?(property_name) ? @result[property_name][0] : nil
+      end
+
+      # Updates the path for this PROPFIND.
+      #
+      # @param string path
+      # @return void
+      attr_writer :path
+
+      # Returns the path this PROPFIND request is for.
+      #
+      # @return string
+      attr_reader :path
+
+      # Returns the depth of this propfind request.
+      #
+      # @return int
+      attr_reader :depth
+
+      # Updates the depth of this propfind request.
+      #
+      # @param int depth
+      # @return void
+      attr_writer :depth
+
+      # Returns all propertynames that have a 404 status, and thus don't have a
+      # value yet.
+      #
+      # @return array
+      def load_404_properties
+        return [] if @items_left == 0
+        result = []
+        @result.each do |property_name, stuff|
+          result << property_name if stuff[0] == 404
+        end
+        result
+      end
+
+      # Returns the full list of requested properties.
+      #
+      # This returns just their names, not a status or value.
+      #
+      # @return array
+      def requested_properties
+        @properties
+      end
+
+      # Returns true if this was an '{DAV:}allprops' request.
+      #
+      # @return bool
+      def all_props?
+        @request_type == ALLPROPS
+      end
+
+      # Returns a result array that's often used in multistatus responses.
+      #
+      # The array uses status codes as keys, and property names and value pairs
+      # as the value of the top array.. such as :
+      #
+      # [
+      #  200 => [ '{DAV:}displayname' => 'foo' ],
+      # ]
+      #
+      # @return array
+      def result_for_multi_status
+        results = {
+          200 => {},
+          404 => {}
+        }
+        @result.each do |property_name, info|
+          results[info[0]] = {} unless results.key?(info[0])
+          results[info[0]][property_name] = info[1]
+        end
+
+        results.delete(404) if @request_type == ALLPROPS
+        results
+      end
+
+      # The path that we're fetching properties for.
+      #
+      # @var string
+      attr_accessor :path
+
+      # The Depth of the request.
+      #
+      # 0 means only the current item. 1 means the current item + its children.
+      # It can also be DEPTH_INFINITY if this is enabled in the server.
+      #
+      # @var int
+      attr_accessor :depth
+
+      # The type of request. See the TYPE constants
+      attr_accessor :request_type
+
+      # A list of requested properties
+      #
+      # @var array
+      attr_accessor :properties
+
+      # The result of the operation.
+      #
+      # The keys in this array are property names.
+      # The values are an array with two elements: the http status code and then
+      # optionally a value.
+      #
+      # Example:
+      #
+      # [
+      #    "{DAV:}owner" : [404],
+      #    "{DAV:}displayname" : [200, "Admin"]
+      # ]
+      #
+      # @var array
+      attr_accessor :result
+
+      # This is used as an internal counter for the number of properties that do
+      # not yet have a value.
+      #
+      # @var int
+      attr_accessor :items_left
+
+      def initialize_copy(_original)
+        @properties = @properties.deep_dup
+        @result = @result.deep_dup
+      end
+    end
+  end
+end