corosync 0.0.3 → 0.1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ec6cba2dc8f6d3d85accfe0821274b1bc3268e2a
-  data.tar.gz: 05257c44ede07405190a84caaf509be8216095d6
+  metadata.gz: d3b3eae3af47a1cbdf65addeeb1a19236e86836c
+  data.tar.gz: 70b0ad25954babd0459a34564688779de7aa5946
 SHA512:
-  metadata.gz: 16c7e8a4d0ac77525d5ba950d9f04b025d0424c07b39ba613ec70843f5ce80acf2eab56bc1762923fc5b0a22ad29710314553e8841322890338118755c12eebf
-  data.tar.gz: e818f76f4e96fa0bf648a62767c3ca7208646b36d319d4ae81c58d578a4a62a6c5fac6a08a22ed573e2994ba635c812a4b944f9b9749f75dd0382258a697bffe
+  metadata.gz: 0cc2801a58368731e1411b12f834980a90c9931df3e8c2c7d1b6ef9c79dcc840def720919f4d3b4db0c7890c070aa1cdacdfb1e371001a0c35cdbb20cff3b5f0
+  data.tar.gz: 88c1f83e655f0c8e30e723cc857a034f2d0296fc0e75b8371daec93e2e3bf4350746b9eab0eabf1981d2baf9beb176bf60ad7db4ea46700f33d988fe8bce5e3c

data/Gemfile.lock

@@ -1,6 +1,6 @@
 GIT
   remote: git://github.com/ffi/ffi-swig-generator.git
-  revision: 818e921fc85aa58550c15e558af81edd1e8e9f69
+  revision: b420db1b6f2b9530ed88fc641de350cac92d47ac
   specs:
     ffi-swig-generator (0.3.3)
       nokogiri (>= 1.6.0)
@@ -10,12 +10,12 @@ GEM
   remote: https://rubygems.org/
   specs:
     diff-lcs (1.2.4)
-    ffi (1.9.0)
+    ffi (1.9.3)
     json (1.8.1)
     mini_portile (0.5.2)
-    nokogiri (1.6.0)
+    nokogiri (1.6.1)
       mini_portile (~> 0.5.0)
-    rake (10.1.0)
+    rake (10.1.1)
     rdoc (4.0.1)
       json (~> 1.4)
     rspec (2.14.1)

data/README.md

@@ -10,26 +10,45 @@ Corosync is a cluster communication engine for communication between nodes opera
 * **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.
+* **CMAP** - CMAP is a key/value store of the Corosync configuration database. You can get/set keys/values and watch them for changes.
 
 
 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.
+CPG, Quorum, Votequorum, and CMAP are feature complete. Possibly with bugs, but I personally use CPG very heavily, along the basic features of Quorum and CMAP.
 
 ## Examples
 
-### CPG
+There are fully functional example scripts in the `examples` directory. But below are some brief snippets.
 
+### CPG
     require 'corosync/cpg'
     cpg = Corosync::CPG.new('mygroup')
-    cpg.on_message do |message, membership|
-      puts "Received #{message}"
+    cpg.on_message do |message, sender|
+      puts "Received #{message} from #{sender.nodeid}:#{sender.pid}"
     end
     puts "Member node IDs: #{cpg.members.map {|m| m.nodeid}.join(" ")}"
     cpg.send "hello"
     loop do
       cpg.dispatch
     end
+
+### CMAP
+    require 'corosync/cmap'
+    cmap = Corosync::CMAP.new
+    cmap.set('mykey.foo', :int32, -1234)
+    puts "mykey.foo is #{cmap.get('mykey.foo')}"
+
+
+## Contributions
+I welcome any contributions in the form of bugs or pull requests. One thing to be aware of in terms of new features is that the goal of this gem is to provide a low level interface to the Corosync library. Features which simplify or abstract things should be implemented as separate gems. For example, my own [corosync commander](http://github.com/phemmer/ruby-corosync-commander).
+
+
+## Versioning
+
+I use a slight variant of [semantic versioning](http://semver.org). The scheme is: DESIGN.MAJOR.MINOR.PATCH
+
+The DESIGN is used to indicate when not only is it no longer backwards compatable, but the fundamental design has changed. Meaning that it may take more than a little tweaking to accomidate for the changes. This should rarely, if ever, happen.

data/Rakefile

@@ -22,7 +22,7 @@ rule '.rb' => ['.i'] do |t|
 	end
 end
 
-corosync_services = ['cpg']
+corosync_services = ['cpg','quorum','votequorum', 'cmap']
 multitask :ffi => ['ffi/common.rb'] + corosync_services.map{|s| "ffi/#{s}.rb"}
 
 ########################################
@@ -32,3 +32,64 @@ RSpec::Core::RakeTask.new(:test) do |t|
 	t.pattern = 'spec/**/*.rb'
 	t.rspec_opts = '-c -f d --fail-fast'
 end
+
+########################################
+@gemspec_file = Dir.glob('*.gemspec').first
+def spec
+	require 'rubygems' unless defined? Gem::Specification
+	@spec ||= eval(File.read(@gemspec_file))
+end
+
+desc 'Bump version'
+task 'version' do
+	current_version = File.read('VERSION').chomp
+	current_version_commit = %x{git rev-parse --verify #{current_version} 2>/dev/null}.chomp
+	current_head_commit = %x{git rev-parse HEAD}.chomp
+	if current_version_commit != '' and current_version_commit != current_head_commit then
+		# there have been commits since the current version
+
+		next_version = current_version.split('.')
+		next_version[-1] = next_version.last.to_i + 1
+		next_version = next_version.join('.')
+		print "Next version? (#{next_version}): "
+		response = STDIN.gets.chomp
+		if response != '' then
+			raise StandardError, "Not a valid version" unless response.match(/^[0-9\.]+$/)
+			next_version = response
+		end
+
+		File.open('VERSION', 'w') do |file|
+			file.puts next_version
+		end
+		message = %x{git log #{current_version_commit}..HEAD --pretty=format:'* %s%n  %an (%ai) - @%h%n'}.gsub(/'/, "'\\\\''")
+
+		sh "git commit -m 'Version: #{next_version}\n\n#{message}' VERSION"
+		sh "git tag #{next_version}"
+
+		@spec = nil
+	end
+end
+
+desc 'Build gem file'
+task 'build' do
+	sh "gem build #{@gemspec_file}"
+end
+
+desc 'Publish gem file'
+task 'publish' do
+	gem_file = "#{spec.name}-#{spec.version}.gem"
+	sh "git push"
+	sh "gem push #{gem_file}"
+end
+
+desc 'Release a new version'
+task 'release' do
+	raise StandardError, "Not on master branch" if %x{git rev-parse --abbrev-ref HEAD}.chomp != "master"
+	raise StandardError, "Uncommitted files" if %x{git status --porcelain}.chomp.size != 0
+
+	[:test, :version, :build, :publish].each do |task|
+		puts "# #{task}\n"
+		Rake::Task[task].execute
+		puts "\n"
+	end
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0.0

data/corosync.gemspec

@@ -1,6 +1,4 @@
-require File.expand_path('../lib/version.rb', __FILE__)
-
-Gem::Specification.new 'corosync', Corosync::GEM_VERSION do |s|
+Gem::Specification.new 'corosync', File.read('VERSION').chomp do |s|
 	s.description = 'An interface to the Corosync clustering services.'
 	s.summary = 'Corosync library interface'
 	s.homepage = 'http://github.com/phemmer/ruby-corosync/'

data/examples/cmap-cli.rb

@@ -0,0 +1,72 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'corosync/cmap'
+
+def list
+  cmap = Corosync::CMAP.new(true)
+
+  cmap.keys.each do |key|
+    type, value = cmap.get(key)
+    puts "#{key} (#{type}) = #{value.inspect}"
+  end
+end
+def get(key)
+  cmap = Corosync::CMAP.new(true)
+
+  type, value = cmap.get(key)
+  puts "#{key} (#{type}) = #{value.inspect}"
+end
+def set(key, type, value)
+  cmap = Corosync::CMAP.new(true)
+
+  if type == 'float' or type == 'double' then
+    value = value.to_f
+  elsif type.match(/^u?int(8|16|32|64)$/) then
+    value = value.to_i
+  end
+
+  cmap.set(key, type.to_sym, value)
+end
+def delete(key)
+  cmap = Corosync::CMAP.new(true)
+
+  cmap.delete(key)
+end
+def inc(key)
+  cmap = Corosync::CMAP.new(true)
+
+  cmap.inc(key)
+end
+def dec(key)
+  cmap = Corosync::CMAP.new(true)
+
+  cmap.dec(key)
+end
+def track(key)
+  cmap = Corosync::CMAP.new(true)
+
+  cmap.track_add(key, [:add, :delete, :modify]) do |action, key, value_type, value, value_old_type, value_old|
+    puts "action=#{action.inspect} key=#{key.inspect} value_type=#{value_type.inspect} value=#{value.inspect} value_old_type=#{value_old_type.inspect} value_old=#{value_old.inspect}"
+  end
+
+  loop do
+    cmap.dispatch
+  end
+end
+
+args = ARGV.dup
+action = args.shift
+if action == 'list' then
+  list(*args)
+elsif action == 'get' then
+  get(*args)
+elsif action == 'set' then
+  set(*args)
+elsif action == 'delete' then
+  delete(*args)
+elsif action == 'inc' then
+  inc(*args)
+elsif action == 'dec' then
+  dec(*args)
+elsif action == 'track' then
+  track(*args)
+end

data/examples/cpg-chat.rb

@@ -0,0 +1,75 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'corosync/cpg'
+require 'json'
+
+require 'zlib'
+def makeid(member)
+  Zlib::crc32("#{member.nodeid} #{member.pid}").to_s(36)
+end
+
+names = {}
+
+cpg = Corosync::CPG.new
+cpg.on_message do |message, sender|
+  id = makeid(sender)
+  message = JSON.parse(message)
+  if message['type'] == 'name' then
+    $stdout.puts "! #{names[id] || id} is now known as #{message['data']}" if names[id] != message['data']
+    names[id] = message['data']
+  elsif message['type'] == 'text' then
+    name = names[id] || id
+    $stdout.puts "#{name}: #{message['data']}"
+  end
+end
+
+cpg.on_confchg do |member_list, left_list, join_list|
+  if join_list.include?(cpg.member) then
+    # we just joined the cluster
+    other_list = member_list.to_a - [cpg.member]
+    $stdout.puts "! we joined the cluster. Our name: #{makeid(cpg.member)}. Other members: #{other_list.map{|m| makeid(m)}.join(', ')}"
+  elsif join_list.size > 0 then
+    # someone else joined the cluster
+    join_list.each do |m|
+      id = makeid(m)
+      $stdout.puts "! #{names[id] || id} joined the cluster"
+      names.delete(m)
+    end
+
+    # send our name if we have one
+    id = makeid(cpg.member)
+    cpg.send({'type' => 'name', 'data' => names[id]}.to_json) if names[id]
+  end
+  left_list.each do |m|
+    id = makeid(m)
+    $stdout.puts "! #{names[id] || id} left the cluster"
+    names.delete(m)
+  end
+end
+
+cpg.join($0)
+
+ios = [$stdin, cpg.fd]
+inbuf = ''
+while ios.size > 0 do
+  ios_ready = IO.select(ios)
+  if ios_ready[0].include?(cpg.fd) then
+    cpg.dispatch
+  end
+  if ios_ready[0].include?($stdin) then
+    inbuf << $stdin.read_nonblock(1024)
+    while line = inbuf.slice!(/^(.*)#{$/}/) do
+      if line.match(/^\/name (.+)/) then
+        cpg.send({'type' => 'name', 'data' => $1}.to_json)
+      elsif line.match(/^\/names/) then
+        members = []
+        cpg.members.each do |m|
+          id = makeid(m)
+          members << (names[id] || id)
+        end
+        $stdout.puts "! names: #{members.join(', ')}"
+      else
+        cpg.send({'type' => 'text', 'data' => line}.to_json)
+      end
+    end
+  end
+end

data/examples/{example.rb → cpg-monitor.rb}

@@ -2,7 +2,7 @@ $:.unshift(File.expand_path('../../lib', __FILE__))
 require 'corosync/cpg'
 
 cpg = Corosync::CPG.new
-cpg.on_message do |message, nodeid, pid|
+cpg.on_message do |message, sender|
 	puts "MESSAGE: #{message.inspect}"
 end
 cpg.on_confchg do |member_list, left_list, joined_list|

data/ffi/cmap.i

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

data/ffi/cmap.rb

@@ -0,0 +1,91 @@
+
+require File.expand_path('../common.rb', __FILE__)
+
+module Corosync
+  extend FFI::Library
+  ffi_lib 'libcmap'
+
+  typedef :uint64, :cmap_handle_t
+  typedef :uint64, :cmap_iter_handle_t
+  typedef :uint64, :cmap_track_handle_t
+  CMAP_KEYNAME_MAXLEN = 255
+  CMAP_KEYNAME_MINLEN = 3
+  CMAP_TRACK_ADD = 4
+  CMAP_TRACK_DELETE = 1
+  CMAP_TRACK_MODIFY = 2
+  CMAP_TRACK_PREFIX = 8
+  CMAP_VALUETYPE_INT8 = 1
+  CMAP_VALUETYPE_UINT8 = 2
+  CMAP_VALUETYPE_INT16 = 3
+  CMAP_VALUETYPE_UINT16 = 4
+  CMAP_VALUETYPE_INT32 = 5
+  CMAP_VALUETYPE_UINT32 = 6
+  CMAP_VALUETYPE_INT64 = 7
+  CMAP_VALUETYPE_UINT64 = 8
+  CMAP_VALUETYPE_FLOAT = 9
+  CMAP_VALUETYPE_DOUBLE = 10
+  CMAP_VALUETYPE_STRING = 11
+  CMAP_VALUETYPE_BINARY = 12
+  cmap_value_types_t = enum :cmap_value_types_t, [
+    :int8, 1,
+    :uint8, 2,
+    :int16, 3,
+    :uint16, 4,
+    :int32, 5,
+    :uint32, 6,
+    :int64, 7,
+    :uint64, 8,
+    :float, 9,
+    :double, 10,
+    :string, 11,
+    :binary, 12,
+  ]
+
+  class CmapNotifyValue < FFI::Struct
+    layout(
+           :type, :cmap_value_types_t,
+           :len, :size_t,
+           :data, :pointer
+    )
+  end
+  Callback_cmap_notify_fn_t = callback(:cmap_notify_fn_t, [ :cmap_handle_t, :cmap_track_handle_t, :int32, :string, CmapNotifyValue.by_value, CmapNotifyValue.by_value, :pointer ], :void)
+  attach_function :cmap_initialize, :cmap_initialize, [ :pointer ], :cs_error_t
+  attach_function :cmap_finalize, :cmap_finalize, [ :cmap_handle_t ], :cs_error_t
+  attach_function :cmap_fd_get, :cmap_fd_get, [ :cmap_handle_t, :pointer ], :cs_error_t
+  attach_function :cmap_dispatch, :cmap_dispatch, [ :cmap_handle_t, :cs_dispatch_flags_t ], :cs_error_t
+  attach_function :cmap_context_get, :cmap_context_get, [ :cmap_handle_t, :pointer ], :cs_error_t
+  attach_function :cmap_context_set, :cmap_context_set, [ :cmap_handle_t, :pointer ], :cs_error_t
+  attach_function :cmap_set, :cmap_set, [ :cmap_handle_t, :string, :pointer, :size_t, :cmap_value_types_t ], :cs_error_t
+  attach_function :cmap_set_int8, :cmap_set_int8, [ :cmap_handle_t, :string, :int8 ], :cs_error_t
+  attach_function :cmap_set_uint8, :cmap_set_uint8, [ :cmap_handle_t, :string, :uint8 ], :cs_error_t
+  attach_function :cmap_set_int16, :cmap_set_int16, [ :cmap_handle_t, :string, :int16 ], :cs_error_t
+  attach_function :cmap_set_uint16, :cmap_set_uint16, [ :cmap_handle_t, :string, :uint16 ], :cs_error_t
+  attach_function :cmap_set_int32, :cmap_set_int32, [ :cmap_handle_t, :string, :int32 ], :cs_error_t
+  attach_function :cmap_set_uint32, :cmap_set_uint32, [ :cmap_handle_t, :string, :uint32 ], :cs_error_t
+  attach_function :cmap_set_int64, :cmap_set_int64, [ :cmap_handle_t, :string, :int64 ], :cs_error_t
+  attach_function :cmap_set_uint64, :cmap_set_uint64, [ :cmap_handle_t, :string, :uint64 ], :cs_error_t
+  attach_function :cmap_set_float, :cmap_set_float, [ :cmap_handle_t, :string, :float ], :cs_error_t
+  attach_function :cmap_set_double, :cmap_set_double, [ :cmap_handle_t, :string, :double ], :cs_error_t
+  attach_function :cmap_set_string, :cmap_set_string, [ :cmap_handle_t, :string, :string ], :cs_error_t
+  attach_function :cmap_delete, :cmap_delete, [ :cmap_handle_t, :string ], :cs_error_t
+  attach_function :cmap_get, :cmap_get, [ :cmap_handle_t, :string, :pointer, :pointer, :pointer ], :cs_error_t
+  attach_function :cmap_get_int8, :cmap_get_int8, [ :cmap_handle_t, :string, :pointer ], :cs_error_t
+  attach_function :cmap_get_uint8, :cmap_get_uint8, [ :cmap_handle_t, :string, :pointer ], :cs_error_t
+  attach_function :cmap_get_int16, :cmap_get_int16, [ :cmap_handle_t, :string, :pointer ], :cs_error_t
+  attach_function :cmap_get_uint16, :cmap_get_uint16, [ :cmap_handle_t, :string, :pointer ], :cs_error_t
+  attach_function :cmap_get_int32, :cmap_get_int32, [ :cmap_handle_t, :string, :pointer ], :cs_error_t
+  attach_function :cmap_get_uint32, :cmap_get_uint32, [ :cmap_handle_t, :string, :pointer ], :cs_error_t
+  attach_function :cmap_get_int64, :cmap_get_int64, [ :cmap_handle_t, :string, :pointer ], :cs_error_t
+  attach_function :cmap_get_uint64, :cmap_get_uint64, [ :cmap_handle_t, :string, :pointer ], :cs_error_t
+  attach_function :cmap_get_float, :cmap_get_float, [ :cmap_handle_t, :string, :pointer ], :cs_error_t
+  attach_function :cmap_get_double, :cmap_get_double, [ :cmap_handle_t, :string, :pointer ], :cs_error_t
+  attach_function :cmap_get_string, :cmap_get_string, [ :cmap_handle_t, :string, :pointer ], :cs_error_t
+  attach_function :cmap_inc, :cmap_inc, [ :cmap_handle_t, :string ], :cs_error_t
+  attach_function :cmap_dec, :cmap_dec, [ :cmap_handle_t, :string ], :cs_error_t
+  attach_function :cmap_iter_init, :cmap_iter_init, [ :cmap_handle_t, :string, :pointer ], :cs_error_t
+  attach_function :cmap_iter_next, :cmap_iter_next, [ :cmap_handle_t, :cmap_iter_handle_t, :pointer, :pointer, :pointer ], :cs_error_t
+  attach_function :cmap_iter_finalize, :cmap_iter_finalize, [ :cmap_handle_t, :cmap_iter_handle_t ], :cs_error_t
+  attach_function :cmap_track_add, :cmap_track_add, [ :cmap_handle_t, :string, :int32, Callback_cmap_notify_fn_t, :pointer, :pointer ], :cs_error_t
+  attach_function :cmap_track_delete, :cmap_track_delete, [ :cmap_handle_t, :cmap_track_handle_t ], :cs_error_t
+
+end

data/ffi/common.rb

@@ -8,7 +8,7 @@ module Corosync
   class Iovec < FFI::Struct
     layout(
            :iov_base, :pointer,
-           :iov_len, :uint
+           :iov_len, :size_t
     )
   end
   typedef :int64, :cs_time_t