cylons 0.0.1 → 0.0.2

data/lib/cylons/{remote_proxy.rb → agent.rb}

@@ -1,69 +1,68 @@
 require 'cylons/associations'
 
 module Cylons
-  
+
   #this is the local application remote which is dynamically built, from the registry
-  class RemoteProxy
+  class Agent
     include ::ActiveModel::Dirty
     include ::ActiveModel::AttributeMethods
-    include ActiveAttr::Model
-    include ActiveAttr::MassAssignment
+    include ::ActiveAttr::Model
+    include ::ActiveAttr::MassAssignment
     include ::Cylons::Attributes
-    extend ::Cylons::Associations::ClassMethods
-        
+    include ::Cylons::Associations
+
+    class_attribute :unsucessful_remote_connection_attempts
+    self.unsucessful_remote_connection_attempts ||= 0
+
+    class << self
+      attr_accessor :schema, :built
+    end
+
+    @built = false
+
+    def self.inherited(subklass)
+      ::Cylons.connect unless ::Cylons.connected?
+    end
+
+    def self.build_agent
+      load_schema
+      @built = true
+    end
+
+    def self.service_class_name
+      "#{name}Service"
+    end
+
     def self.load_schema
-      @schema = ::Cylons::RemoteRegistry.get_remote_schema(self.name.downcase)
-      
+      ::Cylons.logger.debug { "Loading schema for #{name}" }
+
+      @schema = ::Cylons::RemoteRegistry.get_remote_schema(name.downcase)
+
       @schema.remote_attributes.each do |remote_attribute|
         attribute remote_attribute.to_sym
       end
-      
+
       @schema.remote_associations.each do |association_hash|
         __send__("build_remote_#{association_hash[:association_type]}_association", association_hash)
       end
     end
-    
-    class << self
-      attr_accessor :remote, :schema
-    end
-    
-    attr_accessor :errors
-    
-    def destroy
-      return unless self.attributes["id"]
-      result = self.class.remote.destroy(self.attributes["id"])
-    end
-    
-    #have to manually update attributes if id wasnt set, i believe attr_accessible oddity so maybe can rip out later
-    def save
-      if self.attributes["id"]
-        result = self.class.remote.save(self.attributes["id"], self.attributes.with_indifferent_access.slice(*self.changed))
-        self.changed_attributes.clear
-      else
-        result = self.class.remote.save(nil, self.attributes.with_indifferent_access.slice(*self.changed))
-        
-        if result.errors.messages.present?
-          self.assign_attributes({:errors => result.errors})
-        else
-          self.assign_attributes(result.attributes)
-        end
-      end
-      
-      result
-    end
 
     def self.all
       remote.all
     end
-    
+
+    def self.agent_namespace
+      @agent_namespace ||= ::Cylons::RemoteDiscovery.namespace_for_agent(self.name)
+    end
+
     def self.count
       remote.count
     end
-    
+
     def self.first
       remote.first
     end
-    
+
     def self.find(id)
       remote.find(id)
     end
@@ -71,29 +70,87 @@ module Cylons
     def self.last
       remote.last
     end
-    
+
     def self.create(params)
       remote.create(params)
     end
-    
+
     def self.search(params)
       remote.search(params)
     end
-    
+
     def self.scope_by(params)
       remote.scope_by(params)
     end
-    
+
     def self.first_or_create(params)
       result = remote.scope_by(params).first
       result = remote.create(params) unless result.present?
       result
     end
-    
+
     def self.first_or_initialize(params)
       result = remote.scope_by(params).first
       result ||= remote.new(params) unless result.present?
       result
     end
+
+    def self.remote
+      remote_connection_failed! unless remote?
+
+      build_agent unless built
+
+      ::DCell::Node[agent_namespace][service_class_name.to_sym]
+    end
+
+    def self.remote?
+      agent_namespace && remote_application? && remote_service?
+    end
+
+    def self.remote_application?
+      ::DCell::Node.all.any?{ |node|
+        node.id == agent_namespace
+      }
+    end
+
+    def self.remote_service?
+      ::DCell::Node[agent_namespace].actors.include?(service_class_name.to_sym)
+    end
+
+    def self.remote_connection_failed!
+      if self.unsucessful_remote_connection_attempts > ::Cylons.config.remote_connection_failure_threshold
+        self.unsucessful_remote_connection_attempts = 0
+        raise ::Cylons::CylonsRemoteServiceNotFound, "#{service_class_name} not found"
+      else
+        sleep(::Cylons.config.remote_connection_failure_timeout)
+        self.unsucessful_remote_connection_attempts += 1
+        remote_connection_failed! unless remote?
+      end
+    end
+
+    attr_accessor :errors
+
+    def destroy
+      return unless self.attributes["id"]
+      result = self.class.remote.destroy(self.attributes["id"])
+    end
+
+    #have to manually update attributes if id wasnt set, i believe attr_accessible oddity so maybe can rip out later
+    def save
+      if self.attributes["id"]
+        result = self.class.remote.save(self.attributes["id"], self.attributes.with_indifferent_access.slice(*self.changed))
+        self.changed_attributes.clear
+      else
+        result = self.class.remote.save(nil, self.attributes.with_indifferent_access.slice(*self.changed))
+
+        if result.errors.messages.present?
+          self.assign_attributes({:errors => result.errors})
+        else
+          self.assign_attributes(result.attributes)
+        end
+      end
+
+      result
+    end
   end
-end
+end

data/lib/cylons/config.rb

@@ -0,0 +1,26 @@
+require 'active_support/ordered_options'
+require 'cylons'
+require 'cylons/registry_adapter'
+
+module Cylons
+  class Config < ::ActiveSupport::InheritableOptions
+    def initialize(*args)
+      super(*args)
+
+      self[:address] ||= ::Cylons::Interface.primary
+      self[:port] ||= (9000 + rand(100))
+      self[:logger] ||= ::Cylons::Logging.logger
+      self[:model_paths] ||= nil
+      self[:registry] ||= nil
+      self[:registry_adapter] ||= :zk
+      self[:registry_port] ||= nil
+      self[:remote_namespace] ||= nil
+      self[:remote_connection_failure_timeout] ||= 10
+      self[:remote_connection_failure_threshold] ||= 2
+    end
+
+    def registry
+      @registry ||= ::Cylons::RegistryAdapter.send(self[:registry_adapter])
+    end
+  end
+end

data/lib/cylons/connection.rb

@@ -5,40 +5,36 @@ module Cylons
     class << self
       @connected ||= false
       attr_accessor :connected
-      
+
       alias_method :connected?, :connected
     end
-    
+
     def self.validate_configuration
       raise ::Cylons::RemoteNamespaceNotSet unless ::Cylons.configuration.remote_namespace.present?
     end
-    
-    #todo: FixMe
-    #super hacky.. pass in SKIP_CYLONS=true when running rake tasks for now, ew
-    def self.connect?
-      ENV['SKIP_CYLONS'].present?
-    end
-    
+
     def self.connect
-      return if connect?
+      return if ::Cylons.silence?
+
       validate_configuration
+
       ::Cylons.logger.info "STARTING DCELL FOR #{::Cylons.configuration.remote_namespace} NOW"
-      
+
       ::Cylons.logger.info "Cylons attempting to connect to registry at #{node_address}"
 
       ::DCell.start :id => ::Cylons.configuration.remote_namespace,
                     :addr => node_address,
                     :registry => registry_hash
-                    
+
       @connected = true
     end
-    
+
     def self.node_address
       "tcp://#{::Cylons.configuration.address}:#{::Cylons.configuration.port}"
     end
-    
+
     def self.registry_hash
       ::Cylons.configuration.registry
     end
   end
-end
+end

data/lib/cylons/errors.rb

@@ -2,10 +2,11 @@ module Cylons
   class CylonsError < StandardError; end
   class CylonsConfigurationError < CylonsError; end
   class CylonsRemoteError < CylonsError; end
+  class CylonsRemoteServiceNotFound < CylonsError; end
   class CylonsRemoteProxyError < CylonsError; end
   class CylonsRecordNotFound < CylonsRemoteError; end
   class InvalidRegistryAdapter < CylonsConfigurationError; end
   class CouldNotConnectToRegistry < CylonsConfigurationError; end
   class RemoteNamespaceNotSet < CylonsConfigurationError; end
   class HowDoYouKillThatWhichHasNoLife < CylonsRemoteProxyError; end
-end
+end

data/lib/cylons/local_registry.rb

@@ -4,27 +4,21 @@ require 'cylons/remote_registry'
 
 module Cylons
   class LocalRegistry
-
     @remotes ||= []
     @loaded_remotes ||= []
-    
+
     class << self
       attr_accessor :remotes, :loaded_remotes
     end
-    
+
     def self.register(klass)
       @remotes << klass
     end
-  
-    def self.register_class?(namespaced_class_name)
-      !defined?(namespaced_class_name.constantize)
-    end
-    
+
     def self.register_remote_schemas
       @remotes.each do |remote|
         ::Cylons::RemoteRegistry.register_remote_schema(remote)
       end
     end
-    
-  end 
-end
+  end
+end

data/lib/cylons/logging.rb

@@ -0,0 +1,41 @@
+require 'logger'
+
+module Cylons
+  module Logging
+    def self.initialize_logger(log_target=$stdout, log_level=::Logger::INFO)
+      @counter ||= 0
+      @counter = @counter + 1
+      @logger = ::Logger.new(log_target)
+      @logger.level = log_level
+      @logger
+    end
+
+    def self.logger
+      defined?(@logger) ? @logger : initialize_logger
+    end
+
+    def self.logger=(new_logger)
+      @logger = new_logger
+    end
+
+    def logger
+      ::Cylons::Logging.logger
+    end
+
+    def log_exception(ex)
+      logger.error { ex.message }
+      logger.error { ex.backtrace[0..5].join("\n") }
+      logger.debug { ex.backtrace.join("\n") }
+    end
+
+    def log_signature
+      @_log_signature ||= "[#{self.class == Class ? self.name : self.class.name}]"
+    end
+
+    def sign_message(message)
+      "#{log_signature} #{message}"
+    end
+  end
+end
+
+# Taken from [protobuf](https://github.com/localshred/protobuf)

data/lib/cylons/railtie.rb

@@ -2,37 +2,16 @@ require 'cylons'
 require 'rails'
 require 'rails/railtie'
 require 'active_record'
-require 'ransack'
-require 'ransack/search'
-require 'ransack/adapters/active_record/base'
-require 'will_paginate'
+require 'will_paginate/array'
 
 module Cylons
   class Railtie < ::Rails::Railtie
-    config.after_initialize do
-      ::Cylons::RemoteDiscovery.load_remotes unless ::Cylons.silence? || ::Cylons::RemoteDiscovery.loaded?
-    end
-
     ::ActiveSupport.on_load(:cylons) do
       ::Cylons::Connection.connect unless ::Cylons.silence? || ::Cylons::RemoteDiscovery.loaded? || ::Cylons::Connection.connected?
-      ::Cylons::RemoteDiscovery.load_remotes unless ::Cylons.silence? || ::Cylons::RemoteDiscovery.loaded?
-    end
-    
-    #todo: overwrite ransack search method to auto paginate by default, or pull ransack out..
+    end if ::Cylons.connect?
+
     ::ActiveSupport.on_load(:active_record) do
-      ::ActiveRecord::Base.extend ::Ransack::Adapters::ActiveRecord::Base
       require 'will_paginate/active_record'
-      
-      case ::ActiveRecord::VERSION::STRING
-      when /^3\.0\./
-        require 'ransack/adapters/active_record/3.0/context'
-      when /^3\.1\./
-        require 'ransack/adapters/active_record/3.1/context'
-      when /^3\.2\./
-        require 'ransack/adapters/active_record/3.2/context'
-      else
-        require 'ransack/adapters/active_record/context'
-      end
     end
   end
-end
+end

data/lib/cylons/registry_adapter.rb

@@ -15,8 +15,17 @@ module Cylons
     def self.zk(options = {})
       zk_registry_hash = zk_defaults.dup
       zk_registry_hash[:server] = ::Cylons.configuration.registry_address if ::Cylons.configuration.registry_address
-      zk_registry_hash[:server] = ::Cylons.configuration.registry_port if ::Cylons.configuration.registry_port
+      zk_registry_hash[:registry_port] = ::Cylons.configuration.registry_port if ::Cylons.configuration.registry_port
       zk_registry_hash
     end
+    
+    def self.redis_defaults
+      {:adapter => 'redis', :port => 6379, :address => "127.0.0.1"}
+    end
+    
+    def self.redis(options = {})
+      redis_registry_hash = redis_defaults.dup
+      redis_registry_hash
+    end
   end
 end

data/lib/cylons/remote.rb

@@ -1,29 +1,18 @@
 require 'cylons/remote_registry'
 require 'cylons/active_record_extensions'
 
-#todo: fix
-#think RemoteRegistry needs to be split into a local registry, which the remote registry
-#is pushed information to, or pulls information from, because the damn dcell wont stop
-#trying to connect or throwing not configured errors when rake tasks and what not, 
-#need complete separation of local/remote
-#update, think I mostly fixed issue but leaving note here becaue better separation
-#still needs to be done.
 module Cylons
   module Remote
-    
-    def self.included(klass)
-      klass.class_eval do
-        @remote_associations ||= []
-        
-        class << self
-          attr_accessor :remote_associations
-        end
-        
-        extend ::Cylons::ActiveRecordExtensions::ClassMethods
-        extend ::Cylons::Associations::ClassMethods
-        
-        ::Cylons::RemoteRegistry.register(klass)
-      end
+    extend ::ActiveSupport::Concern
+
+    include ::Cylons::ActiveRecordExtensions
+    include ::Cylons::Associations
+
+    included do
+      class_attribute :remote_associations
+      self.remote_associations = []
+
+      ::Cylons::RemoteRegistry.register(self)
     end
   end
-end
+end