classroom 0.0.1

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rake'
+require 'rake/testtask'
+
+task :default => [:test_units]
+
+desc "Run basic tests"
+Rake::TestTask.new("test_units") do |t|
+	t.pattern = 'test/*_test.rb'
+	t.verbose = true
+	t.warning = true
+end
+
+task :run_server do
+  system 'ruby -Ilib examples/server.rb'
+end

data/classroom.gemspec

@@ -0,0 +1,16 @@
+require 'rubygems'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'classroom'
+  s.version = "0.0.1"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "ClassRoom is a 'class server' based on DRb"
+  s.files = Dir.glob("**/**/**").delete_if {|item| item.include?(".svn")}
+  s.test_files = Dir.glob("test/*_test.rb")
+  s.require_path = 'lib'
+  s.autorequire = 'classroom'
+  s.author = "Peter Cooper"
+  s.email = "coops@petercooper.co.uk"
+  s.rubyforge_project = "classroom"
+  s.homepage = "http://classroom.rubyforge.org"
+end

data/examples/demo_client.rb

@@ -0,0 +1,35 @@
+# Add a basic class to the ClassRoom server and use it
+
+require 'rubygems'
+require 'classroom'
+
+# A basic 'queue' class with a fixed length queue and
+# push and pull methods to use the queue.
+klass = %q{
+  class BasicQueue
+	  def initialize(size = 10); @size = size; @data = Array.new; end
+	  def push(item); @data.length < @size ? (@data << item) && true : nil; end
+	  def pull; @data.shift; end
+	  def self.dummy_class_method; (1..10).to_a; end
+  end
+}
+
+# Here's the magic..
+class_server = ClassRoom::Client.new(ARGV.first || 'classroom://:2001')
+class_server.add_class(klass)
+class_server.load_class(binding, :all)
+
+# Create and use objects as you would normally, but remember
+# 'BasicQueue' actually exists on the ClassRoom server and,
+# if you wished, could be changed mid-execution by another
+# client!
+q = BasicQueue.new(5)
+10.times { |i| q.push("test #{i}") }
+10.times { puts q.pull }
+
+r = BasicQueue.new(10)
+10.times { |i| r.push("test #{i}") }
+10.times { puts r.pull }
+
+# Yes, class methods work out of the box too!
+puts BasicQueue.dummy_class_method.inspect

data/examples/demo_client2.rb

@@ -0,0 +1,20 @@
+# This client will run ONLY IF the BasicQueue class exists on the
+# ClassRoom server. If you ran demo_client.rb first, this should be
+# fine.
+
+# This client should return exactly the same as demo_client.rb,
+# proving the class is running entirely off of the ClassRoom server.
+
+require 'rubygems'
+require 'classroom'
+
+class_server = ClassRoom::Client.new(ARGV.first || 'classroom://:2001')
+class_server.load_class(binding, :BasicQueue)
+
+q = BasicQueue.new(5)
+10.times { |i| q.push("test #{i}") }
+10.times { puts q.pull }
+
+r = BasicQueue.new(10)
+10.times { |i| r.push("test #{i}") }
+10.times { puts r.pull }

data/examples/demo_client3.rb

@@ -0,0 +1,32 @@
+# A basic demo with a basic class
+
+require 'rubygems'
+require 'classroom'
+
+# A basic class whose function you can mostly ignore
+klass = %q{
+  class BasicDataClass
+	  def initialize(params); @data = params; end
+	  def method_missing(method, *args); @data[method]; end
+	  def size; @data.size; end
+	  def self.dummy_class_method; (1..10).to_a; end
+  end
+}
+
+# Connect to the ClassRoom server and upload the class
+class_server = ClassRoom::Client.new(ARGV.first || 'classroom://:2001')
+class_server.add_class(klass)
+
+# Load local references to all the classes on the ClassRoom server,
+# including BasicDataClass
+class_server.load_class(binding, :all)
+
+# Create and use objects as you would normally, but remember
+# 'BasicDataClass' actually exists on the ClassRoom server
+c = BasicDataClass.new(:chunky => "Bacon", :roger => "Rabbit")
+puts c.class    # => BasicDataClass
+puts c.chunky   # => Bacon
+puts c.size     # => 2
+
+# Yes, class methods work out of the box too!
+puts BasicDataClass.dummy_class_method

data/examples/demo_client4.rb

@@ -0,0 +1,49 @@
+# A demonstration of nested classes all working perfectly..
+# (we hope!)
+
+require 'rubygems'
+require 'classroom'
+
+# A basic 'queue' class with a fixed length queue and
+# push and pull methods to use the queue.
+klass = %q{
+  class BasicParent
+    def self.give_child
+      BasicParent::BasicChild.new
+    end
+    def self.x
+      "PARENT CLASS METHOD X"
+    end
+    def x
+      "PARENT CHILD METHOD X"
+    end
+    attr_accessor :blah
+    class BasicChild
+      def self.x
+        "CHILD CLASS METHOD X"
+      end
+      def x
+        "CHILD OBJECT METHOD X"
+      end
+      class BasicSubChild
+        def self.x
+          "GRANDCHILD CLASS METHOD X"
+        end
+      end
+    end
+  end
+}
+
+# Here's the magic..
+class_server = ClassRoom::Client.new(ARGV.first || 'druby://coop-pb:2001')
+class_server.add_class(klass)
+class_server.load_class(binding, :all)
+#class_server.load_non_present_classes(binding)
+
+puts BasicParent.give_child.x
+puts BasicParent.x
+puts BasicParent::BasicChild::BasicSubChild.x
+
+x = BasicParent.new
+x.blah = 50
+puts x.blah

data/examples/demo_client5.rb

@@ -0,0 +1,51 @@
+# Attempt to do nasty / insecure operations!
+
+require 'rubygems'
+require 'classroom'
+
+# A basic 'queue' class with a fixed length queue and
+# push and pull methods to use the queue.
+klass = %q{
+  class BasicParent
+    def do_nasty
+      `ls -l`
+    end
+    def do_nasty2
+      x = 'ls'
+      y = '-l'
+      z = 'system'
+      eval z + '"' + x + ' ' + y + '"'
+    end
+    def do_nasty3
+      ClassRoom::ClassServerContainer.attr_writer(:xyzzy)
+    end
+  end
+}
+
+# Here's the magic..
+class_server = ClassRoom::Client.new(ARGV.first || 'druby://coop-pb:2001')
+class_server.add_class(klass)
+class_server.load_class(binding, :all)
+
+a = BasicParent.new
+
+puts "Nasty 1"
+begin
+  a.do_nasty
+rescue
+  puts "FAILED WITH #{$!}}!"
+end
+
+puts "Nasty 2"
+begin
+  a.do_nasty2
+rescue
+  puts "FAILED WITH #{$!}}!"
+end
+
+puts "Nasty 3"
+begin
+  a.do_nasty3
+rescue
+  puts "FAILED WITH #{$!}}!"
+end

data/examples/server.rb

@@ -0,0 +1,9 @@
+# A very basic ClassRoom server
+
+require 'rubygems'
+require 'classroom'
+
+url = ClassRoom::ClassServer.prepare
+puts "ClassRoom server running at #{url}"
+ClassRoom::ClassServer.start
+

data/examples/test_modules.rb

@@ -0,0 +1,48 @@
+# Tests that modules work in one sense
+
+require 'rubygems'
+require 'classroom'
+
+klass = %q{
+  module TestModule
+    class BasicParent
+      def self.give_child
+        BasicParent::BasicChild.new
+      end
+      def self.x
+        "PARENT CLASS METHOD X"
+      end
+      def x
+        "PARENT CHILD METHOD X"
+      end
+      attr_accessor :blah
+      class BasicChild
+        def self.x
+          "CHILD CLASS METHOD X"
+        end
+        def x
+          "CHILD OBJECT METHOD X"
+        end
+        class BasicSubChild
+          def self.x
+            "GRANDCHILD CLASS METHOD X"
+          end
+        end
+      end
+    end
+  end
+}
+
+# Here's the magic..
+class_server = ClassRoom::Client.new(ARGV.first || 'druby://coop-pb:2001')
+class_server.add_class(klass)
+class_server.load_non_present_classes(binding)
+
+puts class_server.classes.inspect
+puts TestModule::BasicParent.give_child.x
+puts TestModule::BasicParent.x
+puts TestModule::BasicParent::BasicChild::BasicSubChild.x
+
+x = TestModule::BasicParent.new
+x.blah = 50
+puts x.blah

data/examples/test_modules2.rb

@@ -0,0 +1,32 @@
+# Tests that module mixins work entirely on the server end
+
+require 'rubygems'
+require 'classroom'
+
+# A basic 'queue' class with a fixed length queue and
+# push and pull methods to use the queue.
+klass = %q{
+  module TestModule
+    def blah
+      "blah #{@s}"
+    end
+  end
+}
+
+klass2 = %q{
+  class Something
+    include TestModule
+    def initialize(s)
+      @s = s
+    end
+  end
+}
+
+# Here's the magic..
+class_server = ClassRoom::Client.new(ARGV.first || 'druby://coop-pb:2001')
+class_server.add_class(klass)
+class_server.add_class(klass2)
+class_server.load_class(binding, :all)
+
+x = Something.new(10)
+puts x.blah

data/examples/test_modules3.rb

@@ -0,0 +1,35 @@
+# THIS TEST WILL NOT WORK!! UNIMPLEMENTED FEATURE!!
+
+# Use a remote module from the ClassRoom server as a mixin
+# on a local class.. (currently not possible)
+
+require 'rubygems'
+require 'classroom'
+
+# A basic 'queue' class with a fixed length queue and
+# push and pull methods to use the queue.
+klass = %q{
+  module TestModule
+    def blah
+      "blah #{@s}"
+    end
+  end
+}
+
+
+# Here's the magic..
+class_server = ClassRoom::Client.new(ARGV.first || 'druby://coop-pb:2001')
+class_server.add_class(klass)
+class_server.load_class(binding, :all)
+
+
+class Something
+ include TestModule
+ def initialize(s)
+   @s = s
+ end
+end
+
+
+x = Something.new(10)
+puts x.blah

data/lib/classroom.rb

@@ -0,0 +1,241 @@
+require 'drb/drb'
+require 'thread'
+
+module ClassRoom
+
+  # Create a 'blank slate' class template so we don't have any extraneous
+  # methods lying around to be (potentially) abused.
+  # Technique by http://onestepback.org/index.cgi/Tech/Ruby/BlankSlate.rdoc
+  class BlankSlate
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+  end
+  
+  # Provide a separate module as the container for our user classes
+  module ClassContainer
+  end
+  
+  # The class that proxies between user classes on the ClassRoom server and
+  # the requests made by client apps. It stores references to the user classes,
+  # evals the code, and allows instances to be created of the user classes.
+  class ClassServerContainer < BlankSlate
+    @@classes = []
+        
+    # Add class(es) to the ClassRoom server
+    def self.add_class(code)
+      base_class = code.scan(/(class|module)\s+([\w\:]+)/).collect{|c| c[1]}.flatten.first
+      base_class.untaint
+      @@classes << base_class
+
+      # Actually add the class to the ClassRoom server
+      begin
+        # Force the code to run by untainting it
+        code.untaint
+        # Force the code into the ClassContainer module and force a
+        # SAFE mode where all data is considered tainted. This stops
+        # users running system commands, etc.
+        eval("module ClassRoom; module ClassContainer\n$SAFE = 3\n" + code + "\nend; end")
+      rescue
+        # If the user's code was bad, duck out.
+        return nil
+      end
+
+      # Now the code is loaded.. loop through all of the classes and add their
+      # full (nested) names to the class list so automatic loading
+      # can work for clients
+      classes_to_check = [base_class]
+      classes_to_check.each do |class_name|
+        class_internal = eval("ClassRoom::ClassContainer::#{class_name}")
+        class_internal.constants.each do |subclass_name| 
+          if class_internal.const_get(subclass_name).is_a?(Class) || class_internal.const_get(subclass_name).is_a?(Module)
+            sub_class = class_name + "::" + subclass_name
+            @@classes << sub_class
+            classes_to_check << sub_class
+          end
+        end          
+      end
+      
+      # Hack to make sure the classes array is clean
+      @@classes.collect! { |c| c.to_sym }
+      @@classes.uniq!
+      true
+    end
+    
+    # THESE ARE NOT WORKING
+    #def self.remove_class(class_name)
+    #  class_internal = eval("ClassRoom::ClassContainer")
+    #  class_internal.constants.each do |subclass_name|
+    #    if class_internal.const_get(subclass_name).is_a?(Class) || class_internal.const_get(subclass_name).is_a?(Module)
+    #      class_internal.remove_const(subclass_name) if subclass_name.to_s == class_name.to_s
+    #    end
+    #  end
+    #end
+    #
+    #def self.remove_all
+    #  class_internal = eval("ClassRoom::ClassContainer")
+    #  class_internal.constants.each do |subclass_name|
+    #    if class_internal.const_get(subclass_name).is_a?(Class) || class_internal.const_get(subclass_name).is_a?(Module)
+    #      class_internal.remove_const(subclass_name)
+    #    end
+    #  end     
+    #end
+    
+    # Return a list of all classes in the ClassContainer
+    # (must be a nicer way to do this without logging it ourselves..?)
+    def self.classes
+      return @@classes
+    end
+    
+    # Return a new instance of a class in the ClassContainer    
+    def self.new_instance_of(class_name, *args)
+      begin
+        obj = eval('ClassRoom::ClassContainer::' + class_name.to_s).new(*args)
+        obj.extend(DRbUndumped)
+        obj
+      rescue
+        nil
+      end
+    end
+    
+    # Call a class method on a class in the ClassContainer
+    # (this might need work to check what comes back and whether to
+    # mix in DRbUndumped if it's an object)
+    def self.class_method(class_name, method_name, *args)
+      begin
+        obj = eval('ClassRoom::ClassContainer::' + class_name.to_s).send(method_name.to_s, *args)
+        obj.extend(DRbUndumped) if self.classes.detect { |c| obj.class.to_s.index(c.to_s) }
+        obj
+      rescue
+        nil
+      end
+    end
+            
+  end
+  
+  # Provides methods to get the server up and running easily
+  class ClassServer < BlankSlate
+    # Prepare DRb to act as a server using the correct URL
+    # Do some messy hacks to get our own URL scheme
+  	def self.prepare(drb_url = 'classroom://:2001')
+  		$SAFE = 1
+  		drb_url.gsub!('classroom:', 'druby:')
+  		DRb.start_service(drb_url, ClassServerContainer)
+  		return DRb.uri.gsub('druby:', 'classroom:')
+  	end
+  	
+  	# Do the thread.join with DRb to actually get the server processing requests
+  	# TODO: Get this daemonizing!
+  	def self.start
+  	  #fork do
+  	  #  Process.setsid
+  	  #  exit if fork
+      #  trap("TERM") {daemon.stop; exit}
+  		  Kernel.send :remove_method, :system
+        class << Kernel; self; end.send :remove_method, :system
+  		  $SAFE = 3
+  		  DRb.thread.join
+  		#end
+  	end
+  end
+  
+  # Provides methods for the client side
+  class Client < BlankSlate
+    
+    def self.get_drb(drb_url)
+      @@drb[drb_url]
+    end
+    
+    # Set up the DRbObject referring to the ClassRoom server
+    def initialize(drb_url)
+      @drb_url = drb_url.gsub('classroom:', 'druby:')
+      (@@drb ||= {})[@drb_url] = DRbObject.new(nil, @drb_url)
+    end
+    
+    # Passes through calls for non-local methods to the DRb server
+    def method_missing(method, *args)
+      @@drb[@drb_url].send(method, *args)
+    end
+    
+    # Returns a proxy object referring to the remote class required
+    def remote_class(class_name)
+      ClassRoom::Client::ProxyObject.new(@drb, class_name)
+    end
+        
+    # Load a class (or all classes, if :all is specified) from the 
+    # ClassRoom server to be used locally
+    def load_class(b, *classes)
+      return nil unless classes && b
+      classes = self.classes if classes.first == :all
+      classes.each do |class_name|
+        eval %Q{
+          class #{class_name} < ClassRoom::Client::ProxyObject
+          end
+          #{class_name}.class_name = :\"#{class_name}\"
+          #{class_name}.drb = ClassRoom::Client::get_drb('#{@drb_url}')
+        }, b
+      end
+    end
+
+    # Load all classes on the ClassRoom server that do not already
+    # exist locally (not fully tested yet!)
+    def load_non_present_classes(b)
+      return nil unless b
+      classes = self.classes
+      classes.each do |class_name|
+        eval %Q{
+          unless defined?(#{class_name})
+            class #{class_name} < ClassRoom::Client::ProxyObject
+            end
+          end
+        }, b
+        eval %Q{
+          begin
+          #{class_name}.drb = @drb
+          rescue
+          end
+        }
+        eval %Q{
+          begin
+          #{class_name}.class_name = :\"#{class_name}\"
+          rescue
+          end
+        }
+      end
+    end
+    
+    # ProxyObject acts as a local proxy for ClassRoom clients and
+    # handles passing through requests to run class methods and initializations
+    class ProxyObject
+      
+      # Set up a weird /true/ class variable system (that is, class variable ==
+      # class variable, not weird hierarchy variable-foo as is Ruby's wont)
+      def self.drb; @@drb[self.to_s.to_sym]; end
+      def self.drb=(d); (@@drb ||= {})[self.to_s.to_sym] = d; end
+      def self.class_name; @@class_name[self.to_s.to_sym]; end
+      def self.class_name=(d); (@@class_name ||= {})[self.to_s.to_sym] = d; end
+      def drb; @@drb[self.class.to_s.to_sym]; end
+      def class_name; @@class_name[self.class.to_s.to_sym]; end
+     
+      # Create an instance of the remote class
+      def initialize(*args)
+        @drbed_object = drb.send(:new_instance_of, self.class.to_s.to_sym, *args)
+      end
+      
+      # If we're getting methods called on the proxy, they must be for 
+      # the remote class rather than a method, so ask the ClassRoom server
+      # to run the class_method on the supplied object
+      def self.method_missing(method, *args)
+        drb.send(:class_method, class_name, method, *args)
+      end
+      
+      # Return the 'real' class name
+      #def class; @class_name; end
+  
+      def method_missing(method, *args)
+        @drbed_object.send(method, *args)
+      end
+    
+    end
+    
+  end
+
+end

data/test/classroom_test.rb

@@ -0,0 +1,46 @@
+require 'test/unit'
+require 'rubygems'
+require 'classroom'
+
+# Get a binding for the top level
+$top_level_binding = binding
+
+class ClassRoomTest < Test::Unit::TestCase
+
+  def setup
+    $class_server = ClassRoom::Client.new('classroom://:2001')    
+    
+  end
+  
+  def test_a_classroom_server_responds
+    assert $class_server.classes.class == Array
+  end
+  
+  def test_b_can_add_basic_class
+    klass = %q{
+      class SmallClass
+        def self.result; "GOOD CLASS"; end
+        def result; "GOOD INSTANCE"; end
+      end
+    }
+    assert $class_server.add_class(klass)
+  end
+  
+  def test_c_can_use_class_method_directly
+    assert_equal "GOOD CLASS", $class_server.class_method(:SmallClass, :result)    
+  end
+
+  def test_d_can_create_instance_directly
+    assert_equal "GOOD INSTANCE", $class_server.new_instance_of(:SmallClass).result   
+  end
+  
+  def test_e_can_import_classes
+    assert $class_server.load_class($top_level_binding, :all)
+  end
+
+  def test_f_can_use_imported_classes
+    assert_equal "GOOD CLASS", SmallClass.result
+    assert_equal "GOOD INSTANCE", SmallClass.new.result
+  end
+  
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: classroom
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2006-07-12 00:00:00 +01:00
+summary: ClassRoom is a 'class server' based on DRb
+require_paths: 
+- lib
+email: coops@petercooper.co.uk
+homepage: http://classroom.rubyforge.org
+rubyforge_project: classroom
+description: 
+autorequire: classroom
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Peter Cooper
+files: 
+- classroom.gemspec
+- examples
+- lib
+- Rakefile
+- test
+- examples/demo_client.rb
+- examples/demo_client2.rb
+- examples/demo_client3.rb
+- examples/demo_client4.rb
+- examples/demo_client5.rb
+- examples/server.rb
+- examples/test_modules.rb
+- examples/test_modules2.rb
+- examples/test_modules3.rb
+- lib/classroom.rb
+- test/classroom_test.rb
+test_files: 
+- test/classroom_test.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+