rsence 2.0.0.0.pre

data/lib/plugins/plugin_plugins.rb

@@ -0,0 +1,47 @@
+##   Riassence Framework
+ #   Copyright 2010 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
+ ##
+
+## Interface to enable plugins in a plugin. Just include this in your subclass of Plugin.
+module PluginPlugins
+  def init
+    super
+    @plugin_plugins = RSence::PluginManager.new( [ bundle_path('plugins') ] )
+  end
+  def open
+    super
+    @plugin_plugins.delegate(:open)
+  end
+  def close
+    super
+    @plugin_plugins.delegate(:close)
+  end
+  def flush
+    super
+    @plugin_plugins.delegate(:flush)
+  end
+  def idle( msg )
+    super
+    @plugin_plugins.delegate(:idle,msg)
+  end
+  def init_ses( msg )
+    super
+    @plugin_plugins.delegate(:init_ses,msg)
+  end
+  def restore_ses( msg )
+    super
+    @plugin_plugins.delegate(:restore_ses,msg)
+  end
+  def cloned_target( msg, source_session )
+    super
+    @plugin_plugins.delegate(:cloned_target,msg,source_session)
+  end
+  def cloned_source( msg, target_session )
+    super
+    @plugin_plugins.delegate(:cloned_source,msg,target_session)
+  end
+end

data/lib/plugins/plugin_sqlite_db.rb

@@ -0,0 +1,72 @@
+##   Riassence Framework
+ #   Copyright 2009 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
+ ##
+
+# Include this module in your plugin class to automatically
+# create and connect/disconnect an sqllite database.
+# The plugin instance will have a @db Sequel object refering
+# to the sqlite database automatically created
+module PluginSqliteDB
+  
+  # First calls superclass, then creates database directory and database.
+  # Then calls init_db_tables.
+  def init
+    super
+    db_dir = File.join( @path, 'db' )
+    unless File.directory?( db_dir )
+      Dir.mkdir( db_dir )
+    end
+    @db_path = File.join( db_dir, "#{@name}.db" )
+    unless File.exist?( @db_path )
+      @db = Sequel.sqlite( @db_path )
+      create_db_tables
+      @db.disconnect
+    end
+    
+  end
+  
+  # Automatically opens the database connection, then calls update_db.
+  def open
+    @db = Sequel.sqlite( @db_path )
+    update_db
+    super
+  end
+  
+  # Automatically closes (disconnects) the database. Calls flush_db before closing.
+  def close
+    flush_db
+    @db.disconnect
+    super
+  end
+  
+  # Extend this method to do something immediately after the @db object is assigned.
+  # An usage scenario would be updating some tables or deleting some junk rows.
+  def update_db
+  end
+  
+  # Extend this method to do something immediately before the @db object is disconnected.
+  # An usage scenario would be deleting some junk rows or writing some pending data in memory into the database.
+  def flush_db
+  end
+  
+  # Extend this method to define tables or initial data for the tables.
+  # It's called once, when the database is created.
+  #
+  # NOTE: In a future reversion, tables might be defined from a configuration file.
+  #
+  # = Usage:
+  #   @db.create_table :my_table do
+  #     primary_key :id
+  #     String :my_text_column
+  #   end
+  #   my_table = @db[:my_table]
+  #   my_table.insert(:my_text_column => 'Some text')
+  # 
+  def create_db_tables
+  end
+end
+

data/lib/plugins/plugin_util.rb

@@ -0,0 +1,96 @@
+
+module PluginUtil
+  
+  include RSence
+
+  # Extend to do any initial configuration. Not doing anything by default.
+  def init
+  end
+  
+  # Extend this method to open objects like streams and database connections.
+  # It is called when everything is constructed after all plugins are loaded.
+  def open
+  end
+  
+  # Extend to save your plugin state or store any data that needs to be
+  # persistent. It's always called before close, but doesn't necessarily mean
+  # a close call is imminent.
+  def flush
+  end
+  
+  # Extend this method to close objects like streams and database connections.
+  # It's called when plugins are about to be destructed, so don't expect any
+  # calls after it has been called. When this method is called, it's the last
+  # chance to save persistent data before being destructed, so implement
+  # the +#flush+ method for primarily storing data.
+  def close
+  end
+  
+  # Returns the contents of the file given as +path+.
+  #
+  # The plugin bundle's path is used as the prefix, unless +path+ starts with '/' or '..'
+  #
+  # If the file doesn't exist, it returns +false+.
+  def file_read( path )
+    path = bundle_path( path )
+    return false unless File.exist?( path )
+    return File.read( path )
+  end
+  
+  def yaml_read( path )
+    file_data = file_read( path )
+    if not file_data
+      return false
+    else
+      return YAML.load( file_data )
+    end
+  end
+  
+  def method_undefined?( *args )
+    puts "Method undefined: #{args.inspect}"
+  end
+  
+  # Writes the +data+ into the file +path+.
+  #
+  # The plugin bundle's path is used as the prefix, unless +path+ starts with '/' or '..'
+  #
+  # It returns a success code (+false+ for failure and +true+ for success).
+  def file_write( path, data )
+    path = bundle_path( path )
+    begin
+      datafile = File.open( path, 'wb' )
+      datafile.write( data )
+      datafile.close
+      return true
+    rescue => e
+      warn "file_write error for path #{path} #{e}"
+      return false
+    end
+  end
+  alias file_save file_write
+  
+  # Makes a full path using the plugin bundle as the 'local path'.
+  # The (optional) +prefix+ is a subdirectory in the bundle,
+  # the +suffix+ is the file extension.
+  def bundle_path( path, prefix=false, suffix=false )
+    if suffix
+      path = "#{path}#{suffix}" unless path.end_with?(suffix)
+    end
+    if prefix
+      path = File.join( prefix, path )
+    end
+    if path[0].chr != '/' and path[0..1] != '..'
+      path = File.join( @path, path )
+    end
+    return path
+  end
+  
+  alias compose_plugin_path bundle_path
+  
+  # Helper method to return the time formatted according to the HTTP RFC
+  def httime(time=false)
+    time = Time.new unless time 
+    return time.gmtime.strftime('%a, %d %b %Y %H:%M:%S %Z')
+  end
+  
+end

data/lib/plugins/pluginmanager.rb

@@ -0,0 +1,517 @@
+##   Riassence Framework
+ #   Copyright 2006 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
+ ##
+
+
+def bundle_loader( params )
+  src_path = params[:src_path]
+  mod = Module.new do |m|
+    @@bundle_path    = params[:bundle_path   ]
+    @@bundle_name    = params[:bundle_name   ]
+    @@bundle_info    = params[:bundle_info   ]
+    @@plugin_manager = params[:plugin_manager]
+    begin
+      if params[:bundle_info][:inits_self] == false
+        m::module_eval( File.read(src_path) )
+      elsif params[:bundle_info][:reloadable] == false
+        require src_path[0..-4]
+      else
+        load src_path
+      end
+    rescue => e
+      @@plugin_manager.plugin_error(
+        e,
+        'BundleLoaderError',
+        "An error occurred while loading the plugin bundle #{@@bundle_name}.",
+        @@bundle_path
+      )
+    end
+  end
+  return mod
+end
+
+
+module RSence
+
+# Contains the PluginUtil module which has common methods for the bundle classes
+require 'plugins/plugin_util'
+
+# plugin.rb contains the Plugin skeleton class
+require 'plugins/plugin'
+
+# guiparser.rb contains the Yaml serializer for gui trees.
+# It uses JSONRenderer on the client to build user interfaces.
+require 'plugins/guiparser'
+
+# gui_plugin.rb is an extension of Plugin that uses
+# GUIParser to init the gui automatically.
+require 'plugins/gui_plugin'
+
+# plugin_sqlite_db.rb contains automatic local sqlite database
+# creation for a plugin that includes it.
+require 'plugins/plugin_sqlite_db'
+
+# servlet includes the Servlet class, for handling any requests / responses
+require 'plugins/servlet'
+
+# Interface for plugins in a plugin bundle
+require 'plugins/plugin_plugins'
+
+## = Abstract
+## PluginManager is the service that loads and provides method delegation
+## amongst all installed plugins.
+##
+## = Usage
+## plugin_paths = [ 'plugins', '/home/me/rsence/plugins' ]
+## myPluginManager = RSence::PluginManager.new( plugin_paths )
+##
+class PluginManager
+  
+  attr_reader :transporter, :sessions
+  
+  # Initialize with a list of directories as plugin_paths.
+  # It's an array containing all plugin directories to scan.
+  def initialize( plugin_paths, transporter=nil, autoreload=false )
+    if transporter
+      @transporter = transporter
+      @sessions = transporter.sessions
+    end
+    @plugin_paths = plugin_paths
+    puts "Loading plugins..."
+    scan_plugins
+    puts "Plugins loaded."
+    puts "Riassence Framework is online."
+    if autoreload
+      @thr = Thread.new do
+        Thread.pass
+        while true
+          begin
+            changed_plugins!
+          rescue => e
+            warn e.inspect
+          end
+          sleep 3
+        end
+      end
+    end
+  end
+  
+  def method_missing( sym, *args, &block )
+    if @registry.has_key?(sym)
+      if args == [] and block == nil
+        return @registry[sym]
+      elsif block == nil
+        call( sym, *args )
+      end
+    end
+  end
+  
+  def changed_plugins!
+    @plugin_paths.each do |path|
+      next unless File.directory? path
+      Dir.entries(path).each do |bundle_name|
+        next if bundle_name =~ /&\./
+        bundle_path = File.expand_path( File.join( path, bundle_name ) )
+        next unless File.directory?( bundle_path )
+        bundle_file = bundle_name+'.rb'
+        next unless File.exists?( File.join( bundle_path, bundle_file ) )
+        if File.exists?( File.join( bundle_path, 'disabled' ) )
+          if @registry.has_key?( bundle_name.to_sym )
+            puts "Disabling bundle #{bundle_name}..."
+            unload_bundle( bundle_name.to_sym )
+            if ARGV.include?('-say')
+              Thread.new do
+                Thread.pass
+                system(%{say "Unloaded #{bundle_name.to_s}."})
+              end
+            end
+          end
+        else
+          if not @registry.has_key?( bundle_name.to_sym )
+            puts "Loading bundle #{bundle_name}..."
+            load_bundle( bundle_path, bundle_name.to_sym, bundle_name+'.rb' )
+            call( bundle_name.to_sym, :open )
+            if ARGV.include?('-say')
+              Thread.new do
+                Thread.pass
+                system(%{say "Loaded #{bundle_name.to_s}."})
+              end
+            end
+          else
+            # puts "Checking if bundle #{bundle_name} is changed..."
+            info = @info[bundle_name.to_sym]
+            if info[:reloadable] and plugin_changed?( bundle_name.to_sym )
+              puts "Bundle #{bundle_name} has changed, reloading..."
+              unload_bundle( bundle_name.to_sym )
+              load_bundle( bundle_path, bundle_name.to_sym, bundle_name+'.rb' )
+              call( bundle_name.to_sym, :open )
+              if ARGV.include?('-say')
+                Thread.new do
+                  Thread.pass
+                  system(%{say "Reloaded #{bundle_name.to_s}."})
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  def unload_bundle( bundle_name )
+    if @registry.has_key?( bundle_name )
+      call( bundle_name, :flush )
+      call( bundle_name, :close )
+      @registry.delete( bundle_name )
+      @aliases.each do |a_name,b_name|
+        if b_name == bundle_name
+          @aliases.delete( a_name )
+        end
+      end
+      if @servlets.include?( bundle_name )
+        @servlets.delete( bundle_name )
+      end
+      if @info.include?( bundle_name )
+        @info.delete( bundle_name )
+      end
+    end
+  end
+  
+  def plugin_changed?( plugin_name )
+    info = @info[plugin_name]
+    last_changed = info[:last_changed]
+    newest_change = most_recent( info[:path], last_changed )
+    return last_changed < newest_change
+  end
+  
+  # Top-level method for scanning all plugin directories.
+  # Clears previously loaded plugins.
+  def scan_plugins
+    @registry = {}
+    @info     = {}
+    @aliases  = {}
+    @servlets = []
+    # @types    = {
+    #   :gui     => [],
+    #   :plugin  => [],
+    #   :servlet => []
+    # }
+    @plugin_paths.each do |path|
+      next unless File.directory? path
+      scan_plugindir( path )
+    end
+    delegate( :open )
+  end
+  
+  def registry( plugin_name )
+    return @registry[ plugin_name ]
+  end
+  alias [] registry
+  
+  # Scans a directory of plugins, calls +load_plugin+ for bundles that match
+  # the definition of a plugin bundle.
+  #  - Skips bundles starting with a dot
+  #  - Skips bundles without a ruby source file with the same
+  #    name as the directory (plus '.rb').
+  #  - Skips bundles containing a file or directory named 'disabled'
+  def scan_plugindir( path )
+    Dir.entries(path).each do |bundle_name|
+      # puts "bundle_name: #{bundle_name}"
+      next if bundle_name[0].chr == '.'
+      bundle_path = File.expand_path( File.join( path, bundle_name ) )
+      # puts "#{File.stat(bundle_path).inspect}"
+      next unless File.directory?( bundle_path )
+      bundle_file = bundle_name+'.rb'
+      if not File.exists?( File.join( bundle_path, bundle_file ) )
+        bundle_file = 'main.rb'
+        next unless File.exists?( File.join( bundle_path, bundle_file ) )
+      end
+      next if File.exists?( File.join( bundle_path, 'disabled' ) )
+      
+      load_bundle( bundle_path, bundle_name.to_sym, bundle_file )
+    end
+  end
+  
+  # Finds the most recent file in the path
+  def most_recent( bundle_path, newest_date=0 )
+    path_date = File.stat( bundle_path ).mtime.to_i
+    is_dir = File.directory?( bundle_path )
+    if path_date > newest_date and not is_dir
+      # puts "File is newer: #{bundle_path}"
+      newest_date = path_date
+    end
+    if is_dir
+      Dir.entries( bundle_path ).each do |entry_name|
+        next if entry_name[0].chr == '.'
+        full_path = File.join( bundle_path, entry_name )
+        unless File.directory?( full_path )
+          next unless entry_name.include?('.') and ['yaml','rb'].include?( entry_name.split('.')[-1] )
+        end
+        newest_date = most_recent( full_path, newest_date )
+      end
+    end
+    return newest_date
+  end
+  
+  # Gets plugin information
+  def bundle_info( bundle_path )
+    
+    bundle_name = File.split( bundle_path )[1]
+    
+    # Default bundle information
+    info = {
+      # The human-readable product name of the package
+      :title => bundle_name.capitalize,
+      
+      # The human-readable version of the package
+      :version => '0.0.0',
+      
+      # A brief description of the package (rdoc formatting supported)
+      :description => 'No Description given',
+      
+      # A flag (when false) prevents the plugin from automatically reload when changed.
+      :reloadable => true,
+      
+      # A flag (when false) enables automatic construction
+      # of the Plugin and Servlet classes contained.
+      :inits_self => true,
+      
+      # System version requirement.
+      :sys_version => '>= 1.0.0',
+      
+      # Path to bundle
+      :path => bundle_path,
+      
+      # Name of bundle
+      :name => bundle_name.to_sym,
+      
+      # Last change
+      :last_changed => most_recent( bundle_path  )
+      
+    }
+    
+    info_path = File.join( bundle_path, 'info.yaml' )
+    if File.exists?( info_path )
+      info_yaml = YAML.load( File.read( info_path ) )
+      info_yaml.each do |info_key,info_value|
+        info[ info_key.to_sym ] = info_value
+      end
+    end
+    return info
+    
+  end
+  
+  # Loads a plugin bundle.
+  def load_bundle( bundle_path, bundle_name, bundle_file )
+    
+    if @registry.has_key?( bundle_name.to_sym )
+      warn "Warning: Bundle #{bundle_name} already loaded."
+      return
+    end
+    
+    bundle_file_path = File.join( bundle_path, bundle_file )
+    
+    bundle_info = bundle_info( bundle_path )
+    
+    @info[bundle_name.to_sym] = bundle_info
+    
+    bundle_src = File.read( bundle_file_path )
+    
+    if RUBY_VERSION.to_f >= 1.9
+      puts "ruby 1.9.x"
+      puts "ruby version: #{RUBY_VERSION.inspect}"
+      src_path = bundle_file_path
+      plugin_manager = self
+      module_ns = Module.new do |m|
+        @@bundle_path    = bundle_path
+        @@bundle_name    = bundle_name
+        @@bundle_info    = bundle_info
+        @@plugin_manager = plugin_manager
+        def m.bundle_path; @@bundle_path; end
+        # puts "using eval"
+        # m::module_eval( File.read(src_path) )
+        # puts "using require"
+        # require src_path[0..-4]
+        puts "using load"
+        load src_path
+      end
+    else
+      module_ns         = bundle_loader( {
+        :bundle_path    => bundle_path,
+        :bundle_name    => bundle_name,
+        :bundle_info    => bundle_info,
+        :plugin_manager => self,
+        :src_path       => bundle_file_path,
+        :src            => bundle_src
+      } )
+    end
+    
+    unless bundle_info[:inits_self]
+      # puts "#{bundle_name}: #{module_ns.constants.inspect}"
+      module_ns.constants.each do |module_const_name|
+        module_const = module_ns.const_get( module_const_name )
+        if module_const.class == Class
+          # puts "is class"
+          module_const.ancestors.each do |ancestor|
+            # puts "ancestor: #{ancestor.to_s.inspect}"
+            if ancestor.to_s == "Servlet"
+              module_const.new
+              break
+            elsif ancestor.to_s == "Plugin"
+              puts "bundle_name: #{bundle_name}"
+              module_const.new.register( bundle_name )
+              break
+            elsif ancestor.to_s == "Object"
+              puts "Can't init class: #{module_const.to_s}"
+              break
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  def register_bundle( inst, bundle_name )
+    bundle_name = bundle_name.to_sym
+    if @registry.has_key?( bundle_name )
+      if registry[ bundle_name ] != inst
+        warn "Tried to register a conflicting bundle name: #{bundle_name.inspect}; ignoring"
+      else
+        warn "Use @plugins.register_alias to register more than one name per plugin."
+        register_alias( inst.name.to_sym, bundle_name )
+      end
+    else
+      inst.init if inst.respond_to? :init and not inst.inited
+      @registry[ bundle_name ] = inst
+      if inst.respond_to?( :match )
+        @servlets.push( bundle_name )
+      end
+    end
+  end
+  
+  def register_alias( bundle_name, alias_name )
+    if @aliases.has_key?( alias_name.to_sym )
+      warn "Alias already taken: #{alias_name.inspect}"
+    else
+      @aliases[ alias_name ] = bundle_name.to_sym
+    end
+  end
+  
+  def plugin_error( e, err_location, err_location_descr, eval_repl=false )
+    err_msg = [
+      "*"*40,
+      err_location,
+      err_location_descr,
+      "#{e.class.to_s}, #{e.message}",
+      "Backtrace:",
+      "\t"+e.backtrace.join("\n\t"),
+      "*"*40
+    ].join("\n")+"\n"
+    puts
+    puts "eval repl: #{eval_repl}"
+    puts
+    if eval_repl
+      err_msg = err_msg.gsub('from (eval):',"from #{eval_repl}:")
+    end
+    $stderr.write( err_msg )
+  end
+  
+  def match_servlet_uri( uri, req_type=:get )
+    match_score = {}
+    @servlets.each do | servlet_name |
+      servlet = @registry[ servlet_name ]
+      next unless servlet.respond_to?( req_type )
+      begin
+        if servlet.match( uri, req_type )
+          score = servlet.score
+          match_score[ score ] = [] unless match_score.has_key? score
+          match_score[ score ].push( servlet_name )
+        end
+      rescue => e
+        plugin_error(
+          e,
+          "RSence::PluginManager.match_servlet_uri",
+          "servlet: #{servlet_name.inspect}, req_type: #{req_type.inspect}, uri: #{uri.inspect}",
+          servlet_name
+        )
+      end
+    end
+    match_scores = match_score.keys.sort
+    if match_scores.empty?
+      return false
+    else
+      matches_order = []
+      matches_best  = match_score[ match_scores[0] ]
+      if matches_best.size > 1
+        matches_best = matches_best[ rand( matches_best.size ) ]
+      else
+        matches_best = matches_best.first
+      end
+      matches_order.push( matches_best )
+      match_score.keys.sort.each do |match_n|
+        match_score[ match_n ].each do | match_name |
+          matches_order.push( match_name ) unless matches_order.include? match_name
+        end
+      end
+      return matches_order
+    end
+  end
+  
+  def delegate( method_name, *args )
+    @registry.each do | plugin_name, plugin |
+      if plugin.respond_to?( method_name )
+        plugin.send( method_name, *args  )
+      end
+    end
+  end
+  
+  def shutdown
+    delegate( :flush )
+    delegate( :close )
+  end
+  
+  def call( plugin_name, method_name, *args )
+    plugin_name = plugin_name.to_sym
+    if @registry.has_key?( plugin_name )
+      if @registry[ plugin_name ].respond_to?( method_name )
+        return @registry[ plugin_name ].send( method_name, *args )
+      else
+        puts "No method #{method_name.inspect} for plugin #{plugin_name.inspect}"
+        return false
+      end
+    else
+      puts "No such plugin: #{plugin_name.inspect}"
+      return false
+    end
+  end
+  
+  alias run_plugin call
+  
+  def match_servlet( req_type, req, resp, session )
+    req_uri = req.fullpath
+    matches_order = match_servlet_uri( req_uri, req_type )
+    return false unless matches_order
+    matches_order.each do |servlet_name|
+      begin
+        @registry[servlet_name].send( req_type, req, resp, session )
+        return true
+      rescue => e
+        plugin_error(
+          e,
+          "RSence::PluginManager.match_servlet",
+          "servlet_name: #{servlet_name.inspect}, req_type: #{req_type.inspect}",
+          servlet_name
+        )
+        next
+      end
+    end
+    return false
+  end
+  
+end
+
+end