markbates-distribunaut 0.0.1

data/README

@@ -0,0 +1,43 @@
+=== Example #1
+
+  # 'Server' application
+  require 'distribunaut'
+
+  configatron.distribunaut.app_name = :user_app
+  configatron.distribunaut.share_objects = true
+
+  class User
+    include Distribunaut::Distributable
+
+    attr_accessor :username
+
+    def self.hi
+      'hello!!!'
+    end
+
+    def save
+      puts "Saving: #{self.inspect}"
+    end
+
+  end
+
+  DRb.thread.join
+  
+  # 'Client' application
+  require 'distribunaut'
+
+  puts Distribunaut::Distributed::User.hi
+
+  User = Distribunaut::Distributed::User
+
+  puts User.hi
+
+  user = User.new
+
+  puts user.inspect
+
+  user.username = 'markbates'
+
+  puts user.inspect
+
+  user.save

data/bin/distribunaut_ring_server

@@ -0,0 +1,33 @@
+#!/usr/local/bin/ruby
+# require 'rubygems'
+require 'daemons'
+require 'rinda/ring'
+require 'rinda/tuplespace'
+require 'fileutils' 
+require 'optparse'
+require 'optparse/time'
+require 'ostruct'
+
+options = OpenStruct.new
+opts = OptionParser.new do |opts|
+  opts.banner = <<-BANNER
+Usage: distribunaut_ring_server <command>
+Available commands are:
+
+- start
+- stop
+- restart
+
+BANNER
+end
+
+opts.parse!(ARGV)
+
+FileUtils.mkdir_p(File.join("tmp", "pids"))
+
+Daemons.run_proc('distribunaut_ring_server', {:dir_mode => :normal, :dir => File.join("tmp", "pids"), :monitor => true, :multiple => false}) do
+  puts 'Starting distribunaut_ring_server...'
+  DRb.start_service
+  Rinda::RingServer.new(Rinda::TupleSpace.new)
+  DRb.thread.join
+end

data/lib/distribunaut/distributable.rb

@@ -0,0 +1,65 @@
+module Distribunaut # :nodoc:
+  # Include this module into any class it will instantly register that class with
+  # the distribunaut_ring_server. The class will be registered with the name of the class
+  # and the distribunaut.distributed_app_name configured in your config/configatron/*.rb file.
+  # If the distribunaut.distributed_app_name configuration parameter is nil it will raise
+  # an Distribunaut::Distributed::Errors::ApplicationNameUndefined exception.
+  # 
+  # Example:
+  #  class User
+  #    include Distribunaut::Distributable
+  #    def name
+  #      "mark"
+  #    end
+  #  end
+  # 
+  #  Distribunaut::Distributed::User.new.name # => "mark"
+  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
+
+              def method_missing(sym, *args)
+                #{base}.send(sym, *args)
+              end
+              
+              def inspect
+                #{base}.inspect
+              end
+              
+              def to_s
+                #{base}.to_s
+              end
+            
+            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)
+        end
+      end
+      
+  end # Distributable
+end # Distribunaut
+
+module DRb # :nodoc:
+  class DRbObject # :nodoc:
+
+    alias_method :_original_inspect, :inspect unless method_defined?(:_original_inspect)
+    
+    def inspect
+      "#{_original_inspect}|#{method_missing(:inspect)}"
+    end
+    
+    undef :id if method_defined?(:id)
+    
+  end
+end

data/lib/distribunaut/distributed.rb

@@ -0,0 +1,24 @@
+module Distribunaut # :nodoc:
+  module Distributed # :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)
+    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.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)
+    end
+    
+  end # Distributed
+end # Distribunaut

data/lib/distribunaut/errors/errors.rb

@@ -0,0 +1,33 @@
+module Distribunaut
+  module Distributed # :nodoc:
+    module Errors # :nodoc:
+      
+      # Raised when an unknown distributed application is referenced.
+      class UnknownApplication < StandardError
+        # Takes the application name.
+        def initialize(app_name)
+          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
+      end
+      
+      # Raised when the distributed path is not a well formed addressable format
+      class InvalidAddressableURIFormat < StandardError
+        def inititalize(msg)
+          super("Invalid addressable format: #{msg}")
+        end
+      end      
+    end # Errors
+  end # Distributed
+end # Distribunaut

data/lib/distribunaut/tasks/ring_server_tasks.rake

@@ -0,0 +1,33 @@
+require 'rinda/ring'
+namespace :distribunaut do
+  namespace :ring_server do
+    
+    desc "Start the Rinda ring server"
+    task :start do
+      `distribunaut_ring_server start`
+    end
+    
+    desc "Stop the Rinda ring server"
+    task :stop do
+      `distribunaut_ring_server stop`
+    end
+    
+    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}"
+        services.each do |service|
+          puts "#{service[0]}: #{service[1]} on #{service[2].__drburi} - #{service[3]}"
+        end
+      end
+      
+    end # services
+    
+  end # ring_server
+end # distribunaut
+
+alias_task "distribunaut:ring_server:restart", "distribunaut:ring_server:stop", "distribunaut:ring_server:start"

data/lib/distribunaut/utils/rinda.rb

@@ -0,0 +1,48 @@
+module Distribunaut
+  module Distributed
+    module Utils # :nodoc:
+      module Rinda
+        
+        def self.register_or_renew(options = {})
+          options = handle_options(options)
+          begin
+            ring_server.take([options[:space], options[:klass_def], nil, nil], options[:timeout])
+          rescue Exception => e
+            # Distribunaut.logger.error(e)
+          end
+          register(options)
+        end
+        
+        def self.register(options = {})
+          options = handle_options(options)
+          ring_server.write([options[:space], 
+                             options[:klass_def], 
+                             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[:space], options[:klass_def], 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)
+        end
+        
+      end
+    end
+  end
+end

data/lib/distribunaut.rb

@@ -0,0 +1,24 @@
+require 'configatron'
+require 'cachetastic'
+require 'drb/drb'
+require 'drb/acl'
+require 'rinda/ring'
+require 'rinda/tuplespace'
+require 'addressable/uri'
+require 'activesupport'
+
+base = File.join(File.dirname(__FILE__), 'distribunaut')
+
+configatron.distribunaut.set_default(:share_routes, false)
+configatron.distribunaut.set_default(:share_objects, false)
+configatron.distribunaut.set_default(:share_views, false)
+configatron.distribunaut.set_default(:app_name, nil)
+configatron.distribunaut.set_default(:site_domain, nil)
+configatron.distribunaut.set_default(:timeout, 0)
+configatron.distribunaut.set_default(:enable_view_cache, false)
+
+# load *.rb files
+Dir.glob(File.join(base, "**", "*.rb")).each do |f|
+  require(f)
+end
+

data/lib/distribunaut_tasks.rb

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

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: markbates-distribunaut
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- markbates
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-05 00:00:00 -07:00
+default_executable: distribunaut_ring_server
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: configatron
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: cachetastic
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: addressable
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: daemons
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: "distribunaut was developed by: markbates"
+email: ""
+executables: 
+- distribunaut_ring_server
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/distribunaut/distributable.rb
+- lib/distribunaut/distributed.rb
+- lib/distribunaut/errors/errors.rb
+- lib/distribunaut/tasks/ring_server_tasks.rake
+- lib/distribunaut/utils/rinda.rb
+- lib/distribunaut.rb
+- lib/distribunaut_tasks.rb
+- README
+- bin/distribunaut_ring_server
+has_rdoc: true
+homepage: ""
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: distribunaut
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: distribunaut
+test_files: []
+