redcar 0.2.9dev

data/lib/freebase2/lib/freebase/freebase.rb

@@ -0,0 +1,60 @@
+# Purpose: FreeBASE constant declarations and module inclusion
+#    
+# $Id: freebase.rb,v 1.3 2003/07/16 21:07:08 ljulliar Exp $
+#
+# Authors:  Rich Kilmer <rich@infoether.com>
+# Contributors:
+#
+# This file is part of the FreeRIDE project
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# COPYING file.
+# 
+# Copyright (c) 2001 Rich Kilmer. All rights reserved.
+#
+
+module FreeBASE
+
+  #version information
+  VERSION_MAJOR = 0
+  VERSION_MINOR = 1
+  VERSION_RELEASE = 0
+
+  #state transitions for plugins
+  UNLOADED = "UNLOADED"
+  LOADING = "LOADING"
+  LOADED = "LOADED"
+  STARTING = "STARTING"
+  RUNNING = "RUNNING"
+  STOPPING = "STOPPING"
+  UNLOADING = "UNLOADING"
+  ERROR = "ERROR"
+  
+  #system state transition order
+  STARTUP_STATES = [UNLOADED, LOADING, LOADED, STARTING, RUNNING]
+  SHUTDOWN_STATES = [STOPPING, LOADED, UNLOADING, UNLOADED]
+
+end
+
+##
+# Test whether a file path is absolute or relative
+# (used in several method of freebase to load/store
+#  plugin config files
+#
+class File
+  def File.absolute_path?(path)
+    if RUBY_PLATFORM =~ /(mswin32|mingw32)/
+      path =~ %r{^([a-zA-Z]:)*[/\\]+}
+    else
+      path[0..0] == File::SEPARATOR
+    end
+  end
+end
+
+require File.dirname(__FILE__) + '/core'
+require File.dirname(__FILE__) + '/plugin'
+require File.dirname(__FILE__) + '/databus'
+require File.dirname(__FILE__) + '/properties'
+require File.dirname(__FILE__) + '/readers'
+require File.dirname(__FILE__) + '/configuration'

data/lib/freebase2/lib/freebase/logger.rb

@@ -0,0 +1,117 @@
+# Purpose: Sample logger plugin
+#    
+# $Id: logger.rb,v 1.2 2003/06/24 05:00:43 richkilmer Exp $
+#
+# Authors:  Rich Kilmer <rich@infoether.com>
+# Contributors:
+#
+# This file is part of the FreeRIDE project
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# COPYING file.
+# 
+# Copyright (c) 2001 Rich Kilmer. All rights reserved.
+#
+
+module FreeBASE
+  module Plugins
+    class Logger
+    
+      class SimpleFileLogger
+        LEVELS = ['disabled', 'error', 'info', 'debug']
+        def initialize(logName, logFile, logLevel)
+          @logName = logName
+          @logFile = logFile
+          ensure_logdir
+          self.logLevel = logLevel
+          @file = File.new(logFile, "a")
+          @file.sync = true
+        end
+        
+        def ensure_logdir
+          path = File.dirname(@logFile).split(File::SEPARATOR)
+          (path.size-1).times do |i|
+            dir = File.join(*path[0,i+2])
+            unless File.exist?(dir)
+              Dir.mkdir(dir)
+            end
+          end
+        end
+        
+        def logLevel=(logLevel)
+          logLevel = LEVELS[logLevel] if logLevel.kind_of? Numeric
+          @logLevel = logLevel.downcase
+          case @logLevel
+          when 'disabled'
+            @logLevelInt = 0
+          when 'error'
+            @logLevelInt = 1
+          when 'info'
+            @logLevelInt = 2
+          when 'debug'
+            @logLevelInt = 3
+          else
+            raise "Unknown Logger level: #{@logLevel}"
+          end
+        end
+        
+        def close
+          @file.close
+        end
+        
+        def time
+          Time.now.strftime("%Y-%m-%d %H:%M:%S")
+        end
+        
+        def error(message)
+          return if @logLevelInt < 1
+          @file.puts "#{time} :: [ERROR] #{message}"
+        end
+        
+        def info(message)
+          return if @logLevelInt < 2
+          @file.puts "#{time} :: [INFO]  #{message}"
+        end
+        
+        def debug(message)
+          return if @logLevelInt < 3
+          @file.puts "#{time} :: [DEBUG] #{message}"
+        end
+
+      end
+    
+      extend FreeBASE::StandardPlugin
+    
+      def self.start(plugin)
+        begin
+          system_properties = plugin["/system/properties"].manager
+          logName = system_properties["config/log_name"]
+          logFile = system_properties["config/log_file"]
+          # Create log file in user directory if it exists
+          user_logFile = DefaultPropertiesReader.user_filename(logFile)
+          if !user_logFile.nil?
+            logFile = user_logFile
+          end
+          logLevel = system_properties["config/log_level"]        
+          logger = SimpleFileLogger.new(logName, logFile, logLevel)
+          ["info", "error", "debug"].each do |logType| #clear the existing log entries
+            while msg = plugin["/log/#{logType}"].queue.leave
+              logger.send(logType, msg)
+            end
+          end
+          plugin["close"].set_proc { logger.close }
+          plugin["set_level"].set_proc{ |level| logger.logLevel = level }
+          plugin["/log"].set_proc { |logType, message| logger.send(logType, message) }
+          plugin["/log"].manager = logger
+          plugin.transition(FreeBASE::RUNNING)
+        rescue
+          puts $!
+          puts $!.backtrace.join("\n")
+          plugin.transition_failure
+        end
+      end
+    end
+    
+  end
+end

data/lib/freebase2/lib/freebase/plugin.rb

@@ -0,0 +1,384 @@
+# Purpose: Wrapper for FreeBASE plugin instanciation
+#    
+# $Id: plugin.rb,v 1.2 2003/06/11 21:23:01 ljulliar Exp $
+#
+# Authors:  Rich Kilmer <rich@infoether.com>
+# Contributors:
+#
+# This file is part of the FreeRIDE project
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# COPYING file.
+# 
+# Copyright (c) 2001 Rich Kilmer. All rights reserved.
+#
+
+require 'rexml/document'
+
+module FreeBASE
+
+  module StandardPlugin
+      def load(plugin)
+        plugin.transition(FreeBASE::LOADED)
+      end
+      
+      def start(plugin)
+        plugin.transition(FreeBASE::RUNNING)
+      end
+      
+      def stop(plugin)
+        plugin.transition(FreeBASE::LOADED)
+      end
+      
+      def unload(plugin)
+        plugin.transition(FreeBASE::UNLOADED)
+      end
+  end
+  
+  class SubsystemPlugin
+    extend StandardPlugin
+  end
+
+  ##
+  # The Plugin class is the wrapper for the actual plugin instance
+  #
+  class Plugin
+    
+    attr_reader :plugin_configuration, :core
+    
+    #transition definitions
+    FAILURE_TRANSITIONS = 
+      { LOADING   => UNLOADED, 
+        STARTING  => LOADED, 
+        STOPPING  => RUNNING, 
+        UNLOADING => LOADED }
+                            
+    LEGAL_TRANSITIONS = 
+      { UNLOADED  => [LOADING],
+        LOADING   => [LOADED],
+        LOADED    => [STARTING, UNLOADING],
+        STARTING  => [RUNNING],
+        RUNNING   => [STOPPING],
+        STOPPING  => [LOADED, RUNNING],
+        UNLOADING => [UNLOADED] }
+                    
+    SYSTEM_TRANSITIONS = 
+      { LOADING   => [UNLOADED, :load],
+        STARTING  => [LOADED, :start],
+        STOPPING  => [RUNNING, :stop],
+        UNLOADING => [LOADED, :unload] }
+        
+    ST_CONDITION = 0
+    ST_METHOD = 1
+                           
+    ##
+    # Returns the properties object for this plugin.  This raises an
+    # exception if there is not properties file definded in the plugin.xml
+    # file <properties>.....</properties.
+    #
+    # return:: [FreeBASE::DataBus::Properties] The Properties object
+    # raise:: [RuntimException] If the properties is undefined.
+    #
+    def properties
+      raise "No properties file defined for #{@plugin_configuration.name} in plugin.xml" unless @properties
+      @properties
+    end
+    
+    ##
+    # Loads the supplied .xml file and extracts its attribute values
+    #
+    # core:: [FreeBASE::Core] The FreeBASE core instance
+    # plugin_configuration:: [FreeBASE::PluginConfiguration] The object that holds this plugin's configuration
+    #
+    def initialize(core, plugin_configuration)
+      @core = core
+      @plugin_configuration = plugin_configuration
+      # configure base slot
+      @base_slot = @core.bus["/plugins/#{@plugin_configuration.name}"]
+      @base_slot.data = self
+      @base_slot.propagate_notifications = false
+      @base_slot.manager = self
+      # create properties manager
+      if @plugin_configuration.properties_path
+        @properties = Properties.new(@plugin_configuration.name, "1.0", @base_slot["properties"], @plugin_configuration.base_path+"/"+@plugin_configuration.properties_path) 
+      end
+      #local log
+      @base_slot["log/info"].queue
+      @base_slot["log/error"].queue
+      @base_slot["log/debug"].queue
+      @base_slot["log"].subscribe self
+      @base_slot["state"].data = UNLOADED
+      @base_slot["info/author"].data = @plugin_configuration.author
+      @base_slot["info/version"].data = @plugin_configuration.version
+      @base_slot["info/description"].data = @plugin_configuration.description
+      @base_slot["actions/reload"].set_proc do 
+        self.reload
+      end
+      if @plugin_configuration.tests
+        @base_slot["actions/test"].set_proc do 
+          self.test
+        end
+        @plugin_configuration.tests.each do |testcase|
+          @base_slot["actions/test/#{testcase["testcase"]}"].set_proc do 
+            self.test(testcase["testcase"])
+          end
+        end
+      end
+    end
+    
+    ##
+    # Gets the info log slot
+    #
+    # return:: [FreeBASE::DataBus::Slot] The slot used for logging informational messages
+    #
+    def log_info
+      @base_slot["log/info"]
+    end
+    
+    ##
+    # Gets the debug log slot
+    #
+    # return:: [FreeBASE::DataBus::Slot] The slot used for logging debug messages
+    #
+    def log_debug
+      @base_slot["log/debug"]
+    end
+    
+    ##
+    # Gets the error log slot
+    #
+    # return:: [FreeBASE::DataBus::Slot] The slot used for logging error messages
+    #
+    def log_error
+      @base_slot["log/error"]
+    end
+    
+    ##
+    # Handle callback from Slot object
+    #
+    def databus_notify(event, slot)
+      basePath = @base_slot.path
+      case slot.path
+      when basePath+"log/info/", basePath+"log/error/", basePath+"log/debug/"
+        if event == :notify_queue_join
+          @base_slot["/log/#{slot.name}"].queue << "Plugin(#{@plugin_configuration.name}): #{slot.queue.leave}" 
+        end
+      end
+    end
+    
+    ##
+    # Transitions from current state to error state
+    # as specified in FAILURE_TRANSITIONS table
+    #
+    def transition_failure
+      state = FAILURE_TRANSITIONS[@base_slot["state"].data]
+      @base_slot["state"].data = state if state
+    end
+    
+    ##
+    # Transitions to the new state (sets ./state slot)
+    #
+    # state:: [String] The state to transition to
+    # raise:: [RuntimeException] If you cannot transition from current to proposed state
+    #
+    def transition(state)
+      currentState = @base_slot["state"].data
+      @base_slot["log/debug"] << "State transition: #{currentState} -> #{state}"
+#       puts "#{plugin_configuration.name} State transition: #{currentState} -> #{state}"
+#       puts "dependencies: #{plugin_configuration.fwd_start_graph.map{|p| p.name}.inspect}"
+#       puts "reverse_deps: #{plugin_configuration.rev_start_graph.map{|p| p.name}.inspect}"
+      unless LEGAL_TRANSITIONS[currentState].include?(state)
+        raise "Cannot transition to #{state} from #{currentState}"
+      end
+      @base_slot["state"].data = state
+    end
+    
+    def state
+      @base_slot['state'].data
+    end
+    
+    # Require the plugins files
+    def require_files
+      log_requires do
+        $LOAD_PATH << File.expand_path(
+            File.join(
+              @plugin_configuration.full_base_path, 
+              "lib"))
+        if @plugin_configuration.require_path
+          require @plugin_configuration.require_path
+        else
+          # loads from default path plugin_dir/lib/plugin_name if no load path given
+          path = File.expand_path(
+              File.join(
+                @plugin_configuration.full_base_path, 
+                "lib", 
+                @plugin_configuration.name))
+          require path
+        end
+      end
+    end
+    
+    ##
+    # Loads the plugin instance by calling load on the Module defined by startup_module.
+    #
+    def load
+      transition(LOADING)
+      begin
+        raise Exception.new("unment dependencies") unless @plugin_configuration.dependencies_met?
+        require @plugin_configuration.dependencies_path if @plugin_configuration.dependencies_path
+        require_files
+        object = eval(@plugin_configuration.startup_module)
+        object.load if object.respond_to?(:load)
+        transition(FreeBASE::LOADED)
+      rescue Exception => error
+        if error.is_a?(SystemExit)
+          exit
+        end
+        puts error
+        puts error.backtrace
+        log_error << "Error loading #{@plugin_configuration.name}\n#{error.to_s}\n#{error.backtrace.join("\n")}"
+        transition_failure
+      end
+    end
+    
+    ##
+    # Starts the plugin instance by calling start on the Module defined by startup_module.
+    #
+    def start
+      if @base_slot['state'].data == LOADED
+        transition(STARTING)
+        begin
+          raise Exception.new("unment dependencies") unless @plugin_configuration.dependencies_met?
+          log_requires do
+            object = eval(@plugin_configuration.startup_module)
+            object.start if object.respond_to?(:start)
+          end
+          transition(FreeBASE::RUNNING)
+        rescue Exception => error
+          puts error
+          puts error.backtrace
+          log_error << "Error starting #{@plugin_configuration.name}\n#{error.to_s}\n#{error.backtrace.join("\n")}"
+          transition_failure
+        end
+      end
+    end
+    
+    ##
+    # Stops the plugin instance by calling stop on the Module defined by startup_module.
+    #
+    def stop
+      if @base_slot["state"].data == RUNNING
+        transition(STOPPING) 
+        eval(@plugin_configuration.startup_module).stop(self)
+      end
+    end
+    
+    ##
+    # Unloads the plugin instance by calling unload on the Module defined by startup_module.
+    #
+    def unload
+      if @base_slot['state'].data == LOADED
+        transition(UNLOADING)
+        eval(@plugin_configuration.startup_module).unload(self)
+      end
+    end
+    
+    ##
+    # Calls the [](path) method on the @local_bus DataBus
+    #
+    def [](path)
+      return @base_slot[path]
+    end
+    
+    ##
+    # Logs all files that Ruby loads during the invocation of the block passed in.
+    #
+    def log_requires(type=:plugin)
+      before = $".dup 
+      yield
+      after = $".dup
+      prev = @base_slot["files/"+type.to_s].data || []
+      diff = (after-before)
+      diff = diff.reject do
+      end
+      @base_slot["files/"+type.to_s].data = (prev + diff).uniq
+    end
+    
+    ##
+    # Reloads all files logged as having been loaded by this plugin.
+    #
+    def reload
+      print "[FB2] reloading #{@plugin_configuration.name} ["
+      plugin = @base_slot.manager
+      plugin.stop
+      plugin.unload
+      # remove methods from testcase
+      if pm = @plugin_configuration.test_module
+        begin
+          if tc = eval(pm)
+            tc.instance_methods.select{|m| m=~/^test_/}.each do |meth|
+              tc.class_eval { remove_method(meth) }
+            end
+          end
+        rescue
+        end
+      end
+        
+      @base_slot["files"].each_slot do |s|
+        (s.data||[]).each do |f|
+          if File.extname(f) == ".rb"
+            Kernel.load f
+            print "'#{f}', "
+          end
+        end
+      end
+      puts "]"
+      plugin.load
+      plugin.start
+    end
+    
+    def require_testcase(testcase_path)
+      log_requires(:test) do
+        require testcase_path
+      end
+    end
+    
+    ##
+    # Loads and executes the plugin's test path.
+    #
+    def test(testcase=nil)
+      if @plugin_configuration.tests
+        require 'test/unit'
+        
+        # we do not want the tests to run on exit:
+        Test::Unit.run = false
+        
+        suite = Test::Unit::TestSuite.new(testcase)
+        
+        @plugin_configuration.tests.each do |test_info|
+          if testcase == nil or test_info["testcase"] == testcase
+            log_requires(:test) do
+              require test_info["path"]
+            end
+            suite << eval(test_info["testcase"]).suite
+          end
+        end
+        
+        require 'test/unit/ui/console/testrunner'
+        begin
+          Test::Unit::UI::Console::TestRunner.new(suite).start
+        rescue Object => e
+          puts e
+          puts e.message
+          puts e.backtrace
+        end
+      end
+    end
+
+    # Load and run specs for the plugin
+    def spec
+      puts "running specs"
+    end
+  end
+end