dav4rack 0.1.1 → 0.1.2

data/README.rdoc

@@ -119,9 +119,8 @@ virtualized resources.
 There are some helpers worth mentioning that make things a little easier. DAV4Rack::Resource#accept_redirect? method is available to Resources.
 If true, the currently connected client will accept and properly use a 302 redirect for a GET request. Most clients do not properly
 support this, which can be a real pain when working with virtualized files that may be located some where else, like S3. To deal with
-those clients that don't support redirects, a helper has been provided so resources don't have to deal with proxying themselves. The 
-DAV4Rack::RemoteFile allows the resource to simply tell Rack to download and send the file from the provided resource and go away, allowing the 
-process to be freed up to deal with other waiters. A very simple example:
+those clients that don't support redirects, a helper has been provided so resources don't have to deal with proxying themselves. The DAV4Rack::RemoteFile
+is a modified Rack::File that can do some interesting things. First, lets look at its most basic use:
 
   class MyResource < DAV4Rack::Resource
     def setup
@@ -138,6 +137,62 @@ process to be freed up to deal with other waiters. A very simple example:
     end
   end
   
+This is a simple proxy. When Rack receives the RemoteFile, it will pull a chunk of data from object, which in turn pulls it from the socket, and
+sends it to the user over and over again until the EOF is reached. This much the same method that Rack::File uses but instead we are pulling
+from a socket rather than an actual file. Now, instead of proxying these files from a remote server every time, lets cache them:
+
+  response.body = DAV4Rack::RemoteFile.new(item[:url], :size => content_length, :mime_type => content_type, :cache_directory => '/tmp')
+
+Providing the :cache_directory will let RemoteFile cache the items locally, and then search for them on subsequent requests before heading out
+to the network. The cached file name is based off the SHA1 hash of the file path, size and last modified time. It is important to note that for
+services like S3, the path will often change, making this cache pretty worthless. To combat this, we can provide a reference to use instead:
+
+  response.body = DAV4Rack::RemoteFile.new(item[:url], :size => content_length, :mime_type => content_type, :cache_directory => '/tmp', :cache_ref => item[:static_url])
+  
+These methods will work just fine, but it would be really nice to just let someone else deal with the proxying and let the process get back
+to dealing with actual requests. RemoteFile will happily do that as long as the frontend server is setup correctly. Using the sendfile approach
+will tell the RemoteFile to simply pass the headers on and let the server deal with doing the actual proxying. First, lets look at an implementation
+using all the features, and then degrade that down to the bare minimum. These examples are NGINX specific, but are based off the Rack::Sendfile implementation
+and as such should be applicable to other servers. First, a simplified NGINX server block:
+
+  server {
+    listen 80;
+    location / {
+      proxy_set_header X-Real-IP $remote_addr;
+      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+      proxy_set_header Host $http_host;
+      proxy_set_header X-Sendfile-Type X-Accel-Redirect;
+      proxy_set_header X-Accel-Remote-Mapping webdav_redirect
+      proxy_pass http://my_app_server;
+    }
+
+    location ~* /webdav_redirect/(.*?)/(.*) {
+      internal;
+      resolver 127.0.0.1;
+      set $re_host $1;
+      set $re_path $2;
+      set $re_url http://$re_host/$re_path?$args;
+      proxy_set_header Authorization '';
+      proxy_set_header Host $re_host;
+      proxy_max_temp_file_size 0;
+      proxy_pass $re_url;
+    }
+  }
+
+With this in place, the parameters for the RemoteFile change slightly:
+  
+  response.body = DAV4Rack::RemoteFile.new(item[:url], :size => content_length, :mime_type => content_type, :sendfile => true)
+  
+The RemoteFile will automatically take care of building out the correct path and sending the proper headers. If the X-Accel-Remote-Mapping header
+is not available, you can simply pass the value:
+
+  response.body = DAV4Rack::RemoteFile.new(item[:url], :size => content_length, :mime_type => content_type, :sendfile => true, :sendfile_prefix => 'webdav_redirect')
+  
+And if you don't have the X-Sendfile-Type header set, you can fix that by changing the value of :sendfile:
+
+  response.body = DAV4Rack::RemoteFile.new(item[:url], :size => content_length, :mime_type => content_type, :sendfile => 'X-Accel-Redirect', :sendfile_prefix => 'webdav_redirect')
+
+And if you have none of the above because your server hasn't been configured for sendfile support, your out of luck until it's configured.
 
 == Authentication
 
@@ -160,7 +215,7 @@ Callbacks can be called before or after a method call. For example:
 
   class MyResource < DAV4Rack::Resource
     before do |resource, method_name|
-      my_authentication_method
+      resource.send(:my_authentication_method)
     end
     
     after do |resource, method_name|

data/dav4rack.gemspec

@@ -1,5 +1,5 @@
 $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + '/lib/'
-require 'dav4rack'
+require 'dav4rack/version'
 Gem::Specification.new do |s|
   s.name = 'dav4rack'
   s.version = DAV4Rack::VERSION
@@ -30,6 +30,7 @@ lib/dav4rack/remote_file.rb
 lib/dav4rack/lock.rb
 lib/dav4rack/lock_store.rb
 lib/dav4rack/logger.rb
+lib/dav4rack/version.rb
 bin/dav4rack
 spec/handler_spec.rb
 README.rdoc

data/lib/dav4rack/handler.rb

@@ -51,7 +51,7 @@ module DAV4Rack
       Logger.info "Processing WebDAV request: #{request.path} (for #{request.ip} at #{Time.now}) [#{request.request_method}]"
       Logger.info "Completed in: #{((Time.now.to_f - start.to_f) * 1000).to_i} ms | #{response.status} [#{request.url}]"
       
-      response.finish
+      response.body.is_a?(Rack::File) ? response.body.call(env) : response.finish
     end
     
   end

data/lib/dav4rack/remote_file.rb

@@ -11,44 +11,64 @@ module DAV4Rack
     
     alias :to_path :path
     
-    # path:: Path to remote file
-    # args:: Optional argument hash. Allowed keys: :size, :mime_type, :last_modified
-    # Create a reference to a remote file. 
-    # NOTE: HTTPError will be raised if path does not return 200 result
+    # path:: path to file (Actual path, preferably a URL since this is a *REMOTE* file)
+    # args:: Hash of arguments:
+    #         :size -> Integer - number of bytes
+    #         :mime_type -> String - mime type
+    #         :last_modified -> String/Time - Time of last modification
+    #         :sendfile -> True or String to define sendfile header variation
+    #         :cache_directory -> Where to store cached files
+    #         :cache_ref -> Reference to be used for cache file name (useful for changing URLs like S3)
+    #         :sendfile_prefix -> String directory prefix. Eg: 'webdav' will result in: /wedav/#{path.sub('http://', '')}
+    #         :sendfile_fail_gracefully -> Boolean if true will simply proxy if unable to determine proper sendfile
     def initialize(path, args={})
-      @fpath = args[:url]
-      @size = args[:size] || nil
-      @mime_type = args[:mime_type] || 'text/plain'
-      @modified = args[:last_modified] || nil
-      @cache = args[:cache_directory] || nil
-      cached_file = @cache + '/' + Digest::SHA1.hexdigest(@fpath)
-      if(File.exists?(cached_file))
+      @path = path
+      @args = args
+      @heads = {}
+      @cache_file = args[:cache_directory] ? cache_file_path : nil
+      @redefine_prefix = nil
+      if(@cache_file && File.exists?(@cache_file))
         @root = ''
-        @path_info = cached_file
+        @path_info = @cache_file
         @path = @path_info
+      elsif(args[:sendfile])
+        @redefine_prefix = 'sendfile'
+        @sendfile_header = args[:sendfile].is_a?(String) ? args[:sendfile] : nil
       else
-        begin
-          @cf = File.open(cached_file, 'w+')
-        rescue
-          @cf = nil
-        end
-        @uri = URI.parse(path)
-        @con = Net::HTTP.new(@uri.host, @uri.port)
-        @call_path = @uri.path + (@uri.query ? "?#{@uri.query}" : '')
-        res = @con.request_get(@call_path)
-        @heads = res.to_hash
-        res.value
-        @store = nil
-        self.public_methods.each do |method|
-          m = method.to_s.dup
-          next unless m.slice!(0,7) == 'remote_'
-          self.class.class_eval "undef :'#{m}'"
-          self.class.class_eval "alias :'#{m}' :'#{method}'"
-        end
+        setup_remote
       end
+      do_redefines(@redefine_prefix) if @redefine_prefix
+    end
+    
+    # env:: Environment variable hash
+    # Process the call
+    def call(env)
+      serving(env)
     end
 
-    def remote_serving
+    # env:: Environment variable hash
+    # Return an empty result with the proper header information
+    def sendfile_serving(env)
+      header = @sendfile_header || env['sendfile.type'] || env['HTTP_X_SENDFILE_TYPE']
+      unless(header)
+        raise 'Failed to determine proper sendfile header value' unless @args[:sendfile_fail_gracefully]
+        setup_remote
+        do_redefines('remote')
+        call(env)
+      end
+      prefix = (@args[:sendfile_prefix] || env['HTTP_X_ACCEL_REMOTE_MAPPING']).to_s.sub(/^\//, '').sub(/\/$/, '')
+      [200, {
+             "Last-Modified" => last_modified,
+             "Content-Type" => content_type,
+             "Content-Length" => size,
+             header => "/#{prefix}/#{URI.decode(@path.sub('http://', ''))}"
+            },
+      ['']]
+    end
+    
+    # env:: Environment variable hash
+    # Return self to be processed
+    def remote_serving(e)
       [200, {
              "Last-Modified"  => last_modified,
              "Content-Type"   => content_type,
@@ -56,15 +76,7 @@ module DAV4Rack
             }, self]
     end
     
-    
-    def remote_call(env)
-      dup._call(env)
-    end
-    
-    def remote__call(env)
-      serving
-    end
-    
+    # Get the remote file
     def remote_each
       if(@store)
         yield @store
@@ -78,19 +90,57 @@ module DAV4Rack
       end
     end
     
+    # Size based on remote headers or given size
     def size
       @heads['content-length'] || @size
     end
     
     private
     
+    # Content type based on provided or remote headers
     def content_type
       @mime_type || @heads['content-type']
     end
     
+    # Last modified type based on provided, remote headers or current time
     def last_modified
-      @heads['last-modified'] || @modified
+      @heads['last-modified'] || @modified || Time.now.httpdate
     end
 
+    # Builds the path for the cached file
+    def cache_file_path
+      raise IOError.new 'Write permission is required for cache directory' unless File.writable?(@args[:cache_directory])
+      "#{@args[:cache_directory]}/#{Digest::SHA1.hexdigest((@args[:cache_ref] || @path).to_s + size.to_s + last_modified.to_s)}.cache"
+    end
+    
+    # prefix:: prefix of methods to be redefined
+    # Redefine methods to do what we want in the proper situation
+    def do_redefines(prefix)
+      self.public_methods.each do |method|
+        m = method.to_s.dup
+        next unless m.slice!(0, prefix.to_s.length + 1) == "#{prefix}_"
+        self.class.class_eval "undef :'#{m}'"
+        self.class.class_eval "alias :'#{m}' :'#{method}'"
+      end
+    end
+    
+    # Sets up all the requirements for proxying a remote file
+    def setup_remote
+      if(@cache_file)
+        begin
+          @cf = File.open(@cache_file, 'w+')
+        rescue
+          @cf = nil
+        end
+      end
+      @uri = URI.parse(@path)
+      @con = Net::HTTP.new(@uri.host, @uri.port)
+      @call_path = @uri.path + (@uri.query ? "?#{@uri.query}" : '')
+      res = @con.request_get(@call_path)
+      @heads = res.to_hash
+      res.value
+      @store = nil
+      @redefine_prefix = 'remote'
+    end
   end
 end

data/lib/dav4rack/version.rb

@@ -0,0 +1,3 @@
+module DAV4Rack
+  VERSION = '0.1.2'
+end

data/lib/dav4rack.rb

@@ -7,7 +7,3 @@ require 'dav4rack/http_status'
 require 'dav4rack/resource'
 require 'dav4rack/handler'
 require 'dav4rack/controller'
-
-module DAV4Rack
-  VERSION = '0.1.1'
-end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dav4rack
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 31
   prerelease: false
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Chris Roberts
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-11 00:00:00 -07:00
+date: 2010-08-12 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -74,6 +74,7 @@ files:
 - lib/dav4rack/lock.rb
 - lib/dav4rack/lock_store.rb
 - lib/dav4rack/logger.rb
+- lib/dav4rack/version.rb
 - bin/dav4rack
 - spec/handler_spec.rb
 - README.rdoc