cylons 0.0.1 → 0.0.2

data/lib/cylons/remote_discovery.rb

@@ -1,5 +1,5 @@
 require 'dcell'
-require 'cylons/remote_proxy'
+
 module Cylons
   class RemoteDiscovery
     class << self
@@ -7,33 +7,44 @@ module Cylons
       attr_accessor :loaded, :loaded_remote_class_names
       alias_method :loaded?, :loaded
     end
-    
-    def self.load_remotes
+
+    def self.service_mappings
+      service_mapping_hash = {}
+
+      ::DCell::Node.all.each do |node|
+        namespace = node.id
+        filtered_nodes = (node.actors - [:node_manager, :dcell_server, :info])
+
+        remote_class_names = filtered_nodes.select{|name| name.to_s.include?("Service") }.each do |remote_class_name|
+          service_mapping_hash[remote_class_name] = node.id
+        end
+      end
+
+      service_mapping_hash
+    end
+
+    def self.namespace_for_agent(agent_name)
+      service_mappings["#{agent_name}Service".to_sym]
+    end
+
+    def self.remote_class_names
+      discovered_remote_class_names = []
+
       ::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)
+            discovered_remote_class_names << 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]
+
+      discovered_remote_class_names
     end
-    
+
     def self.remote_proxy_class_name(namespace, remote_class_name)
       "#{namespace}::#{remote_class_name.to_s}".gsub('Service', '')
     end
   end
-end
+end

data/lib/cylons/remote_pagination.rb

@@ -0,0 +1,32 @@
+module Cylons
+  module RemotePagination
+    extend ::ActiveSupport::Concern
+
+    META_METHODS = [
+      :total_pages,
+      :current_page
+    ].freeze
+
+    SEARCH_OPTION_KEYS = [:opts, :options].freeze
+    MAX_PER_PAGE = 1000
+
+    module ClassMethods
+      def search(params = {})
+        search_options = params.extract!(*SEARCH_OPTION_KEYS)
+
+        search_options.delete_if {|k,v| v.nil? }
+
+        query_scope = params.inject(all) do |query, hash_pair|
+          query.__send__("by_#{hash_pair[0]}", hash_pair[1]).all
+        end.all
+
+        if search_options.present?
+          query_scope.paginate(:page => search_options[:options][:page], :per_page => search_options[:options][:per_page])
+        else
+          query_scope.paginate(:page => 1, :per_page => MAX_PER_PAGE)
+        end
+      end
+
+    end
+  end
+end

data/lib/cylons/remote_registry.rb

@@ -6,44 +6,41 @@ module Cylons
     @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)
+      ::Cylons::Connection.connect unless ::Cylons::Connection.connected?
       @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
+      ::DCell::Global.keys.include? "#{name}_schema".to_sym
     end
-    
+
     def self.get_remote_schema(name)
       ::DCell::Global["#{name}_schema".to_sym]
     end
-  end 
-end
+  end
+end

data/lib/cylons/remote_schema.rb

@@ -1,7 +1,7 @@
 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
@@ -9,4 +9,4 @@ module Cylons
       @remote_klass ||= klass.name.downcase.to_sym
     end
   end
-end
+end

data/lib/cylons/rpc.rb

@@ -1,86 +1,78 @@
-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
+    include ::ActiveModel::Dirty
+    include ::Cylons::Attributes
+
+    #need to wrap because to_a will leak connections otherwise
+    def all
+      ::ActiveRecord::Base.connection_pool.with_connection do
+        execute(:all).to_a
       end
-      
-      def execute_with_args(rpc_method, *args)
+    end
+
+    def create(params)
+      execute(:create, params)
+    end
+
+    def destroy(id)
+      execute(:destroy, id)
+    end
+
+    def execute(rpc_method, *args)
+      puts Thread.current.object_id
+
+      ::ActiveRecord::Base.connection_pool.with_connection do
+        puts ::ActiveRecord::Base.connection_pool.instance_variable_get("@connections").size
         begin
-          @last_response = self.class.model.send(rpc_method.to_sym, *args)
+          if args.any?
+            @last_response = self.class.model.send(rpc_method.to_sym, *args)
+          else
+            @last_response = self.class.model.send(rpc_method.to_sym)
+          end
+
+          @last_response
         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
+    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
+    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
+
+    def search(params)
+      response = execute(:search, params)
+    end
+
+    def scope_by(params)
+      execute(:scope_by, params)
+    end
+
+    def save(id = nil, attributes)
+      if(id)
+        execute(:update, id, attributes)
+      else
+        execute(:create, attributes)
       end
-      
-      def update(attributes)
-        execute_with_args(:update, attributes.keys, attributes.values)
-      end      
+    end
+
+    def update(attributes)
+      execute(:update, attributes.keys, attributes.values)
     end
   end
-end
+end

data/lib/cylons/service_manager.rb

@@ -4,41 +4,51 @@ require 'cylons/remote_registry'
 module Cylons
   class ServiceManager
     def self.start
-      ::Cylons.logger.info "LOADING REMOTES"
-      puts "LOADING REMOTES"
-      ::Cylons::RemoteDiscovery.load_remotes unless ::Cylons::RemoteDiscovery.loaded?
-      puts "STARTING LOCAL REMOTE SERVICES"
-      ::Cylons.logger.info "STARTING LOCAL REMOTE SERVICES"
+      ::Cylons.logger.info "STARTING CYLON SERVICES"
       start_services
     end
-    
+
+    #todo: split supervision and building
     def self.start_service(model_klass)
-      service_klass = build_service(model_klass)
-      service_klass.supervise_as service_klass.name.to_sym
+      unless service_defined?(model_klass)
+        service_klass = build_service(model_klass)
+
+        service_klass.supervise_as service_klass.name.to_sym
+      end
     end
-    
+
     def self.build_service(model_klass)
       proxy_service_class_name = "#{model_klass.name}Service"
-      Object.const_set(proxy_service_class_name, Class.new(::Cylons::Service))
+      ::Object.const_set(proxy_service_class_name, ::Class.new(::Cylons::Service))
       service_klass = proxy_service_class_name.constantize
-      
       service_klass.model = model_klass
-      puts "REGISTERING_SERVICE_FOR #{model_klass}"
+
+      ::Cylons.logger.info "REGISTERING_SERVICE_FOR #{model_klass}"
+
       service_klass
     end
-    
+
+    def self.service_defined?(model_klass)
+      proxy_service_class_name = "#{model_klass.name}Service"
+
+      const_defined?(:"#{proxy_service_class_name}")
+    end
+
     def self.start_services
       ::Cylons::RemoteRegistry.remotes.each do |remote|
         start_service(remote)
       end if remotes?
     end
-    
-    def self.service_klass_name
-      "#{klass.name}Service"
-    end
-    
+
     def self.remotes?
       ::Cylons::RemoteRegistry.remotes.any?
-    end    
+    end
+
+    def self.stop
+      ::Cylons::RemoteRegistry.remotes.each do |remote|
+        ::Cylons.logger.info{ "Shutting Down #{remote.name}"}
+        remote.stop
+      end
+    end
   end
-end
+end

data/lib/cylons/version.rb

@@ -1,3 +1,3 @@
 module Cylons
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/inventory_test_app.rb

@@ -0,0 +1,24 @@
+# The DCell specs start a completely separate Ruby VM running this code
+# for complete integration testing using 0MQ over TCP
+
+require 'rubygems'
+require 'bundler'
+require 'active_record'
+Bundler.setup
+
+require 'cylons'
+
+ENV["RPC"] = "1"
+
+::Cylons.configure do |config|
+  #if you are running multiple machines, connect to the ZK registry machine via:
+  # config.registry_address = "X.X.X.X"
+  config.remote_namespace = "InventoryTest"
+  # config.registry_adapter = :zk
+end
+
+class Product < ActiveRecord::Base
+  include ::Cylons::Remote
+end
+
+::Cylons::ServiceManager.start

data/spec/lib/cylons/connection_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe ::Cylons::Connection do
+  subject { described_class }
+
+  its(:connected) { should be true }
+
+  describe ".validate_configuration" do
+    it "should raise error if no remote namespace present" do
+      ::Cylons.configuration.remote_namespace.stub(:present?).and_return(false)
+      expect{ subject.validate_configuration }.to raise_error ::Cylons::RemoteNamespaceNotSet
+    end
+  end
+
+end

data/spec/lib/cylons/interface_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe ::Cylons::Interface do
+  subject { described_class }
+
+  its(:primary) { should eq ::IPSocket.getaddress(::Socket.gethostname) }
+end