mutex store

module Merb::Cache
  class MutexFetchStore < StrategyStore
    def initialize(config = {})
      super(config)
      @interval = config[:sleep_interval] || 0.1
      @timeout = config[:timeout] || 0.5
    end

    def writable?(key, parameters = {}, conditions = {})
      contexts.any? {|c| c.writable?(key, parameters, conditions)}
    end

    def read(key, parameters = {})
      contexts.capture_first {|c| c.read(key, parameters)}
    end

    def write(key, data = nil, parameters = {}, conditions = {})
      if writable?(key, conditions)
        contexts.capture_first {|c| c.write(key, data, parameters, conditions)}
      end
    end

    def fetch(key, parameters = {}, conditions = {}, &blk)
      if data = read(key, parameters)
        return data
      end

      contexts.capture_first {|c| c.mutexed_fetch(c, key, parameters, conditions, &blk)} if writable?(key, conditions)
    end

    def mutexed_fetch(store, key, parameters = {}, conditions, &data_blk)
      if store.exists?(mutex_key, parameters)
        mutexed_read(store, key, parameters)
      else
        mutexed_write(store, key, parameters, conditions, &data_blk)
      end
    end

    def mutexed_read(store, key, parameters)
      timer = 0.0

      while(store.exists?(mutex_key, parameters))
        return nil if timer > @timeout
        sleep(@interval)
        timer += @interval
      end

      store.read(key, parameters)
    end

    def mutexed_write(store, key, parameters, conditions, &data_blk)
      store.write(mutex_key, Thread.current.object_id, parameters)

      if store.read(mutex_key, parameters) == Thread.current.object_id
        store.fetch(key, parameters, conditions, &data_blk)
      else
        mutexed_read(store, key, parameters)
      end
    ensure
      store.delete(mutex_key, parameters)
    end

    def delete(key, parameters = {})
      contexts.capture_intersection {|c| c.delete(digest(key, parameters))}
    end

    def delete_all
      raise NotImplementedError
    end

    def mutex_key(key)
      "#{key}_mutex"
    end
  end
end