markbates-distribunaut 0.0.2 → 0.0.2.20090406

data/lib/distribunaut/distributable.rb

@@ -40,10 +40,9 @@ module Distribunaut # :nodoc:
             
             end
           }
-          raise Distribunaut::Distributed::Errors::ApplicationNameUndefined.new if configatron.distribunaut.app_name.nil?
-          Distribunaut::Distributed::Utils::Rinda.register_or_renew(:space => configatron.distribunaut.app_name.to_sym, 
-                                                            :klass_def => "#{base}".to_sym, 
-                                                            :object => "Distribunaut::Distributed::#{base}Proxy".constantize.instance)
+          obj = "Distribunaut::Distributed::#{base}Proxy".constantize.instance
+          Distribunaut::Distributed::Utils::Rinda.register_or_renew(:space => "#{base}".to_sym, 
+                                                  :object => obj)
         end
       end
       

data/lib/distribunaut/distributed.rb

@@ -3,21 +3,21 @@ module Distribunaut # :nodoc:
     
     # Looks up and tries to find the missing constant using the ring server.
     def self.const_missing(const)
-      Distribunaut::Distributed::Utils::Rinda.read(:klass_def => "#{const}".to_sym)
+      Distribunaut::Distributed::Utils::Rinda.read(:space => "#{const}".to_sym)
     end
     
     # Allows for the specific lookup of services on the ring server
     # 
     # Examples:
-    #   Distribunaut::Distributed::Utils::Rinda.register_or_renew(:space => :app_1, :klass_def => :Test, :object => "Hello World!")
-    #   Distribunaut::Distributed::Utils::Rinda.register_or_renew(:space => :app_2, :klass_def => :Test, :object => "Hello WORLD!")
+    #   Distribunaut::Distributed::Utils::Rinda.register_or_renew(:app_name => :app_1, :space => :Test, :object => "Hello World!")
+    #   Distribunaut::Distributed::Utils::Rinda.register_or_renew(:app_name => :app_2, :space => :Test, :object => "Hello WORLD!")
     #   Distribunaut::Distributed.lookup("distributed://app_1/Test") # => "Hello World!"
     #   Distribunaut::Distributed.lookup("distributed://app_2/Test") # => "Hello WORLD!"
     def self.lookup(address)
       uri = Addressable::URI.parse(address)
       path = uri.path[1..uri.path.size] # remove the first slash
       host = uri.host
-      Distribunaut::Distributed::Utils::Rinda.read(:klass_def => path.to_sym, :space => host.to_sym)
+      Distribunaut::Distributed::Utils::Rinda.read(:space => path.to_sym, :app_name => host.to_sym)
     end
     
   end # Distributed

data/lib/distribunaut/errors/errors.rb

@@ -9,14 +9,6 @@ module Distribunaut
           super("APPLICATION: #{app_name} is not a known/registered distributed application.")
         end
       end
-    
-      # Raised when an unknown distributed route name for a distributed application is referenced.
-      class UnknownRouteName < StandardError
-        # Takes the application name and the route name.
-        def initialize(app_name, route_name)
-          super("ROUTE_NAME: #{route_name}, is not a known/registered distributed route name for application: #{app_name}.")
-        end
-      end
       
       # Raised when an application doesn't declare it's application name for use in a distributed system.
       class ApplicationNameUndefined < StandardError
@@ -27,7 +19,8 @@ module Distribunaut
         def inititalize(msg)
           super("Invalid addressable format: #{msg}")
         end
-      end      
+      end
+      
     end # Errors
   end # Distributed
 end # Distribunaut

data/lib/distribunaut/utils/rinda.rb

@@ -6,7 +6,7 @@ module Distribunaut
         def self.register_or_renew(options = {})
           options = handle_options(options)
           begin
-            ring_server.take([options[:space], options[:klass_def], nil, nil], options[:timeout])
+            ring_server.take([options[:app_name], options[:space], nil, nil], options[:timeout])
           rescue Exception => e
             # Distribunaut.logger.error(e)
           end
@@ -15,8 +15,8 @@ module Distribunaut
         
         def self.register(options = {})
           options = handle_options(options)
-          ring_server.write([options[:space], 
-                             options[:klass_def], 
+          ring_server.write([options[:app_name], 
+                             options[:space], 
                              options[:object], 
                              options[:description]], 
                             ::Rinda::SimpleRenewer.new)
@@ -34,12 +34,18 @@ module Distribunaut
         
         def self.read(options = {})
           options = handle_options(options)
-          ring_server.read([options[:space], options[:klass_def], nil, options[:description]], options[:timeout])[2]
+          ring_server.read([options[:app_name], options[:space], nil, options[:description]], options[:timeout])[2]
         end
         
         private
         def self.handle_options(options = {})
-          {:space => nil, :klass_def => nil, :object => nil, :description => nil, :timeout => configatron.distribunaut.timeout}.merge(options)
+          raise Distribunaut::Distributed::Errors::ApplicationNameUndefined.new if configatron.distribunaut.app_name.nil?
+          {:app_name => configatron.distribunaut.app_name, 
+           :space => nil, 
+           :object => nil, 
+           :description => nil, 
+           :timeout => configatron.distribunaut.timeout
+          }.merge(options)
         end
         
       end

metadata

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