tilia-dav 3.1.0.pre.alpha2

data/lib/tilia/dav/locks.rb

@@ -0,0 +1,9 @@
+module Tilia
+  module Dav
+    module Locks
+      require 'tilia/dav/locks/lock_info'
+      require 'tilia/dav/locks/backend'
+      require 'tilia/dav/locks/plugin'
+    end
+  end
+end

data/lib/tilia/dav/locks/backend.rb

@@ -0,0 +1,12 @@
+module Tilia
+  module Dav
+    module Locks
+      module Backend
+        require 'tilia/dav/locks/backend/backend_interface'
+        require 'tilia/dav/locks/backend/abstract_backend'
+        require 'tilia/dav/locks/backend/file'
+        require 'tilia/dav/locks/backend/sequel'
+      end
+    end
+  end
+end

data/lib/tilia/dav/locks/backend/abstract_backend.rb

@@ -0,0 +1,16 @@
+module Tilia
+  module Dav
+    module Locks
+      module Backend
+        # This is an Abstract clas for lock backends.
+        #
+        # Currently this backend has no function, but it exists for consistency, and
+        # to ensure that if default code is required in the backend, there will be a
+        # non-bc-breaking way to do so.
+        class AbstractBackend
+          include BackendInterface
+        end
+      end
+    end
+  end
+end

data/lib/tilia/dav/locks/backend/backend_interface.rb

@@ -0,0 +1,41 @@
+module Tilia
+  module Dav
+    module Locks
+      module Backend
+        # If you are defining your own Locks backend, you must implement this
+        # interface.
+        module BackendInterface
+          # Returns a list of Sabre\DAV\Locks\LockInfo objects
+          #
+          # This method should return all the locks for a particular uri, including
+          # locks that might be set on a parent uri.
+          #
+          # If returnChildLocks is set to true, this method should also look for
+          # any locks in the subtree of the uri for locks.
+          #
+          # @param string uri
+          # @param bool return_child_locks
+          # @return array
+          def locks(uri, return_child_locks)
+          end
+
+          # Locks a uri
+          #
+          # @param string uri
+          # @param Locks\LockInfo lock_info
+          # @return bool
+          def lock(uri, lock_info)
+          end
+
+          # Removes a lock from a uri
+          #
+          # @param string uri
+          # @param Locks\LockInfo lock_info
+          # @return bool
+          def unlock(uri, lock_info)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tilia/dav/locks/backend/file.rb

@@ -0,0 +1,146 @@
+require 'yaml'
+
+module Tilia
+  module Dav
+    module Locks
+      module Backend
+        # This Locks backend stores all locking information in a single file.
+        #
+        # Note that this is not nearly as robust as a database. If you are considering
+        # using this backend, keep in mind that the PDO backend can work with SqLite,
+        # which is designed to be a good file-based database.
+        #
+        # It literally solves the problem this class solves as well, but much better.
+        class File < AbstractBackend
+          # The storage file
+          #
+          # @var string
+          # RUBY: attr_accessor :locks_file
+
+          # Constructor
+          #
+          # @param string locks_file path to file
+          def initialize(locks_file)
+            @locks_file = locks_file
+          end
+
+          # Returns a list of Sabre\DAV\Locks\LockInfo objects
+          #
+          # This method should return all the locks for a particular uri, including
+          # locks that might be set on a parent uri.
+          #
+          # If returnChildLocks is set to true, this method should also look for
+          # any locks in the subtree of the uri for locks.
+          #
+          # @param string uri
+          # @param bool return_child_locks
+          # @return array
+          def locks(uri, return_child_locks)
+            new_locks = []
+
+            locks = data
+
+            locks.each do |lock|
+              next unless lock.uri == uri ||
+                          # deep locks on parents
+                          (lock.depth != 0 && uri.index("#{lock.uri}/") == 0) ||
+                          # locks on children
+                          (return_child_locks && lock.uri.index("#{uri}/") == 0)
+              new_locks << lock
+            end
+
+            # Checking if we can remove any of these locks
+            new_locks.each_with_index do |lock, k|
+              new_locks.delete_at(k) if Time.now.to_i > lock.timeout + lock.created
+            end
+            new_locks
+          end
+
+          # Locks a uri
+          #
+          # @param string uri
+          # @param LockInfo lock_info
+          # @return bool
+          def lock(uri, lock_info)
+            # We're making the lock timeout 30 minutes
+            lock_info.timeout = 1800
+            lock_info.created = Time.now.to_i
+            lock_info.uri = uri
+
+            locks = data
+
+            locks.each_with_index do |lock, k|
+              if lock.token == lock_info.token ||
+                 Time.now.to_i > lock.timeout + lock.created
+                locks.delete_at(k)
+              end
+            end
+
+            locks << lock_info
+            put_data(locks)
+            true
+          end
+
+          # Removes a lock from a uri
+          #
+          # @param string uri
+          # @param LockInfo lock_info
+          # @return bool
+          def unlock(_uri, lock_info)
+            locks = data
+            locks.each_with_index do |lock, k|
+              next unless lock.token == lock_info.token
+              locks.delete_at(k)
+              put_data(locks)
+              return true
+            end
+
+            false
+          end
+
+          protected
+
+          # Loads the lockdata from the filesystem.
+          #
+          # @return array
+          def data
+            return [] unless ::File.exist?(@locks_file)
+
+            # opening up the file, and creating a shared lock
+            handle = ::File.open(@locks_file, 'r')
+            handle.flock(::File::LOCK_SH)
+
+            # Reading data until the eof
+            data = handle.readlines.join('')
+
+            # We're all good
+            handle.flock(::File::LOCK_UN)
+            handle.close
+
+            # Unserializing and checking if the resource file contains data for this file
+            data = YAML.load(data)
+            data || []
+          end
+
+          # Saves the lockdata
+          #
+          # @param array new_data
+          # @return void
+          def put_data(new_data)
+            # opening up the file, and creating an exclusive lock
+            handle = ::File.open(@locks_file, 'a+')
+            handle.flock(::File::LOCK_EX)
+
+            # We can only truncate and rewind once the lock is acquired.
+            handle.truncate(0)
+            handle.rewind
+
+            handle.write(YAML.dump(new_data))
+            handle.flock(::File::LOCK_UN)
+            handle.close
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tilia/dav/locks/backend/sequel.rb

@@ -0,0 +1,154 @@
+module Tilia
+  module Dav
+    module Locks
+      module Backend
+        # The Lock manager allows you to handle all file-locks centrally.
+        #
+        # This Lock Manager stores all its data in a database. You must pass a PDO
+        # connection object in the constructor.
+        class Sequel < AbstractBackend
+          # The PDO tablename this backend uses.
+          #
+          # @var string
+          attr_accessor :table_name
+
+          protected
+
+          # The PDO connection object
+          #
+          # @var sequel
+          attr_accessor :sequel
+
+          public
+
+          # Constructor
+          #
+          # @param sequel
+          def initialize(sequel)
+            @sequel = sequel
+            @table_name = 'locks'
+          end
+
+          # Returns a list of Sabre\DAV\Locks\LockInfo objects
+          #
+          # This method should return all the locks for a particular uri, including
+          # locks that might be set on a parent uri.
+          #
+          # If returnChildLocks is set to true, this method should also look for
+          # any locks in the subtree of the uri for locks.
+          #
+          # @param string uri
+          # @param bool return_child_locks
+          # @return array
+          def locks(uri, return_child_locks)
+            # NOTE: the following 10 lines or so could be easily replaced by
+            # pure sql. MySQL's non-standard string concatenation prevents us
+            # from doing this though.
+            query = "SELECT owner, token, timeout, created, scope, depth, uri FROM #{@table_name} WHERE (created > (? - timeout)) AND ((uri = ?)"
+            params = [Time.now.to_i, uri]
+
+            # We need to check locks for every part in the uri.
+            uri_parts = uri.split('/')
+
+            # We already covered the last part of the uri
+            uri_parts.pop
+
+            current_path = ''
+
+            uri_parts.each do |part|
+              current_path << '/' unless current_path.blank?
+              current_path << part
+
+              query << ' OR (depth!=0 AND uri = ?)'
+              params << current_path
+            end
+
+            if return_child_locks
+              query << ' OR (uri LIKE ?)'
+              params << "#{uri}/%"
+            end
+
+            query << ')'
+
+            lock_list = []
+            @sequel.fetch(query, *params) do |row|
+              lock_info = LockInfo.new
+              lock_info.owner = row[:owner]
+              lock_info.token = row[:token]
+              lock_info.timeout = row[:timeout]
+              lock_info.created = row[:created]
+              lock_info.scope = row[:scope]
+              lock_info.depth = row[:depth]
+              lock_info.uri   = row[:uri]
+              lock_list << lock_info
+            end
+
+            lock_list
+          end
+
+          # Locks a uri
+          #
+          # @param string uri
+          # @param LockInfo lock_info
+          # @return bool
+          def lock(uri, lock_info)
+            # We're making the lock timeout 30 minutes
+            lock_info.timeout = 30 * 60
+            lock_info.created = Time.now.to_i
+            lock_info.uri = uri
+
+            locks = locks(uri, false)
+            exists = false
+            locks.each do |lock|
+              exists = true if lock.token == lock_info.token
+            end
+
+            if exists
+              update_ds = @sequel[
+                "UPDATE #{@table_name} SET owner = ?, timeout = ?, scope = ?, depth = ?, uri = ?, created = ? WHERE token = ?",
+                lock_info.owner,
+                lock_info.timeout,
+                lock_info.scope,
+                lock_info.depth,
+                uri,
+                lock_info.created,
+                lock_info.token
+              ]
+              update_ds.update
+            else
+              insert_ds = @sequel[
+                "INSERT INTO #{@table_name} (owner,timeout,scope,depth,uri,created,token) VALUES (?,?,?,?,?,?,?)",
+                lock_info.owner,
+                lock_info.timeout,
+                lock_info.scope,
+                lock_info.depth,
+                uri,
+                lock_info.created,
+                lock_info.token
+              ]
+              insert_ds.insert
+            end
+
+            true
+          end
+
+          # Removes a lock from a uri
+          #
+          # @param string uri
+          # @param LockInfo lock_info
+          # @return bool
+          def unlock(uri, lock_info)
+            delete_ds = @sequel[
+              "DELETE FROM #{@table_name} WHERE uri = ? AND token = ?",
+              uri,
+              lock_info.token
+            ]
+            result = delete_ds.delete
+
+            result == 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tilia/dav/locks/lock_info.rb

@@ -0,0 +1,60 @@
+module Tilia
+  module Dav
+    module Locks
+      # LockInfo class
+      #
+      # An object of the LockInfo class holds all the information relevant to a
+      # single lock.
+      class LockInfo
+        # A shared lock
+        SHARED = 1
+
+        # An exclusive lock
+        EXCLUSIVE = 2
+
+        # A never expiring timeout
+        TIMEOUT_INFINITE = -1
+
+        # The owner of the lock
+        #
+        # @var string
+        attr_accessor :owner
+
+        # The locktoken
+        #
+        # @var string
+        attr_accessor :token
+
+        # How long till the lock is expiring
+        #
+        # @var int
+        attr_accessor :timeout
+
+        # UNIX Timestamp of when this lock was created
+        #
+        # @var int
+        attr_accessor :created
+
+        # Exclusive or shared lock
+        #
+        # @var int
+        attr_accessor :scope
+
+        # Depth of lock, can be 0 or Sabre\DAV\Server::DEPTH_INFINITY
+        attr_accessor :depth
+
+        # The uri this lock locks
+        #
+        # TODO: This value is not always set
+        # @var mixed
+        attr_accessor :uri
+
+        # TODO: document
+        def initialize
+          @scope = EXCLUSIVE
+          @depth = 0
+        end
+      end
+    end
+  end
+end