tilia-dav 3.1.0.pre.alpha2

data/lib/tilia/dav/temporary_file_filter_plugin.rb

@@ -0,0 +1,248 @@
+require 'digest'
+
+module Tilia
+  module Dav
+    # Temporary File Filter Plugin
+    #
+    # The purpose of this filter is to intercept some of the garbage files
+    # operation systems and applications tend to generate when mounting
+    # a WebDAV share as a disk.
+    #
+    # It will intercept these files and place them in a separate directory.
+    # these files are not deleted automatically, so it is adviceable to
+    # delete these after they are not accessed for 24 hours.
+    #
+    # Currently it supports:
+    #   * OS/X style resource forks and .DS_Store
+    #   * desktop.ini and Thumbs.db (windows)
+    #   * .*.swp (vim temporary files)
+    #   * .dat.* (smultron temporary files)
+    #
+    # Additional patterns can be added, by adding on to the
+    # temporaryFilePatterns property.
+    class TemporaryFileFilterPlugin < ServerPlugin
+      # This is the list of patterns we intercept.
+      # If new patterns are added, they must be valid patterns for preg_match.
+      #
+      # @var array
+      attr_accessor :temporary_file_patterns
+
+      # A reference to the main Server class
+      #
+      # @var Sabre\DAV\Server
+      # RUBY: attr_accessor :server
+
+      # This is the directory where this plugin
+      # will store it's files.
+      #
+      # @var string
+      # RUBY: attr_accessor :data_dir
+
+      # Creates the plugin.
+      #
+      # Make sure you specify a directory for your files. If you don't, we
+      # will use PHP's directory for session-storage instead, and you might
+      # not want that.
+      #
+      # @param string|null data_dir
+      def initialize(data_dir = nil)
+        @temporary_file_patterns = [
+          /^\._(.*)$/,     # OS/X resource forks
+          /^.DS_Store$/,   # OS/X custom folder settings
+          /^desktop.ini$/, # Windows custom folder settings
+          /^Thumbs.db$/,   # Windows thumbnail cache
+          /^.(.*).swp$/,   # ViM temporary files
+          /^\.dat(.*)$/,   # Smultron seems to create these
+          /^~lock.(.*)\#$/ # Windows 7 lockfiles
+        ]
+
+        data_dir = ::File.join(Dir.tmpdir, 'tiliadav', '') unless data_dir
+        Dir.mkdir(data_dir) unless ::File.directory?(data_dir)
+        @data_dir = data_dir
+      end
+
+      # Initialize the plugin
+      #
+      # This is called automatically be the Server class after this plugin is
+      # added with Sabre\DAV\Server::add_plugin
+      #
+      # @param Server server
+      # @return void
+      def setup(server)
+        @server = server
+        @server.on('beforeMethod',     method(:before_method))
+        @server.on('beforeCreateFile', method(:before_create_file))
+      end
+
+      # This method is called before any HTTP method handler
+      #
+      # This method intercepts any GET, DELETE, PUT and PROPFIND calls to
+      # filenames that are known to match the 'temporary file' regex.
+      #
+      # @param RequestInterface request
+      # @param ResponseInterface response
+      # @return bool
+      def before_method(request, response)
+        temp_location = temp_file?(request.path)
+        return true unless temp_location
+
+        case request.method
+        when 'GET'
+          http_get(request, response, temp_location)
+        when 'PUT'
+          http_put(request, response, temp_location)
+        when 'PROPFIND'
+          http_propfind(request, response, temp_location)
+        when 'DELETE'
+          http_delete(request, response, temp_location)
+        else
+          true
+        end
+      end
+
+      # This method is invoked if some subsystem creates a new file.
+      #
+      # This is used to deal with HTTP LOCK requests which create a new
+      # file.
+      #
+      # @param string uri
+      # @param resource data
+      # @return bool
+      def before_create_file(uri, data, _parent, _modified)
+        temp_path = temp_file?(uri)
+        if temp_path
+          h_r = @server.http_response
+          h_r.update_header('X-Sabre-Temp', 'true')
+          ::File.open(temp_path, 'w') do |file|
+            file.write(data)
+          end
+          return false
+        end
+
+        nil
+      end
+
+      protected
+
+      # This method will check if the url matches the temporary file pattern
+      # if it does, it will return an path based on @data_dir for the
+      # temporary file storage.
+      #
+      # @param string path
+      # @return bool|string
+      def temp_file?(path)
+        # We're only interested in the basename.
+        temp_path = Tilia::Http::UrlUtil.split_path(path)[1]
+
+        @temporary_file_patterns.each do |temp_file|
+          if temp_path =~ temp_file
+            return "#{data_dir}/sabredav_#{Digest::MD5.hexdigest(path)}.tempfile"
+          end
+        end
+
+        false
+      end
+
+      public
+
+      # This method handles the GET method for temporary files.
+      # If the file doesn't exist, it will return false which will kick in
+      # the regular system for the GET method.
+      #
+      # @param RequestInterface request
+      # @param ResponseInterface h_r
+      # @param string temp_location
+      # @return bool
+      def http_get(_request, h_r, temp_location)
+        return nil unless ::File.exist?(temp_location)
+
+        h_r.update_header('Content-Type', 'application/octet-stream')
+        h_r.update_header('Content-Length', ::File.size(temp_location))
+        h_r.update_header('X-Sabre-Temp', 'true')
+        h_r.status = 200
+        h_r.body = ::File.open(temp_location, 'r')
+        false
+      end
+
+      # This method handles the PUT method.
+      #
+      # @param RequestInterface request
+      # @param ResponseInterface h_r
+      # @param string temp_location
+      # @return bool
+      def http_put(_request, h_r, temp_location)
+        h_r.update_header('X-Sabre-Temp', 'true')
+
+        new_file = !::File.exist?(temp_location)
+
+        if !new_file && @server.http_request.header('If-None-Match')
+          fail Exception::PreconditionFailed, 'The resource already exists, and an If-None-Match header was supplied'
+        end
+
+        ::File.open(temp_location, 'w') do |file|
+          file.write(@server.http_request.body)
+        end
+
+        h_r.status = new_file ? 201 : 200
+        false
+      end
+
+      # This method handles the DELETE method.
+      #
+      # If the file didn't exist, it will return false, which will make the
+      # standard HTTP DELETE handler kick in.
+      #
+      # @param RequestInterface request
+      # @param ResponseInterface h_r
+      # @param string temp_location
+      # @return bool
+      def http_delete(_request, h_r, temp_location)
+        return nil unless ::File.exist?(temp_location)
+
+        ::File.unlink(temp_location)
+        h_r.update_header('X-Sabre-Temp', 'true')
+        h_r.status = 204
+        false
+      end
+
+      # This method handles the PROPFIND method.
+      #
+      # It's a very lazy method, it won't bother checking the request body
+      # for which properties were requested, and just sends back a default
+      # set of properties.
+      #
+      # @param RequestInterface request
+      # @param ResponseInterface h_r
+      # @param string temp_location
+      # @return bool
+      def http_propfind(request, h_r, temp_location)
+        return false unless ::File.exist?(temp_location)
+
+        h_r.update_header('X-Sabre-Temp', 'true')
+        h_r.status = 207
+        h_r.update_header('Content-Type', 'application/xml; charset=utf-8')
+
+        properties = {
+          'href' => request.path,
+          200    => {
+            '{DAV:}getlastmodified'            => Xml::Property::GetLastModified.new(::File.mtime(temp_location)),
+            '{DAV:}getcontentlength'           => ::File.size(temp_location),
+            '{DAV:}resourcetype'               => Xml::Property::ResourceType.new(nil),
+            "{#{Server::NS_SABREDAV}}tempFile" => true
+          }
+        }
+
+        data = @server.generate_multi_status([properties])
+        h_r.body = data
+        false
+      end
+
+      protected
+
+      # This method returns the directory where the temporary files should be stored.
+      #
+      # @return string
+      attr_reader :data_dir
+    end
+  end
+end

data/lib/tilia/dav/tree.rb

@@ -0,0 +1,270 @@
+require 'stringio'
+
+module Tilia
+  module Dav
+    # The tree object is responsible for basic tree operations.
+    #
+    # It allows for fetching nodes by path, facilitates deleting, copying and
+    # moving.
+    class Tree
+      # The root node
+      #
+      # @var ICollection
+      attr_accessor :root_node
+
+      # This is the node cache. Accessed nodes are stored here.
+      # Arrays keys are path names, values are the actual nodes.
+      #
+      # @var array
+      attr_accessor :cache
+
+      # Creates the object
+      #
+      # This method expects the rootObject to be passed as a parameter
+      #
+      # @param ICollection root_node
+      def initialize(root_node)
+        self.root_node = root_node
+        self.cache = {}
+      end
+
+      # Returns the INode object for the requested path
+      #
+      # @param string path
+      # @return INode
+      def node_for_path(path)
+        path = path.gsub(%r{^/+|/+$}, '')
+        return cache[path] if cache.key? path
+
+        # Is it the root node?
+        return root_node if path.size == 0
+
+        # Attempting to fetch its parent
+        (parent_name, base_name) = Tilia::Http::UrlUtil.split_path(path)
+
+        # If there was no parent, we must simply ask it from the root node.
+        if parent_name == ''
+          node = root_node.child(base_name)
+        else
+          # Otherwise, we recursively grab the parent and ask him/her.
+          parent = node_for_path(parent_name)
+
+          unless parent.is_a? ICollection
+            fail Exception::NotFound, "Could not find node at path: #{path}"
+          end
+
+          node = parent.child(base_name)
+        end
+
+        cache[path] = node
+      end
+
+      # This function allows you to check if a node exists.
+      #
+      # Implementors of this class should override this method to make
+      # it cheaper.
+      #
+      # @param string path
+      # @return bool
+      def node_exists(path)
+        # The root always exists
+        return true if path == ''
+
+        (parent, base) = Tilia::Http::UrlUtil.split_path(path)
+
+        parent_node = node_for_path(parent)
+        return false unless parent_node.is_a? ICollection
+        parent_node.child_exists(base)
+      rescue Exception::NotFound => e
+        false
+      end
+
+      # Copies a file from path to another
+      #
+      # @param string source_path The source location
+      # @param string destination_path The full destination path
+      # @return void
+      def copy(source_path, destination_path)
+        source_node = node_for_path(source_path)
+
+        # grab the dirname and basename components
+        (destination_dir, destination_name) = Tilia::Http::UrlUtil.split_path(destination_path)
+
+        destination_parent = node_for_path(destination_dir)
+        copy_node(source_node, destination_parent, destination_name)
+
+        mark_dirty(destination_dir)
+      end
+
+      # Moves a file from one location to another
+      #
+      # @param string source_path The path to the file which should be moved
+      # @param string destination_path The full destination path, so not just the destination parent node
+      # @return int
+      def move(source_path, destination_path)
+        (source_dir,) = Tilia::Http::UrlUtil.split_path(source_path)
+        (destination_dir, destination_name) = Tilia::Http::UrlUtil.split_path(destination_path)
+
+        if source_dir == destination_dir
+          # If this is a 'local' rename, it means we can just trigger a rename.
+          source_node = node_for_path(source_path)
+          source_node.name = destination_name
+        else
+          new_parent_node = node_for_path(destination_dir)
+          move_success = false
+          if new_parent_node.is_a? IMoveTarget
+            # The target collection may be able to handle the move
+            source_node = node_for_path(source_path)
+            move_success = new_parent_node.move_into(destination_name, source_path, source_node)
+          end
+          unless move_success
+            copy(source_path, destination_path)
+            node_for_path(source_path).delete
+          end
+        end
+        mark_dirty(source_dir)
+        mark_dirty(destination_dir)
+      end
+
+      # Deletes a node from the tree
+      #
+      # @param string path
+      # @return void
+      def delete(path)
+        node = node_for_path(path)
+        node.delete
+
+        (parent,) = Tilia::Http::UrlUtil.split_path(path)
+        mark_dirty(parent)
+      end
+
+      # Returns a list of childnodes for a given path.
+      #
+      # @param string path
+      # @return array
+      def children(path)
+        node = node_for_path(path)
+        children = node.children
+        basePath = path.gsub(/^\/+|\/+$/, '') + '/'
+
+        children.each do |child|
+          cache[basePath + child.name] = child
+        end
+
+        children
+      end
+
+      # This method is called with every tree update
+      #
+      # Examples of tree updates are:
+      #   * node deletions
+      #   * node creations
+      #   * copy
+      #   * move
+      #   * renaming nodes
+      #
+      # If Tree classes implement a form of caching, this will allow
+      # them to make sure caches will be expired.
+      #
+      # If a path is passed, it is assumed that the entire subtree is dirty
+      #
+      # @param string path
+      # @return void
+      def mark_dirty(path)
+        # We don't care enough about sub-paths
+        # flushing the entire cache
+        path = path.gsub(%r{^/+|/+$}, '') + '/'
+        cache.each do |node_path, _node|
+          if node_path == path || node_path.index(path + '/') == 0
+            cache.delete node_path
+          end
+        end
+      end
+
+      # This method tells the tree system to pre-fetch and cache a list of
+      # children of a single parent.
+      #
+      # There are a bunch of operations in the WebDAV stack that request many
+      # children (based on uris), and sometimes fetching many at once can
+      # optimize this.
+      #
+      # This method returns an array with the found nodes. It's keys are the
+      # original paths. The result may be out of order.
+      #
+      # @param array paths List of nodes that must be fetched.
+      # @return array
+      def multiple_nodes(paths)
+        # Finding common parents
+        parents = {}
+        paths.each do |path|
+          (parent, node) = Tilia::Http::UrlUtil.split_path(path)
+          unless parents.key? parent
+            parents[parent] = [node]
+          else
+            parents[parent] << node
+          end
+        end
+
+        result = {}
+
+        parents.each do |parent, children|
+          parent_node = node_for_path(parent)
+          if parent_node.is_a?(IMultiGet)
+            parent_node.multiple_children(children).each do |child_node|
+              full_path = parent + '/' + child_node.name
+              result[full_path] = child_node
+              cache[full_path] = child_node
+            end
+          else
+            children.each do |child|
+              full_path = parent + '/' + child
+              result[full_path] = node_for_path(full_path)
+            end
+          end
+        end
+
+        result
+      end
+
+      protected
+
+      # copy_node
+      #
+      # @param INode source
+      # @param ICollection destination_parent
+      # @param string destination_name
+      # @return void
+      def copy_node(source, destination_parent, destination_name = nil)
+        destination_name = source.name unless destination_name
+
+        if source.is_a? IFile
+          data = source.get
+
+          # If the body was a string, we need to convert it to a stream
+          if data.is_a? String
+            stream = StringIO.new
+            stream.write data
+            stream.rewind
+            data = stream
+          end
+          destination_parent.create_file(destination_name, data)
+          destination = destination_parent.child(destination_name)
+        elsif source.is_a? ICollection
+          destination_parent.create_directory(destination_name)
+
+          destination = destination_parent.child(destination_name)
+          source.children.each do |child|
+            copy_node(child, destination)
+          end
+        end
+
+        if source.is_a?(IProperties) && destination.is_a?(IProperties)
+          props = source.properties([])
+          prop_patch = PropPatch.new(props)
+          destination.prop_patch(prop_patch)
+          prop_patch.commit
+        end
+      end
+    end
+  end
+end