markbates-distribunaut 0.1.20090406 → 0.1.20090407

data/lib/distribunaut/distributable.rb

@@ -42,7 +42,7 @@ module Distribunaut # :nodoc:
           }
           obj = "Distribunaut::Distributed::#{base}Proxy".constantize.instance 
           raise Distribunaut::Distributed::Errors::ApplicationNameUndefined.new if configatron.distribunaut.app_name.nil?
-          Distribunaut::Distributed::Utils::Rinda.register_or_renew(:space => "#{base}".to_sym, 
+          Distribunaut::Utils::Rinda.register_or_renew(:space => "#{base}".to_sym, 
                                                                     :object => obj,
                                                                     :app_name => configatron.distribunaut.app_name)
         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(:space => "#{const}".to_sym)
+      Distribunaut::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(: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::Utils::Rinda.register_or_renew(:app_name => :app_1, :space => :Test, :object => "Hello World!")
+    #   Distribunaut::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(:space => path.to_sym, :app_name => host.to_sym)
+      Distribunaut::Utils::Rinda.read(:space => path.to_sym, :app_name => host.to_sym)
     end
     
   end # Distributed

data/lib/distribunaut/tuple.rb

@@ -0,0 +1,38 @@
+module Distribunaut # :nodoc:
+  class Tuple
+    
+    attr_accessor :app_name
+    attr_accessor :space
+    attr_accessor :object
+    attr_accessor :description
+    attr_accessor :timeout
+    
+    def initialize(values = {})
+      values.each do |k, v|
+        self.send("#{k}=", v)
+      end
+    end
+    
+    def to_array
+      [self.app_name, self.space, self.object, self.description]
+    end
+    
+    def to_search_array
+      [self.app_name, self.space, nil, nil]
+    end
+    
+    class << self
+      
+      def from_array(ar)
+        tuple = Distribunaut::Tuple.new
+        tuple.app_name = ar[0]
+        tuple.space = ar[1]
+        tuple.object = ar[2]
+        tuple.description = ar[3]
+        return tuple
+      end
+      
+    end
+      
+  end # Tuple
+end # Distribunaut

data/lib/distribunaut/utils/rinda.rb

@@ -1,53 +1,45 @@
 module Distribunaut
-  module Distributed
-    module Utils # :nodoc:
-      module Rinda
-        
-        def self.register_or_renew(options = {})
-          options = handle_options(options)
-          begin
-            ring_server.take([options[:app_name], options[:space], nil, nil], options[:timeout])
-          rescue ::Rinda::RequestExpiredError => e
-            # it's ok that it expired. It could be that it was never registered.
-          end
-          register(options)
+  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.
         end
-        
-        def self.register(options = {})
-          options = handle_options(options)
-          ring_server.write([options[:app_name], 
-                             options[:space], 
-                             options[:object], 
-                             options[:description]], 
-                            ::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(options = {})
-          options = handle_options(options)
-          ring_server.read([options[:app_name], options[:space], nil, options[:description]], options[:timeout])[2]
-        end
-        
-        private
-        def self.handle_options(options = {})
-          {:app_name => nil, 
-           :space => nil, 
-           :object => nil, 
-           :description => nil, 
-           :timeout => configatron.distribunaut.timeout
-          }.merge(options)
+        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
+      
+      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
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: markbates-distribunaut
 version: !ruby/object:Gem::Version 
-  version: 0.1.20090406
+  version: 0.1.20090407
 platform: ruby
 authors: 
 - markbates
@@ -66,6 +66,7 @@ files:
 - lib/distribunaut/errors/errors.rb
 - lib/distribunaut/extensions/drb_object.rb
 - lib/distribunaut/tasks/ring_server_tasks.rake
+- lib/distribunaut/tuple.rb
 - lib/distribunaut/utils/rinda.rb
 - lib/distribunaut.rb
 - lib/distribunaut_tasks.rb