mack-distributed 0.7.0

data/doc/rdoc-style.css

@@ -0,0 +1,208 @@
+
+body {
+    font-family: Verdana,Arial,Helvetica,sans-serif;
+    font-size:   90%;
+    margin: 0;
+    margin-left: 40px;
+    padding: 0;
+    background: white;
+}
+
+h1,h2,h3,h4 { margin: 0; color: #efefef; background: transparent; }
+h1 { font-size: 150%; }
+h2,h3,h4 { margin-top: 1em; }
+
+a { background: #eef; color: #039; text-decoration: none; }
+a:hover { background: #039; color: #eef; }
+
+/* Override the base stylesheet's Anchor inside a table cell */
+td > a {
+  background: transparent;
+  color: #039;
+  text-decoration: none;
+}
+
+/* and inside a section title */
+.section-title > a {
+  background: transparent;
+  color: #eee;
+  text-decoration: none;
+}
+
+/* === Structural elements =================================== */
+
+div#index {
+    margin: 0;
+    margin-left: -40px;
+    padding: 0;
+    font-size: 90%;
+}
+
+
+div#index a {
+    margin-left: 0.7em;
+}
+
+div#index .section-bar {
+   margin-left: 0px;
+   padding-left: 0.7em;
+   background: #ccc;
+   font-size: small;
+}
+
+
+div#classHeader, div#fileHeader {
+    width: auto;
+    color: white;
+    padding: 0.5em 1.5em 0.5em 1.5em;
+    margin: 0;
+    margin-left: -40px;
+    border-bottom: 3px solid #006;
+}
+
+div#classHeader a, div#fileHeader a {
+    background: inherit;
+    color: white;
+}
+
+div#classHeader td, div#fileHeader td {
+    background: inherit;
+    color: white;
+}
+
+
+div#fileHeader {
+    background: #057;
+}
+
+div#classHeader {
+    background: #048;
+}
+
+
+.class-name-in-header {
+  font-size:  180%;
+  font-weight: bold;
+}
+
+
+div#bodyContent {
+    padding: 0 1.5em 0 1.5em;
+}
+
+div#description {
+    padding: 0.5em 1.5em;
+    background: #efefef;
+    border: 1px dotted #999;
+}
+
+div#description h1,h2,h3,h4,h5,h6 {
+    color: #125;;
+    background: transparent;
+}
+
+div#validator-badges {
+    text-align: center;
+}
+div#validator-badges img { border: 0; }
+
+div#copyright {
+    color: #333;
+    background: #efefef;
+    font: 0.75em sans-serif;
+    margin-top: 5em;
+    margin-bottom: 0;
+    padding: 0.5em 2em;
+}
+
+
+/* === Classes =================================== */
+
+table.header-table {
+    color: white;
+    font-size: small;
+}
+
+.type-note {
+    font-size: small;
+    color: #DEDEDE;
+}
+
+.xxsection-bar {
+    background: #eee;
+    color: #333;
+    padding: 3px;
+}
+
+.section-bar {
+   color: #333;
+   border-bottom: 1px solid #999;
+    margin-left: -20px;
+}
+
+
+.section-title {
+    background: #79a;
+    color: #eee;
+    padding: 3px;
+    margin-top: 2em;
+    margin-left: -30px;
+    border: 1px solid #999;
+}
+
+.top-aligned-row {  vertical-align: top }
+.bottom-aligned-row { vertical-align: bottom }
+
+/* --- Context section classes ----------------------- */
+
+.context-row { }
+.context-item-name { font-family: monospace; font-weight: bold; color: black; }
+.context-item-value { font-size: small; color: #448; }
+.context-item-desc { color: #333; padding-left: 2em; }
+
+/* --- Method classes -------------------------- */
+.method-detail {
+    background: #efefef;
+    padding: 0;
+    margin-top: 0.5em;
+    margin-bottom: 1em;
+    border: 1px dotted #ccc;
+}
+.method-heading {
+  color: black;
+  background: #ccc;
+  border-bottom: 1px solid #666;
+  padding: 0.2em 0.5em 0 0.5em;
+}
+.method-signature { color: black; background: inherit; }
+.method-name { font-weight: bold; }
+.method-args { font-style: italic; }
+.method-description { padding: 0 0.5em 0 0.5em; }
+
+/* --- Source code sections -------------------- */
+
+a.source-toggle { font-size: 90%; }
+div.method-source-code {
+    background: #262626;
+    color: #ffdead;
+    margin: 1em;
+    padding: 0.5em;
+    border: 1px dashed #999;
+    overflow: hidden;
+}
+
+div.method-source-code pre { color: #ffdead; overflow: hidden; }
+
+/* --- Ruby keyword styles --------------------- */
+
+.standalone-code { background: #221111; color: #ffdead; overflow: hidden; }
+
+.ruby-constant  { color: #7fffd4; background: transparent; }
+.ruby-keyword { color: #00ffff; background: transparent; }
+.ruby-ivar    { color: #eedd82; background: transparent; }
+.ruby-operator  { color: #00ffee; background: transparent; }
+.ruby-identifier { color: #ffdead; background: transparent; }
+.ruby-node    { color: #ffa07a; background: transparent; }
+.ruby-comment { color: #b22222; font-weight: bold; background: transparent; }
+.ruby-regexp  { color: #ffa07a; background: transparent; }
+.ruby-value   { color: #7fffd4; background: transparent; }

data/lib/mack-distributed/distributable.rb

@@ -0,0 +1,68 @@
+module Mack # :nodoc:
+  # Include this module into any class it will instantly register that class with
+  # the mack_ring_server. The class will be registered with the name of the class
+  # and the mack.distributed_app_name configured in your config/app_config/*.yml file.
+  # If the mack.distributed_app_name configuration parameter is nil it will raise
+  # an Mack::Distributed::Errors::ApplicationNameUndefined exception.
+  # 
+  # Example:
+  #  class User
+  #    include Mack::Distributable
+  #    def name
+  #      "mark"
+  #    end
+  #  end
+  # 
+  #  Mack::Distributed::User.new.name # => "mark"
+  module Distributable
+      
+      def self.included(base) # :nodoc:
+        if app_config.mack.share_objects
+          base.class_eval do
+            include ::DRbUndumped
+          end
+          eval %{
+            class ::Mack::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
+            
+              # def respond_to?(sym)
+              #   #{base}.respond_to?(sym)
+              # end
+            end
+          }
+          raise Mack::Distributed::Errors::ApplicationNameUndefined.new if app_config.mack.distributed_app_name.nil?
+          Mack::Distributed::Utils::Rinda.register_or_renew(:space => app_config.mack.distributed_app_name.to_sym, 
+                                                            :klass_def => "#{base}".to_sym, 
+                                                            :object => "Mack::Distributed::#{base}Proxy".constantize.instance)
+        end
+      end
+      
+  end # Distributable
+end # Mack
+
+module DRb # :nodoc:
+  class DRbObject # :nodoc:
+
+    alias_method :original_inspect, :inspect
+    
+    def inspect
+      "#{original_inspect}|#{method_missing(:inspect)}"
+    end
+    
+    undef :id
+    
+  end
+end

data/lib/mack-distributed/distributed.rb

@@ -0,0 +1,24 @@
+module Mack # :nodoc:
+  module Distributed # :nodoc:
+    
+    # Looks up and tries to find the missing constant using the ring server.
+    def self.const_missing(const)
+      Mack::Distributed::Utils::Rinda.read(:klass_def => "#{const}".to_sym)
+    end
+    
+    # Allows for the specific lookup of services on the ring server
+    # 
+    # Examples:
+    #   Mack::Distributed::Utils::Rinda.register_or_renew(:space => :app_1, :klass_def => :Test, :object => "Hello World!")
+    #   Mack::Distributed::Utils::Rinda.register_or_renew(:space => :app_2, :klass_def => :Test, :object => "Hello WORLD!")
+    #   Mack::Distributed.lookup("distributed://app_1/Test") # => "Hello World!"
+    #   Mack::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
+      Mack::Distributed::Utils::Rinda.read(:klass_def => path.to_sym, :space => host.to_sym)
+    end
+    
+  end # Distributed
+end # Mack

data/lib/mack-distributed/errors/errors.rb

@@ -0,0 +1,33 @@
+module Mack
+  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 # Mack

data/lib/mack-distributed/extensions/route_map.rb

@@ -0,0 +1,26 @@
+module Mack
+  module Routes # :nodoc:
+    class RouteMap # :nodoc:
+      
+      # let's make sure we only do the alias_method once.
+      unless self.private_instance_methods.include?("normal_connect_with_named_route")
+        
+        alias_method :normal_connect_with_named_route, :connect_with_named_route
+      
+        def connect_with_named_route(n_route, pattern, options = {}) # :nodoc:
+          n_route = n_route.methodize
+          normal_connect_with_named_route(n_route, pattern, options)
+          if app_config.mack.share_routes
+            Mack::Routes::Urls.class_eval %{
+              def #{n_route}_distributed_url(options = {})
+                (@dsd || app_config.mack.distributed_site_domain) + #{n_route}_url(options)
+              end
+            }
+          end
+        end # connect_with_named_route
+        
+      end
+      
+    end # RouteMap
+  end # Routes
+end # Mack

data/lib/mack-distributed/extensions/urls.rb

@@ -0,0 +1,32 @@
+module Mack # :nodoc:
+  module Routes # :nodoc:
+    module Urls
+      
+      alias_deprecated_method :droute_url, :distributed_url, '0.7.0', '>=0.8.0'
+      # Retrieves a distributed route from a DRb server.
+      # 
+      # Example:
+      #   distributed_url(:app_1, :home_page_url)
+      #   distributed_url(:registration_app, :signup_url, {:from => :google})
+      def distributed_url(app_name, route_name, options = {})
+        route_name = route_name.to_s
+        if route_name.match(/_url$/)
+          unless route_name.match(/_distributed_url$/)
+            route_name.gsub!("_url", "_distributed_url")
+          end
+        else
+          route_name << "_distributed_url"
+        end
+        
+        if !app_config.mack.distributed_app_name.nil? && app_name.to_sym == app_config.mack.distributed_app_name.to_sym
+          # if it's local let's just use it and not go out to Rinda
+          return self.send(route_name, options)
+        end
+        d_urls = Mack::Distributed::Routes::Urls.get(app_name)
+        raise Mack::Distributed::Errors::UnknownRouteName.new(app_name, route_name) unless d_urls.respond_to?(route_name)
+        return d_urls.run(route_name, options)
+      end # distributed_url
+      
+    end # Urls
+  end # Routes
+end # Mack

data/lib/mack-distributed/routes/urls.rb

@@ -0,0 +1,51 @@
+module Mack
+  module Distributed
+    module Routes # :nodoc:
+      # A class used to house the Mack::Routes::Url module for distributed applications.
+      # Functionally this class does nothing, but since you can't cache a module, a class is needed.
+      class Urls
+        include DRbUndumped
+        
+        def initialize(dsd) # :nodoc:
+          @dsd = dsd
+        end
+        
+        def put
+          Mack::Distributed::Utils::Rinda.register_or_renew(:space => app_config.mack.distributed_app_name.to_sym, 
+                                                            :klass_def => :distributed_routes, 
+                                                            :object => self, :timeout => 0)
+        end
+        
+        def run(meth, options)
+          self.send(meth, options)
+        end
+        
+        class << self
+          
+          def get(app_name)
+            Mack::Distributed::Utils::Rinda.read(:space => app_name.to_sym, :klass_def => :distributed_routes)
+          end
+          
+        end
+        
+      end # Urls
+      
+    end # Routes
+  end # Distributed
+  
+end # Mack
+
+Mack::Routes.after_class_method(:build) do
+  if app_config.mack.share_routes
+    raise Mack::Distributed::Errors::ApplicationNameUndefined.new if app_config.mack.distributed_app_name.nil?
+    
+    d_urls = Mack::Distributed::Routes::Urls.new(app_config.mack.distributed_site_domain)
+    d_urls.put
+    Mack::Routes::Urls.include_safely_into(Mack::Distributed::Routes::Urls)
+    Mack::Distributed::Routes::Urls.protected_instance_methods.each do |m|
+      Mack::Distributed::Routes::Urls.instance_eval do
+        public m if m.match(/_url$/)
+      end
+    end
+  end
+end

data/lib/mack-distributed/tasks/ring_server_tasks.rake

@@ -0,0 +1,33 @@
+require 'rinda/ring'
+namespace :mack do
+  namespace :ring_server do
+    
+    desc "Start the Rinda ring server"
+    task :start do
+      `mack_ring_server start`
+    end
+    
+    desc "Stop the Rinda ring server"
+    task :stop do
+      `mack_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 # mack
+
+alias_task "mack:ring_server:restart", "mack:ring_server:stop", "mack:ring_server:start"

data/lib/mack-distributed/utils/rinda.rb

@@ -0,0 +1,48 @@
+module Mack
+  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
+            # Mack.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 app_config.mack.distributed_acl
+            acl = ACL.new(app_config.mack.distributed_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 => app_config.mack.drb_timeout}.merge(options)
+        end
+        
+      end
+    end
+  end
+end

data/lib/mack-distributed/views/rendering/type/distributed.rb

@@ -0,0 +1,39 @@
+module Mack
+  module Rendering
+    module Type
+      class Distributed < Mack::Rendering::Type::Base
+
+        # render(:distributed, "distributed://host/resource")
+        def render
+            uri = Addressable::URI.parse(self.render_value)
+            raise InvalidAddressableURIFormat.new("#{self.render_value}") if uri.host.nil? or uri.path.nil?
+            
+            app_name = uri.host
+            resource = File.join("app", "views", uri.path)
+            
+            data = Mack::Distributed::View.ref(app_name)
+            if data
+              raw = ""
+              Mack::Rendering::Engine::Registry.engines[:distributed].each do |e|
+                @engine = find_engine(e).new(self.view_template)
+
+                view_path = "#{resource}.#{self.options[:format]}.#{@engine.extension}"
+                raw = data.get(view_path)
+                break if !raw.nil?
+              end
+              
+              raise Mack::Errors::ResourceNotFound.new("#{self.options[:distributed]}") if raw.nil?
+              
+              old_render_value = self.view_template.render_value.dup
+              self.view_template.render_value = raw
+              Mack::Rendering::Type::Inline.new(self.view_template).render
+              # self.view_template.render_value = old_render_value
+            end
+        end
+      end
+    end
+  end
+end
+
+Mack::Rendering::Engine::Registry.register(:distributed, :builder)
+Mack::Rendering::Engine::Registry.register(:distributed, :erubis)

data/lib/mack-distributed/views/rendering/type/layout.rb

@@ -0,0 +1,46 @@
+module Mack
+  module Rendering # :nodoc:
+    module Type # :nodoc:
+      class Layout
+      
+        unless public_instance_methods.include?("old_render")
+          alias_method :old_render, :render
+        end
+        
+        def render
+          if !self.options[:layout].starts_with?("distributed")
+            # this is the regular layout, so call the local_render method
+            old_render
+          else
+            uri = Addressable::URI.parse(self.options[:layout])
+            raise InvalidAddressableURIFormat.new("#{self.options[:layout]}") if uri.host.nil? or uri.path.nil?
+            
+            app_name = uri.host
+            resource = File.join("app", "views", "layouts", uri.path)
+
+            data = Mack::Distributed::View.ref(app_name)
+            if data
+              raw = ""
+              Mack::Rendering::Engine::Registry.engines[:layout].each do |e|
+                @engine = find_engine(e).new(self.view_template)
+
+                layout_path = "#{resource}.#{self.options[:format]}.#{@engine.extension}"
+                raw = data.get(layout_path)
+                break if !raw.nil?
+              end
+
+              raise Mack::Errors::ResourceNotFound.new("#{self.options[:distributed]}") if raw.nil?
+
+              old_render_value = self.view_template.render_value.dup
+              self.view_template.render_value = raw
+              Mack::Rendering::Type::Inline.new(self.view_template).render
+              # self.view_template.render_value = old_render_value
+            end
+          end
+        end
+        
+      end
+    end
+  end
+end
+

data/lib/mack-distributed/views/view.rb

@@ -0,0 +1,41 @@
+module Mack
+  module Distributed
+    class View
+      
+      include Singleton
+      include DRbUndumped
+      
+      def get(resource)
+        path = File.join(Mack.root, resource)
+        raw = Mack::Distributed::ViewCache.get(path)
+        return raw
+      end
+      
+      class << self
+        def register
+          if app_config.mack.share_views
+            raise Mack::Distributed::Errors::ApplicationNameUndefined.new if app_config.mack.distributed_app_name.nil?
+            # Mack.logger.info "Registering Mack::Distributed::View for '#{app_config.mack.distributed_app_name}' with Rinda"
+            
+            Mack::Distributed::Utils::Rinda.register_or_renew(:space => app_config.mack.distributed_app_name.to_sym,
+                                                              :klass_def => :distributed_views, 
+                                                              :object => Mack::Distributed::View.instance)
+          end
+        end
+        
+        def ref(app_name)          
+          begin
+            obj = Mack::Distributed::Utils::Rinda.read(:space => app_name.to_sym, 
+                                                       :klass_def => :distributed_views)
+            return obj
+          rescue Rinda::RequestExpiredError => er
+            Mack.logger.warn(er)
+          end
+          
+          return nil
+        end
+      end
+      
+    end # View
+  end # Distributed
+end # Mack

data/lib/mack-distributed/views/view_cache.rb

@@ -0,0 +1,32 @@
+module Mack
+  module Distributed
+    class ViewCache < Cachetastic::Caches::Base
+      
+      class << self
+        include Mack::ViewHelpers::LinkHelpers
+      
+        def get(path)
+          raw = super(path) do
+            raw = ""
+            if File.exists?(path)
+              raw = File.read(path)
+
+              # preprocess the raw content so we can resolve css/javascript/image path
+              arr = raw.scan(/<%=.*?%>/)
+              arr.each do |scriptlet|
+                if scriptlet.match(/stylesheet/) or scriptlet.match(/javascript/) or scriptlet.match(/image/)
+                  res = ERB.new(scriptlet).result(binding)
+                  raw.gsub!(scriptlet, res)
+                end 
+              end # if arr.each
+            end # if File.exists?
+            
+            set(path, raw)
+          end # super(key)
+          return raw
+        end # def get
+      end # class << self
+      
+    end # ViewCache
+  end # Distributed
+end # Mack