corosync 0.0.1 → 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0ebdf0a21a91d835cd04ebbdccba82d69b791636
+  data.tar.gz: bfbc00cbe277b8bdf5fb7fc8f7e7f7286accd97b
+SHA512:
+  metadata.gz: 09db7ddafba097fde8bd040d98e667cb6f8b291020804d5c503334432c883c0792360547b66b9caa48204ee2e85131d96dafcbe8390cd12ce984245ea522d15b
+  data.tar.gz: 65a2cc445d24f1c7f3ac033cc485ba2457ba5e3460c237c30b30e06a3f17dc61f684990c18eaa65cd174360addc5e9456a9089efe0841a7abcd612988966881c

data/.gitignore

@@ -0,0 +1 @@
+.yardoc

data/Gemfile

@@ -0,0 +1,12 @@
+# A sample Gemfile
+source "https://rubygems.org"
+
+gem 'ffi'
+
+group :development do
+	gem 'ffi-swig-generator', :git => 'git://github.com/ffi/ffi-swig-generator.git'
+	gem 'rake', :require => false
+	gem 'yard'
+	gem 'rdoc'
+	gem 'rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,40 @@
+GIT
+  remote: git://github.com/ffi/ffi-swig-generator.git
+  revision: 818e921fc85aa58550c15e558af81edd1e8e9f69
+  specs:
+    ffi-swig-generator (0.3.3)
+      nokogiri (>= 1.6.0)
+      rake (>= 0.9.2.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.4)
+    ffi (1.9.0)
+    json (1.8.1)
+    mini_portile (0.5.2)
+    nokogiri (1.6.0)
+      mini_portile (~> 0.5.0)
+    rake (10.1.0)
+    rdoc (4.0.1)
+      json (~> 1.4)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.6)
+    rspec-expectations (2.14.3)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    yard (0.8.7.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ffi
+  ffi-swig-generator!
+  rake
+  rdoc
+  rspec
+  yard

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Patrick Hemmer <patrick.hemmer@gmail.com>
+
+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,34 @@
+# ruby-corosync
+
+## Description
+
+Ruby-corosync is a gem for interfacing ruby with the corosync cluster services.
+
+Corosync is a cluster communication engine for communication between nodes operating as a cluster. The services it offers are as follows:
+
+* **CPG** - The CPG service which allows sending messages between nodes. Processes can join a 'group' and broadcast messages to that group. Order is preserved in that messages are guaranteed to arrive in the same order to all members.
+* **SAM** - SAM is a service which is meant to ensure processes remain operational. You can instruct corosync to start a process, and should that process die, corosync can notify you, and start it back up.
+* **Quorum** - The quorum service is a very basic service used for keeping track of whether the cluster has quorum or not.
+* **Votequorum** - The votequorum service is a more powerful version of the quorum service. It allows you to control the number of votes provided by any one node such that you can control the logic that determines whether the cluster is quorate.
+* **CMAP** - CMAP is a key/value store. It allows you to store keys & their values, and subscribe to changes made to those keys.
+
+
+Corosync offers these services through a C API. This gem utilizes [ffi](http://github.com/ffi/ffi) to provide the interface to that API.
+
+## State
+
+Currently the only supported service is CPG. It is fully functional, though it may change as it is very young.
+
+## Examples
+
+### CPG
+
+    cpg = Corosync::CPG.new('mygroup')
+    cpg.on_message do |message, membership|
+      puts "Received #{message}"
+    end
+    puts "Member node IDs: #{cpg.members.map {|m| m.nodeid}.join(" ")}"
+    cpg.send "hello"
+    loop do
+      cpg.dispatch
+    end

data/Rakefile

@@ -0,0 +1,34 @@
+########################################
+desc "Create ffi/*.rb files"
+multitask :ffi
+
+file 'ffi/common.i' do # exempt 'ffi/common.i' from the service rule below
+end
+rule '.i' => [proc {'ffi/service.i.erb'}] do |t|
+	File.open(t.name, 'w') do |f|
+		puts "generating #{t.name}\n"
+		require 'erb'
+		service = t.name.split('/').last.split('.').first
+		erb = ERB.new(File.read("ffi/service.i.erb"), nil, '-')
+		f.write erb.result(binding)
+	end
+end
+rule '.rb' => ['.i'] do |t|
+	puts "generating #{t.name}\n"
+	xml = %x{swig -I/usr/include -xml -o /dev/stdout #{t.source}}
+	require 'ffi-swig-generator'
+	File.open(t.name, 'w') do |f|
+		f.write FFI::Generator::Parser.new.generate(Nokogiri::XML(xml))
+	end
+end
+
+corosync_services = ['cpg']
+multitask :ffi => ['ffi/common.rb'] + corosync_services.map{|s| "ffi/#{s}.rb"}
+
+########################################
+desc 'Run tests'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:test) do |t|
+	t.pattern = 'spec/**/*.rb'
+	t.rspec_opts = '-c -f d --fail-fast'
+end

data/corosync.gemspec

@@ -0,0 +1,13 @@
+require File.expand_path('../lib/version.rb', __FILE__)
+
+Gem::Specification.new 'corosync', Corosync::GEM_VERSION do |s|
+	s.description = 'An interface to the Corosync clustering services.'
+	s.summary = 'Corosync library interface'
+	s.homepage = 'http://github.com/phemmer/ruby-corosync/'
+	s.author = 'Patrick Hemmer'
+	s.email = 'patrick.hemmer@gmail.com'
+	s.license = 'MIT'
+	s.files = %x{git ls-files}.split("\n")
+
+	s.add_runtime_dependency 'ffi', '~> 1.9'
+end

data/examples/example.rb

@@ -0,0 +1,20 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'corosync/cpg'
+
+cpg = Corosync::CPG.new
+cpg.on_message do |message, nodeid, pid|
+	puts "MESSAGE: #{message.inspect}"
+end
+cpg.on_confchg do |member_list, left_list, joined_list|
+	puts "CONFCHG:"
+	puts "  MEMBER_LIST=#{member_list.inspect}"
+	puts "  LEFT_LIST=#{left_list.inspect}"
+	puts "  JOINED_LIST=#{joined_list.inspect}"
+end
+cpg.join('mygroup')
+cpg.send('my message')
+loop do
+	puts "MEMBERS=#{cpg.members.inspect}"
+	cpg.dispatch
+	puts "LOOP"
+end

data/ffi/common.i

@@ -0,0 +1,18 @@
+%module Corosync
+%{
+require 'ffi'
+
+module Corosync
+  extend FFI::Library
+  ffi_lib 'libcorosync_common'
+
+%}
+struct iovec /* from bits/uio.h */
+  {
+    void *iov_base;	/* Pointer to data.  */
+    size_t iov_len;	/* Length of data.  */
+  };
+%include <corosync/corotypes.h>
+%{
+end
+%}

data/ffi/common.rb

@@ -0,0 +1,120 @@
+
+require 'ffi'
+
+module Corosync
+  extend FFI::Library
+  ffi_lib 'libcorosync_common'
+
+  class Iovec < FFI::Struct
+    layout(
+           :iov_base, :pointer,
+           :iov_len, :uint
+    )
+  end
+  typedef :int64, :cs_time_t
+  CS_FALSE = 0
+  CS_TRUE = !0
+  CS_MAX_NAME_LENGTH = 256
+  class CsNameT < FFI::Struct
+    layout(
+           :length, :uint16,
+           :value, [:uint8, 256]
+    )
+  end
+  class CsVersionT < FFI::Struct
+    layout(
+           :releaseCode, :char,
+           :majorVersion, :uchar,
+           :minorVersion, :uchar
+    )
+  end
+  CS_DISPATCH_ONE = 1
+  CS_DISPATCH_ALL = 2
+  CS_DISPATCH_BLOCKING = 3
+  CS_DISPATCH_ONE_NONBLOCKING = 4
+  cs_dispatch_flags_t = enum :cs_dispatch_flags_t, [
+    :one, 1,
+    :all, 2,
+    :blocking, 3,
+    :one_nonblocking, 4,
+  ]
+
+  CS_TRACK_CURRENT = 0x01
+  CS_TRACK_CHANGES = 0x02
+  CS_TRACK_CHANGES_ONLY = 0x04
+  CS_OK = 1
+  CS_ERR_LIBRARY = 2
+  CS_ERR_VERSION = 3
+  CS_ERR_INIT = 4
+  CS_ERR_TIMEOUT = 5
+  CS_ERR_TRY_AGAIN = 6
+  CS_ERR_INVALID_PARAM = 7
+  CS_ERR_NO_MEMORY = 8
+  CS_ERR_BAD_HANDLE = 9
+  CS_ERR_BUSY = 10
+  CS_ERR_ACCESS = 11
+  CS_ERR_NOT_EXIST = 12
+  CS_ERR_NAME_TOO_LONG = 13
+  CS_ERR_EXIST = 14
+  CS_ERR_NO_SPACE = 15
+  CS_ERR_INTERRUPT = 16
+  CS_ERR_NAME_NOT_FOUND = 17
+  CS_ERR_NO_RESOURCES = 18
+  CS_ERR_NOT_SUPPORTED = 19
+  CS_ERR_BAD_OPERATION = 20
+  CS_ERR_FAILED_OPERATION = 21
+  CS_ERR_MESSAGE_ERROR = 22
+  CS_ERR_QUEUE_FULL = 23
+  CS_ERR_QUEUE_NOT_AVAILABLE = 24
+  CS_ERR_BAD_FLAGS = 25
+  CS_ERR_TOO_BIG = 26
+  CS_ERR_NO_SECTIONS = 27
+  CS_ERR_CONTEXT_NOT_FOUND = 28
+  CS_ERR_TOO_MANY_GROUPS = 30
+  CS_ERR_SECURITY = 100
+  cs_error_t = enum :cs_error_t, [
+    :ok, 1,
+    :err_library, 2,
+    :err_version, 3,
+    :err_init, 4,
+    :err_timeout, 5,
+    :err_try_again, 6,
+    :err_invalid_param, 7,
+    :err_no_memory, 8,
+    :err_bad_handle, 9,
+    :err_busy, 10,
+    :err_access, 11,
+    :err_not_exist, 12,
+    :err_name_too_long, 13,
+    :err_exist, 14,
+    :err_no_space, 15,
+    :err_interrupt, 16,
+    :err_name_not_found, 17,
+    :err_no_resources, 18,
+    :err_not_supported, 19,
+    :err_bad_operation, 20,
+    :err_failed_operation, 21,
+    :err_message_error, 22,
+    :err_queue_full, 23,
+    :err_queue_not_available, 24,
+    :err_bad_flags, 25,
+    :err_too_big, 26,
+    :err_no_sections, 27,
+    :err_context_not_found, 28,
+    :err_too_many_groups, 30,
+    :err_security, 100,
+  ]
+
+  CS_IPC_TIMEOUT_MS = -1
+  CS_TIME_MS_IN_SEC = 1000
+  CS_TIME_US_IN_SEC = 1000000
+  CS_TIME_NS_IN_SEC = 1000000000
+  CS_TIME_US_IN_MSEC = 1000
+  CS_TIME_NS_IN_MSEC = 1000000
+  CS_TIME_NS_IN_USEC = 1000
+  # inline function cs_timestamp_get
+  attach_function :qb_to_cs_error, :qb_to_cs_error, [ :int ], :cs_error_t
+  attach_function :cs_strerror, :cs_strerror, [ :cs_error_t ], :string
+  attach_function :hdb_error_to_cs, :hdb_error_to_cs, [ :int ], :cs_error_t
+
+end

data/ffi/cpg.i

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

data/ffi/cpg.rb

@@ -0,0 +1,127 @@
+
+require File.expand_path('../common.rb', __FILE__)
+
+module Corosync
+  extend FFI::Library
+  ffi_lib 'libcpg'
+
+  typedef :uint64, :cpg_handle_t
+  typedef :uint64, :cpg_iteration_handle_t
+  CPG_TYPE_UNORDERED = 0
+  CPG_TYPE_FIFO = CPG_TYPE_UNORDERED + 1
+  CPG_TYPE_AGREED = CPG_TYPE_FIFO + 1
+  CPG_TYPE_SAFE = CPG_TYPE_AGREED + 1
+  cpg_guarantee_t = enum :cpg_guarantee_t, [
+    :unordered,
+    :fifo,
+    :agreed,
+    :safe,
+  ]
+
+  CPG_FLOW_CONTROL_DISABLED = 0
+  CPG_FLOW_CONTROL_ENABLED = CPG_FLOW_CONTROL_DISABLED + 1
+  cpg_flow_control_state_t = enum :cpg_flow_control_state_t, [
+    :disabled,
+    :enabled,
+  ]
+
+  CPG_REASON_JOIN = 1
+  CPG_REASON_LEAVE = 2
+  CPG_REASON_NODEDOWN = 3
+  CPG_REASON_NODEUP = 4
+  CPG_REASON_PROCDOWN = 5
+  cpg_reason_t = enum :cpg_reason_t, [
+    :join, 1,
+    :leave, 2,
+    :nodedown, 3,
+    :nodeup, 4,
+    :procdown, 5,
+  ]
+
+  CPG_ITERATION_NAME_ONLY = 1
+  CPG_ITERATION_ONE_GROUP = 2
+  CPG_ITERATION_ALL = 3
+  cpg_iteration_type_t = enum :cpg_iteration_type_t, [
+    :name_only, 1,
+    :one_group, 2,
+    :all, 3,
+  ]
+
+  CPG_MODEL_V1 = 1
+  cpg_model_t = enum :cpg_model_t, [
+    :v1, 1,
+  ]
+
+  class CpgAddress < FFI::Struct
+    layout(
+           :nodeid, :uint32,
+           :pid, :uint32,
+           :reason, :uint32
+    )
+  end
+  CPG_MAX_NAME_LENGTH = 128
+  class CpgName < FFI::Struct
+    layout(
+           :length, :uint32,
+           :value, [:char, 128]
+    )
+  end
+  CPG_MEMBERS_MAX = 128
+  class CpgIterationDescriptionT < FFI::Struct
+    layout(
+           :group, CpgName,
+           :nodeid, :uint32,
+           :pid, :uint32
+    )
+  end
+  class CpgRingId < FFI::Struct
+    layout(
+           :nodeid, :uint32,
+           :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)
+  class CpgCallbacksT < FFI::Struct
+    layout(
+           :cpg_deliver_fn, :cpg_deliver_fn_t,
+           :cpg_confchg_fn, :cpg_confchg_fn_t
+    )
+  end
+  class CpgModelDataT < FFI::Struct
+    layout(
+           :model, :cpg_model_t
+    )
+  end
+  CPG_MODEL_V1_DELIVER_INITIAL_TOTEM_CONF = 0x01
+  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,
+           :flags, :uint
+    )
+  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_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
+  attach_function :cpg_context_set, :cpg_context_set, [ :cpg_handle_t, :pointer ], :cs_error_t
+  attach_function :cpg_dispatch, :cpg_dispatch, [ :cpg_handle_t, :cs_dispatch_flags_t ], :cs_error_t
+  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_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_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_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_finalize, :cpg_iteration_finalize, [ :cpg_iteration_handle_t ], :cs_error_t
+
+end

data/ffi/service.i.erb

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

data/lib/corosync/cpg/member.rb

@@ -0,0 +1,50 @@
+module Corosync
+	class CPG
+	end
+end
+
+class Corosync::CPG::Member
+	# @return [Integer] Node ID of the member
+	attr_reader :nodeid
+
+	# @return [Integer] Process ID of the member
+	attr_reader :pid
+
+	# @overload initialize(member)
+	#   @param member [FFI::Pointer<Corosync::CpgAddress>, Corosync::CpgAddress]
+	# @overload initialize(nodeid, pid)
+	#   @param nodeid [Integer]
+	#   @param pid [Integer]
+	def initialize(*args)
+		if args.size == 1 then
+			member = args.first
+
+			member = Corosync::CpgAddress.new(member) if member.is_a?(FFI::Pointer)
+			if member.is_a?(Corosync::CpgAddress) then
+				@nodeid = member[:nodeid]
+				@pid = member[:pid]
+			else
+				raise ArgumentError, "Invalid argument type"
+			end
+		elsif args.size == 2 then
+			@nodeid = args.shift.to_i
+			@pid = args.shift.to_i
+		else
+			raise ArgumentError, "wrong number of arguments (#{args.size} for 1..2)"
+		end
+	end
+
+	# @return [Boolean]
+	def ==(target)
+		self.class == target.class and @nodeid == target.nodeid and @pid == target.pid
+	end
+	alias_method :eql?, :==
+
+	def hash
+		[@nodid,@pid].hash
+	end
+
+	def to_s
+		"#{@nodeid}:#{@pid}"
+	end
+end

data/lib/corosync/cpg/member_list.rb

@@ -0,0 +1,99 @@
+require File.expand_path('../member.rb', __FILE__)
+
+module Corosync
+	class CPG
+	end
+end
+class Corosync::CPG::MemberList
+	include Enumerable
+
+	def self.new(*list)
+		# return the input list if we were passed a MemberList
+		return list[0] if list.size == 1 and list[0].is_a?(self)
+		super
+	end
+	def initialize(*list)
+		@list = {}
+
+		list = list[0] if list.size <= 1
+
+		if list.is_a?(Array) then
+			list.each do |recipient|
+				self << recipient
+			end
+		elsif list.is_a?(Corosync::CPG::Member) then
+			self << list
+		elsif list.nil? then
+			# nothing
+		else
+			raise ArgumentError, "Invalid recipient type: #{list.class}"
+		end
+	end
+
+	# Add a member to the list
+	# @param member [FFI::Pointer<Corosync::CpgAddress>,Corosync::CPG::Member] Member to add
+	def << (member)
+		if member.is_a?(FFI::Pointer) then
+			cpgaddress = Corosync::CpgAddress.new(member)
+			@list[Corosync::CPG::Member.new(cpgaddress)] = cpgaddress[:reason]
+		else
+			@list[member] = nil
+		end
+	end
+
+	# Number of members in list
+	# @return [Integer]
+	def size
+		@list.size
+	end
+
+	# Iterate over all the {Corosync::CPG::Member member} objects in the list.
+	# @param block [Proc]
+	# @yieldparam member [Corosync::CPG::Member]
+	def each(&block)
+		@list.each_key &block
+	end
+
+	# Get a list of all members also present in another list
+	# @param list [Corosync::CPG::MemberList]
+	# @return [Corosync::CPG::MemberList]
+	def &(list)
+		@list.keys & list.to_a
+	end
+
+	# Delete member from list
+	# @param member [Corosync::CPG::Member] Member to delete
+	# @return [void]
+	def delete(member)
+		@list.delete(member)
+	end
+
+	# Duplicate
+	# @return [Corosync::CPG::MemberList]
+	def dup
+		new = self.class.new
+		self.each do |member|
+			new << member.dup
+		end
+		new
+	end
+
+	# In the case of join/leave lists, this gets the reason a member is in the list.
+	# @param member [Corosync::CPG::Member] Member look up
+	# @return [Symbol, Integer, NilClass] Reason for the membership.
+	#   * :join => The member joined the group normally.
+	#   * :leave => The member left the group normally.
+	#   * :nodedown => The member left the group because the node left the cluster.
+	#   * :nodeup => The member joined the group because it was already a member of a group on a node that just joined the cluster.
+	#   * :procdown => The member left the group uncleanly (without calling {#leave})
+	def reason(member)
+		member = Corosync::CPG::Member.new if !member.is_a?(Corosync::CPG::Member)
+		@list[member]
+	end
+
+	# @return [Corosync::CPG::MemberList]
+	def freeze
+		@list.freeze
+		self
+	end
+end

data/lib/corosync/cpg.rb

@@ -0,0 +1,277 @@
+require File.expand_path('../../corosync.rb', __FILE__)
+require File.expand_path('../../../ffi/cpg.rb', __FILE__)
+
+require 'corosync/cpg/member_list'
+require 'corosync/cpg/member'
+
+# CPG is used for sending messages between processes (usually on multiple servers).
+# The benefits offered by CPG over normal IPC is that message order is guaranteed.
+# If you have 3 nodes, and both node 1 and node 2 send a message at the exact same time, all 3 nodes will receive the messages in the same order. One of the key details in this is that a node will also receive it's own message.
+# You can also be notified whenever nodes join or leave the group. The order of these messages is preserved as well.
+#
+# This is all done through callbacks. You define a block of code to execute, and whenever a message is received, it is passed to that block.  
+# After registering the callbacks, you call {#dispatch} to check for any pending messages, upon which the appropriate callbacks will be executed.
+#
+# The simplest usage of this library is to call `Corosync::CPG.new('groupname')`. This will connect to CPG and join the specified group. Note though that upon joining a group, the library automatically calls {#dispatch} once on it's own. This is so that it can get the initial confchg message and obtain a group membership list. As such you will not have been able to establish a callback yet. The solution to this is to create the CPG object without joining, register your callbacks, and then call {#join}.
+#
+# == Threading notice
+# With MRI Ruby 1.9.3 and older, you cannot call {#dispatch} from within a thread. Attempting to do so will result in a segfault.  
+# This is because the Corosync library allocates a very large buffer on the stack, and these versions of Ruby do not allocate enough memory to the thread stack.  
+# With MRI Ruby 2.0.0 the behavior is a bit different. There is a workaround, but without it, calling {#dispatch} will result in the thread hanging. The workaround is that you you can pass the environment variable RUBY_THREAD_MACHINE_STACK_SIZE to increase the size of the thread stack. The recommended size is 1572864.
+#
+# ----
+#
+# @example
+#   cpg = Corosync::CPG.new('mygroup')
+#   cpg.on_message do |message, member|
+#     puts "Received #{message}"
+#   end
+#   puts "Member node IDs: #{cpg.members.map {|m| m.nodeid}.join(" ")}"
+#   cpg.send "hello"
+#   loop do
+#     cpg.dispatch
+#   end
+
+class Corosync::CPG
+	# The IO object containing the file descriptor events and messages come across.
+	# You can use this to check for activity, but do not read anything from it.
+	# @return [IO]
+	attr_reader :fd
+
+	# Members currently in the group.
+	# @return [Corosync::CPG::MemberList]
+	attr_reader :members
+
+	# Name of the currently joined group
+	# @return [String]
+	attr_reader :group
+
+	# Creates a new CPG connection to the CPG service.  
+	# You can spawn as many connections as you like in a single process, but each connection can only belong to a single group.  
+	# If you get an *ERR_LIBRARY* error, corosync is likely not running.  
+	# If you get an *EACCESS* error, you're likely not running as root (or havent set a `uidgid` directive in the config).
+	#
+	# @param group [String] The name of the group to join. If not provided, you must call {#join} later.
+	#
+	# @return [void]
+	def initialize(group = nil)
+		# The model has to be preserved so it doesn't get garbage collected.
+		# Apparently CPG needs to reference it long after initialization :-(
+		#  (cpg.c:423)
+		@model = Corosync::CpgModelV1DataT.new
+		@model[:cpg_deliver_fn] = self.method(:callback_deliver)
+		@model[:cpg_confchg_fn] = self.method(:callback_confchg)
+		@model[:cpg_totem_confchg_fn] = self.method(:callback_totem_confchg)
+
+		@group = nil
+		@fd = nil
+		@handle = nil
+		@members = Corosync::CPG::MemberList.new
+
+		join group if group
+	end
+
+	# Connect to the CPG service.
+	# @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
+		@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
+		@fd = IO.new(fd_ptr.read_int)
+	end
+
+	# Shuts down the connection to the CPG service.
+	# @return [void]
+	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
+
+		@group = nil
+		@fd = nil
+		@model = nil
+		@handle = nil
+		@members = Corosync::CPG::MemberList.new
+
+		true
+	end
+	alias_method :close, :finalize
+
+	# Join the specified closed process group.  
+	# Note that the library will automatically make a call to {#dispatch} upon join. This is so that it can obtain a group membership list. If you wish to receive the initial join message, you must register the callback with {#on_confchg} before calling {#join}.
+	# @param name [String] Name of the group. Maximum length of 128 characters.
+	# @return [void]
+	def join(name)
+		connect if @handle.nil?
+
+		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
+
+		dispatch
+
+		@group = name
+
+		self
+	end
+
+	# Leave the current closed process group.
+	# @return [void]
+	def leave()
+		return if !@group
+		cpg_name = Corosync::CpgName.new
+		cpg_name[:value] = @group
+		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
+
+		@group = nil
+		@members = Corosync::CPG::MemberList.new
+	end
+
+	# Checks for a single pending events 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
+		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"
+		end
+		return true
+	end
+
+	# Proc to call when a message is received.
+	# @param block [Proc] Proc to call when a message is received. Pass +Nil+ to disable the callback.
+	# @yieldparam message [String] Message content.
+	# @yieldparam member [Corosync::CPG::Member] Member from which the message came
+	# @return [void]
+	def on_message(&block)
+		@callback_deliver = block
+	end
+	def callback_deliver(handle, group_name_p, nodeid, pid, message_p, message_len)
+		return if !@callback_deliver
+		message = message_p.read_bytes(message_len)
+		@callback_deliver.call(message, Corosync::CPG::Member.new(nodeid, pid))
+	end
+	private :callback_deliver
+
+	# Proc to call when a node joins/leaves the group.
+	# If this is set before calling {#join}, it will be called when joining the group.
+	# @param block [Proc] Proc to call when a node joins/leaves the group. Pass +Nil+ to disable the callback.
+	# @yieldparam member_list [Corosync::CPG::MemberList] Members in the group after the change completed.
+	# @yieldparam left_list [Corosync::CPG::MemberList] Members who left the group.
+	# @yieldparam joined_list [Corosync::CPG::MemberList] Members who joined the group.
+	# @return [void]
+	def on_confchg(&block)
+		@callback_confchg = block
+	end
+	def callback_confchg(handle, group_name_p, member_list_p, member_list_size, left_list_p, left_list_size, joined_list_p, joined_list_size)
+		member_list = Corosync::CPG::MemberList.new
+		member_list_size.times do |i|
+			member_list << (member_list_p + i * Corosync::CpgAddress.size)
+		end
+
+		@members = member_list.dup.freeze
+
+		return if !@callback_confchg # no point in continuing otherwise
+
+		left_list = Corosync::CPG::MemberList.new
+		left_list_size.times do |i|
+			left_list << (left_list_p + i * Corosync::CpgAddress.size)
+		end
+
+		joined_list = Corosync::CPG::MemberList.new
+		joined_list_size.times do |i|
+			joined_list << (joined_list_p + i * Corosync::CpgAddress.size)
+		end
+
+		@callback_confchg.call(member_list, left_list, joined_list)
+	end
+	private :callback_confchg
+
+	# Proc to call when a node joins/leaves the cluster.
+	# If this is set before calling {#connect} or {#join}, it will be called when connecting to the cluster.
+	# @param block [Proc] Proc to call when a node joins/leaves the cluster.
+	# @yieldparam ring_id [Integer] Ring ID change occurred on.
+	# @yieldparam member_list [Array<Integer>] Node ID of members in the cluster after the change completed.
+	# @return [void]
+	def on_totem_confchg(&block)
+		@callback_totem_confchg = block
+	end
+	def callback_totem_confchg(handle, ring_id, member_list_size, member_list_p)
+		return if !@callback_totem_confchg
+		member_list = member_list_size.times.collect do |i|
+			(member_list_p + i * Corosync.find_type(:uint32).size).read_uint32
+		end
+		@callback_totem_confchg.call(ring_id, member_list)
+	end
+	private :callback_totem_confchg
+
+	# The node ID of ourself.
+	# @!attribute nodeid [r]
+	# @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
+		nodeid_p.read_uint
+	end
+
+	# Returns the {Corosync::CPG::Member member} object describing ourself.
+	# @return [Corosync::CPG::Member]
+	def member
+		Corosync::CPG::Member.new(self.nodeid, $$)
+	end
+
+	# Send one or more messages to the group.
+	# Sending multiple messages through a single call to {#send} ensures that the messages will be delivered consecutively without another message in the middle.
+	# @param messages [Array<String>,String] The message(s) to send.
+	# @return [void]
+	def send(messages)
+		messages = [messages] if !messages.is_a?(Array)
+		
+		iovec_list_p = FFI::MemoryPointer.new(Corosync::Iovec, messages.size)
+		iovec_list = messages.size.times.collect do |i|
+			iovec = Corosync::Iovec.new(iovec_list_p + i * Corosync::Iovec.size)
+			message = messages[i].to_s
+			iovec[:iov_base] = FFI::MemoryPointer.from_string(message)
+			iovec[:iov_len] = message.size
+		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
+	end
+end

data/lib/corosync.rb

@@ -1,2 +1,6 @@
-require 'corosync/resource'
-require 'corosync/cluster'
+$:.unshift File.expand_path('../', __FILE__)
+require File.expand_path('../../ffi/common.rb', __FILE__)
+require 'version'
+
+module Corosync
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Corosync
+	GEM_VERSION = '0.0.2'
+end

data/spec/corosync/cpg/member.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Corosync::CPG::Member do
+	before(:all) do
+		@member1 = Corosync::CPG::Member.new(1001,20001)
+		@member2 = Corosync::CPG::Member.new(1001,20002)
+	end
+
+	it 'checks equality' do
+		member = Corosync::CPG::Member.new(1001,20001)
+
+		expect(member).to eq(@member1)
+		expect(member).not_to eq(@member2)
+	end
+
+	it 'hashes consistently' do
+		member = Corosync::CPG::Member.new(1001,20001)
+		
+		expect(member.hash).to eq(@member1.hash)
+	end
+
+	it 'converts to string' do
+		expect(@member1.to_s).to eq("1001:20001")
+	end
+
+	it 'has nodeid accessor' do
+		expect(@member1.nodeid).to eq(1001)
+	end
+
+	it 'has pid accessor' do
+		expect(@member1.pid).to eq(20001)
+	end
+
+	it 'can create from CpgAddress pointer' do
+		cpgaddress = Corosync::CpgAddress.new
+		cpgaddress[:nodeid] = 1001
+		cpgaddress[:pid] = 20001
+		member = Corosync::CPG::Member.new(cpgaddress.pointer)
+
+		expect(member).to eq(@member1)
+	end
+end

data/spec/corosync/cpg/member_list.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Corosync::CPG::MemberList do
+	before(:all) do
+		@list1 = Corosync::CPG::MemberList.new
+		@list1 << Corosync::CPG::Member.new(1000,20000)
+		@list1 << Corosync::CPG::Member.new(1001,20001)
+		@list1 << Corosync::CPG::Member.new(1002,20002)
+		@list1 << Corosync::CPG::Member.new(1003,20003)
+		@list1 << Corosync::CPG::Member.new(1004,20004)
+		@list2 = Corosync::CPG::MemberList.new
+		@list2 << Corosync::CPG::Member.new(1000,20010)
+		@list2 << Corosync::CPG::Member.new(1002,20002)
+		@list2 << Corosync::CPG::Member.new(1005,20005)
+	end
+
+	it 'knows its size' do
+		expect(@list1.size).to eq(5)
+	end
+
+	it 'ands the list' do
+		list = @list1 & @list2
+
+		expect(list.size).to eq(1)
+		expect(list).to include(Corosync::CPG::Member.new(1002,20002))
+	end
+
+	it 'dups the list' do
+		list = @list1.dup
+
+		expect(list.first).to eq(@list1.first)
+		expect(list.first.object_id).not_to eq(@list1.first.object_id)
+	end
+
+	it 'can check inclusion' do
+		target = Corosync::CPG::Member.new(1001,20001)
+
+		expect(@list1).to include(target)
+		expect(@list2).not_to include(target)
+	end
+
+	it 'adds a member' do
+		list = @list1.dup
+		target = Corosync::CPG::Member.new(1006,20006)
+		list << target
+
+		expect(list.size).to eq(@list1.size + 1)
+		expect(list).to include(target)
+	end
+
+	it 'deletes a member' do
+		list = @list1.dup
+		target = Corosync::CPG::Member.new(1001,20001)
+		list.delete(target)
+
+		expect(list.size).to eq(@list1.size - 1)
+		expect(list).not_to include(target)
+	end
+end

data/spec/corosync/cpg.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Corosync::CPG do
+	context '#initialize offline' do
+		before(:all) do
+			@cpg = Corosync::CPG.new
+		end
+
+		it 'creates a CPG object' do
+			expect(@cpg).to be_an_instance_of(Corosync::CPG)
+			expect(@cpg.fd).to be_nil
+		end
+
+		it 'connects' do
+			@cpg.connect
+
+			expect(@cpg.fd).to be_an_instance_of(IO)
+		end
+
+		it 'joins a group' do
+			group_name = "RSPEC-#{Random.rand(2 ** 32)}"
+			@cpg.join(group_name)
+
+			expect(@cpg.group).to eq(group_name)
+		end
+
+		it 'has ourself as a member' do
+			expect(@cpg.members).to include(@cpg.member)
+		end
+	end
+
+	context '#initialize with join' do
+		before(:all) do
+			@group_name = "RSPEC-#{Random.rand(2 ** 32)}"
+			@cpg = Corosync::CPG.new(@group_name)
+		end
+		it 'creates a CPG object and joins a group' do
+			expect(@cpg).to be_an_instance_of(Corosync::CPG)
+			expect(@cpg.fd).to be_an_instance_of(IO)
+			expect(@cpg.group).to eq(@group_name)
+		end
+
+		it 'has ourself as a member' do
+			expect(@cpg.members).to include(@cpg.member)
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+# we have to use the full path because rspec puts itself higher on the list, and we end up requiring `spec/corosync/cpg`
+require File.expand_path('../../lib/corosync/cpg', __FILE__)

metadata

@@ -1,47 +1,80 @@
 --- !ruby/object:Gem::Specification
 name: corosync
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 0.0.2
 platform: ruby
 authors:
-- Pavel Ivanov
+- Patrick Hemmer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-06 00:00:00.000000000 Z
-dependencies: []
-description: 
-email: ivpavig@gmail.com
+date: 2013-11-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+description: An interface to the Corosync clustering services.
+email: patrick.hemmer@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- corosync.gemspec
+- examples/example.rb
+- ffi/common.i
+- ffi/common.rb
+- ffi/cpg.i
+- ffi/cpg.rb
+- ffi/service.i.erb
 - lib/corosync.rb
-- lib/corosync/resource.rb
-- lib/corosync/cluster.rb
-homepage: 
-licenses: []
+- lib/corosync/cpg.rb
+- lib/corosync/cpg/member.rb
+- lib/corosync/cpg/member_list.rb
+- lib/version.rb
+- spec/corosync/cpg.rb
+- spec/corosync/cpg/member.rb
+- spec/corosync/cpg/member_list.rb
+- spec/spec_helper.rb
+homepage: http://github.com/phemmer/ruby-corosync/
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
-summary: A simple wrapper for corosync cmd tool 'crm'
+specification_version: 4
+summary: Corosync library interface
 test_files: []
+has_rdoc: 

data/lib/corosync/cluster.rb

@@ -1,105 +0,0 @@
-module Corosync
-  class Cluster
-    COMMAND = "crm"
-
-    def initialize
-      parse
-    end
-
-    def healthy
-      if @online.size < @nodes_configured
-        false
-      elsif @resources_started.size < @resources_configured
-        false
-      elsif @failed_actions.size != 0
-        false
-      else
-        true
-      end  
-    end
-
-    def health_description
-      description = ""
-      ok = healthy
-      
-      if ok
-        description += "OK"
-      else
-        description += "ERROR"
-      end
-      description += ", #{@nodes_configured} nodes configured"
-      if @online.size != 0
-        description += ", #{@online.size} nodes online #{@online.inspect}"
-      end
-      if !ok && @offline.size != 0
-        description += ", #{@offline.size} nodes offline #{@offline.inspect}"
-      end   
-      description += ", #{@resources_configured} resources configured"
-      if @resources_started.size != 0
-        description += ", #{@resources_started.size} resources started #{@resources_started.inspect}"
-      end
-      if !ok && @resources_stopped.size != 0
-        description += ", #{@resources_stopped.size} resources stopped #{@resources_stopped.inspect}"
-      end
-      if !ok && @failed_actions.size != 0
-        description += ", Failed actions #{@failed_actions.inspect}"
-      end
-      description.gsub("\"", "")
-    end
-
-    private
-
-    def parse
-      # get status info
-      cmd = COMMAND + " status"
-      output = `#{cmd}`
-
-      # parse output
-      @nodes_configured = []
-      if /(\d+) Nodes configured/.match(output)
-        @nodes_configured = Regexp.last_match[1].to_i 
-      else
-        raise "Can't parse output"
-      end
-
-      @resources_configured = []
-      if /(\d+) Resources configured/.match(output)
-        @resources_configured = Regexp.last_match[1].to_i
-      else
-        raise "Can't parse output"
-      end
-
-      @online = []
-      if /Online: \[ ([\w ]*) \]/.match(output)
-        @online = Regexp.last_match[1].split(' ')  
-      end
-
-      @offline = []
-      if /OFFLINE: \[ ([\w ]*) \]/.match(output)
-        @offline = Regexp.last_match[1].split(' ')  
-      end
-
-      raise "Can't parse output" if @online.empty? && @offline.empty?
-
-      @resources_started = []
-      @resources_stopped = []
-      resources = output.scan(/^\s*(\w+)\s*\([\w:]+\):\s*([\w ]*)$/)
-      resources.each do |res|
-        status = res[1].split(' ')
-        if status.include? 'Started'
-          @resources_started << res[0]
-        else
-          @resources_stopped << res[0]
-        end
-      end
-
-      raise "Can't parse output" if @resources_started.empty? && @resources_stopped.empty?
-
-      @failed_actions = []
-      if (/Failed actions:.*/m).match(output)
-        failed = Regexp.last_match[0].scan(/^\s+.*$/)
-        @failed_actions = failed.map { |e| e.lstrip }
-      end
-    end
-  end
-end

data/lib/corosync/resource.rb

@@ -1,34 +0,0 @@
-module Corosync
-  class Resource
-    COMMAND = "crm resource"
-    
-    attr_reader :status, :started_on, :started_locally
-
-    def initialize(name)
-      @name = name
-      parse
-    end
-
-    private
-
-    def parse
-      # get status info
-      cmd = COMMAND + " status #{@name}"
-      output = `#{cmd}`
-
-      # parse it
-      if output.include? "NOT running"
-        @status = "stopped"
-      elsif /is running on: (\w*)/.match(output)
-        @status = "started"
-        @started_on = Regexp.last_match[1]
-
-        # get hostname of the current machine
-        current_hostname = `hostname`.gsub!("\n", "")
-        @started_locally = @started_on == current_hostname 
-      else
-        raise "Can't parse output"
-      end
-    end  
-  end
-end