rsence-pre 2.1.0.1.pre

data/lib/plugins/pluginmanager.rb

@@ -0,0 +1,635 @@
+##   RSence
+ #   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
+ ##
+
+ 
+require 'plugins/plugins'
+require 'plugins/dependencies'
+
+module RSence
+  
+  ## PluginManager is the service that loads and provides method delegation
+  ## amongst its plugin bundles.
+  ##
+  ## = Usage
+  ##  plugin_paths = [ 'plugins', '/home/me/rsence/plugins' ]
+  ##  myPluginManager = RSence::PluginManager.new( plugin_paths )
+  ##
+  class PluginManager
+    
+    attr_reader :transporter, :sessions
+    
+    # Returns the registry data for plugin bundle +plugin_name+
+    def registry( plugin_name )
+      return @registry[ plugin_name ]
+    end
+    alias [] registry
+    
+    # By default, calling a method not defined calls a plugin of that name
+    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
+    
+    # Registers alias name for a plugin bundle.
+    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
+    
+    # Registers plugin class +inst+ into the registry using +bundle_name+
+    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 ) and ( inst.respond_to?( :get ) or inst.respond_to?( :post ) )
+          @servlets.push( bundle_name )
+        end
+      end
+    end
+    
+    def callable?( plugin_name, method_name )
+      return false if @deps.category?( plugin_name )
+      return false unless @registry.has_key?( plugin_name )
+      plugin = @registry[plugin_name]
+      return false unless plugin.respond_to?( method_name )
+      return true
+    end
+    
+    # Calls the method +method_name+ with args +args+ of the plugin +plugin_name+.
+    # Returns false, if no such plugin or method exists.
+    def call( plugin_name, method_name, *args )
+      plugin_name = plugin_name.to_sym
+      if callable?( plugin_name, method_name )
+        begin
+          return @registry[ plugin_name ].send( method_name, *args )
+        rescue => e
+          plugin_error(
+            e,
+            "RSence::PluginManager.call error",
+            "plugin_name: #{plugin_name.inspect}, method_name: #{method_name.inspect}",
+            plugin_name
+          )
+        end
+      elsif @deps.category?( plugin_name )
+        warn "Warning! Tried to call category: #{plugin_name.inpsect}"
+      elsif not @registry.has_key?( plugin_name )
+        warn "Warning! No such plugin: #{plugin_name.inspect}"
+      elsif not @registry[ plugin_name ].respond_to?( method_name )
+        warn "Warning! Plugin: #{plugin_name.inspect} does not respond to #{method_name.inspect}"
+      end
+      return false
+    end
+    alias run_plugin call
+    
+    # Prettier error handling.
+    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"
+      if eval_repl
+        puts
+        puts "plugin: #{eval_repl}"
+        puts
+        err_msg = err_msg.gsub(/^\t\(eval\)\:/s,"\t#{eval_repl}:")
+      end
+      $stderr.write( err_msg )
+    end
+    
+    # Search servlets that match the +uri+ and +req_type+
+    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
+    
+    # Calls the servlet that matches the +req_type+ and +req.fullpath+ with
+    # the highest score.
+    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
+    
+    # Delegates +method_name+ with +args+ to any loaded
+    # plugin that responds to the method.
+    def delegate( method_name, *args )
+      @deps.list.each do |plugin_name|
+        call( plugin_name, method_name, *args ) if callable?( plugin_name, method_name )
+      end
+    end
+    
+    # Reverse delegate +method_name+ with +args+ to any loaded
+    # plugin that responds to the method.
+    def delegate_reverse( method_name, *args )
+      @deps.list.reverse.each do |plugin_name|
+        call( plugin_name, method_name, *args ) if callable?( plugin_name, method_name )
+      end
+    end
+    
+    # Delegates the +flush+ and +close+ methods to any
+    # loaded plugins, in that order.
+    def shutdown
+      @transporter.online = false
+      @deps.list.reverse.each do |bundle_name|
+        unload_bundle( bundle_name )
+      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
+        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 )
+            has_dot = entry_name.include?('.')
+            next unless has_dot
+            is_src_file = ['yaml','rb'].include?( entry_name.split('.')[-1] )
+            next unless is_src_file
+          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, src_file )
+      
+      # Default bundle information
+      info = {
+        
+        # The human-readable product name of the package
+        :title => bundle_name.to_s.capitalize,
+        
+        # The human-readable version of the package
+        :version => '0.0.0',
+        
+        # A brief description of the package (rdoc formatting supported)
+        :description => 'No Description',
+        
+        # A flag (when false) prevents the plugin from automatically reload when changed.
+        :reloadable => true,
+        
+        # System version requirement.
+        # NOTE: Has no effect yet!
+        :sys_version => '>= 1.0.0',
+        
+        # Dependency, by default the system category (built-in plugins).
+        # A nil ( "~" in yaml ) value means no dependencies.
+        :depends_on     => [ :system ],
+        
+        # Optional, name of category. The built-in plugins are :system
+        :category       => nil,
+        
+        # Optional, name of plugin to replace
+        # NOTE: Has no effect yet!
+        :replaces       => nil,
+        
+        # Optional, reverse dependency. Loads before the prepended plugin(category).
+        # NOTE: Doesn't support packages yet!
+        :prepends       => nil
+        
+      }
+      
+      # Merge info.yaml data into info
+      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
+      else
+        warn "Expected info.yaml, using defaults:"
+        warn "  #{info_path}"
+      end
+      
+      @deps.set_deps( bundle_name, info[:depends_on] )
+      if info[:category]
+        if info[:category].class == Symbol
+          @deps.add_category( info[:category] ) unless @deps.category?( info[:category] )
+          @deps.set_deps( info[:category], bundle_name )
+        else
+          warn "Invalid category: #{info[:category].inspect}"
+        end
+      end
+      if info[:prepends]
+        if info[:prepends].class == Array
+          info[:prepends].each do |prep|
+            @deps.set_deps( prep, bundle_name )
+          end
+        else
+          @deps.set_deps( info[:prepends], bundle_name )
+        end
+      end
+      
+      # Extra information, not override-able in info.yaml
+      
+      # Path of bundle
+      info[:path] = bundle_path
+        
+      # Name of bundle
+      info[:name] = bundle_name
+        
+      # Full path of source file
+      info[:src_file] = src_file
+        
+      # Timestamp of last changed file
+      info[:last_changed] = most_recent( bundle_path )
+      
+      # ..however, don't accept future timestamps:
+      time_now = Time.now.to_i
+      info[:last_changed] = time_now if info[:last_changed] > time_now
+      
+      return info
+    end
+    
+    # Loads a plugin bundle.
+    def load_bundle( name )
+      
+      if @deps.unresolved?(name)
+        warn "Warning: Bundle #{name} has unmet dependencies."
+        return
+      end
+      
+      if @registry.has_key?( name )
+        warn "Warning: Bundle #{name} already loaded."
+        return
+      end
+      puts "Loading bundle: #{name.inspect}" if RSence.args[:debug]
+      
+      info = @info[ name ]
+      
+      path = info[:path]
+      src_file = info[:src_file]
+      
+      bundle_src = File.read( src_file )
+      
+      module_ns         = Plugins.bundle_loader( {
+        :bundle_path    => path,
+        :bundle_name    => name,
+        :bundle_info    => info,
+        :plugin_manager => self,
+        :src_path       => src_file,
+        :src            => bundle_src
+      } )
+      
+      module_ns.constants.each do |module_const_name|
+        module_const = module_ns.const_get( module_const_name )
+        if module_const.class == Class
+          type = module_const.bundle_type
+          if [:Servlet, :Plugin, :GUIPlugin].include? type
+            bundle_inst = module_const.new( name, info, path, self )
+            bundle_inst.register( name ) if [ :Plugin, :GUIPlugin ].include?( type )
+            break
+          else
+            warn "Can't init class: #{module_const.to_s}"
+            break
+          end
+        else
+          warn "Invalid module_const.class: #{module_const.class.inspect}"
+        end
+      end
+    end
+    
+    # loads all bundles found in order of dependency
+    def load_bundles
+      @deps.list.each do |name|
+        load_bundle( name ) if @deps.loadable?( name )
+      end
+    end
+    
+    # If a bundle is found, set its dependencies etc
+    def bundle_found( bundle_path, bundle_name, src_file )
+      @info[ bundle_name ] = bundle_info( bundle_path, bundle_name, src_file )
+    end
+    
+    # Returns false, if the plugin directory isn't valid.
+    # Returns [bundle_path, src_file] otherwise.
+    def valid_plugindir?( path, bundle_name )
+      return false if bundle_name[0].chr == '.'
+      bundle_path = File.expand_path( File.join( path, bundle_name ) )
+      return false unless File.directory?( bundle_path )
+      bundle_file = bundle_name+'.rb'
+      src_file = File.join( bundle_path, bundle_file )
+      if not File.exists?( src_file )
+        bundle_file = 'main.rb'
+        src_file = File.join( bundle_path, bundle_file )
+        return false unless File.exists?( src_file )
+      end
+      return [ bundle_path, src_file ]
+    end
+    
+    # Returns true, if the bundle is disabled
+    def disabled?( bundle_path )
+      File.exists?( File.join( bundle_path, 'disabled' ) )
+    end
+    
+    # Returns true, if the bundle is loaded.
+    def loaded?( bundle_name )
+      @registry.has_key?( bundle_name )
+    end
+    
+    # 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 find_bundles( path )
+      bundles_found = []
+      Dir.entries(path).each do |bundle_name|
+        bundle_status = valid_plugindir?( path, bundle_name )
+        if bundle_status
+          (bundle_path, src_file) = bundle_status
+          unless disabled?( bundle_path )
+            bundles_found.push( [bundle_path, bundle_name.to_sym, src_file] )
+          end
+        end
+      end
+      return bundles_found
+    end
+    
+    # Unloads the plugin bundle named +bundle_name+
+    def unload_bundle( bundle_name )
+      if @registry.has_key?( bundle_name )
+        unload_order = @deps.del_order( bundle_name )
+        unload_order.each do |unload_dep|
+          unload_bundle( unload_dep ) unless unload_dep == bundle_name
+        end
+        puts "Unloading bundle: #{bundle_name.inspect}" if RSence.args[:debug]
+        @deps.del_item( bundle_name )
+        online_status = @transporter.online?
+        @transporter.online = false
+        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
+        @transporter.online = online_status
+        return unload_order
+      end
+    end
+    
+    # Returns true, if a plugin bundle has changed.
+    # Only compares timestamp, not checksum.
+    def 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
+    
+    # Logs and speaks the message, if the speech synthesis command "say" exists.
+    def say( message )
+      puts message
+      if RSence.args[:say]
+        Thread.new do
+          Thread.pass
+          system(%{say "#{message.gsub('"','')}"})
+        end
+      end
+    end
+    
+    # Checks for changed plugin bundles and unloads/loads/reloads them accordingly.
+    def update_bundles!
+      (are_found, to_load, to_unload, to_reload) = [[],[],[],[]]
+      found_map = {}
+      @plugin_paths.each do |path|
+        are_found += find_bundles( path )
+      end
+      are_found.each do |item|
+        (path, name, src_file) = item
+        found_map[name] = item
+        is_loaded = loaded?( name )
+        if is_loaded and changed?( name )
+          to_reload.push( name )
+        elsif not is_loaded
+          to_load.push( name )
+        end
+      end
+      @registry.keys.each do |name|
+        to_unload.push( name ) if not found_map.has_key?( name )
+      end
+      to_unload.each do |name|
+        next if @deps.category?( name )
+        if RSence.args[:verbose]
+          print "Unloading #{name.inspect}..."; STDOUT.flush
+        end
+        unload_bundle( name )
+        puts "done!" if RSence.args[:verbose]
+      end
+      to_reload.each do |name|
+        next if @deps.category?( name )
+        if RSence.args[:verbose]
+          print "Unloading #{name.inspect}..."; STDOUT.flush
+        end
+        unload_order = unload_bundle( name )
+        to_load += unload_order
+        puts "done!" if RSence.args[:verbose]
+      end
+      info_map = {}
+      to_load.each do |name|
+        next unless found_map.has_key? name
+        info_map[name] = bundle_info( *found_map[name] )
+      end
+      no_deps = {}
+      to_load.dup.each do |name|
+        if @deps.unresolved?( name )
+          no_deps[ name ] = @deps.deps_on( name )
+          @deps.del_item( name )
+          to_load.delete( name )
+        end
+      end
+      to_open = []
+      @deps.list.each do |name|
+        next if @deps.category?( name )
+        next unless to_load.include?( name )
+        info = info_map[name]
+        if RSence.args[:verbose]
+          if to_reload.include?( name )
+            print "Reloading #{name.inspect}..."
+          else
+            print "Loading #{name.inspect}..."
+          end
+          STDOUT.flush
+        end
+        @info[name] = info
+        load_bundle( name )
+        to_open.push( name )
+        puts "done!" if RSence.args[:verbose]
+      end
+      unless no_deps.empty?
+        warn "Warning! Unable to load the following bundles; missing dependencies:"
+        no_deps.each do |name,deps|
+          warn "  #{name} depends on: #{deps.join(', ')}"
+        end
+      end
+      to_open.each do |name|
+        if RSence.args[:verbose]
+          print "Opening #{name.inspect}..."; STDOUT.flush
+        end
+        call( name, :open )
+        puts "done!" if RSence.args[:verbose]
+      end
+      if not (to_load.empty? and to_unload.empty? and to_reload.empty?)
+        puts "Plugin bundles:"
+        puts "  loaded: #{to_load.join(', ')}" unless to_load.empty?
+        puts "  unloaded: #{to_unload.join(', ')}" unless to_unload.empty?
+        puts "  reloaded: #{to_reload.join(', ')}" unless to_reload.empty?
+        puts "  opened: #{to_open.join(', ')}" unless to_open.empty?
+      end
+    end
+    
+    # Top-level method for scanning all plugin directories.
+    # Clears previously loaded plugins.
+    def init_bundles!
+      @registry = {} # bundle_name => bundle_instance mapping
+      @info     = {} # bundle_name => bundle_info mapping
+      @aliases  = {} # bundle_alias => bundle_name mapping
+      @servlets = [] # bundle_name list of Servlet class instances
+      update_bundles!
+    end
+    
+    # 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, name_prefix=false,
+                    resolved_deps=[], resolved_categories={} )
+      if transporter
+        @transporter = transporter
+        @sessions    = transporter.sessions
+      end
+      @name_prefix = name_prefix
+      @plugin_paths = plugin_paths
+      @deps = Dependencies.new( resolved_deps, resolved_categories )
+      puts "Loading #{name_prefix+' ' if name_prefix}plugins..." if RSence.args[:verbose]
+      init_bundles!
+      puts %{Plugins #{"of #{name_prefix} " if name_prefix}loaded.} if RSence.args[:verbose]
+      if autoreload
+        @thr = Thread.new do
+          Thread.pass
+          while true
+            begin
+              update_bundles!
+            rescue => e
+              plugin_error( e, "PluginManager#update_bundles!", "An error occurred while reloading bundles" )
+            end
+            sleep 3
+          end
+        end
+      end
+    end
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+