corosync 0.0.3 → 0.1.0.0

data/lib/corosync/cpg.rb

@@ -24,7 +24,7 @@ require 'corosync/cpg/member'
 # @example
 #   require 'corosync/cpg'
 #   cpg = Corosync::CPG.new('mygroup')
-#   cpg.on_message do |message, member|
+#   cpg.on_message do |message, sender|
 #     puts "Received #{message}"
 #   end
 #   puts "Member node IDs: #{cpg.members.map {|m| m.nodeid}.join(" ")}"
@@ -71,17 +71,12 @@ class Corosync::CPG
 	# @return [void]
 	def connect
 		handle_ptr = FFI::MemoryPointer.new(Corosync.find_type(:cpg_handle_t))
-		cs_error = Corosync.cpg_model_initialize(handle_ptr, Corosync::CPG_MODEL_V1, @model.pointer, nil);
-		if cs_error != :ok then
-			raise StandardError, "Received #{cs_error.to_s.upcase} attempting to connect to corosync"
-		end
+		model_cast = Corosync::CpgModelDataT.new(@model.to_ptr)
+		Corosync.cs_send(:cpg_model_initialize, handle_ptr, Corosync::CPG_MODEL_V1, model_cast, nil)
 		@handle = handle_ptr.read_uint64
 
 		fd_ptr = FFI::MemoryPointer.new(:int)
-		cs_error = Corosync.cpg_fd_get(@handle, fd_ptr)
-		if cs_error != :ok then
-			raise StandardError, "Received #{cs_error.to_s.upcase} attempting to get handle descriptor"
-		end
+		Corosync.cs_send(:cpg_fd_get, @handle, fd_ptr)
 		@fd = IO.new(fd_ptr.read_int)
 	end
 
@@ -90,10 +85,7 @@ class Corosync::CPG
 	def finalize
 		return if @handle.nil?
 
-		cs_error = Corosync.cpg_finalize(@handle)
-		if cs_error != :ok then
-			raise StandardError, "Received #{cs_error.to_s.upcase} attempting to perform finalize"
-		end
+		Corosync.cs_send(:cpg_finalize, @handle)
 
 		@group = nil
 		@fd = nil
@@ -113,10 +105,7 @@ class Corosync::CPG
 		cpg_name = Corosync::CpgName.new
 		cpg_name[:value] = name
 		cpg_name[:length] = name.size
-		cs_error = Corosync.cpg_join(@handle, cpg_name)
-		if cs_error != :ok then
-			raise StandardError, "Received #{cs_error.to_s.upcase} attempting to join group"
-		end
+		Corosync.cs_send(:cpg_join, @handle, cpg_name)
 
 		@group = name
 
@@ -132,10 +121,7 @@ class Corosync::CPG
 		cpg_name[:length] = @group.size
 
 		# we can't join multiple groups, so I dont know why corosync requires you to specify the group name
-		cs_error = Corosync.cpg_leave(@handle, cpg_name)
-		if cs_error != :ok then
-			raise StandardError, "Received #{cs_error.to_s.upcase} attempting to leave group"
-		end
+		Corosync.cs_send(:cpg_leave, @handle, cpg_name)
 
 		@group = nil
 	end
@@ -151,11 +137,14 @@ class Corosync::CPG
 			timeout = nil if timeout == -1
 			select([@fd], [], [], timeout)
 		end
-		cs_error = Corosync.cpg_dispatch(@handle, Corosync::CS_DISPATCH_ONE_NONBLOCKING)
-		return false if cs_error == :err_try_again
-		if cs_error != :ok then
-			raise StandardError, "Received #{cs_error.to_s.upcase} attempting perform dispatch"
+
+		begin
+			Corosync.cs_send!(:cpg_dispatch, @handle, Corosync::CS_DISPATCH_ONE_NONBLOCKING)
+		rescue Corosync::TryAgainError => e
+			raise e if e.depth > 1 # this exception is from a nested corosync function, not our cpg_dispatch we just called
+			return false
 		end
+
 		return true
 	end
 
@@ -229,10 +218,7 @@ class Corosync::CPG
 	# @return [Integer]
 	def nodeid
 		nodeid_p = FFI::MemoryPointer.new(:uint)
-		cs_error = Corosync.cpg_local_get(@handle, nodeid_p)
-		if cs_error != :ok then
-			raise StandardError, "Received #{cs_error.to_s.upcase} attempting to get nodeid"
-		end
+		Corosync.cs_send(:cpg_local_get, @handle, nodeid_p)
 		nodeid_p.read_uint
 	end
 
@@ -246,25 +232,21 @@ class Corosync::CPG
 		cpg_name[:length] = @group.size
 
 		iteration_handle_ptr = FFI::MemoryPointer.new(Corosync.find_type(:cpg_iteration_handle_t))
-		cs_error = Corosync.cpg_iteration_initialize(@handle, Corosync::CPG_ITERATION_ONE_GROUP, cpg_name, iteration_handle_ptr)
-		if cs_error != :ok then
-			raise StandardError, "Received #{cs_error.to_s.upcase} attempting to initialize member iteration"
-		end
+		Corosync.cs_send(:cpg_iteration_initialize, @handle, Corosync::CPG_ITERATION_ONE_GROUP, cpg_name, iteration_handle_ptr)
 		iteration_handle = iteration_handle_ptr.read_uint64
 
 		begin
 			iteration_description = Corosync::CpgIterationDescriptionT.new
-			while (cs_error = Corosync.cpg_iteration_next(iteration_handle, iteration_description.pointer)) == :ok do
-				members << Corosync::CPG::Member.new(iteration_description)
-			end
-			if cs_error != :err_no_sections then
-				raise StandardError, "Received #{cs_error.to_s.upcase} attempting to iterate group members"
+			begin
+				loop do
+					Corosync.cs_send(:cpg_iteration_next, iteration_handle, iteration_description)
+					members << Corosync::CPG::Member.new(iteration_description)
+				end
+			rescue Corosync::NoSectionsError
+				# signals end of iteration
 			end
 		ensure
-			cs_error = Corosync.cpg_iteration_finalize(iteration_handle)
-			if cs_error != :ok then
-				raise StandardError, "Received #{cs_error.to_s.upcase} attempting to finalize member iteration"
-			end
+			Corosync.cs_send(:cpg_iteration_finalize, iteration_handle)
 		end
 
 		members
@@ -292,9 +274,8 @@ class Corosync::CPG
 		end
 		iovec_len = messages.size
 
-		cs_error = Corosync.cpg_mcast_joined(@handle, Corosync::CPG_TYPE_AGREED, iovec_list_p, iovec_len)
-		if cs_error != :ok then
-			raise StandardError, "Received #{cs_error.to_s.upcase} attempting to send a message"
-		end
+		Corosync.cs_send(:cpg_mcast_joined, @handle, Corosync::CPG_TYPE_AGREED, iovec_list_p, iovec_len)
+
+		true
 	end
 end

data/lib/corosync/exceptions.rb

@@ -0,0 +1,34 @@
+module Corosync
+
+  # Base class that all Corosync exceptions descend from.  
+  # Corosync exception classes are programitcally generated from the `:cs_error_t` enum in `ffi/common.rb`. See that file for a comprehensive list of exception classes. The `:err_try_again` value will map to `Corosync::TryAgainError`. All exception classes follow the same pattern.
+  class Error < StandardError
+		Map = {}
+
+    # @!attribute [rw] depth
+    # The number of {Corosync.cs_send} methods the exception has passed through. This is important so that we don't rescue nested exceptions. For example, we call cs_send(:cpg_dispatch) which calls a callback which calls cs_send(:cpg_mcast_joined). If the cpg_mcast_joined were to raise an exception, and we had a rescue around the cpg_dispatch, we wouldn't know whether the exception came from cpg_mcast_joined or cpg_dispatch. However in this case the depth would be 2, and so we would know not to rescue it.
+    # @return [Fixnum] Number of cs_send methods the exception has passed through
+    def depth
+      @depth ||= 0
+    end
+    def depth=(value)
+      @depth = value
+    end
+  end
+
+  Corosync.enum_type(:cs_error_t).to_h.each do |name, value|
+    next if name == :ok
+
+    name_s = name.to_s.sub(/^err_/, '').capitalize.gsub(/_(.)/){|m| m[1].upcase} + 'Error'
+
+    c = Class.new(Error) do
+      const_set :VALUE, value
+      def value
+        self.class.const_get :VALUE
+      end
+    end
+		const_set name_s, c
+
+		Error::Map[name] = c
+  end
+end

data/lib/corosync/quorum.rb

@@ -0,0 +1,143 @@
+require File.expand_path('../../corosync.rb', __FILE__)
+require File.expand_path('../../../ffi/quorum.rb', __FILE__)
+
+# Quorum is used for tracking the health of the cluster.
+# This simply reads the quorum state as defined by corosync. Whenever the node gains or loses quorum, a notification callback is called. You can also poll the quorum state instead of using a callback.
+#
+# ----
+#
+# @example
+#   require 'corosync/quorum'
+#   quorum = Corosync::Quorum.new
+#   quorum.on_notify do |quorate,member_list|
+#     puts "Cluster is#{quorate ? '' ' not'} quorate"
+#     puts "  Members: #{member_list.join(' ')}"
+#   end
+#   quorum.connect
+#   loop do
+#     quorum.dispatch
+#   end
+
+class Corosync::Quorum
+	# The IO object containing the file descriptor notifications come across.
+	# You can use this to check for activity, but do not read anything from it.
+	# @return [IO]
+	attr_reader :fd
+
+	# Creates a new Quorum instance
+	#
+	# @param connect [Boolean] Whether to join the cluster immediately. If not provided, you must call {#connect} and/or {#connect} later.
+	#
+	# @return [void]
+	def initialize(connect = false)
+		@handle = nil
+		@fd = nil
+
+		@callbacks = Corosync::QuorumCallbacksT.new
+		@callbacks[:quorum_notify_fn] = self.method(:callback_notify)
+
+		self.connect if connect
+	end
+
+	# Connect to the Quorum service
+	# @param start [Boolean] Whether to start listening for notifications (will not make initial call to callback).
+	# @return [void]
+	def connect(start = false)
+		handle_ptr = FFI::MemoryPointer.new(Corosync.find_type(:quorum_handle_t))
+		quorum_type_ptr = FFI::MemoryPointer.new(:uint32)
+
+		Corosync.cs_send(:quorum_initialize, handle_ptr, @callbacks, quorum_type_ptr)
+
+		@handle = handle_ptr.read_uint64
+
+		fd_ptr = FFI::MemoryPointer.new(:int)
+		Corosync.cs_send(:quorum_fd_get, @handle, fd_ptr)
+		@fd = IO.new(fd_ptr.read_int)
+
+		self.start if start
+	end
+
+	# Shuts down the connection to the Quorum service
+	# @return [void]
+	def finalize
+		return if @handle.nil?
+
+		Corosync.cs_send(:quorum_finalize, @handle)
+
+		@handle = nil
+		@fd = nil
+	end
+
+	# Start monitoring for changes to quorum status.
+	# This basically just enables triggering the callback. If not called you can still call {#quorate?} to get quorum state.
+	# @param initial_callback [Boolean] Whether to call the callback after start.
+	# @return [Boolean]
+	def start(initial_callback = false)
+		connect if @handle.nil?
+
+		Corosync.cs_send(:quorum_trackstart, @handle, Corosync::CS_TRACK_CHANGES)
+
+		if initial_callback and @callback_notify then
+			@callback_notify.call(quorate?, [])
+		end
+	end
+
+	# Stop monitoring for changes to quorum status.
+	# @return [void]
+	def stop
+		Corosync.cs_send(:quorum_trackstop, @handle)
+	end
+
+	# Checks for a single pending event and triggers the appropriate callback if found.
+	# @param timeout [Integer] How long to wait for an event.
+	#   * +-1+: Indefinite. Wait forever
+	#   * +0+: Non-blocking. If there isn't a pending event, return immediately
+	#   * +>0+: Wait the specified number of seconds.
+	# @return [Boolean] Returns +True+ if an event was triggered. Otherwise +False+.
+	def dispatch(timeout = -1)
+		if !timeout != 0 then
+			timeout = nil if timeout == -1
+			select([@fd], [], [], timeout)
+		end
+
+		begin
+			Corosync.cs_send!(:quorum_dispatch, @handle, Corosync::CS_DISPATCH_ONE_NONBLOCKING)
+		rescue Corosync::TryAgainError => e
+			raise e if e.depth > 1 # this exception is from a nested corosync function, not our quorum_dispatch we just called
+			return false
+		end
+
+		return true
+	end
+
+	# Proc to call when quorum state changes.
+	# @param block [Proc] Proc to call when quorm state changes. Pass +Nil+ to disable the callback.
+	# @yieldparam quorate [Boolean] Whether cluster is quorate.
+	# @yieldparam members [Array<Fixnum>] Node ID of cluster members.
+	# @return [void]
+	def on_notify(&block)
+		@callback_notify = block
+	end
+	def callback_notify(handle, quorate, ring_id, view_list_entries, view_list_ptr)
+		return if !@callback_notify
+
+		view_list = view_list_ptr.read_array_of_type(FFI.find_type(:uint32), :read_uint32, view_list_entries)
+		#view_list = []
+		#view_list_entries.times do |i|
+			#view_list << (view_list_ptr + i * FFI.type_size(:uint32)).read_uint32
+		#end
+
+		@callback_notify.call(quorate > 0, view_list)
+	end
+	private :callback_notify
+
+	# Get node quorum status
+	# @return [Boolean] Whether node is quorate.
+	def getquorate
+		quorate_ptr = FFI::MemoryPointer.new(:int)
+		Corosync.cs_send(:quorum_getquorate, @handle, quorate_ptr)
+
+		quorate_ptr.read_int > 0
+	end
+	alias_method :quorate?, :getquorate
+end

data/lib/corosync/votequorum.rb

@@ -0,0 +1,218 @@
+require File.expand_path('../../corosync.rb', __FILE__)
+require File.expand_path('../../../ffi/votequorum.rb', __FILE__)
+
+# Votequorum is used for tracking the health of the cluster.
+# This monitors the quorum state as configured. Whenever the node gains or loses quorum, a notification callback is called. You can also poll the quorum state instead of using a callback.
+#
+# ----
+#
+# @example
+#   require 'corosync/votequorum'
+#   vq = Corosync::Votequorum.new
+#   vq.on_notify do |quorate,node_list|
+#     puts "Cluster is#{quorate ? '' ' not'} quorate"
+#     puts "  Nodes:"
+#     node_list.each do |name,state|
+#       puts "    #{name}=#{state}"
+#     end
+#   end
+#   vq.connect
+#   loop do
+#     vq.dispatch
+#   end
+class Corosync::Votequorum
+	require 'ostruct'
+
+	# The IO object containing the file descriptor notifications come across.
+	# You can use this to check for activity, but do not read anything from it.
+	# @return [IO]
+	attr_reader :fd
+
+	# Creates a new Votequorum instance
+	#
+	# @param connect [Boolean] Whether to join the cluster immediately. If not provided, you must call {#connect} and/or {#connect} later.
+	#
+	# @return [void]
+	def initialize(connect = false)
+		@handle = nil
+		@fd = nil
+
+		@callbacks = Corosync::VotequorumCallbacksT.new
+		@callbacks[:votequorum_notify_fn] = self.method(:callback_notify)
+		@callbacks[:votequorum_expectedvotes_notify_fn] = self.method(:callback_expectedvotes_notify)
+
+		self.connect if connect
+	end
+
+	# Connect to the Votequorum service
+	# @param start [Boolean] Whether to start listening for notifications (will not make initial call to callback).
+	# @return [void]
+	def connect(start = false)
+		handle_ptr = FFI::MemoryPointer.new(Corosync.find_type(:votequorum_handle_t))
+
+		Corosync.cs_send(:votequorum_initialize, handle_ptr, @callbacks)
+
+		@handle = handle_ptr.read_uint64
+
+		fd_ptr = FFI::MemoryPointer.new(:int)
+		Corosync.cs_send(:votequorum_fd_get, @handle, fd_ptr)
+		@fd = IO.new(fd_ptr.read_int)
+
+		self.start if start
+	end
+
+	# Shuts down the connection to the Quorum service
+	# @return [void]
+	def finalize
+		return if @handle.nil?
+
+		Corosync.cs_send(:votequorum_finalize, @handle)
+
+		@handle = nil
+		@fd = nil
+	end
+
+	# Start monitoring for changes to quorum status/config.
+	# This basically just enables triggering the callback. If not called you can still call {#quorate?} to get quorum state.
+	# @param initial_callback [Boolean] Whether to call the callback after start.
+	# @return [Boolean]
+	def start(initial_callback = false)
+		connect if @handle.nil?
+
+		Corosync.cs_send(:votequorum_trackstart, @handle, 0, Corosync::CS_TRACK_CHANGES)
+
+		if initial_callback and @callback_notify then
+			@callback_notify.call(quorate?)
+		end
+	end
+
+	# Stop monitoring for changes.
+	# @return [void]
+	def stop
+		Corosync.cs_send(:votequorum_trackstop, @handle)
+	end
+
+	# Checks for a single pending event and triggers the appropriate callback if found.
+	# @param timeout [Integer] How long to wait for an event.
+	#   * +-1+: Indefinite. Wait forever
+	#   * +0+: Non-blocking. If there isn't a pending event, return immediately
+	#   * +>0+: Wait the specified number of seconds.
+	# @return [Boolean] Returns +True+ if an event was triggered. Otherwise +False+.
+	def dispatch(timeout = -1)
+		if !timeout != 0 then
+			timeout = nil if timeout == -1
+			select([@fd], [], [], timeout)
+		end
+
+		begin
+			Corosync.cs_send(:votequorum_dispatch, @handle, Corosync::CS_DISPATCH_ONE_NONBLOCKING)
+		rescue Corosync::TryAgainError
+			return false
+		end
+
+		return true
+	end
+
+	# Proc to call when quorum state changes.
+	# @param block [Proc] Proc to call when quorm state changes. Pass +Nil+ to disable the callback.
+	# @yieldparam quorate [Boolean] Whether cluster is quorate.
+	# @yieldparam nodes [Hash] Hash of node IDs and their state.
+	#   The state is one of :member, :dead, or :leaving
+	# @return [void]
+	def on_notify(&block)
+		@callback_notify = block
+	end
+	def callback_notify(handle, context, quorate, node_list_entries, node_list_ptr)
+		return if !@callback_notify
+
+		node_list = {}
+		node_list_entries.times do |i|
+			node = Corosync::VotequorumNodeT.new(node_list_ptr + i * Corosync::VotequorumNodeT.size)
+			node_list[node[:nodeid]] = {
+				Corosync::VOTEQUORUM_NODESTATE_MEMBER => :member,
+				Corosync::VOTEQUORUM_NODESTATE_DEAD => :dead,
+				Corosync::VOTEQUORUM_NODESTATE_LEAVING => :leaving,
+			}[node[:state]]
+			node_list[node[:nodeid]] = :UNKNOWN if node_list[node[:nodeid]].nil?
+		end
+
+		@callback_notify.call(quorate > 0, node_list)
+	end
+	private :callback_notify
+
+	# Proc to call when the number of expected votes changes.
+	# @param block [Proc] Proc to call when the expected votes changes. Pass +Nil+ to disable the callback.
+	# @yieldparam expected_votes [Integer] New number of expected votes.
+	# @return [void]
+	def on_expectedvotes_notify(&block)
+		@callback_expectedvotes_notify = block
+	end
+	def callback_expectedvotes_notify(handle, context, expected_votes)
+		return if !@callback_expectedvotes_notify
+
+		@callback_expectedvotes_notify.call(expected_votes)
+	end
+	private :callback_expectedvotes_notify
+
+	# Get the votequorum info about a node.
+	# The return openstruct will contain the following keys
+	#   * node_id - Integer
+	#   * node_state - Symbol: :member or :dead or :leaving
+	#   * node_votes - Integer
+	#   * node_expected_votes - Integer
+	#   * highest_expected - Integer
+	#   * total_votes - Integer
+	#   * quorum - Integer
+	#   * flags - Array<Symbol> where each symbol is one of: :twonode, :quorate, :wait_for_all, :last_man_standing, :auto_tie_breaker, :allow_downscale, :qdevice_registered, :qdevice_alive, :qdevice_cast_vote, or :qdevice_master_wins
+	#   * qdevice_votes - Integer
+	#   * qdevice_name - String
+	# @param node_id [Integer] The node id to look up. 0 for the current node.
+	# @return [OpenStruct]
+	def info(node_id = 0)
+		info = Corosync::VotequorumInfo.new
+
+		Corosync.cs_send(:votequorum_getinfo, @handle, node_id, info)
+
+		info = OpenStruct.new(Hash[info.members.zip(info.values)])
+
+		info.qdevice_name = info.qdevice_name.to_s
+
+		flags = info.flags
+		info.flags = []
+		[:twonode,:quorate,:wait_for_all,:last_man_standing,:auto_tie_breaker,:allow_downscale,:qdevice_registered,:qdevice_alive,:qdevice_cast_vote,:qdevice_master_wins].each do |flag_name|
+			flag_value = Corosync.const_get("VOTEQUORUM_INFO_#{flag_name.to_s.upcase}")
+			info.flags << flag_name if flags & flag_value >= 1
+		end
+
+		info
+		#Corosync::Votequorum::Info.new info
+	end
+
+	# Set the number of expected votes for this node
+	# @param count [Integer]
+	# @return [void]
+	def set_expected(count)
+		Corosync.cs_send(:votequorum_setexpected, @handle, count)
+	end
+	alias_method :expected=, :set_expected
+
+	# Set the number of votes contributed by the specified node.
+	# @param count [Integer]
+	# @param node_id [Integer] The node to modify
+	# @return [void]
+	def set_votes(count, node_id = 0)
+		Corosync.cs_send(:votequorum_setvotes, @handle, node_id, count)
+	end
+	# Set the number of votes contributed by this node.
+	# Shorthand for {#set_votes}(count)
+	def votes=(count)
+		set_votes(count)
+	end
+
+	# Get whether this node is quorate or not
+	# Shorthand for {#info}.flags.include?(:quorate)
+	# @return [Boolean]
+	def quorate?
+		self.info.flags.include?(:quorate)
+	end
+end