corosync 0.0.3 → 0.1.0.0

data/ffi/cpg.rb

@@ -5,6 +5,11 @@ module Corosync
   extend FFI::Library
   ffi_lib 'libcpg'
 
+  class CpgCallbacksT < FFI::Struct; end
+  class CpgModelDataT < FFI::Struct; end
+  class CpgName < FFI::Struct; end
+  class CpgAddress < FFI::Struct; end
+  class CpgIterationDescriptionT < FFI::Struct; end
   typedef :uint64, :cpg_handle_t
   typedef :uint64, :cpg_iteration_handle_t
   CPG_TYPE_UNORDERED = 0
@@ -69,7 +74,7 @@ module Corosync
   CPG_MEMBERS_MAX = 128
   class CpgIterationDescriptionT < FFI::Struct
     layout(
-           :group, CpgName,
+           :group, CpgName.by_value,
            :nodeid, :uint32,
            :pid, :uint32
     )
@@ -80,14 +85,29 @@ module Corosync
            :seq, :uint64
     )
   end
-  Callback_cpg_deliver_fn_t = callback(:cpg_deliver_fn_t, [ :cpg_handle_t, :pointer, :uint32, :uint32, :pointer, :uint ], :void)
-  Callback_cpg_confchg_fn_t = callback(:cpg_confchg_fn_t, [ :cpg_handle_t, :pointer, :pointer, :uint, :pointer, :uint, :pointer, :uint ], :void)
-  Callback_cpg_totem_confchg_fn_t = callback(:cpg_totem_confchg_fn_t, [ :cpg_handle_t, CpgRingId, :uint32, :pointer ], :void)
+  Callback_cpg_deliver_fn_t = callback(:cpg_deliver_fn_t, [ :cpg_handle_t, :pointer, :uint32, :uint32, :pointer, :size_t ], :void)
+  Callback_cpg_confchg_fn_t = callback(:cpg_confchg_fn_t, [ :cpg_handle_t, :pointer, :pointer, :size_t, :pointer, :size_t, :pointer, :size_t ], :void)
+  Callback_cpg_totem_confchg_fn_t = callback(:cpg_totem_confchg_fn_t, [ :cpg_handle_t, CpgRingId.by_value, :uint32, :pointer ], :void)
   class CpgCallbacksT < FFI::Struct
     layout(
-           :cpg_deliver_fn, :cpg_deliver_fn_t,
-           :cpg_confchg_fn, :cpg_confchg_fn_t
+           :cpg_deliver_fn, Callback_cpg_deliver_fn_t,
+           :cpg_confchg_fn, Callback_cpg_confchg_fn_t
     )
+    def cpg_deliver_fn=(cb)
+      @cpg_deliver_fn = cb
+      self[:cpg_deliver_fn] = @cpg_deliver_fn
+    end
+    def cpg_deliver_fn
+      @cpg_deliver_fn
+    end
+    def cpg_confchg_fn=(cb)
+      @cpg_confchg_fn = cb
+      self[:cpg_confchg_fn] = @cpg_confchg_fn
+    end
+    def cpg_confchg_fn
+      @cpg_confchg_fn
+    end
+
   end
   class CpgModelDataT < FFI::Struct
     layout(
@@ -98,14 +118,36 @@ module Corosync
   class CpgModelV1DataT < FFI::Struct
     layout(
            :model, :cpg_model_t,
-           :cpg_deliver_fn, :cpg_deliver_fn_t,
-           :cpg_confchg_fn, :cpg_confchg_fn_t,
-           :cpg_totem_confchg_fn, :cpg_totem_confchg_fn_t,
+           :cpg_deliver_fn, Callback_cpg_deliver_fn_t,
+           :cpg_confchg_fn, Callback_cpg_confchg_fn_t,
+           :cpg_totem_confchg_fn, Callback_cpg_totem_confchg_fn_t,
            :flags, :uint
     )
+    def cpg_deliver_fn=(cb)
+      @cpg_deliver_fn = cb
+      self[:cpg_deliver_fn] = @cpg_deliver_fn
+    end
+    def cpg_deliver_fn
+      @cpg_deliver_fn
+    end
+    def cpg_confchg_fn=(cb)
+      @cpg_confchg_fn = cb
+      self[:cpg_confchg_fn] = @cpg_confchg_fn
+    end
+    def cpg_confchg_fn
+      @cpg_confchg_fn
+    end
+    def cpg_totem_confchg_fn=(cb)
+      @cpg_totem_confchg_fn = cb
+      self[:cpg_totem_confchg_fn] = @cpg_totem_confchg_fn
+    end
+    def cpg_totem_confchg_fn
+      @cpg_totem_confchg_fn
+    end
+
   end
-  attach_function :cpg_initialize, :cpg_initialize, [ :pointer, :pointer ], :cs_error_t
-  attach_function :cpg_model_initialize, :cpg_model_initialize, [ :pointer, :cpg_model_t, :pointer, :pointer ], :cs_error_t
+  attach_function :cpg_initialize, :cpg_initialize, [ :pointer, CpgCallbacksT.ptr ], :cs_error_t
+  attach_function :cpg_model_initialize, :cpg_model_initialize, [ :pointer, :cpg_model_t, CpgModelDataT.ptr, :pointer ], :cs_error_t
   attach_function :cpg_finalize, :cpg_finalize, [ :cpg_handle_t ], :cs_error_t
   attach_function :cpg_fd_get, :cpg_fd_get, [ :cpg_handle_t, :pointer ], :cs_error_t
   attach_function :cpg_context_get, :cpg_context_get, [ :cpg_handle_t, :pointer ], :cs_error_t
@@ -114,14 +156,14 @@ module Corosync
   attach_function :cpg_join, :cpg_join, [ :cpg_handle_t, :pointer ], :cs_error_t
   attach_function :cpg_leave, :cpg_leave, [ :cpg_handle_t, :pointer ], :cs_error_t
   attach_function :cpg_mcast_joined, :cpg_mcast_joined, [ :cpg_handle_t, :cpg_guarantee_t, :pointer, :uint ], :cs_error_t
-  attach_function :cpg_membership_get, :cpg_membership_get, [ :cpg_handle_t, :pointer, :pointer, :pointer ], :cs_error_t
+  attach_function :cpg_membership_get, :cpg_membership_get, [ :cpg_handle_t, CpgName.ptr, CpgAddress.ptr, :pointer ], :cs_error_t
   attach_function :cpg_local_get, :cpg_local_get, [ :cpg_handle_t, :pointer ], :cs_error_t
   attach_function :cpg_flow_control_state_get, :cpg_flow_control_state_get, [ :cpg_handle_t, :pointer ], :cs_error_t
-  attach_function :cpg_zcb_alloc, :cpg_zcb_alloc, [ :cpg_handle_t, :uint, :pointer ], :cs_error_t
+  attach_function :cpg_zcb_alloc, :cpg_zcb_alloc, [ :cpg_handle_t, :size_t, :pointer ], :cs_error_t
   attach_function :cpg_zcb_free, :cpg_zcb_free, [ :cpg_handle_t, :pointer ], :cs_error_t
-  attach_function :cpg_zcb_mcast_joined, :cpg_zcb_mcast_joined, [ :cpg_handle_t, :cpg_guarantee_t, :pointer, :uint ], :cs_error_t
+  attach_function :cpg_zcb_mcast_joined, :cpg_zcb_mcast_joined, [ :cpg_handle_t, :cpg_guarantee_t, :pointer, :size_t ], :cs_error_t
   attach_function :cpg_iteration_initialize, :cpg_iteration_initialize, [ :cpg_handle_t, :cpg_iteration_type_t, :pointer, :pointer ], :cs_error_t
-  attach_function :cpg_iteration_next, :cpg_iteration_next, [ :cpg_iteration_handle_t, :pointer ], :cs_error_t
+  attach_function :cpg_iteration_next, :cpg_iteration_next, [ :cpg_iteration_handle_t, CpgIterationDescriptionT.ptr ], :cs_error_t
   attach_function :cpg_iteration_finalize, :cpg_iteration_finalize, [ :cpg_iteration_handle_t ], :cs_error_t
 
 end

data/ffi/quorum.i

@@ -0,0 +1,14 @@
+%module Corosync
+%{
+require File.expand_path('../common.rb', __FILE__)
+
+module Corosync
+  extend FFI::Library
+  ffi_lib 'libquorum'
+
+%}
+%import "common.i"
+%include <corosync/quorum.h>
+%{
+end
+%}

data/ffi/quorum.rb

@@ -0,0 +1,36 @@
+
+require File.expand_path('../common.rb', __FILE__)
+
+module Corosync
+  extend FFI::Library
+  ffi_lib 'libquorum'
+
+  class QuorumCallbacksT < FFI::Struct; end
+  typedef :uint64, :quorum_handle_t
+  Callback_quorum_notification_fn_t = callback(:quorum_notification_fn_t, [ :quorum_handle_t, :uint32, :uint64, :uint32, :pointer ], :void)
+  class QuorumCallbacksT < FFI::Struct
+    layout(
+           :quorum_notify_fn, Callback_quorum_notification_fn_t
+    )
+    def quorum_notify_fn=(cb)
+      @quorum_notify_fn = cb
+      self[:quorum_notify_fn] = @quorum_notify_fn
+    end
+    def quorum_notify_fn
+      @quorum_notify_fn
+    end
+
+  end
+  QUORUM_FREE = 0
+  QUORUM_SET = 1
+  attach_function :quorum_initialize, :quorum_initialize, [ :pointer, QuorumCallbacksT.ptr, :pointer ], :cs_error_t
+  attach_function :quorum_finalize, :quorum_finalize, [ :quorum_handle_t ], :cs_error_t
+  attach_function :quorum_fd_get, :quorum_fd_get, [ :quorum_handle_t, :pointer ], :cs_error_t
+  attach_function :quorum_dispatch, :quorum_dispatch, [ :quorum_handle_t, :cs_dispatch_flags_t ], :cs_error_t
+  attach_function :quorum_getquorate, :quorum_getquorate, [ :quorum_handle_t, :pointer ], :cs_error_t
+  attach_function :quorum_trackstart, :quorum_trackstart, [ :quorum_handle_t, :uint ], :cs_error_t
+  attach_function :quorum_trackstop, :quorum_trackstop, [ :quorum_handle_t ], :cs_error_t
+  attach_function :quorum_context_set, :quorum_context_set, [ :quorum_handle_t, :pointer ], :cs_error_t
+  attach_function :quorum_context_get, :quorum_context_get, [ :quorum_handle_t, :pointer ], :cs_error_t
+
+end

data/ffi/votequorum.i

@@ -0,0 +1,14 @@
+%module Corosync
+%{
+require File.expand_path('../common.rb', __FILE__)
+
+module Corosync
+  extend FFI::Library
+  ffi_lib 'libvotequorum'
+
+%}
+%import "common.i"
+%include <corosync/votequorum.h>
+%{
+end
+%}

data/ffi/votequorum.rb

@@ -0,0 +1,87 @@
+
+require File.expand_path('../common.rb', __FILE__)
+
+module Corosync
+  extend FFI::Library
+  ffi_lib 'libvotequorum'
+
+  class VotequorumCallbacksT < FFI::Struct; end
+  class VotequorumInfo < FFI::Struct; end
+  typedef :uint64, :votequorum_handle_t
+  VOTEQUORUM_INFO_TWONODE = 1
+  VOTEQUORUM_INFO_QUORATE = 2
+  VOTEQUORUM_INFO_WAIT_FOR_ALL = 4
+  VOTEQUORUM_INFO_LAST_MAN_STANDING = 8
+  VOTEQUORUM_INFO_AUTO_TIE_BREAKER = 16
+  VOTEQUORUM_INFO_ALLOW_DOWNSCALE = 32
+  VOTEQUORUM_INFO_QDEVICE_REGISTERED = 64
+  VOTEQUORUM_INFO_QDEVICE_ALIVE = 128
+  VOTEQUORUM_INFO_QDEVICE_CAST_VOTE = 256
+  VOTEQUORUM_INFO_QDEVICE_MASTER_WINS = 512
+  VOTEQUORUM_QDEVICE_NODEID = 0
+  VOTEQUORUM_QDEVICE_MAX_NAME_LEN = 255
+  VOTEQUORUM_QDEVICE_DEFAULT_TIMEOUT = 10000
+  VOTEQUORUM_NODESTATE_MEMBER = 1
+  VOTEQUORUM_NODESTATE_DEAD = 2
+  VOTEQUORUM_NODESTATE_LEAVING = 3
+  class VotequorumInfo < FFI::Struct
+    layout(
+           :node_id, :uint,
+           :node_state, :uint,
+           :node_votes, :uint,
+           :node_expected_votes, :uint,
+           :highest_expected, :uint,
+           :total_votes, :uint,
+           :quorum, :uint,
+           :flags, :uint,
+           :qdevice_votes, :uint,
+           :qdevice_name, [:char, 255]
+    )
+  end
+  class VotequorumNodeT < FFI::Struct
+    layout(
+           :nodeid, :uint32,
+           :state, :uint32
+    )
+  end
+  Callback_votequorum_notification_fn_t = callback(:votequorum_notification_fn_t, [ :votequorum_handle_t, :uint64, :uint32, :uint32, :pointer ], :void)
+  Callback_votequorum_expectedvotes_notification_fn_t = callback(:votequorum_expectedvotes_notification_fn_t, [ :votequorum_handle_t, :uint64, :uint32 ], :void)
+  class VotequorumCallbacksT < FFI::Struct
+    layout(
+           :votequorum_notify_fn, Callback_votequorum_notification_fn_t,
+           :votequorum_expectedvotes_notify_fn, Callback_votequorum_expectedvotes_notification_fn_t
+    )
+    def votequorum_notify_fn=(cb)
+      @votequorum_notify_fn = cb
+      self[:votequorum_notify_fn] = @votequorum_notify_fn
+    end
+    def votequorum_notify_fn
+      @votequorum_notify_fn
+    end
+    def votequorum_expectedvotes_notify_fn=(cb)
+      @votequorum_expectedvotes_notify_fn = cb
+      self[:votequorum_expectedvotes_notify_fn] = @votequorum_expectedvotes_notify_fn
+    end
+    def votequorum_expectedvotes_notify_fn
+      @votequorum_expectedvotes_notify_fn
+    end
+
+  end
+  attach_function :votequorum_initialize, :votequorum_initialize, [ :pointer, VotequorumCallbacksT.ptr ], :cs_error_t
+  attach_function :votequorum_finalize, :votequorum_finalize, [ :votequorum_handle_t ], :cs_error_t
+  attach_function :votequorum_dispatch, :votequorum_dispatch, [ :votequorum_handle_t, :cs_dispatch_flags_t ], :cs_error_t
+  attach_function :votequorum_fd_get, :votequorum_fd_get, [ :votequorum_handle_t, :pointer ], :cs_error_t
+  attach_function :votequorum_getinfo, :votequorum_getinfo, [ :votequorum_handle_t, :uint, VotequorumInfo.ptr ], :cs_error_t
+  attach_function :votequorum_setexpected, :votequorum_setexpected, [ :votequorum_handle_t, :uint ], :cs_error_t
+  attach_function :votequorum_setvotes, :votequorum_setvotes, [ :votequorum_handle_t, :uint, :uint ], :cs_error_t
+  attach_function :votequorum_trackstart, :votequorum_trackstart, [ :votequorum_handle_t, :uint64, :uint ], :cs_error_t
+  attach_function :votequorum_trackstop, :votequorum_trackstop, [ :votequorum_handle_t ], :cs_error_t
+  attach_function :votequorum_context_get, :votequorum_context_get, [ :votequorum_handle_t, :pointer ], :cs_error_t
+  attach_function :votequorum_context_set, :votequorum_context_set, [ :votequorum_handle_t, :pointer ], :cs_error_t
+  attach_function :votequorum_qdevice_register, :votequorum_qdevice_register, [ :votequorum_handle_t, :string ], :cs_error_t
+  attach_function :votequorum_qdevice_unregister, :votequorum_qdevice_unregister, [ :votequorum_handle_t, :string ], :cs_error_t
+  attach_function :votequorum_qdevice_update, :votequorum_qdevice_update, [ :votequorum_handle_t, :string, :string ], :cs_error_t
+  attach_function :votequorum_qdevice_poll, :votequorum_qdevice_poll, [ :votequorum_handle_t, :string, :uint ], :cs_error_t
+  attach_function :votequorum_qdevice_master_wins, :votequorum_qdevice_master_wins, [ :votequorum_handle_t, :string, :uint ], :cs_error_t
+
+end

data/lib/corosync.rb

@@ -1,6 +1,74 @@
 $:.unshift File.expand_path('../', __FILE__)
 require File.expand_path('../../ffi/common.rb', __FILE__)
-require 'version'
 
+require_relative './ffi_pointer.rb'
 module Corosync
+  VERSION = File.read(File.expand_path('../../VERSION', __FILE__)).chomp
+
+  require_relative 'corosync/exceptions'
+
+  # Calls a Corosync method and raises an exception on errors.
+  # This is a convenience method to handle error responses when calling various corosync library functions. When an error is returned, an exception is raised.
+  # The exceptions are programatically generated based off the `:cs_error_t` enum defined in `ffi/common.rb`. For example, `:err_try_again` maps to `Corosync::TryAgainError`.
+  #
+  # @param method [Symbol] name of the method to call
+  # @param args
+  #
+  # @return [TrueClass, Integer] Returns `true` on success, and an integer if the return value is not known (this should not happen unless you're running a newer version of corosync than the gem was released for).
+  def self.cs_send!(method, *args)
+    cs_error = nil
+
+    begin
+      cs_error = send(method, *args)
+    rescue Corosync::Error => e
+      e.depth += 1
+      raise e
+    end
+
+    return true if cs_error == :ok # short circuit the rest of the method since this should be true the majority of the time
+
+    if exception_class = Error::Map[cs_error] then
+      exception = exception_class.new("Received #{cs_error.to_s.upcase} during #{method}")
+      exception.depth = 1
+      raise exception
+    end
+
+    cs_error
+  end
+
+  # Calls a Corosync method and raises an exception on error while handling retries.
+  # This is the same as {cs_send!} except that on the event of TryAgainError, it retries for up to 3 seconds.
+  #
+  # @param method [Symbol] name of the method to call
+  # @param args
+  #
+  # @return [TrueClass, Integer] Returns `true` on success, and an integer if the return value is not known (this should not happen unless you're running a newer version of corosync than the gem was released for).
+  # @see cs_send!
+  def self.cs_send(method, *args)
+    cs_error = nil
+
+    time_start = Time.new.to_f
+    begin
+      begin
+        cs_error = send(method, *args)
+      rescue Corosync::Error => e
+        e.depth += 1
+        raise e
+      end
+
+      return true if cs_error == :ok # short circuit the rest of the method since this should be true the majority of the time
+
+      break if cs_error != :err_try_again
+      sleep 0.05
+    end while Time.new.to_f - time_start < 3
+
+    if exception_class = Error::Map[cs_error] then
+      exception = exception_class.new("Received #{cs_error.to_s.upcase} during #{method}")
+      exception.depth = 1
+      raise exception
+    end
+
+    cs_error
+  end
 end
+

data/lib/corosync/cmap.rb

@@ -0,0 +1,381 @@
+require File.expand_path('../../corosync.rb', __FILE__)
+require File.expand_path('../../../ffi/cmap.rb', __FILE__)
+
+# CMAP is used to access the corosync configuration database for the local node.
+# You can list keys, get/set/delete values, and watch for changes.
+#
+# Many of the methods take or return a 'type'. The type is a symbol for one of CMAP's supported types. The symbols are:
+# * :int8
+# * :uint8
+# * :int16
+# * :uint16
+# * :int32
+# * :uint32
+# * :int64
+# * :uint64
+# * :float
+# * :double
+# * :string
+#
+# ----
+#
+# @example
+#   require 'corosync/cmap'
+#   cmap = Corosync::CMAP.new(true)
+#   cmap.set('mykey.foo', :int32, -1234)
+#   puts "mykey.foo is #{cmap.get('mykey.foo')}"
+
+class Corosync::CMAP
+	# The IO object containing the file descriptor events and messages come across.
+	# You can use this to check for activity prior to calling {#dispatch}, but do not read anything from it.
+	# @return [IO]
+	attr_reader :fd
+
+	# Starts a new instance of CMAP.
+	# You can have as many instances as you like, but no real reason for more than one.
+	#
+	# @param connect [Boolean] Whether to automatically call {#connect}
+	def initialize(connect = true)
+		@handle = nil
+
+		@track_handle_callbacks = {}
+
+		self.connect if connect
+	end
+
+	# Connect to the CMAP service.
+	#
+	# @return [void]
+	def connect
+		handle_ptr = FFI::MemoryPointer.new(Corosync.find_type(:cmap_handle_t))
+
+		Corosync.cs_send(:cmap_initialize, handle_ptr)
+
+		@handle = handle_ptr.read_uint64
+
+		fd_ptr = FFI::MemoryPointer.new(:int)
+		Corosync.cs_send(:cmap_fd_get, @handle, fd_ptr)
+		@fd = IO.new(fd_ptr.read_int)
+	end
+
+	# Disconnect from the CMAP service.
+	#
+	# @return [void]
+	def finalize
+		return if @handle.nil?
+
+		Corosync.cs_send(:cmap_finalize, @handle)
+
+		@handle = nil
+		@fd = nil
+	end
+
+	# Retrieve a key by the specified name.
+	# Will raise {Corosync::NotExistError} if the key does not exist.
+	#
+	# @return [Array<type, value>] The type and value of the key
+	def get(name)
+		#TODO? make it just return nil if the key doesn't exist
+		size_ptr = FFI::MemoryPointer.new(:size_t)
+		type_ptr = FFI::MemoryPointer.new(Corosync.find_type(:cmap_value_types_t))
+
+		size = 256
+
+		begin
+			size_ptr.write_type(:size_t, size)
+			value_ptr = FFI::MemoryPointer.new(size)
+
+			Corosync.cs_send(:cmap_get, @handle, name, value_ptr, size_ptr, type_ptr)
+		rescue Corosync::InvalidParamError => e
+			# err_invalid_param is supposed to indicate our buffer was too small
+			value_ptr.free
+			size << 1
+			retry if size < 1024 ** 2 # 1 MB
+
+			raise e
+		end
+
+		type = type_ptr.read_type(Corosync.find_type(:cmap_value_types_t))
+		type = Corosync.enum_type(:cmap_value_types_t)[type]
+		if type == :binary then
+			raise RuntimeError, "Binary, not sure how to handle this. Corosync docs don't clearly indicate what it is"
+		end
+
+		[type, value_ptr.send("read_#{type}".downcase.to_sym)]
+	end
+
+	# Retrieve a key's value.
+	# This is just a conveinence wrapper around {#get} to only get the value if you don't want the type.
+	#
+	# @param name [String] The name of the key to look up
+	#
+	# @return [Number, String] The value of the key
+	def get_value(name)
+		type, value = get(name)
+		value
+	end
+
+	# Set a key to the specified type & value.
+	# This will create the key if it doesn't exist, and will otherwise modify it, including changing the type if it doesn't match.
+	#
+	# @param name [String] The name of the key
+	# @param type [Symbol] One of CMAP's supported types
+	# @param value [Number,String] The value to set
+	#
+	# @return [Number,String] The value as stored in the CMAP service. This will normally be the value passed in, but if you store a non-string as a string, the return will be the result of to_s
+	def set(name, type, value)
+		# get byte size
+		if type == :string then
+			size = value.bytesize
+		elsif SIZEMAP.keys.include?(type) then
+			size = SIZEMAP[type].bytes
+		elsif type == :float then
+			size = 4
+		elsif type == :double then
+			size = 8
+		elsif type == :binary then
+			size = value.bytesize
+		end
+
+		value_ptr = FFI::MemoryPointer.new(size)
+		value_ptr.write_type(type, value)
+		Corosync.cs_send(:cmap_set, @handle, name, value_ptr, size, type)
+
+		value
+	end
+
+	# @!visibility private
+	NumType = Struct.new(:min, :max, :bytes)
+	# @!visibility private
+	SIZEMAP = {
+		:int8 => NumType.new(-2 ** 7, 2 ** 7 - 1, 1),
+		:uint8 => NumType.new(0, 2 ** 8 - 1, 1),
+		:int16 => NumType.new(-2 ** 15, 2 ** 15 - 1, 2),
+		:uint16 => NumType.new(0, 2 ** 16 - 1, 2),
+		:int32 => NumType.new(-2 ** 31, 2 ** 31 - 1, 4),
+		:uint32 => NumType.new(0, 2 ** 32 - 1, 4),
+		:int64 => NumType.new(-2 ** 63, 2 ** 63 - 1, 8),
+		:uint64 => NumType.new(0, 2 ** 64 - 1, 8),
+	}
+	# Set a key to the specified value.
+	# A convenience wrapper around {#set} to automatically determine the type.
+	# If the value is numeric, we will use the same type as the existing value (if it already exists). Otherwise we pick the smallest type that will hold the value.
+	#
+	# @param name [String] The name of the key
+	# @param value [Number,String] The value to set
+	#
+	# @return [Number,String] The value as stored in the CMAP service. This will normally be the value passed in, but if you store a non-string as a string, the return will be the result of to_s
+	def set_value(name, value)
+		type = catch :type do
+			# strings are strings
+			throw :type, :string if value.is_a?(String)
+
+			# try and get existing type
+			begin
+				type_ptr = FFI::MemoryPointer.new(Corosync.find_type(:cmap_value_types_t))
+				size_ptr = FFI::MemoryPointer.new(:size_t)
+				Corosync.cs_send(:cmap_get, @handle, name, nil, size_ptr, type_ptr)
+				type = type_ptr.read_type(Corosync.find_type(:cmap_value_types_t))
+				type = Corosync.enum_type(:cmap_value_types_t)[type]
+				if SIZEMAP.keys.include(type) then
+					size = size_ptr.read_type(:size_t)
+					if size <= SIZEMAP[type].bytes then
+						# it fits within the existing type
+						throw :type, type
+					end
+					# it doesnt fit, we need to re-type it
+				end
+			rescue Corosync::NotExistError
+			end
+
+			# find the type that will fit
+			if value.is_a?(Float) then
+				type = :double
+			elsif value.is_a?(Numeric) then
+				if value.abs <= 2 ** 7 and value < 0 then
+					type = :int8
+				elsif value <= 2 ** 8 and value >= 0 then
+					type = :uint8
+				elsif value.abs <= 2 ** 15 and value < 0 then
+					type = :int16
+				elsif value <= 2 ** 16 and value >= 0 then
+					type = :uint16
+				elsif value.abs <= 2 ** 31 and value < 0 then
+					type = :int32
+				elsif value <= 2 ** 32 and value >= 0 then
+					type = :uint32
+				elsif value.abs <= 2 ** 63 and value < 0 then
+					type = :int64
+				elsif value < 2 ** 64 and value >= 0 then
+					type = :uint64
+				else
+					raise ArgumentError, "Corosync cannot handle numbers larger than 64-bit"
+				end
+
+				throw :type, type
+			end
+
+			# Unknown type, force it into a string
+			throw :type, :string
+		end
+
+		value = value.to_s if type == :string and !value.is_a?(String)
+
+		set(name, type, value)
+	end
+
+	# Delete the specified key.
+	#
+	# @param name [String] The name of the key
+	#
+	# @return [void]
+	def delete(name)
+		Corosync.cs_send(:cmap_delete, @handle, name)
+	end
+
+	# Decrement the specified key.
+	#
+	# @param name [String] The name of the key
+	#
+	# @return [void]
+	def dec(name)
+		Corosync.cs_send(:cmap_dec, @handle, name)
+	end
+
+	# Increment the specified key.
+	#
+	# @param name [String] The name of the key
+	#
+	# @return [void]
+	def inc(name)
+		Corosync.cs_send(:cmap_inc, @handle, name)
+	end
+
+	# Get a list of keys.
+	#
+	# @param prefix [String] Filter the list of keys to those starting with the specified prefix
+	#
+	# @return [Array<String>] List of matching key names
+	def keys(prefix = nil)
+		cmap_iteration_handle_ptr = FFI::MemoryPointer.new(Corosync.find_type(:cmap_iter_handle_t))
+		Corosync.cs_send(:cmap_iter_init, @handle, prefix, cmap_iteration_handle_ptr)
+		cmap_iteration_handle = cmap_iteration_handle_ptr.read_type(Corosync.find_type(:cmap_iter_handle_t))
+
+		keys = []
+
+		key_name_ptr = FFI::MemoryPointer.new(Corosync::CMAP_KEYNAME_MAXLEN)
+		begin
+			begin
+				loop do
+					Corosync.cs_send(:cmap_iter_next, @handle, cmap_iteration_handle, key_name_ptr, nil, nil)
+
+					# we really don't need to get info on the value. it doesn't help us any
+					#value_size = value_len_ptr.read_type(:size_t)
+					#value_type = value_type_ptr.read_type(Corosync.find_type(:cmap_value_types_t))
+					#value_type = Corosync.enum_type(:cmap_value_types_t)[value_type]
+					#keys[key_name_ptr.read_string] = Corosync::CMAP::ValueInfo.new(value_size, value_type)
+
+					keys << key_name_ptr.read_string
+				end
+			rescue Corosync::NoSectionsError
+				# signals end of iteration
+			end
+		ensure
+			Corosync.cs_send(:cmap_iter_finalize, @handle, cmap_iteration_handle)
+		end
+
+		keys
+	end
+
+	# Watch keys for changes.
+	# Calls a callback when the watched key(s) are changed.
+	#
+	# @param name [String] The specified key (or prefix)
+	# @param actions [Array<Symbol>] The operations to watch for
+	#   * :add - The key is added
+	#   * :delete - The key is deleted
+	#   * :modify - The value/type is changed
+	# @param prefix [Boolean] Whether to use the name as a prefix and watch all keys under it
+	# @param block [Proc] The callback to call when an event is triggered.
+	#
+	# @yieldparam action [Symbol] The action that triggered the callback (:add, :delete, :modify)
+	# @yieldparam key [String] The name of the key which changed
+	# @yieldparam value_new_type [Symbol] The type of the new value. +nil+ if just deleted
+	# @yieldparam value_new_data [Number,String] The new value. +nil+ if just deleted
+	# @yieldparam value_old_type [Symbol] The type of the old value. +nil+ if just created
+	# @yieldparam value_old_data [Number,String] The old value. +nil+ if just created
+	#
+	# @return [Object] The handle used to identify the track session. Pass to {#track_delete} to stop tracking.
+	def track_add(name, actions, prefix = false, &block)
+		cs_track_type = 0
+		cs_track_type |= Corosync::CMAP_TRACK_ADD if actions.include?(:add)
+		cs_track_type |= Corosync::CMAP_TRACK_DELETE if actions.include?(:delete)
+		cs_track_type |= Corosync::CMAP_TRACK_MODIFY if actions.include?(:modify)
+
+		cs_track_type |= Corosync::CMAP_TRACK_PREFIX if prefix
+
+		track_handle_ptr = FFI::MemoryPointer.new(Corosync.find_type(:cmap_track_handle_t))
+
+		@track_notify_method ||= self.method(:track_notify) # we have to keep it from being garbage collected
+		Corosync.cs_send(:cmap_track_add, @handle, name, cs_track_type, @track_notify_method, nil, track_handle_ptr)
+
+		track_handle = track_handle_ptr.read_type(Corosync.find_type(:cmap_track_handle_t))
+		@track_handle_callbacks[track_handle] = block
+
+		track_handle
+	end
+
+	# Stop watching for changes.
+	# @param track_handle [Number] The handle returned by {#track_add}
+	#
+	# @return [void]
+	def track_delete(track_handle)
+		@track_handle_callbacks.delete(track_handle)
+		Corosync.cs_send(:cmap_track_delete, @handle, track_handle)
+	end
+
+	# @!visibility private
+	# The callback called by the CMAP library.
+	def track_notify(handle, track_handle, event, key, value_new, value_old, user_data)
+		block = @track_handle_callbacks[track_handle]
+		raise RuntimeError, "Missing callback for track handle #{track_handle.inspect}" unless block # this should not have happened
+
+
+		action = {Corosync::CMAP_TRACK_ADD => :add, Corosync::CMAP_TRACK_DELETE => :delete, Corosync::CMAP_TRACK_MODIFY => :modify}[event]
+		if value_new[:type] != 0 then
+		#if !value_new.null? then
+			#value_new = Corosync::CmapNotifyValue.new(value_new)
+			value_new_type = value_new[:type]
+			value_new_data = value_new[:data].read_type(value_new_type)
+		end
+		if value_old[:type] != 0 then
+		#if !value_old.null? then
+			#value_old = Corosync::CmapNotifyValue.new(value_old)
+			value_old_type = value_old[:type]
+			value_old_data = value_old[:data].read_type(value_old_type)
+		end
+		block.call(action, key, value_new_type, value_new_data, value_old_type, value_old_data)
+	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!(:cmap_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
+end