markbates-distribunaut 0.2.2.20090626214209 → 0.2.20090511204103

data/lib/distribunaut/distributable.rb

@@ -17,7 +17,6 @@ module Distribunaut # :nodoc:
   module Distributable
       
       def self.included(base) # :nodoc:
-        raise Distribunaut::Distributed::Errors::ApplicationNameUndefined.new if configatron.distribunaut.app_name.nil?
         base.class_eval do
           include ::DRbUndumped
         end
@@ -34,23 +33,15 @@ module Distribunaut # :nodoc:
             undef :id if method_defined?(:id)
             undef :inspect if method_defined?(:inspect)
             undef :to_s if method_defined?(:to_s)
-            
-            def borrow(&block)
-              Distribunaut::Utils::Rinda.borrow(:space => :#{base}, 
-                                                :object => self,
-                                                :description => "#{base} Service",
-                                                :app_name => configatron.distribunaut.app_name.to_sym) do |tuple|
-                yield tuple.object
-              end
-            end
           
           end
         }
-        obj = "Distribunaut::Distributed::#{c_name}Proxy".constantize.instance
+        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)
+                                                                  :object => obj,
+                                                                  :description => "#{base} Service",
+                                                                  :app_name => configatron.distribunaut.app_name)
       end
       
   end # Distributable

data/lib/distribunaut/tuple.rb

@@ -21,10 +21,6 @@ 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,81 +2,53 @@ module Distribunaut
   module Utils # :nodoc:
     module Rinda
       
-      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
-      
-        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
-      
-        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 borrow(values = {}, &block)
-          tuple = build_tuple(values)
-          results = ring_server.take(tuple.to_array, tuple.timeout)
-          tuple = Distribunaut::Tuple.from_array(results)
-          tuple.space = "#{tuple.space}-onloan-#{Time.now}".to_sym
-          register(tuple)
-          begin
-            yield tuple if block_given?
-          rescue Exception => e
-            raise e
-          ensure
-            # (.+)-onloan-.+$
-            tuple.space.to_s.match(/(.+)-onloan-.+$/)
-            tuple.space = $1.to_sym
-            register(tuple)
-          end
-        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
+      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.
+        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)
+        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
+      
+      def self.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
+      
+      private
+      def self.build_tuple(values = {})
+        return values if values.is_a?(Distribunaut::Tuple)
+        Distribunaut::Tuple.new({:timeout => configatron.distribunaut.timeout}.merge(values))
+      end
       
     end
   end

data/lib/distribunaut.rb

@@ -8,6 +8,7 @@ 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)
 
@@ -16,6 +17,3 @@ 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: markbates-distribunaut
 version: !ruby/object:Gem::Version 
-  version: 0.2.2.20090626214209
+  version: 0.2.20090511204103
 platform: ruby
 authors: 
 - markbates
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-26 00:00:00 -07:00
+date: 2009-05-11 00:00:00 -07:00
 default_executable: distribunaut_ring_server
 dependencies: 
 - !ruby/object:Gem::Dependency