corosync-commander 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 90dec889b8284d9eacfcf3ad9fc2e30156790428
-  data.tar.gz: 8beb44d2adfb7f708b48e0f986f8e1e8c68300c5
+  metadata.gz: 0f9f90af1b3fac9c2164e54e664cae15be76ef65
+  data.tar.gz: ccddc4d241a87b80def6ce1ad6dae3073a520e5e
 SHA512:
-  metadata.gz: a65aa251126d8f329c7f9d125b9c4d7508270a5fedcf49e2b147612073ceadaddae4afc13683a4355ef6dd0a86830861f346a70c5f5df78f78c3505cec9a5671
-  data.tar.gz: 5ff4ac01de166776a97c30fa7a8d7f5338383bb927e89c2ea68964b06609a9969f1942f01ec044f2597473a67a0195154df7e618d783ffca5be34e70acaf4595
+  metadata.gz: 47de186e7ba2e4bfc304761b6e704f776ded20ab55d3428fdb5dbd5d5e886511fc80ee438003d357a269c5f66703f5c68142502507c38a6b0d55004ccccdf3c1
+  data.tar.gz: 47136a7dbb32771007e34f76a4ae86341b14d360b6cbfa7988e34c05533451961991c2564cce2bcf6da891190d3cbba17129c9f1017649066c472902223764ad

data/.gitignore

@@ -1 +1,2 @@
 *.gem
+.yardoc

data/Rakefile

@@ -2,6 +2,79 @@
 desc 'Run tests'
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:test) do |t|
+	ENV['RUBY_THREAD_MACHINE_STACK_SIZE'] = '1572864'
 	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
+	file = 'lib/version.rb'
+	const = 'CorosyncCommander::GEM_VERSION'
+
+	current_version = %x{ruby -e "require './#{file}'; puts #{const}"}.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
+
+		const_name = const.sub(/^.+:/, '')
+		new_file_content = ''
+		File.open(file, 'r') do |file|
+			file.each_line do |line|
+				new_file_content += line.sub(/(#{const_name}\s*=\s*['"])#{current_version}(['"])/, "\\1#{next_version}\\2")
+			end
+		end
+		File.open(file, 'w') do |file|
+			file.write new_file_content
+		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}' #{file}"
+
+		@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 tag #{spec.version}"
+	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/lib/corosync_commander/execution.rb

@@ -95,6 +95,9 @@ class CorosyncCommander::Execution
 		return if !@queue.is_a?(Queue) # we've called `clear`
 
 		while @pending_members.nil?
+			if Thread.current.object_id == @cc.dispatch_thread.object_id then
+				raise StandardError, "Deadlock! Can not call wait for responses on callback thread."
+			end
 			message = @queue.shift
 
 			next if message.type == 'leave' # we havent received the echo, so we dont care yet

data/lib/corosync_commander.rb

@@ -27,7 +27,7 @@ require File.expand_path('../corosync_commander/callback_list', __FILE__)
 #   hostnames = []
 #   begin
 #     enum.each do |response, node|
-#       hostname << response
+#       hostnames << response
 #     end
 #   rescue CorosyncCommander::RemoteException => e
 #     puts "Caught remote exception: #{e}"
@@ -51,6 +51,9 @@ class CorosyncCommander
 
 	attr_reader :execution_queues
 
+	# @!visibility private
+	attr_reader :dispatch_thread
+
 	# Creates a new instance and connects to CPG.
 	# If a group name is provided, it will join that group. Otherwise it will only connect. This is so that you can establish the command callbacks and avoid NotImplementedError exceptions
 	# @param group_name [String] Name of the group to join
@@ -63,6 +66,9 @@ class CorosyncCommander
 
 		@cpg_members = nil
 
+		@leader_pool = []
+		@leader_pool.extend(Sync_m)
+
 		# we can either share the msgid counter across all threads, or have a msgid counter on each thread and send the thread ID with each message. I prefer the former
 		@next_execution_id = 0
 		@next_execution_id_mutex = Mutex.new
@@ -127,31 +133,41 @@ class CorosyncCommander
 	def cpg_message(message, sender)
 		message = CorosyncCommander::Execution::Message.from_cpg_message(message, sender)
 
-		if sender == @cpg.member || message.recipients.include?(@cpg.member)
+		# This is the possible message classifications
+		# Command echo (potentially also a command to us)
+		# Response echo
+		# Command to us
+		# Response to us
+		# Command to someone else
+		# Response to someone else
+
+		if message.type == 'command' and sender == @cpg.member then
+			# It's a command echo
 			execution_queue = nil
 			@execution_queues.sync_synchronize(:SH) do
 				execution_queue = @execution_queues[message.execution_id]
 			end
 			if !execution_queue.nil? then
 				# someone is listening
-				if sender == @cpg.member and message.type == 'command' then
-					# the Execution object needs a list of the members at the time it's message was received
-					message_echo = message.dup
-					message_echo.type = 'echo'
-					message_echo.content = @cpg_members
-					execution_queue << message_echo
-				else
-					execution_queue << message
-				end
+				message_echo = message.dup
+				message_echo.type = 'echo'
+				message_echo.content = @cpg_members
+				execution_queue << message_echo
+			end
+		elsif message.type != 'command' and message.recipients.include?(@cpg.member) then
+			# It's a response to us
+			execution_queue = nil
+			@execution_queues.sync_synchronize(:SH) do
+				execution_queue = @execution_queues[message.execution_id]
+			end
+			if !execution_queue.nil? then
+				# someone is listening
+				execution_queue << message
 			end
 		end
 
-		if message.recipients.size > 0 and !message.recipients.include?(@cpg.member) then
-			return
-		end
-
-		if message.type == 'command' then
-			# we received a command from another node
+		if message.type == 'command' and (message.recipients.size == 0 or message.recipients.include?(@cpg.member)) then
+			# It's a command to us
 			begin
 				# see if we've got a registered callback
 				command_callback = nil
@@ -163,7 +179,7 @@ class CorosyncCommander
 				end
 
 				command_args = message.content[1]
-				reply_value = command_callback.call(*command_args)
+				reply_value = command_callback.call(message.sender, *command_args)
 				message_reply = message.reply(reply_value)
 				@cpg.send(message_reply)
 			rescue => e
@@ -178,6 +194,18 @@ class CorosyncCommander
 	def cpg_confchg(member_list, left_list, join_list)
 		@cpg_members = member_list
 
+		if leader_position == -1 then # this will only happen on join
+			@leader_pool.sync_synchronize(:EX) do
+				@leader_pool.replace(member_list.to_a)
+			end
+		elsif left_list.size > 0 then
+			@leader_pool.sync_synchronize(:EX) do
+				@leader_pool.delete_if {|m| left_list.include?(m)}
+			end
+		end
+
+		@confchg_callback.call(member_list, left_list, join_list) if @confchg_callback
+
 		# we look for any members leaving the cluster, and if so we notify all threads that are waiting for a response that they may have just lost a node
 		return if left_list.size == 0
 
@@ -194,6 +222,10 @@ class CorosyncCommander
 		end
 	end
 
+	def on_confchg(&block)
+		@confchg_callback = block
+	end
+
 	# @!attribute [r] commands
 	# @return [CorosyncCommander::CallbackList] List of command callbacks
 	def commands
@@ -230,4 +262,29 @@ class CorosyncCommander
 		end
 	end
 	private :execution_queue_finalizer
+
+	# Gets the member's position in the leadership queue.
+	# The leadership position is simply how many nodes currently in the group were in the group before we joined.
+	# @return [Integer]
+	def leader_position
+		@leader_pool.synchronize(:SH) do
+			@leader_pool.size - 1
+		end
+	end
+
+	# Indicates whether we are the group leader.
+	# If we are the leader, it means that we are the oldest member of the group.
+	# This is slightly different than just calling `leader_position == 0` in that if it is -1 (meaning we havent received the CPG confchg callback yet), we wait for the CPG join to complete.
+	# @return [Boolean]
+	def leader?
+		position = nil
+		loop do
+			position = leader_position
+			break if position != -1
+			Thread.pass # let the dispatch thread run so we can get our join message
+			# This isn't ideal as if the dispatch thread doesn't immediatly complete the join, we start spinning.
+			# But the only other way is to use condition variables, which combined with Sync_m, would just be really messy and stupidly complex (and I don't want to go to a plain mutex and lose the ability to use shared locks).
+		end
+		position == 0
+	end
 end

data/lib/version.rb

@@ -1,3 +1,3 @@
 class CorosyncCommander
-	GEM_VERSION = '0.0.1'
+	GEM_VERSION = '0.0.2'
 end

data/spec/corosync_commander.rb

@@ -2,22 +2,6 @@ require 'spec_helper'
 require 'timeout'
 
 describe CorosyncCommander do
-	def fork_execute(wait, cc_recip, command, *args)
-		recip = cc_recip.cpg.member
-		pid = fork do
-			cc = CorosyncCommander.new(cc_recip.cpg.group)
-			exe = cc.execute([recip], command, *args)
-			exe.wait
-			exit!(0)
-		end
-		if wait then
-			status = Process.wait2(pid)
-			status.exitstatus
-		else
-			pid
-		end
-	end
-
 	before(:all) do
 		Timeout.timeout(1) do
 			@cc = CorosyncCommander.new("CorosyncCommander RSPEC #{Random.rand(2 ** 32)}")
@@ -44,7 +28,7 @@ describe CorosyncCommander do
 	end
 
 	it 'registers a callback (block style)' do
-		@cc.commands.register 'summation' do |arg1,arg2|
+		@cc.commands.register 'summation' do |sender,arg1,arg2|
 			arg1 + arg2
 		end
 
@@ -52,7 +36,7 @@ describe CorosyncCommander do
 	end
 
 	it 'registers a callback (assignment style)' do
-		@cc.commands['summation'] = Proc.new do |arg1,arg2|
+		@cc.commands['summation'] = Proc.new do |sender,arg1,arg2|
 			arg1 + arg2
 		end
 		expect(@cc.commands['summation']).to be_a(Proc)
@@ -95,7 +79,7 @@ describe CorosyncCommander do
 			num1 = Random.rand(2 ** 32)
 			num2 = Random.rand(2 ** 32)
 
-			@cc.commands.register('summation2') do |number|
+			@cc.commands.register('summation2') do |sender,number|
 				sum += number
 			end
 
@@ -178,4 +162,21 @@ describe CorosyncCommander do
 			expect(responses.find_all{|r| r == 'OK'}.size).to eq(2)
 		end
 	end
+
+	it 'checks for leadership (true)' do
+		expect(@cc.leader?).to eq(true)
+	end
+
+	it 'checks for leadership (false)' do
+		forkpid = fork do
+			cc = CorosyncCommander.new(@cc.cpg.group)
+			if !cc.leader? then
+				exit 0 # we aren't a leader, as expected
+			end
+			exit 1 # something went wrong
+		end
+
+		status = Process.wait2(forkpid)
+		expect(status[1]).to eq(0)
+	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: corosync-commander
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Patrick Hemmer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-06 00:00:00.000000000 Z
+date: 2013-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: corosync