rsence 2.0.0.0.pre

data/plugins/legacy/info.yaml

@@ -0,0 +1,22 @@
+
+# The human-readable product name of the package
+title: Legacy Compatibility Plugin
+
+# The human-readable version of the package
+version: 2.0.0
+
+# A brief description of the package (rdoc formatting supported)
+description: |
+  This bundle provides compatibility for older plugins that rely on
+  some global variables.
+
+# A flag (when false) prevents the plugin from automatically reload when changed.
+reloadable: false
+
+# A flag (when false) enables automatic construction
+# of the Plugin and Servlet classes contained.
+inits_self: false
+
+# System version requirement.
+sys_version: '>= 2.0.0'
+

data/plugins/legacy/legacy.rb

@@ -0,0 +1,15 @@
+
+class LegacyPlugin < Servlet
+  def init
+    super
+    $PLUGINS = @plugins
+    $config  = ::RSence.config
+    $TICKETSERVE = @plugins[:ticketservices]
+  end
+end
+
+module ::Riassence
+  module Server
+    include RSence
+  end
+end

data/plugins/main/js/riassence_ns.js

@@ -0,0 +1,87 @@
+RSence = {
+  
+  // List of apps initialized utilizing GUITrees, by GUIPlugin name
+  apps: { },
+  
+  // Subview that utilizes GUITrees
+  GUIView: HControl.extend({
+    
+  }),
+  
+  // Application that handles GUITrees, populates its values dynamically
+  GUIApp: HApplication.extend({
+    constructor: function(_options){
+      
+      var
+      _this      = this,
+      
+      // Application priority
+      _priority  = _options.priority?_options.priority:100,
+      
+      // Application label / title
+      _label     = _options.label?_options.label:'Untitled Application',
+      
+      // Application description (multiline)
+      _descr     = _options.descr?_options.descr:'No Description',
+      
+      // Allow multiple instances?
+      _allowMulti = _options.allowMulti?_options.allowMulti:false,
+      
+      // The GUI Tree
+      _valueObj   = _options.valueObj?_options.valueObj:false,
+      
+      // Signal input (from server to client)
+      _sigInput   = _options.sigInput?COMM.Values.values[_options.sigInput]:false,
+      
+      // Signal output (from client to server)
+      _sigOutput  = _options.sigOutput?COMM.Values.values[_options.sigOutput]:false,
+      
+      // Icon image url.
+      // Minimum size is 16x16 and multiple sizes are stacked on top of each other,
+      // largest topmost, smaller versions aligned left below in size order.
+      // Image formats supported are: SVG (except for IE), PNG (all), GIF (all), JPG (all).
+      // Recommended formats are: SVG and PNG24 with transparency / translucency.
+      // Size has to be a factor of two; 16,32,64,128,256,512 are valid dimensions:
+      // 32x32   -> 32x32 single icon
+      // 32x48   -> 32x32 and 16x16
+      // 512x512 -> 512x512 single icon
+      // 512x768 -> 512x512, 256x256
+      // 512x640 -> 512x512, 128x128
+      // 512x896 -> 512x512, 256x256 and 128x128
+      // etc..
+      _iconUrl    = _options.iconUrl?COMM.Values.values[_options.iconUrl]:false;
+      
+      // Construct the application base:
+      _this.base( _priority, _label );
+      
+      // Options combined from vars above
+      _this.options = {
+        label: _label,
+        descr: _descr,
+        allowMulti: _allowMulti,
+        sigInput: _sigInput,
+        sigOutput: _sigOutput,
+        icon: { url: _iconUrl, width: null, height: null },
+        pid: this.appId,
+        views: []
+      };
+      
+      _this.valueObj = _valueObj;
+      _this.value = _valueObj.value;
+      
+      // _this.app = _this;
+      
+      // 
+      // _this.renderer = COMM.JSONRenderer.extend({
+      //   
+      // }).nu( _this.value, _this );
+    },
+    
+    die: function(){
+      this.base();
+      
+    }
+    
+  })
+};
+

data/plugins/main/main.rb

@@ -0,0 +1,234 @@
+#--
+##   Riassence Framework
+ #   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
+ ##
+ #++
+
+class Main < Plugin
+  
+  def init
+    super
+    @conf  = ::RSence.config[:index_html]
+    @bconf = ::RSence.config[:broker_urls]
+  end
+  
+  def match( uri, request_type )
+    if request_type == :post and
+       uri == File.join(@bconf[:hello],'goodbye')
+      return true
+    end
+    return false
+  end
+  
+  def score; 100; end
+  
+  def post( req, res, ses )
+    msg = @plugins.sessions.init_msg( req, res, { :cookies => true } )
+    msg.expire_session()
+    msg.response_done
+  end
+  
+  # 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.reply( [
+          'COMM.Transporter.stop=true;',
+          "location.href=#{resp_addr.to_json};"
+        ].join('') )
+        msg.expire_session()
+      end
+      
+    else
+      ses[:url] = [location_href.data,nil]
+    end
+    
+    # url_responder always accepts locations
+    return true
+    
+  end
+  
+  
+  # new session initialization,
+  # called just once per session.
+  def init_ses(msg)
+    super
+    restore_ses( msg )
+  end
+  
+  # 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
+  def delayed_call( msg, args )
+    get_ses( msg )[:delayed_calls].push( args )
+  end
+  
+  # Initializes the client-side COMM.urlResponder and sesWatcher
+  def boot0( msg, ses )
+    
+    msg.reply read_js( 'riassence_ns' )
+
+    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
+  
+  # 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
+  
+  def dont_init_ui( msg )
+    get_ses( msg )[:dont_init_ui] = true
+  end
+  
+  # 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 $DEBUG_MODE
+        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
+  
+  # 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
+  
+  # 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
+  
+  # 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
+
+## Initialize and register the plugin.
+main = Main.new.register( :main )
+
+
+

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/ticketservices/lib/common.rb

@@ -0,0 +1,300 @@
+#--
+##   Riassence Framework
+ #   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
+ ##
+ #++
+
+module TicketService
+module Common
+  
+
+  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
+  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 $DEBUG_MODE
+        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 $DEBUG_MODE
+        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 $DEBUG_MODE
+        img_id = 'invalid.gif'
+      
+      elsif img_id.size != 84
+        puts "ImgServe.fetch_img: invalid img_id (#{img_id.inspect})" if $DEBUG_MODE
+        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 $DEBUG_MODE
+        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 $DEBUG_MODE
+        file_id = 'invalid.gif'
+      elsif file_id.size != 84
+        puts "fileServe.fetch_file: invalid file_id (#{file_id.inspect})" if $DEBUG_MODE
+        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 $DEBUG_MODE
+        blobobj_id = 'invalid.gif'
+      end
+      if blobobj_id == nil
+        puts "fileServe.fetch_blobobj: invalid uri#2 (#{req.unparsed_uri.inspect})" if $DEBUG_MODE
+        blobobj_id = 'invalid.gif'
+      elsif blobobj_id.size != 84
+        puts "fileServe.fetch_blobobj: invalid blobobj_id (#{blobobj_id.inspect})" if $DEBUG_MODE
+        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 $DEBUG_MODE
+        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 $DEBUG_MODE
+        rsrc_id = 'invalid.gif'
+      elsif rsrc_id.size != 84
+        puts "rsrcServe.fetch_rsrc: invalid rsrc_id (#{rsrc_id.inspect})" if $DEBUG_MODE
+        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