rsence-pre 2.1.0.1.pre

data/plugins/main/main.rb

@@ -0,0 +1,255 @@
+##   RSence
+ #   Copyright 2008 Riassence Inc.
+ #   http://riassence.com/
+ #
+ #   You should have received a copy of the GNU General Public License along
+ #   with this software package. If not, contact licensing@riassence.com
+ ##
+
+
+# The MainPlugin is accessible as +@plugins.main+ from other plugins.
+#
+# = MainPlugin provides mainly client setup and the following services:
+# * The url of the client as a HValue, including the anchor.
+#   * Accessible via +msg.session[:main][:location_href]+
+# * The local time of the client's web browser as a HValue, as seconds since epoch.
+#   * Accessible via +msg.session[:main][:client_time]+
+# * Sequential loading. See {#delayed_call #delayed_call}
+# * Provides the +#init_ui+ event for plugins that respond to it.
+class MainPlugin < Plugin
+  
+  # @private Internal structures, binds configuration data as instance variables
+  def init
+    super
+    @conf  = ::RSence.config[:index_html]
+    @bconf = ::RSence.config[:broker_urls]
+    @goodbye_uri = File.join(@bconf[:hello],'goodbye')
+  end
+  
+  # @private Internal structures, matches the "hello/goodbye" session termination request
+  def match( uri, request_type )
+    if request_type == :post and uri == @goodbye_uri
+      return true
+    end
+    return false
+  end
+  
+  # @private Internal structures, score for the "hello/goodbye" session termination request
+  def score; 100; end
+  
+  # @private Internal structures, handler for the "hello/goodbye" session termination request
+  def post( req, res, ses )
+    @plugins.sessions.expire_ses_by_req( req, res )
+  end
+  
+  # @private url_responder gets called whenever the
+  #          page location.href changes, enabled virtual uris
+  #          to enable back/forward/bookmarking in browsers,
+  #          when software is coded to support it.
+  #
+  # Client-side support is included in js/url_responder.js
+  #
+  # Also allows virtual-host -like behavior, if software is coded to support it.
+  def url_responder(msg,location_href)
+    
+    ses = get_ses( msg )
+    
+    # Virtual locations:
+    if location_href.data.include?('#')
+      
+      # split 'http://localhost:8001/#/some_uri'
+      #   -> ['http://localhost:8001/','/some_uri']
+      ses[:url] = location_href.data.split('#')
+      
+      virtual_uri = ses[:url][1]
+      
+      # built-in support for signing out, deletes the
+      # server-side session and reloads the page
+      if virtual_uri == '/sign_out'
+        resp_addr = @conf[:respond_address]
+        msg.expire_session()
+        msg.reply( [
+          'COMM.Transporter.stop=true;',
+          "location.href=#{resp_addr.to_json};"
+        ].join('') )
+      end
+      
+    else
+      ses[:url] = [location_href.data,nil]
+    end
+    
+    # url_responder always accepts locations
+    return true
+    
+  end
+  
+  
+  # @private new session initialization, called just once per session.
+  def init_ses(msg)
+    super
+    restore_ses( msg )
+  end
+  
+  # @private called once when a session is restored using the cookie's ses_key
+  def restore_ses(msg)
+    super
+    ## Resets session data to defaults
+    ses = get_ses( msg )
+    ses[:boot] = 0
+    ses[:url] = [nil,nil]
+    ses[:delayed_calls] = []
+    ses[:poll_mode] = true
+  end
+  
+  # Interface for adding delayed calls
+  #
+  # When adding a delayed call, use an Array to define a plugin/method with optional arguments that will be called on the next request. The client will call back immediately when a delayed call is pending. The first param of the method is a +msg+. Don't include the +msg+ of the current request in params, it will be inserted automatically for the delayed call.
+  #
+  # It can also be used for loading sequences to the client, when using a String as the +params+.
+  #
+  # == Format of +params+ for plugin callback:
+  # Array:: [ plugin_name, method_name, *args ]
+  #
+  # == Format of +params+ for javascript sequences:
+  # String:: Javascript to send
+  #
+  # Calls will be flushed per request with the following conditions:
+  # * At most four (4) delayed calls will be processed at a time
+  # * If the calls use more than 200ms combined, even less will be processed at a time
+  #
+  # @param [Message] msg The message instance.
+  # @param [Array, String] params The params of the delayed call.
+  #
+  # @return [nil]
+  def delayed_call( msg, params )
+    get_ses( msg )[:delayed_calls].push( params )
+  end
+  
+  # @private Initializes the client-side COMM.urlResponder and sesWatcher
+  def boot0( msg, ses )
+    
+    msg.reply read_js( 'main' )
+
+    msg.reply("ELEM.setStyle(0,'background-color','#{::RSence.config[:main_plugin][:bg_color]}');")
+    
+    ## url_responder is bound in the client-space
+    ## to tell the server its status by updating its value
+    location_href_id = ses[:location_href].val_id.to_json
+    msg.reply "COMM.Values.values[#{location_href_id}].bind(COMM.urlResponder);"
+    
+    ## This enables SesWatcher that changes :client_time every 60 seconds.
+    ## It makes the client to poll the server on regular intervals, when polling mode
+    ## is disabled.
+    # 5000ms = 5secs
+    
+    client_time_id = ses[:client_time].val_id.to_json
+    poll_interval = ::RSence.config[:main_plugin][:server_poll_interval]
+    msg.reply "sesWatcher = COMM.SessionWatcher.nu(#{poll_interval},#{client_time_id});"
+    
+  end
+  
+  # @private Calls the init_ui method of each loaded plugin and removes the loading -message
+  def boot1( msg, ses )
+    # Delegates the init_ui method to each plugin to signal bootstrap completion.
+    msg.plugins.delegate( 'init_ui', msg ) unless ses[:dont_init_ui]
+  end
+  
+  # @private
+  def dont_init_ui( msg )
+    get_ses( msg )[:dont_init_ui] = true
+  end
+  
+  # @private Flushes commands in the :delayed_calls array
+  def flush_delayed( msg, ses )
+    ## Limits the amount of delayed calls to process to 4.
+    ## Prevents the client from choking even when the server
+    ## load is light.
+    if ses[:delayed_calls].size < 4
+      call_count = ses[:delayed_calls].size
+    else
+      call_count = 4
+    end
+    
+    time_start = Time.now.to_f
+    time_taken = 0.0
+    
+    ## process delayed calls, until:
+    ## - over 200ms of cpu time has been spent
+    ## - the :delayed_calls -array is empty
+    ## - call_count limit is reached
+    until time_taken > 0.2 or ses[:delayed_calls].size == 0 or call_count == 0
+      # gets the next call
+      delayed_call = ses[:delayed_calls].shift
+      if RSence.args[:debug]
+        puts "delayed_call: #{delayed_call.inspect}"
+      end
+      # strings are always javascript, used for segmenting client load
+      if delayed_call.class == String
+        msg.reply delayed_call
+      # arrays are plugin calls
+      elsif delayed_call.class == Array
+        # ['plugin_name', 'method_name'] pairs call the named plugin:method with just msg
+        if delayed_call.size == 2
+          (plugin_name,method_name) = delayed_call
+          msg.run(plugin_name,method_name,msg)
+        # if the array contains more items, they are used as additional method params
+        else
+          (plugin_name,method_name) = delayed_call[0..1]
+          method_params = delayed_call[2..-1]
+          msg.run(plugin_name,method_name,msg,*method_params)
+        end
+      end
+      ## calculates time taken
+      time_taken = Time.now.to_f - time_start
+      call_count -= 1
+    end
+    ## Sets the client into poll mode, unless the :delayed_calls -array is empty
+    if ses[:boot] > 1
+      if ses[:delayed_calls].empty?
+        end_polling( msg, ses )
+      else
+        start_polling( msg, ses )
+      end
+    end
+  end
+  
+  # @private When nothing is delayed and the second poll has been made (init_ui called),
+  #          sets the client to non-polling-mode, having only HValue
+  #          changes trigger new requests. SesWatcher makes this happen
+  #          regularly.
+  def end_polling( msg, ses )
+    if ses[:poll_mode] == true
+      msg.reply "COMM.Transporter.poll(0);"
+      ses[:poll_mode] = false
+    end
+  end
+  
+  # @private Starts polling.
+  def start_polling( msg, ses )
+    if ses[:poll_mode] == false
+      msg.reply( "COMM.Transporter.poll(#{::RSence.config[:transporter_conf][:client_poll_priority]});" )
+      ses[:poll_mode] = true
+    end
+  end
+  
+  # @private called on every request of an active, valid session
+  def idle(msg)
+    
+    ses = get_ses( msg )
+    
+    if ses[:boot] == 0
+      boot0( msg, ses )
+    elsif ses[:boot] == 1
+      boot1( msg, ses )
+    elsif not ses[:delayed_calls].empty?
+      flush_delayed( msg, ses )
+    elsif ses[:boot] > 1
+      end_polling( msg, ses )
+    end
+    ## Increment the counter forever.
+    ses[:boot] += 1
+  end
+  
+end
+
+

data/plugins/main/values.yaml

@@ -0,0 +1,8 @@
+:client_time:
+  :value: 0
+  :restore_default: false
+:location_href:
+  :value: ''
+  :restore_default: true
+  :responders:
+  - { :plugin: main, :method: url_responder }

data/plugins/ticket/info.yaml

@@ -0,0 +1,21 @@
+
+# The human-readable product name of the package
+title: Ticket services
+
+# The human-readable version of the package
+version: 2.0.0
+
+# A brief description of the package (rdoc formatting supported)
+description: |
+  This bundle provides various ticket services for serving files and file-like objects using disposable url's.
+
+# A flag (when false) prevents the plugin from automatically reload when changed.
+reloadable: false
+
+# System version requirement.
+sys_version: '>= 2.0.0'
+
+category: :system
+
+depends_on: :core
+

data/plugins/ticket/lib/common.rb

@@ -0,0 +1,392 @@
+##   RSence
+ #   Copyright 2008 Riassence Inc.
+ #   http://riassence.com/
+ #
+ #   You should have received a copy of the GNU General Public License along
+ #   with this software package. If not, contact licensing@riassence.com
+ ##
+
+
+# @private Inner workings of Ticket
+module TicketService
+
+# @private Inner workings of Ticket
+module Common
+  
+  def initialize
+    # storage for tickets to be expired by expiry time
+    # as the key and an array of ids in array as the value
+    @expires = {}
+    @expire_files = {}
+    @expire_blobobj = {}
+    
+    # storage for disposable images
+    @imgs = {
+      
+      # id is used as the uri
+      :by_id   => {},
+      
+      # list of image ids by session id
+      :ses_ids => {}
+    }
+    
+    # storage for other disposable data
+    @files = {
+      
+      # id is used as the uri
+      :by_id   => {},
+      
+      # list of image ids by session id
+      :ses_ids => {}
+    }
+    
+    # an randgen instance used for generating ids (84B long)
+    @randgen = RandGen.new( 84 )
+    
+    # supported image content types
+    @content_types = {
+      'GIF' => 'image/gif',
+      'PNG' => 'image/png',
+      'JPG' => 'image/jpeg'
+    }
+    
+    # static data, initially for invalid/not found error-gif
+    # also all serve_rsrc items
+    @raw_uris = {
+      'invalid.gif' => ['image/gif','53',['749464839316700090000800000000004e7ebe129f400000000000c200000000700090000020c0c8f70a9c810e0229ea2da1a000b3'].pack('h*')],
+      'favicon.ico' => ['image/gif','371',['749464839316010001005d00005e5e3dd1d1a1ca7dbf983cfeb9dc5ff8f848db1effbd1fff27279609a600cacae9e0e0d0dcaeff8e8fff030303010101848424afffff0000007be7008c8c9bffffff878b9e0eba712fcfffb2b282e9c6000d5900020202bd3a70ababbaf8f834f9f9f9f8f8f887fafafafa49060606fefefe0707700707074e3bc2939353ce6cd50404007d7d6cfafafa8edb34dcfcfc0f0d97fbfbfb000000000000000000000000000000000000000000000000000000000000000000000000000000000000129f401000000000c20000000001000100006009040801058c8420e91a258ca41744380506934656846910140e04051092ca650688d282bc2072bb5303e0728c2330d6fbb15a78249291bbf0d0811102353410124677285190b2e524e110e0f208b890a13176a480b0725211c889b16227a44101f0027931b1d171a745a010b2caea82f15845c9627182e2a2e050f5007af0f1a203329bf52be032d2213ca4501021501400b3'].pack('h*')]
+    }
+    
+    @upload_slots = {
+      # upload slots
+      :by_id => {
+        # random key      mime    max_size session_id 
+        # 'test123'  => [ '*/*',  15000,   12         ]
+      },
+      # processed uploads
+      :uploaded => {
+        # same key as :by_id  rsence_uploads:id
+        # 'test123'  =>       [37483,37546,38759]
+      },
+      # upload ids by session id
+      :ses_ids => {
+        # 12 => ['test123']
+      }
+    }
+    
+    @blob_objs = {
+      :by_id   => {},
+      :ses_ids => {}
+    }
+    
+    begin
+      db_uri = ::RSence.config[:database][:ses_db]
+      if db_uri.start_with?('sqlite://')
+        @db = Sequel.sqlite( db_uri.split('sqlite://')[1] )
+      else
+        @db = Sequel.connect( db_uri )
+      end
+    rescue => e
+      if RSence.args[:debug]
+        err_msg = [
+          "ERROR: TicketServices couldn't open database",
+          "#{e.class.to_s}, #{e.message}",
+          "Backtrace:",
+          "\t"+e.backtrace.join("\n\t")
+        ].join("\n")+"\n"
+        $stderr.write( err_msg )
+      elsif RSence.args[:verbose]
+        puts "Failed to open database '#{@db_uri}'."
+        puts "Run RSence in debug mode for full error output."
+      end
+      @upload_id = 0
+      @db = false
+    end
+  end
+
+  attr_accessor :raw_uris # :nodoc:
+  attr_accessor :imgs # :nodoc:
+  attr_accessor :content_types # :nodoc:
+  
+  # Helper method to return the time formatted according to the HTTP RFC
+  def httime(time)
+    return time.gmtime.strftime('%a, %d %b %Y %H:%M:%S %Z')
+  end
+  
+  # Disconnects connection to the database.
+  def shutdown # :nodoc:
+    @db.disconnect if @db
+  end
+  
+  # Serves files and images by returning an URI. Content is given as second 
+  # parameter. Optional third defaults to 'PNG' and defines the format. 
+  # Optional fourth parameter is where there are two possibilities :img 
+  # and :file, defaults to :img. URI works as an ID for data.
+  def serve( msg, content, format='PNG', type=:img )
+    
+    # gets a new, unique identifier
+    ticket_id = @randgen.gen
+    
+    # serve image
+    if type == :img
+      
+      # makes sure the format is in uppper case
+      format.upcase!
+      
+      # checks, that the format is a supported image type
+      unless @content_types.keys.include?( format )
+        puts "ImgServe.serve: invalid format (#{format.inspect})" if RSence.args[:verbose]
+        return File.join(::RSence.config[:broker_urls][:i],'invalid.gif')
+      end
+      
+      # changes the format to GIF for IE6
+      format = 'GIF' if msg.ie6 and format == 'PNG'
+      
+      # stores the image data and meta-data ready to be served
+      storage_hash = @imgs
+      storage_arr = [format,0,content,msg.ses_id]
+      
+      # return an uri that will respond to the data
+      uri = File.join(::RSence.config[:broker_urls][:i],"#{ticket_id}.#{format.downcase}")
+    
+    # serve file
+    elsif type == :file
+      
+      # re-map content_type and filename meta-data from format
+      (content_type, filename) = format
+      
+      # content size for the header
+      content_size = content.size.to_s
+      
+      storage_hash = @files
+      storage_arr = [content_type,content_size,content,msg.ses_id,filename]
+      
+      uri = File.join(::RSence.config[:broker_urls][:f],ticket_id)
+    end
+    
+    # makes sure, that the storage array has a sub-array for sessions (to aid session-based cleanup)
+    storage_hash[:ses_ids][msg.ses_id] = [] unless @imgs[:ses_ids].has_key?(msg.ses_id)
+    
+    # adds the id to the session-specific storage
+    storage_hash[:ses_ids][msg.ses_id].push( ticket_id )
+    
+    storage_hash[:by_id][ticket_id] = storage_arr
+    
+    return uri
+  end
+  
+  # Alias for +Ticketserve#serve+.
+  alias serve_img serve
+  
+  # Flushes disposable storage when the session expires. Session id is given
+  # as a parameter.
+  def expire_ses( ses_id ) # :nodoc:
+    
+    # flush images by session id
+    if @imgs[:ses_ids].has_key?(ses_id)
+      
+      # goes through the array, until it's empty
+      until @imgs[:ses_ids][ses_id].empty?
+        img_id = @imgs[:ses_ids][ses_id].shift
+        del_img( img_id, ses_id )
+      end
+      
+      # finally, removes the session id
+      @imgs[:ses_ids].delete( ses_id )
+    end
+    
+    # flush other data by session id
+    if @files[:ses_ids].has_key?(ses_id)
+      
+      # goes through the array, until it's empty
+      until @files[:ses_ids][ses_id].empty?
+        file_id = @files[:ses_ids][ses_id].shift
+        del_file( file_id, ses_id )
+      end
+      
+      # finally, removes the session id
+      @files[:ses_ids].delete( ses_id )
+    end
+    
+    if @upload_slots[:ses_ids].has_key?(ses_id)
+      # goes through the array, until it's empty
+      until @upload_slots[:ses_ids][ses_id].empty?
+        ticket_id = @upload_slots[:ses_ids][ses_id].shift
+        del_uploads( ticket_id, ses_id )
+      end
+      
+      # finally, removes the session id
+      @upload_slots[:ses_ids].delete( ses_id )
+    end
+    
+    if @blob_objs[:ses_ids].has_key?(ses_id)
+      # goes through the array, until it's empty
+      until @blob_objs[:ses_ids][ses_id].empty?
+        ticket_id = @blob_objs[:ses_ids][ses_id].shift
+        del_blobobj( ticket_id, ses_id )
+      end
+      
+      # finally, removes the session id
+      @blob_objs[:ses_ids].delete( ses_id )
+    end
+    
+  end
+  
+  # Serves data based on get request. Is used automatically by +Broker+.
+  def get_ticket( req, res, type=:img ) # :nodoc:
+    
+    is_invalid = true
+    
+    if type == :img
+      
+      img_id = req.unparsed_uri.match(/^#{::RSence.config[:broker_urls][:i]}(.*)$/)[1]
+      
+      if img_id == nil
+        puts "ImgServe.fetch_img: invalid uri#1 (#{req.unparsed_uri.inspect})" if RSence.args[:verbose]
+        img_id = 'invalid.gif'
+      end
+      
+      img_id = img_id.split('.')[0]
+      
+      if img_id == nil
+        puts "ImgServe.fetch_img: invalid uri#2 (#{req.unparsed_uri.inspect})" if RSence.args[:verbose]
+        img_id = 'invalid.gif'
+      
+      elsif img_id.size != 84
+        puts "ImgServe.fetch_img: invalid img_id (#{img_id.inspect})" if RSence.args[:verbose]
+        img_id = 'invalid.gif'
+      end
+      
+      if @raw_uris.include?(img_id)
+        (content_type,content_size,content) = @raw_uris[img_id]
+        
+      elsif @imgs[:by_id].include?(img_id)
+        
+        (format,content_size_zero,img_data,ses_id) = @imgs[:by_id][img_id]
+        
+        # renders the Magick::Image object
+        content = img_data.to_blob {
+          self.format = format
+        }
+      
+        # content size for the header
+        content_size = content.size.to_s
+      
+        # content type for the header
+        content_type = @content_types[format]
+        
+        if req.header.has_key?('keep-alive') and req.header['keep-alive'].size > 0
+          keep_alive = req.header['keep-alive'][0].to_i
+          keep_alive = 10  if keep_alive < 10
+          keep_alive = 600 if keep_alive > 600
+          push_keepalive( img_id, keep_alive )
+          expire_keepalives
+        else
+          del_img( img_id, ses_id )
+        end
+      else
+        (content_type,content_size,content) = @raw_uris['invalid.gif']
+      end
+      
+    
+    elsif type == :file
+      file_id = req.unparsed_uri.match(/^#{::RSence.config[:broker_urls][:f]}(.*)$/)[1]
+      if file_id == nil
+        puts "fileServe.fetch_file: invalid uri#1 (#{req.unparsed_uri.inspect})" if RSence.args[:verbose]
+        file_id = 'invalid.gif'
+      end
+      file_id = file_id.split('.')[0]
+      if file_id == nil
+        puts "fileServe.fetch_file: invalid uri#2 (#{req.unparsed_uri.inspect})" if RSence.args[:verbose]
+        file_id = 'invalid.gif'
+      elsif file_id.size != 84
+        puts "fileServe.fetch_file: invalid file_id (#{file_id.inspect})" if RSence.args[:verbose]
+        file_id = 'invalid.gif'
+      end
+      if @raw_uris.include?(file_id)
+        (content_type,content_size,content) = @raw_uris[file_id]
+      elsif @files[:by_id].include?(file_id)
+        (content_type,content_size,content,ses_id) = @files[:by_id][file_id]
+        if req.header.has_key?('keep-alive') and req.header['keep-alive'].size > 0
+          keep_alive = req.header['keep-alive'][0].to_i
+          keep_alive = 10  if keep_alive < 10
+          keep_alive = 600 if keep_alive > 600
+          push_keepalive_file( file_id, keep_alive )
+          expire_keepalive_files
+        else
+          del_file( file_id, ses_id )
+        end
+      else
+        (content_type,content_size,content) = @raw_uris['invalid.gif']
+      end
+    
+    elsif type == :blobobj
+      blobobj_id = req.unparsed_uri.match(/^#{::RSence.config[:broker_urls][:b]}(.*)$/)[1]
+      if blobobj_id == nil
+        puts "fileServe.fetch_blobobj: invalid uri#1 (#{req.unparsed_uri.inspect})" if RSence.args[:verbose]
+        blobobj_id = 'invalid.gif'
+      end
+      if blobobj_id == nil
+        puts "fileServe.fetch_blobobj: invalid uri#2 (#{req.unparsed_uri.inspect})" if RSence.args[:verbose]
+        blobobj_id = 'invalid.gif'
+      elsif blobobj_id.size != 84
+        puts "fileServe.fetch_blobobj: invalid blobobj_id (#{blobobj_id.inspect})" if RSence.args[:verbose]
+        blobobj_id = 'invalid.gif'
+      end
+      if @raw_uris.include?(blobobj_id)
+        content_type = @raw_uris[blobobj_id].mime
+        content_size = @raw_uris[blobobj_id].size
+        content      = @raw_uris[blobobj_id].data
+      elsif @blob_objs[:by_id].include?(blobobj_id)
+        (ses_id, blobobj) = @blob_objs[:by_id][blobobj_id]
+        content_type = blobobj.mime
+        content_size = blobobj.size
+        content      = blobobj.data
+        if req.header.has_key?('keep-alive') and req.header['keep-alive'].size > 0
+          keep_alive = req.header['keep-alive'][0].to_i
+          keep_alive = 10  if keep_alive < 10
+          keep_alive = 600 if keep_alive > 600
+          push_keepalive_blobobj( blobobj_id, keep_alive )
+          expire_keepalive_blobobjs
+        else
+          del_blobobj( blobobj_id, ses_id )
+        end
+      else
+        (content_type,content_size,content) = @raw_uris['invalid.gif']
+      end
+      
+    elsif type == :rsrc
+      rsrc_id = req.unparsed_uri.match(/^#{::RSence.config[:broker_urls][:d]}(.*)$/)[1]
+      if rsrc_id == nil
+        puts "rsrcServe.fetch_rsrc: invalid uri#1 (#{req.unparsed_uri.inspect})" if RSence.args[:verbose]
+        rsrc_id = 'invalid.gif'
+      end
+      rsrc_id = rsrc_id.split('.')[0]
+      if rsrc_id == nil
+        puts "rsrcServe.fetch_rsrc: invalid uri#2 (#{req.unparsed_uri.inspect})" if RSence.args[:verbose]
+        rsrc_id = 'invalid.gif'
+      elsif rsrc_id.size != 84
+        puts "rsrcServe.fetch_rsrc: invalid rsrc_id (#{rsrc_id.inspect})" if RSence.args[:verbose]
+        rsrc_id = 'invalid.gif'
+      end
+      if @raw_uris.include?(rsrc_id)
+        (content_type,content_size,content) = @raw_uris[rsrc_id]
+      else
+        (content_type,content_size,content) = @raw_uris['invalid.gif']
+      end
+    end
+    
+    res.status = 200
+    
+    res['Content-Type'] = content_type
+    res['Content-Length'] = content_size
+    
+    res['Date'] = httime( Time.now )
+    res['Expires'] = httime(Time.now+::RSence.config[:cache_expire])
+    
+    res.body = content
+    
+  end
+  
+end
+end