cylons 0.0.1

data/lib/cylons/connection.rb

@@ -0,0 +1,44 @@
+require 'cylons'
+
+module Cylons
+  class Connection
+    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?
+      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

data/lib/cylons/errors.rb

@@ -0,0 +1,11 @@
+module Cylons
+  class CylonsError < StandardError; end
+  class CylonsConfigurationError < CylonsError; end
+  class CylonsRemoteError < 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

data/lib/cylons/interface.rb

@@ -0,0 +1,8 @@
+require 'socket'
+module Cylons
+  class Interface
+    def self.primary
+      ::IPSocket.getaddress(::Socket.gethostname)
+    end
+  end
+end

data/lib/cylons/local_registry.rb

@@ -0,0 +1,30 @@
+require 'dcell'
+require 'cylons/remote_schema'
+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

data/lib/cylons/railtie.rb

@@ -0,0 +1,38 @@
+require 'cylons'
+require 'rails'
+require 'rails/railtie'
+require 'active_record'
+require 'ransack'
+require 'ransack/search'
+require 'ransack/adapters/active_record/base'
+require 'will_paginate'
+
+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..
+    ::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

data/lib/cylons/registry_adapter.rb

@@ -0,0 +1,22 @@
+require 'cylons'
+require 'cylons/interface'
+
+module Cylons
+  class RegistryAdapter
+    
+    VALID_REGISTRY_ADAPTERS = [:zk, :redis].freeze
+    
+    #TODO: Add redis adapter support... maybe..
+    
+    def self.zk_defaults
+      {:adapter => 'zk', :port => '2181', :server => ::Cylons::Interface.primary}
+    end
+    
+    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
+    end
+  end
+end

data/lib/cylons/remote.rb

@@ -0,0 +1,29 @@
+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
+    end
+  end
+end

data/lib/cylons/remote_discovery.rb

@@ -0,0 +1,39 @@
+require 'dcell'
+require 'cylons/remote_proxy'
+module Cylons
+  class RemoteDiscovery
+    class << self
+      @loaded = false
+      attr_accessor :loaded, :loaded_remote_class_names
+      alias_method :loaded?, :loaded
+    end
+    
+    def self.load_remotes
+      ::DCell::Node.all.each do |node|
+        if node.id != ::Cylons.configuration.remote_namespace
+          namespace = node.id
+          remote_class_names = node.actors - [:node_manager, :dcell_server, :info]
+          remote_class_names.select{|name| name.to_s.include?("Service") }.each do |remote_class_name|
+            puts "Building Remote For: #{remote_class_name}"
+            build_remote(namespace, remote_class_name)
+          end if remote_class_names.any?
+        end
+      end
+      
+      @loaded = true
+    end
+    
+    def self.build_remote(namespace, remote_class_name)
+      proxy_class_name = remote_class_name.to_s.gsub('Service', '')
+      Object.const_set(proxy_class_name, Class.new(Cylons::RemoteProxy))
+      
+      proxy_class = proxy_class_name.constantize
+      proxy_class.load_schema
+      proxy_class.remote = ::DCell::Node[namespace][remote_class_name]
+    end
+    
+    def self.remote_proxy_class_name(namespace, remote_class_name)
+      "#{namespace}::#{remote_class_name.to_s}".gsub('Service', '')
+    end
+  end
+end

data/lib/cylons/remote_proxy.rb

@@ -0,0 +1,99 @@
+require 'cylons/associations'
+
+module Cylons
+  
+  #this is the local application remote which is dynamically built, from the registry
+  class RemoteProxy
+    include ::ActiveModel::Dirty
+    include ::ActiveModel::AttributeMethods
+    include ActiveAttr::Model
+    include ActiveAttr::MassAssignment
+    include ::Cylons::Attributes
+    extend ::Cylons::Associations::ClassMethods
+        
+    def self.load_schema
+      @schema = ::Cylons::RemoteRegistry.get_remote_schema(self.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.count
+      remote.count
+    end
+    
+    def self.first
+      remote.first
+    end
+    
+    def self.find(id)
+      remote.find(id)
+    end
+
+    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
+  end
+end

data/lib/cylons/remote_registry.rb

@@ -0,0 +1,49 @@
+require 'dcell'
+require 'cylons/remote_schema'
+
+module Cylons
+  class RemoteRegistry
+    @remotes ||= []
+    @loaded_remotes ||= []
+    @remote_schemas ||= {}
+    
+    class << self
+      attr_accessor :remotes, :loaded_remotes
+    end
+    
+    def self.clear_registry
+      ::DCell.registry.instance_variable_get("@global_registry").clear
+    end
+    
+    def self.register(klass)
+      @remotes << klass
+    end
+  
+    def self.register_class?(namespaced_class_name)
+      !defined?(namespaced_class_name.constantize)
+    end
+    
+    def self.register_schemas
+      @remotes.each do |remote|
+        ::Cylons.logger.info remote
+        register_remote_schema(remote)
+      end
+    end
+    
+    def self.remote_schemas
+      ::DCell::Global.keys
+    end
+    
+    def self.register_remote_schema(klass)
+      ::DCell::Global["#{klass.name.downcase}_schema".to_sym] = ::Cylons::RemoteSchema.new(klass)
+    end
+    
+    def self.remote_schema?(name)
+      ::DCell::Global.has_key? "#{name}_schema".to_sym
+    end
+    
+    def self.get_remote_schema(name)
+      ::DCell::Global["#{name}_schema".to_sym]
+    end
+  end 
+end

data/lib/cylons/remote_schema.rb

@@ -0,0 +1,12 @@
+module Cylons
+  class RemoteSchema
+    attr_accessor :remote_associations, :remote_attributes, :remote_search_scopes, :remote_klass
+    
+    def initialize(klass)
+      @remote_attributes ||= klass.attribute_names
+      @remote_associations ||= klass.remote_associations
+      @remote_search_scopes ||= []
+      @remote_klass ||= klass.name.downcase.to_sym
+    end
+  end
+end

data/lib/cylons/rpc.rb

@@ -0,0 +1,86 @@
+require 'ransack'
+module Cylons
+  module RPC
+    extend ::ActiveSupport::Concern
+    
+    included do
+      include ::ActiveModel::Dirty
+      include ::Cylons::Attributes
+      
+      def all
+        execute(:all)
+      end
+      
+      def create(params)
+        execute(:create, params)
+      end
+      
+      def destroy(id)
+        execute(:destroy, id)
+      end
+      
+      def execute(rpc_method, request_params = {})
+        begin
+          @last_response = self.class.model.send(rpc_method.to_sym, request_params)
+        rescue => e
+          puts e.inspect
+          @last_response = {:error => e.message}
+        end
+      end
+      
+      def execute_with_args(rpc_method, *args)
+        begin
+          @last_response = self.class.model.send(rpc_method.to_sym, *args)
+        rescue => e
+          puts e.inspect
+          puts e.message
+          puts @last_response.inspect
+          @last_response = {:error => e.message}
+        end
+      end
+      
+      def find(id)
+        execute(:find, id)
+      end
+      
+      def first
+        execute(:first)
+      end
+      
+      def first_or_create(params)
+        execute(:first_or_create, params)
+      end
+
+      def last
+        execute(:last)
+      end
+      
+      #todo: Refactor this, hacky
+      def search(params)
+        response = execute(:search, params)
+        
+        if response.respond_to?(:result)
+          return response.result.to_a
+        else
+          return response
+        end
+      end
+      
+      def scope_by(params)
+        execute(:scope_by, params).to_a
+      end
+      
+      def save(id = nil, attributes)
+        if(id)
+          execute_with_args(:update, id, attributes)
+        else
+          execute(:create, attributes)
+        end
+      end
+      
+      def update(attributes)
+        execute_with_args(:update, attributes.keys, attributes.values)
+      end      
+    end
+  end
+end