cylons 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in skynext.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jason Ayre
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,101 @@
+# Cylons
+
+Collectively intelligent remote models which behave very much like models they are claiming to be. (Zero configuration SOA Framework).
+
+Cylons lets your models in one Rails app, act very much like your ActiveRecord models in another Rails app, providing a base for a SOA infrastructure. I hope to be able to make it applicable to more than just AR models as well, however, I also hope to make it past cool proof of concept stage that works, but isn't exactly suitable for a production system, WHICH IS THE STATE IT IS CURRENTLY IN. You've been warned.
+
+### Quick Explanation
+
+
+### Depends heavily on:
+DCell
+Zookeeper (for now, only even though )
+
+### Heavily inspired by
+This concept - http://www.youtube.com/watch?v=Hu-jvAWTZ9o&feature=autoplay&list=PLF88804CB7380F32C&playnext=1#t=4m59s
+ActiveRemote - https://github.com/liveh2o/active_remote
+DCell - https://github.com/celluloid/dcell
+
+### Alternatives
+Ill list more later, because I've literally tried at least the 90% majority of the ruby soa "solutions", but if you are looking for an "enterprise" level SOA framework, I'd recommend:
+
+ActiveRemote - https://github.com/liveh2o/active_remote
+Protobuf - https://github.com/localshred/protobuf
+
+Add those two together == winning.
+
+### Reasons for building
+Originally it started as a way to communicate between my raspberry pis, because http is so last summer. Soon I found myself wanting a database connection. So I ended up making it more active_record like. Those aren't reasons but brain tired done typing yep.
+
+
+### Quick start
+
+
+### How it works?
+
+### Install ZK, Clone and run the examples
+
+```
+git clone https://github.com/jasonayre/cylons_demo
+
+```
+
+open 4 new terminal windows/tabs
+
+*Prepare the inventory management service, inventory*
+
+```
+cd inventory
+SKIP_CYLONS=true bundle exec rake db:create && rake db:migrate && rake db:seed
+```
+
+*Prepare the user credentials service, identify*
+```
+cd identify
+SKIP_CYLONS=true bundle exec rake db:create && rake db:migrate && rake db:seed
+```
+
+*Prepare the categorization service, taxon*
+```
+cd taxon
+SKIP_CYLONS=true bundle exec rake db:create && rake db:migrate && rake db:seed
+```
+*Start Zookeeper, and start each service up with:*
+```
+bundle exec cylons start
+```
+
+*Load that sample data, note the admin app has no database at all, only remote models*
+```
+cd admin
+bx rake db:seed
+```
+
+Note: there will be quite a few N+1 queries happening, intentionally. This is to demonstrate communication between the services, and speed. Each record that is created will make a call to Inventory, to check if that record already exists. If not, it will build the record by doing a Category.first_or_create (Taxon Service), to get the category_id, then it will make 3 additional calls to the Inventory service, 1 for manufacturer, 1 for department, and then finally one to actually create the Product.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cylons'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cylons
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/cylons

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+require 'cylons'
+class Services < ::Thor
+  class_option :app, :default => "./config/environment.rb"
+  
+  desc "start", "Start cylon services"
+  def start
+    puts "Starting services"
+    require options[:app]
+    
+    raise ::Cylons::CouldNotConnectToRegistry unless ::Cylons::Connection.connected?
+    
+    ::Dir.glob(::Rails.root.join('app', 'models', "*.rb")).each{ |file| load file }
+    
+    ::Cylons.logger.info "Cylon Remotes: #{::Cylons::RemoteRegistry.remotes}"
+    
+    ::Cylons::RemoteRegistry.register_schemas
+    
+    ::Cylons::ServiceManager.start
+
+    loop do
+    
+    end
+  end
+end
+
+::Services.start
+
+[:INT, :QUIT, :TERM].each do |signal|
+  trap(signal) do
+    ::Cylons.logger.info "Stopping Cylon Services"
+    puts "Stopping Cylon Services"
+    exit 0
+  end
+end
+

data/cylons.gemspec

@@ -0,0 +1,40 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cylons/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cylons"
+  spec.version       = Cylons::VERSION
+  spec.authors       = ["Jason Ayre"]
+  spec.email         = ["jasonayre@gmail.com"]
+  spec.description   = %q{Collective intelligence meets service oriented architecture. Allows your remote models to act like your local models, while defining simple conventions to build self aware and reusable services. Currently reliant upon Zookeeper.}
+  spec.summary       = %q{Collectively intelligent (and simple), Service Oriented Architecture framework for Rails}
+  spec.homepage      = "https://github.com/jasonayre/cylons"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  
+  spec.add_dependency "active_attr"
+  spec.add_dependency "active_attr"
+  spec.add_dependency "dcell", "0.15.0"
+  spec.add_dependency "thor"
+  spec.add_dependency "zk"
+  spec.add_dependency 'pry'
+  spec.add_dependency "will_paginate"
+  spec.add_dependency "ransack"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "activerecord"
+  # spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec-pride"
+  spec.add_development_dependency "pry-nav"
+  spec.add_development_dependency "simplecov"
+end

data/lib/cylons.rb

@@ -0,0 +1,57 @@
+require 'active_attr'
+require 'active_model'
+require 'active_support/core_ext/array'
+require 'active_support/core_ext/hash'
+require 'active_support/inflector'
+require 'active_support/json'
+require 'will_paginate'
+require "cylons/version"
+
+require 'cylons/attributes'
+require 'cylons/connection'
+require 'cylons/configuration'
+require 'cylons/errors'
+require 'cylons/remote'
+require 'cylons/remote_registry'
+require 'cylons/remote_discovery'
+require 'cylons/remote_proxy'
+require 'cylons/registry_adapter'
+require 'cylons/service'
+require 'cylons/service_manager'
+require 'dcell'
+require 'socket'
+require 'zk'
+require 'dcell/registries/zk_adapter'
+require 'cylons/railtie'
+require 'pry'
+# require 'cylons/railtie' if defined?(Rails)
+
+module Cylons
+  #dont load remotes if test env or SKIP_CYLONS=true (such as when running rake tasks)  
+  def self.skip_cylons?
+    !!ENV["SKIP_CYLONS"]
+  end
+    
+  def self.silence?
+    skip_cylons? || (defined?(Rails) && Rails.env == "test")
+  end
+  
+  class << self
+    attr_accessor :configuration, :logger
+    
+    def configuration
+      @configuration ||= ::Cylons::Configuration.new
+    end
+
+    def configure
+      yield(configuration) if block_given?
+      
+      @logger = configuration.logger
+      
+      ::ActiveSupport.run_load_hooks(:cylons, self)
+    end
+    
+    alias_method :config, :configuration
+  end
+end
+

data/lib/cylons/active_record_extensions.rb

@@ -0,0 +1,59 @@
+require 'cylons/remote_discovery'
+
+module Cylons
+  module ActiveRecordExtensions
+    module ClassMethods
+      
+      SEARCH_OPTION_KEYS = [:opts, :options].freeze
+      
+      def reload_remotes!
+        ::Cylons::RemoteDiscovery.load_remotes unless ::Cylons.silence?
+      end
+      
+      def remote_schema
+        ::Cylons::RemoteRegistry.get_remote_schema(self.name) unless ::Cylons.silence?
+      end
+      
+      def remote_belongs_to(*args)
+        options = args.extract_options!
+        
+        args.each do |arg|
+          options[:foreign_key] = "#{arg}_id"
+          association_hash = {:name => arg, :association_type => :belongs_to, :options => options}
+          self.remote_associations << association_hash
+          build_remote_belongs_to_association(association_hash)
+        end
+      end
+      
+      #store remote has many assoc globally, then define it locally. 
+      def remote_has_many(*args)
+        options = args.extract_options!
+        
+        args.each do |arg|
+          association_hash = {:name => arg, :association_type => :has_many, :options => options}
+          self.remote_associations << association_hash
+          build_remote_has_many_association(association_hash)
+        end
+      end
+      
+      #TODO: Hacky, but something strange is going on here, and syntax will need to chagne for rails4... hrmmm
+      def scope_by(params = {})
+        search_options = params.extract!(*SEARCH_OPTION_KEYS)
+        
+        search_options.delete_if {|k,v| v.nil? }
+        
+        if search_options.present?
+          scoped_search = params.inject(scoped) do |combined_scope, param|
+            combined_scope.send("by_#{param.first}", param.last)
+          end.paginate(:page => search_options[:options][:page], :per_page => search_options[:options][:per_page])
+        else
+          scoped_search = params.inject(scoped) do |combined_scope, param|
+            combined_scope.send("by_#{param.first}", param.last)
+          end
+        end
+        
+        scoped_search
+      end      
+    end
+  end
+end

data/lib/cylons/associations.rb

@@ -0,0 +1,40 @@
+module Cylons
+  module Associations
+    module ClassMethods
+      #To make service load order a non issue, we need to be trixy hobbitses
+      #Here we catch uninitialized constant error and reload remotes if constant hasnt been defined yet
+      #i.e. if a Product service loads after category service, when Product calls the Category.search method
+      #it will throw constant error, we catch that, reload remotes and try one mo time
+      
+      def build_remote_belongs_to_association(association_hash)
+        define_method(association_hash[:name]) do
+          begin
+            foreign_key = association_hash[:options].fetch(:foreign_key, association_hash[:name].to_s.underscore.to_sym)
+            association_hash[:name].to_s.classify.constantize.scope_by(:id => self[foreign_key]).first
+          rescue => e
+            if e.message == "uninitialized constant #{association_hash[:name].classify.to_s}"
+              ::Cylons::RemoteDiscovery.load_remotes
+              association_hash[:name].to_s.classify.constantize.scope_by(:id => self["#{association_hash[:name].to_s}_id".to_sym]).first
+            end
+          end
+        end
+      end
+
+      def build_remote_has_many_association(association_hash)
+        define_method(association_hash[:name]) do
+          begin
+            klass_name = association_hash[:options].fetch(:class_name, association_hash[:name].to_s.singularize.classify)
+            foreign_key = association_hash[:options].fetch(:foreign_key, "#{self.class.name.singularize}_id".downcase.to_sym)
+            klass = klass_name.constantize
+            klass.scope_by(foreign_key => self[:id])
+          rescue => e
+            if e.message == "uninitialized constant #{klass_name}"
+              ::Cylons::RemoteDiscovery.load_remotes
+              klass.scope_by(:id => self["#{association_hash[:name].to_s.singularize}_id"].to_sym)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cylons/attributes.rb

@@ -0,0 +1,31 @@
+module Cylons
+  module Attributes
+    def read_attribute(name)
+      name = name.to_s
+      
+      if @attributes.has_key?(name) || self.respond_to?(name)
+        @attributes[name]
+      else
+        raise ::ActiveAttr::UnknownAttributeError, "unknown attribute: #{name}"
+      end
+    end
+    alias_method :[], :read_attribute
+  
+    # Override #write_attribute (along with #[]=) so we can provide support for
+    # ActiveModel::Dirty.
+    #
+    def write_attribute(name, value)
+      __send__("#{name}_will_change!") if value != self[name]
+      
+      name = name.to_s
+  
+      if @attributes.has_key?(name) || self.respond_to?(name)
+        @attributes[name] = value
+      else
+        raise ::ActiveAttr::UnknownAttributeError, "unknown attribute: #{name}"
+      end
+    end
+    alias_method :[]=, :write_attribute
+    alias_method :attribute=, :write_attribute
+  end
+end

data/lib/cylons/configuration.rb

@@ -0,0 +1,38 @@
+require 'cylons'
+require 'cylons/registry_adapter'
+module Cylons
+  class Configuration
+    attr_accessor :address,
+                  :logger,
+                  :port, 
+                  :registry_address,
+                  :registry_port,
+                  :registry_adapter,
+                  :registry,
+                  :remote_namespace
+
+    #NOTE: I am explicitly setting address to machine address instead of local host due to zookeeper or possibly dcell issue.
+    # Basically I have been unable to connect the machine to registry via 
+    #:addr => "tcp://localhost:9001" or whatever, have needed to connect using
+    #:addr => "tcp://192.168.0.101:9001", not sure if its an id10t error, or a local setting, or zookeeper or dcell
+    # lightbulb: maybe because its trying to connect to remote registry, and its telling the remote machine to use localhost?
+    # bet thats probably it.. Although I dont think I had same prob w redis. IDONTREMEMBER.
+    
+    #TODO look into that further.
+    def initialize
+      self.address = ::Cylons::Interface.primary
+      self.port = (9000 + rand(100))
+      self.logger = ::Rails.logger if defined?(Rails)
+      self
+    end
+    
+    #TODO: uhh refactor this, was having trouble w circular dependency and too tired to trace it down!
+    #This introduces order dependency when setting initializer=badmk
+    
+    def registry_adapter=(adapter)
+      raise ::Cylons::InvalidRegistryAdapter unless ::Cylons::RegistryAdapter::VALID_REGISTRY_ADAPTERS.include?(adapter.to_sym)
+      @registry_adapter = adapter.to_sym
+      @registry = ::Cylons::RegistryAdapter.send(registry_adapter)
+    end
+  end
+end