markbates-distribunaut 0.1.20090407 → 0.2.1.20090624214017

data/lib/distribunaut.rb

@@ -1,5 +1,4 @@
 require 'configatron'
-require 'cachetastic'
 require 'drb/drb'
 require 'drb/acl'
 require 'rinda/ring'
@@ -9,7 +8,6 @@ require 'activesupport'
 
 base = File.join(File.dirname(__FILE__), 'distribunaut')
 
-configatron.distribunaut.set_default(:share_objects, false)
 configatron.distribunaut.set_default(:app_name, nil)
 configatron.distribunaut.set_default(:timeout, 0)
 
@@ -18,3 +16,6 @@ Dir.glob(File.join(base, "**", "*.rb")).each do |f|
   require(f)
 end
 
+# Make sure no one can call eval() and related 
+# methods remotely!
+$SAFE = 1 unless $SAFE > 0

data/lib/distribunaut/distributable.rb

@@ -17,35 +17,31 @@ module Distribunaut # :nodoc:
   module Distributable
       
       def self.included(base) # :nodoc:
-        if configatron.distribunaut.share_objects
-          base.class_eval do
-            include ::DRbUndumped
-          end
-          eval %{
-            class ::Distribunaut::Distributed::#{base}Proxy
-              include Singleton
-              include DRbUndumped
+        base.class_eval do
+          include ::DRbUndumped
+        end
+        c_name = base.name.gsub('::', '_')
+        eval %{
+          class ::Distribunaut::Distributed::#{c_name}Proxy
+            include Singleton
+            include DRbUndumped
 
-              def method_missing(sym, *args)
-                #{base}.send(sym, *args)
-              end
-              
-              def inspect
-                #{base}.inspect
-              end
-              
-              def to_s
-                #{base}.to_s
-              end
-            
+            def method_missing(sym, *args)
+              #{base}.send(sym, *args)
             end
-          }
-          obj = "Distribunaut::Distributed::#{base}Proxy".constantize.instance 
-          raise Distribunaut::Distributed::Errors::ApplicationNameUndefined.new if configatron.distribunaut.app_name.nil?
-          Distribunaut::Utils::Rinda.register_or_renew(:space => "#{base}".to_sym, 
-                                                                    :object => obj,
-                                                                    :app_name => configatron.distribunaut.app_name)
-        end
+            
+            undef :id if method_defined?(:id)
+            undef :inspect if method_defined?(:inspect)
+            undef :to_s if method_defined?(:to_s)
+          
+          end
+        }
+        obj = "Distribunaut::Distributed::#{c_name}Proxy".constantize.instance 
+        raise Distribunaut::Distributed::Errors::ApplicationNameUndefined.new if configatron.distribunaut.app_name.nil?
+        Distribunaut::Utils::Rinda.register_or_renew(:space => "#{base}".to_sym, 
+                                                                  :object => obj,
+                                                                  :description => "#{base} Service",
+                                                                  :app_name => configatron.distribunaut.app_name.to_sym)
       end
       
   end # Distributable

data/lib/distribunaut/extensions/drb_object.rb

@@ -8,6 +8,8 @@ module DRb # :nodoc:
     end
     
     undef :id if method_defined?(:id)
+    undef :kind_of? if method_defined?(:kind_of?)
+    undef :is_a? if method_defined?(:is_a?)
     
   end
 end

data/lib/distribunaut/tasks/ring_server_tasks.rake

@@ -12,22 +12,23 @@ namespace :distribunaut do
       `distribunaut_ring_server stop`
     end
     
+    desc "Restart the Rinda ring server"
+    task :restart => [:stop, :start]
+    
     namespace :services do
       
       desc "Lists all services on the ring server"
       task :list do
-        DRb.start_service
-        ring_server = Rinda::RingFinger.primary
-        services = ring_server.read_all([nil, nil, nil, nil])
-        puts "Services on #{ring_server.__drburi}"
+        require 'distribunaut'
+        puts "Services on #{Distribunaut::Utils::Rinda.ring_server.__drburi}"
+        services = Distribunaut::Utils::Rinda.available_services
         services.each do |service|
-          puts "#{service[0]}: #{service[1]} on #{service[2].__drburi} - #{service[3]}"
+          # puts "#{service[0]}: #{service[1]} on #{service[2].__drburi} - #{service[3]}"
+          puts "#{service.app_name}: #{service.space} on #{service.object.__drburi} - #{service.description}"
         end
       end
       
     end # services
     
   end # ring_server
-end # distribunaut
-
-alias_task "distribunaut:ring_server:restart", "distribunaut:ring_server:stop", "distribunaut:ring_server:start"
+end # distribunaut

data/lib/distribunaut/tuple.rb

@@ -21,6 +21,10 @@ module Distribunaut # :nodoc:
       [self.app_name, self.space, nil, nil]
     end
     
+    def to_s
+      self.to_array.inspect
+    end
+    
     class << self
       
       def from_array(ar)

data/lib/distribunaut/utils/rinda.rb

@@ -2,43 +2,63 @@ module Distribunaut
   module Utils # :nodoc:
     module Rinda
       
-      def self.register_or_renew(values = {})
-        tuple = build_tuple(values)
-        begin
-          ring_server.take(tuple.to_search_array, tuple.timeout)
-        rescue ::Rinda::RequestExpiredError => e
-          # it's ok that it expired. It could be that it was never registered.
+      class << self
+        
+        def register_or_renew(values = {})
+          tuple = build_tuple(values)
+          begin
+            ring_server.take(tuple.to_search_array, tuple.timeout)
+          rescue ::Rinda::RequestExpiredError => e
+            # it's ok that it expired. It could be that it was never registered.
+          end
+          register(values)
         end
-        register(values)
-      end
-      
-      def self.register(values = {})
-        tuple = build_tuple(values)
-        ring_server.write(tuple.to_array, ::Rinda::SimpleRenewer.new)
-      end
-      
-      def self.ring_server
-        if configatron.distribunaut.retrieve(:acl, nil)
-          acl = ACL.new(configatron.distribunaut.acl)
-          DRb.install_acl(acl)
+      
+        def register(values = {})
+          tuple = build_tuple(values)
+          ring_server.write(tuple.to_array, ::Rinda::SimpleRenewer.new)
+        end
+      
+        def ring_server
+          if configatron.distribunaut.retrieve(:acl, nil)
+            acl = ACL.new(configatron.distribunaut.acl)
+            DRb.install_acl(acl)
+          end
+          ::DRb.start_service
+          rs = ::Rinda::RingFinger.primary
+          rs
         end
-        ::DRb.start_service
-        rs = ::Rinda::RingFinger.primary
-        rs
-      end
-      
-      def self.read(values = {})
-        tuple = build_tuple(values)
-        results = ring_server.read(tuple.to_array, tuple.timeout)
-        tuple = Distribunaut::Tuple.from_array(results)
-        tuple.object
-      end
-      
-      private
-      def self.build_tuple(values = {})
-        return values if values.is_a?(Distribunaut::Tuple)
-        Distribunaut::Tuple.new({:timeout => configatron.distribunaut.timeout}.merge(values))
-      end
+      
+        def read(values = {})
+          tuple = build_tuple(values)
+          results = ring_server.read(tuple.to_array, tuple.timeout)
+          tuple = Distribunaut::Tuple.from_array(results)
+          tuple.object
+        end
+      
+        def available_services
+          ring_server = self.ring_server
+          all = ring_server.read_all([nil, nil, nil, nil])
+          services = []
+          all.each do |service|
+            services << Distribunaut::Tuple.from_array(service)
+          end
+          services
+        end
+        
+        def remove_all_services!
+          available_services.each do |service|
+            ring_server.take(service.to_array)
+          end
+        end
+      
+        private
+        def build_tuple(values = {})
+          return values if values.is_a?(Distribunaut::Tuple)
+          Distribunaut::Tuple.new({:timeout => configatron.distribunaut.timeout}.merge(values))
+        end
+      
+      end # class << self
       
     end
   end

data/lib/distribunaut_tasks.rb

@@ -1,6 +1,4 @@
-require File.join(File.dirname(__FILE__), 'gems')
-
 # load tasks
-Dir.glob(File.join(File.dirname(__FILE__), 'distribunaut-distributed', 'tasks', '*.rake')).each do |f|
+Dir.glob(File.join(File.dirname(__FILE__), 'distribunaut', 'tasks', '*.rake')).each do |f|
   load(f)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: markbates-distribunaut
 version: !ruby/object:Gem::Version 
-  version: 0.1.20090407
+  version: 0.2.1.20090624214017
 platform: ruby
 authors: 
 - markbates
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-06 00:00:00 -07:00
+date: 2009-06-24 00:00:00 -07:00
 default_executable: distribunaut_ring_server
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,37 +20,37 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 2.3.0
     version: 
 - !ruby/object:Gem::Dependency 
-  name: cachetastic
+  name: addressable
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 2.0.0
     version: 
 - !ruby/object:Gem::Dependency 
-  name: addressable
+  name: daemons
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 1.0.10
     version: 
 - !ruby/object:Gem::Dependency 
-  name: daemons
+  name: activesupport
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 2.3.0
     version: 
 description: "distribunaut was developed by: markbates"
 email: mark@mackframework.com