zeevex_cluster 0.2.1

data/lib/zeevex_cluster/strategy/zookeeper.rb

@@ -0,0 +1,163 @@
+require 'zeevex_cluster/strategy/base'
+require 'zk'
+require 'zk/election'
+require 'zk-group'
+
+module ZeevexCluster::Strategy
+  class Zookeeper < Base
+    def initialize(options = {})
+      super
+      ZK.logger = logger
+    end
+
+    def start
+      return true if @state == :started
+      setup
+      @state = :started
+    end
+
+    def stop
+      return true unless @state == :started
+      @elector.close
+      @grouper.close
+      @zk.close
+      exited_cluster
+      @state = :stopped
+      true
+    end
+
+    #def am_i_master?
+    #  @state == :started && @elector.leader?
+    #end
+
+    def master_node
+      @state == :started && {:nodename => @elector.leader_data}
+    end
+
+    def members_via_election
+      return unless @state == :started
+
+      root = @elector.root_vote_path
+      @zk.children(root).select {|f| f.start_with? "ballot" }.map do |name|
+        @zk.get(root + '/' + name)[0]
+      end
+    end
+
+    def members
+      @state == :started && @members
+    end
+
+    def data_for_grouper_members(*members)
+      root = @grouper.path
+      Array(members).flatten.map do |name|
+        @zk.get(root + '/' + name)[0]
+      end
+    end
+
+    def resign(delay = nil)
+      return false
+    end
+
+    def steal_election!
+      raise ClusterActionFailed, 'Can not change master' unless am_i_master?
+      true
+    end
+
+    def cluster_key
+      [@namespace, @cluster_name].reject {|x| x.nil? || x.empty? }.join(':')
+    end
+
+    protected
+
+    def setup
+      logger.debug "ZK: setting up"
+
+      @zk = ZK.new(@options[:host] || 'localhost:2181')
+      @zk.wait_until_connected
+
+      @elector = ZK::Election::Candidate.new @zk, cluster_key, :data => @nodename
+      @grouper = ZK::Group.new @zk, cluster_key
+
+      change_cluster_status :online
+
+      @members = []
+
+      setup_winning_callback
+      setup_losing_callback
+      setup_leader_ack_callback
+
+      setup_connection_callbacks
+
+      @grouper.create
+      @grouper.join @nodename
+
+      @grouper.on_membership_change do |last_members, current_members|
+        update_membership(last_members, current_members)
+
+      end
+
+      # this thread will run until we win, in which case
+      # the thread will exit and we'll be master.
+      thr = Thread.new do
+        @elector.vote!
+      end
+      thr.join
+      logger.debug "ZK vote thread exited"
+    end
+
+    def update_membership(last_members, current_members)
+      old_membership = @members
+      @members = data_for_grouper_members(current_members).freeze
+      logger.debug "ZK: membership change from ZK::Group: from #{old_membership.inspect} to #{@members.inspect}"
+      run_hook :membership_change, old_membership, @members
+    end
+
+    def setup_winning_callback
+      @elector.on_winning_election do
+        logger.debug "ZK: winning election!"
+        change_my_status :master
+        change_master_status :good
+      end
+    end
+
+    def setup_losing_callback
+      @elector.on_losing_election do
+        logger.debug "ZK: losing election!"
+        change_my_status :member
+      end
+    end
+
+    def setup_leader_ack_callback
+      @elector.on_leader_ack do
+        logger.debug "ZK: leader ack!"
+        change_master_status :good
+      end
+    end
+
+    def exited_cluster
+      change_my_status :nonmember
+      change_master_status :unknown
+      change_cluster_status :offline
+      @state = :stopped
+    end
+
+    def fail_out_of_cluster
+      stop
+      if @options[:reconnect]
+        logger.debug 'ZK: reconnecting after failure'
+        start
+      end
+    end
+
+    def setup_connection_callbacks
+      @zk.on_expired_session do
+        logger.debug 'ZK: expired session'
+        fail_out_of_cluster
+      end
+
+      @zk.on_state_change do |*args|
+        logger.debug "ZK: state change #{args.inspect}"
+      end
+    end
+  end
+end

data/lib/zeevex_cluster/strategy.rb

@@ -0,0 +1,12 @@
+module ZeevexCluster
+  module Strategy
+    def self.create(ctype, options)
+      require 'zeevex_cluster/strategy/' + ctype.downcase
+      clazz = self.const_get(ctype.capitalize)
+      raise ArgumentError, "Unknown strategy type: #{ctype}" unless clazz
+      ZeevexCluster.Synchronized(clazz.new(options))
+    end
+  end
+end
+
+require 'zeevex_cluster/strategy/base'

data/lib/zeevex_cluster/synchronized.rb

@@ -0,0 +1,46 @@
+# Alex's Ruby threading utilities - taken from https://github.com/alexdowad/showcase
+
+require 'thread'
+require 'zeevex_proxy'
+
+# Wraps an object, synchronizes all method calls
+# The wrapped object can also be set and read out
+#   which means this can also be used as a thread-safe reference
+#   (like a 'volatile' variable in Java)
+class ZeevexCluster::Synchronized < ZeevexProxy::Base
+  def initialize(obj)
+    super
+    @mutex = ::Mutex.new
+  end
+
+  def _set_synchronized_object(val)
+    @mutex.synchronize { @obj = val }
+  end
+  def _get_synchronized_object
+    @mutex.synchronize { @obj }
+  end
+
+  def respond_to?(method)
+    if [:_set_synchronized_object, :_get_synchronized_object].include?(method.to_sym)
+      true
+    else
+      @obj.respond_to?(method)
+    end
+  end
+
+  def method_missing(method, *args, &block)
+    result = @mutex.synchronize { @obj.__send__(method, *args, &block) }
+    # result.__id__ == @obj.__id__ ? self : result
+  end
+end
+
+#
+# make object synchronized unless already synchronized
+#
+def ZeevexCluster.Synchronized(obj)
+  if obj.respond_to?(:_get_synchronized_object)
+    obj
+  else
+    ZeevexCluster::Synchronized.new(obj)
+  end
+end

data/lib/zeevex_cluster/unclustered.rb

@@ -0,0 +1,11 @@
+require 'zeevex_cluster/static'
+
+module ZeevexCluster
+  class Unclustered < Static
+    def initialize(options = {})
+      raise ArgumentError, "Cannot specify master nodename" if options.include?(:master_nodename)
+      options[:master_nodename] = :self
+      super
+    end
+  end
+end

data/lib/zeevex_cluster/util/logging.rb

@@ -0,0 +1,7 @@
+module ZeevexCluster::Util
+  module Logging
+    def logger
+      @logger || ZeevexCluster.logger
+    end
+  end
+end

data/lib/zeevex_cluster/util.rb

@@ -0,0 +1,15 @@
+module ZeevexCluster
+  module Util
+    module All
+      def self.included(base)
+        base.class_eval do
+          include Hookem
+          include ZeevexCluster::Util::Logging
+        end
+      end
+    end
+  end
+end
+
+require 'zeevex_cluster/util/logging'
+require 'hookem'

data/lib/zeevex_cluster/version.rb

@@ -0,0 +1,3 @@
+module ZeevexCluster
+  VERSION = "0.2.1"
+end

data/lib/zeevex_cluster.rb

@@ -0,0 +1,29 @@
+module ZeevexCluster
+  class ClusterException < StandardError; end
+  class NotMaster < ClusterException; end
+  class AlreadyMaster < ClusterException; end
+  class ClusterPolicyViolation < ClusterException; end
+  class ClusterActionFailed < ClusterException; end
+
+  def self.logger
+    @logger
+  end
+
+  def self.logger=(logger)
+    @logger = ZeevexCluster::Synchronized(logger)
+  end
+end
+
+require 'zeevex_cluster/synchronized'
+
+require 'logger'
+require 'zeevex_cluster/nil_logger'
+
+ZeevexCluster.logger = ZeevexCluster::NilLogger.new
+
+require 'zeevex_cluster/util'
+require 'zeevex_cluster/base'
+require 'zeevex_cluster/strategy'
+require 'zeevex_cluster/coordinator'
+require 'zeevex_cluster/election'
+require 'zeevex_cluster/message'

data/script/election.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+$: << File.join(File.dirname(__FILE__), "../lib")
+require 'rubygems'
+require 'pry'
+require 'zeevex_cluster'
+
+ctype = ARGV[0] || 'memcached'
+strategy_type = 'cas'
+
+backend_options = case ctype
+                    when 'memcached' then {:server => '127.0.0.1', :port => 11212}
+                    when 'redis'     then {:server => '127.0.0.1', :port => 6379}
+                    when 'mysql'     then {:server => '127.0.0.1', :port => 3306,
+                                           :coordinator_options => {
+                                               :namespace => 'cmdlinetest',
+                                               :username => 'zcluster',
+                                               :password => 'zclusterp',
+                                               :database => 'zcluster'}
+                                          }
+                    when 'zookeeper'
+                        strategy_type = 'zookeeper'
+                        {:reconnect => true}
+                    else raise 'Must be memcached or redis or mysql'
+                  end.
+    merge({:coordinator_type => ctype})
+
+$c = ZeevexCluster::Election.new :backend_options => backend_options,
+                                 :cluster_name => 'foobs',
+                                 :strategy_type => strategy_type,
+                                 :nodename => "#{Socket.gethostname}:#{`tty`.chomp}",
+                                 :logger => Logger.new(STDOUT),
+                                 :hooks  => {:status_change => lambda {|who, news, olds, *rest|
+                                                                       puts "MSC! #{news} #{olds}"} }
+
+Pry.config.prompt = Pry::DEFAULT_PROMPT.clone
+Pry.config.prompt[0] = proc do |target_self, nest_level, pry|
+  cstatus = case true
+              when $c.master? then "MASTER"
+              when $c.member? then "member"
+              else "offline"
+            end
+  mcount = $c.member? && $c.members ? $c.members.count : 0
+  "[#{pry.input_array.size}] #{cstatus}[#{mcount}] pry(#{Pry.view_clip(target_self)})#{":#{nest_level}" unless nest_level.zero?}> "
+end
+
+binding.pry

data/script/memc.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+$: << File.join(File.dirname(__FILE__), "../lib")
+require 'pry'
+require 'zeevex_cluster'
+require 'zeevex_cluster/memcached'
+
+# ZeevexCluster.logger = Logger.new(STDOUT)
+$c = ZeevexCluster::Memcached.new :backend_options => {:server => '127.0.0.1', :port => 11212},
+                                  :cluster_name => 'foobs',
+                                  :nodename => "#{Socket.gethostname}:#{`tty`.chomp}",
+                                  :logger => Logger.new(STDOUT),
+                                  :hooks  => {:status_change => lambda {|who, news, olds, *rest| puts "MSC! #{news} #{olds}"} }
+

data/script/mysql.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+$: << File.join(File.dirname(__FILE__), "../lib")
+require 'pry'
+require 'zeevex_cluster'
+require 'zeevex_cluster/primitives'
+require 'zeevex_cluster/coordinator'
+require 'zeevex_cluster/coordinator/mysql'
+
+require 'mysql2'
+
+@client ||= Mysql2::Client.new(:host => 'localhost',
+                               :database => 'zcluster',
+                               :username => 'zcluster',
+                               :password => 'zclusterp',
+                               :reconnect => true,
+                               :symbolize_keys => true,
+                               :database_timezone => :utc)
+
+$c = ZeevexCluster::Coordinator::Mysql.new :server => 'localhost',
+                                           :port => 3306,
+                                           :database => 'zcluster',
+                                           :username => 'zcluster',
+                                           :password => 'zclusterp',
+                                           :nodename => 'repl',
+                                           :expiration => 120

data/script/redis.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+$: << File.join(File.dirname(__FILE__), "../lib")
+require 'pry'
+require 'zeevex_cluster'
+require 'zeevex_cluster/coordinator/redis'
+
+# ZeevexCluster.logger = Logger.new(STDOUT)
+$c = ZeevexCluster::Coordinator::Redis.new :backend_options => {:server => '127.0.0.1', :port => 6379, :expiration => 120},
+                                  :server => '127.0.0.1', :port => 6379, :expiration => 120,
+                                  :cluster_name => 'foobs',
+                                  :nodename => "#{Socket.gethostname}:#{`tty`.chomp}",
+                                  :logger => Logger.new(STDOUT),
+                                  :hooks  => {:status_change => lambda {|who, news, olds, *rest| puts "MSC! #{news} #{olds}"} }
+

data/script/repl

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+$: << File.join(File.dirname(__FILE__), "../lib")
+require 'pry'
+require 'zeevex_cluster'
+require 'zeevex_cluster/util/delayed'
+require 'zeevex_cluster/util/future'
+require 'zeevex_cluster/util/promise'
+require 'zeevex_cluster/util/delay'
+
+binding.pry

data/script/repl.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+$: << File.join(File.dirname(__FILE__), "../lib")
+require 'pry'
+require 'zeevex_cluster'
+begin
+require 'zeevex_cluster/primitives'
+rescue LoadError
+end

data/script/ser.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+$: << File.join(File.dirname(__FILE__), "../lib")
+require 'pry'
+require 'zeevex_cluster'
+begin
+require 'zeevex_cluster/primitives'
+rescue LoadError
+end
+
+$s = ZeevexCluster::Serializer::JsonHash.new
+$h = {:a_at => Time.now, :b => [Time.now], :c => {:timestamp => Time.now}}

data/script/static.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+$: << File.join(File.dirname(__FILE__), "../lib")
+require 'rubygems'
+require 'pry'
+require 'zeevex_cluster'
+require 'zeevex_cluster/election'
+require 'zeevex_cluster/strategy/static'
+require 'zeevex_cluster/strategy/unclustered'
+
+# ZeevexCluster.logger = Logger.new(STDOUT)
+ctype = ARGV[0] || 'memcached'
+mname = ARGV[1] || 'none'
+nodename = ARGV[2] || "#{Socket.gethostname}:#{`tty`.chomp}"
+
+if mname == 'self'
+  mname = nodename
+end
+
+backend_options = case ctype
+                    when 'static' then {:master_nodename => mname}
+                    when 'unclustered' then {}
+                    else raise 'Must be static or unclustered'
+                  end.merge(:nodename => nodename)
+
+strategy = ZeevexCluster::Strategy.const_get(ctype.capitalize).new backend_options
+
+$c = ZeevexCluster::Election.new :backend_options => backend_options,
+                                 :strategy => strategy,
+                                 :cluster_name => 'foobs',
+                                 :nodename => nodename,
+                                 :logger => Logger.new(STDOUT),
+                                 :hooks  => {:status_change => lambda {|who, news, olds, *rest| puts "MSC! #{news} #{olds}"} }
+
+binding.pry

data/script/testall

@@ -0,0 +1,2 @@
+#!/bin/zsh
+rvm ree-1.8.7@zeevex_cluster,1.9.3-p327@zeevex_cluster,jruby-1.7.0@zeevex_cluster do bundle exec rspec

data/spec/cluster_static_spec.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe ZeevexCluster::Static do
+  def new_cluster(options = {})
+    ZeevexCluster::Static.new({:master_nodename => :self}.merge(options))
+  end
+
+  context 'creation' do
+    it 'requires the specification of a master nodename' do
+      expect { ZeevexCluster::Static.new }.to raise_error(ArgumentError)
+    end
+
+    it 'accepts a specified nodename for self' do
+      ZeevexCluster::Static.new(:nodename => 'foobar', :master_nodename => 'baz').
+          nodename.should == 'foobar'
+    end
+
+    it 'defaults to our hostname if nodename not specified' do
+      ZeevexCluster::Static.new(:master_nodename => 'baz').
+          nodename.should == Socket.gethostname
+    end
+
+    it 'treats master nodename == :self as our own nodename' do
+      ZeevexCluster::Static.new(:nodename => 'foo', :master_nodename => :self).
+          master.should == 'foo'
+    end
+  end
+
+  context 'when this node is specified as master' do
+    def new_cluster(options = {})
+      options[:master_nodename] = :self
+      super
+    end
+    subject { ZeevexCluster::Static.new(:nodename => 'foo', :master_nodename => 'foo') }
+    it_should_behave_like 'master_node'
+    it_should_behave_like 'member_node'
+  end
+
+  context 'when this node is not specified as master' do
+    def new_cluster(options = {})
+      options[:master_nodename] = 'other'
+      super
+    end
+    subject { ZeevexCluster::Static.new(:nodename => 'foo', :master_nodename => 'bar') }
+    it_should_behave_like 'non_master_node'
+    it_should_behave_like 'member_node'
+  end
+
+end

data/spec/cluster_unclustered_spec.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe ZeevexCluster::Unclustered do
+  context 'creation' do
+    it 'does not require any options' do
+      expect { ZeevexCluster::Unclustered.new }.not_to raise_error(ArgumentError)
+    end
+
+    it 'accepts a specified nodename for self' do
+      ZeevexCluster::Unclustered.new(:nodename => 'foobar').
+          nodename.should == 'foobar'
+    end
+
+    it 'defaults to our hostname if nodename not specified' do
+      ZeevexCluster::Unclustered.new.
+          nodename.should == Socket.gethostname
+    end
+
+    it 'does not accept master nodename option' do
+      expect { ZeevexCluster::Unclustered.new(:master_nodename => "foo") }.
+          to raise_error(ArgumentError)
+    end
+
+    it 'should be subclass of Static cluster type' do
+      ZeevexCluster::Unclustered.new.should be_a(ZeevexCluster::Static)
+    end
+
+    it 'should be master' do
+      ZeevexCluster::Unclustered.new.master?.should be_true
+    end
+  end
+end

data/spec/coordinator/coordinator_memcached_spec.rb

@@ -0,0 +1,102 @@
+require File.join(File.dirname(__FILE__), '../spec_helper')
+require 'zeevex_cluster/coordinator/memcached.rb'
+
+describe ZeevexCluster::Coordinator::Memcached do
+  STORED = "STORED\r\n"
+  EXISTS = "EXISTS\r\n"
+  
+  let :mockery do
+    mock()
+  end
+
+  let :clazz do
+    ZeevexCluster::Coordinator::Memcached
+  end
+
+  let :default_options do
+    {:server => '127.0.0.1', :expiration => 30, :namespace => "foo"}
+  end
+
+  context 'instantiation' do
+    it 'requires server argument' do
+      expect { clazz.new(:expiration => 30) }.
+          to raise_error(ArgumentError)
+    end
+    it 'requires expiration argument' do
+      expect { clazz.new(:server => '127.0.0.1') }.
+          to raise_error(ArgumentError)
+    end
+    it 'constructs successfully with both args' do
+      expect { clazz.new({:server => '127.0.0.1', :expiration => 30}) }.
+          not_to raise_error
+    end
+  end
+
+  context 'basic methods' do
+    subject { clazz.new(default_options.merge(:client => mockery)) }
+    it 'handles add' do
+      mockery.should_receive(:add).with('foo:bar', '{"$primitive":12}', 30, true).and_return(STORED)
+      subject.add('bar', 12).should == true
+    end
+    it 'handles set' do
+      mockery.should_receive(:set).with('foo:bar', '{"$primitive":13}', 30, true).and_return(STORED)
+      subject.set('bar', 13).should == true
+    end
+    it 'handles get' do
+      mockery.should_receive(:get).with('foo:bar', true).and_return('{"$primitive":14}')
+      subject.get('bar').should == 14
+    end
+  end
+
+  context 'cas' do
+    subject { clazz.new(default_options.merge(:client => mockery)) }
+    let :blok do
+      Proc.new do |value|
+        value
+        @block_called = true
+      end
+    end
+
+    it 'delegates with correct arguments' do
+      mockery.should_receive(:cas).with('foo:bar', 45, true).and_return(STORED)
+      subject.cas('bar', :expiration => 45) {|val|}
+    end
+
+    it 'calls block with current value and receive new value' do
+      mockery.should_receive(:cas) do |key, expiration, raw, &block|
+        block.should_not be_nil
+        block.call('{"$primitive":"yeeha"}').should == '{"$primitive":"yeehayeeha"}'
+        STORED
+      end
+      subject.cas('bar', :expiration => 45) do |val|
+        @block_called = true
+        val + val
+      end
+      @block_called.should be_true
+    end
+
+    it 'allows block to abort with no change to value' do
+      mockery.stub(:cas) do |*args, &block|
+        block.call '{"$primitive":7}'
+      end
+      subject.cas('bar') do |val|
+        raise ZeevexCluster::Coordinator::DontChange
+      end.should == false
+    end
+
+    it 'return nil if cas failed due to no key' do
+      mockery.should_receive(:cas).and_return(nil)
+      subject.cas('bar') {|val|}.should be_nil
+    end
+
+    it 'return true if cas succeeded' do
+      mockery.should_receive(:cas).and_return(STORED)
+      subject.cas('bar') {|val|}.should be_true
+    end
+
+    it 'return false if cas conflicted' do
+      mockery.should_receive(:cas).and_return(EXISTS)
+      subject.cas('bar') {|val|}.should be_false
+    end
+  end
+end