infopark-politics 0.8.4 → 0.9.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    M2Y0YWFlODFhZTgwYzc3Nzc1NTI5ZGJkNjEwOGRkNzFiMmE2YzFkOQ==
+    ZTc2ZjhmOTAwNTNjNTNlYWExZjAwM2Y5ZDY0ZDQ4NmViOGVmNjNkZg==
   data.tar.gz: !binary |-
-    MzdhYzlhN2E0YzYxMmMyMjJkMWM4NTAyZTc5MWRjMzFkNDgyOWFiZg==
+    OGEyNjc2N2IwYjcyZjU3NDFiYWE4ZDY2N2Q4NDhjYzIxZDRlMDc1Ng==
 SHA512:
   metadata.gz: !binary |-
-    N2IwOTBjNjljOWNhOTI4N2I5OTY4MWNhMDI0ZjQ4ZGYyMzA3ZjM5YjAyMDJi
-    ZDU3MTU0OTQ1YWUzOGQ5Y2ZkYmNkYTg4ZGQwZmZhNDA0NGY1MjY3ODhkZTgz
-    MTcyYjQ4Mzk5Zjg5MDU3MzIzMDdjOWM3ZjM0NmJkYTI1MzJhOGE=
+    ZmQ0YjM2NzU1YzY0ZjQ3ZWZlOWY5MjE0ZDg1ZTIwMTE1ZjE4OTVjNTE5NmYw
+    ZWQ1ODZiOWFiOWE0NTE3M2RiZjgxYzJhMThiMDJiYzQxZjU5NTQwYWM3OTVi
+    MzlmYTEzODM2Yzg0ZjljMTFlNTc5NWViZTUxZmZiZDkxOGQ1OTY=
   data.tar.gz: !binary |-
-    NDFlODU5NTVmYzE2YzRlMGFlNjdmZjAwMDY5Y2E0MGVkNTEzNzNiZTMzOTY0
-    Y2U3ZTUzMmFjYWZiOGMyNWU2YTRkY2VkMWQ1MDc1Y2I4ZGY1MTdmNDRiMzcy
-    NDQ2YTVhODVmNWUzMDRhMWI5NWY1ZmM2MTU3YmM5ZmQxMDg4MzM=
+    M2JlY2ExN2NiMmZhYWU3MjI0ZjYyMWRiMDljOWY5ZmQ5ZWRhYTBiNmZiNGRk
+    NzZjMTAyMmRiYTYyNGI5ZTJlODNiZjdmNjMzNzU5NjE1Zjc1NzZiYmFlYWMz
+    YTk0YmIzY2E1OWJlMTFlNzM2YWNmMTViMjJkNjhhN2UzNmZhMWQ=

data/infopark-politics.gemspec

@@ -6,7 +6,7 @@ end
 
 Gem::Specification.new do |gem|
   gem.name = "infopark-politics"
-  gem.version = "0.8.4"
+  gem.version = "0.9.0"
   gem.summary = "Algorithms and Tools for Distributed Computing in Ruby."
   gem.description = ""
   gem.authors = ["Mike Perham", "Tilo Prütz"]

data/lib/politics/static_queue_worker.rb

@@ -19,7 +19,7 @@ module Politics
 
       @group_name = name
       @iteration_length = options[:iteration_length]
-      @memcache_client = client_for(Array(options[:servers]))
+      @memcache_config = Array(options[:servers])
       @dictatorship_length = options[:dictatorship_length]
 
       @buckets = []
@@ -30,7 +30,7 @@ module Politics
       log.progname = uri
       log.info { "Registered in group #{group_name} at #{uri}" }
       at_exit do
-        internal_cleanup
+        internal_cleanup(client_for(memcache_config))
         cleanup
       end
     end
@@ -39,10 +39,11 @@ module Politics
     def process_bucket(&block)
       log.debug "start bucket processing"
       raise ArgumentError, "process_bucket requires a block!" unless block_given?
-      unless memcache_client
+      unless memcache_config
         raise ArgumentError, "You must call register_worker before processing!"
       end
 
+      worker_memcache_client = client_for(memcache_config)
       begin
         begin
           raise "self is not alive via drb" unless DRbObject.new(nil, uri).alive?
@@ -50,20 +51,21 @@ module Politics
           raise "cannot reach self via drb: #{e.message}"
         end
         begin
-          nominate
+          nominate(worker_memcache_client)
 
-          if leader? && !(@leader_thread && @leader_thread.alive?)
+          if leader?(worker_memcache_client) && !(@leader_thread && @leader_thread.alive?)
             unless (@leader_thread && @leader_thread.alive?)
               @leader_thread = Thread.new do
-                perform_leader_duties
+                leader_memcache_client = client_for(memcache_config)
+                perform_leader_duties(leader_memcache_client)
               end
             end
           end
 
           # Get a bucket from the leader and process it
           begin
-            log.debug "getting bucket request from leader (#{leader_uri}) and processing it"
-            bucket_process(*leader.bucket_request(uri, bucket_request_context), &block)
+            log.debug "getting bucket request from leader (#{leader_uri(worker_memcache_client)}) and processing it"
+            bucket_process(*leader(worker_memcache_client).bucket_request(uri, bucket_request_context), &block)
           rescue DRb::DRbError => dre
             log.error { "Error talking to leader: #{dre.message}" }
             relax until_next_iteration
@@ -75,44 +77,44 @@ module Politics
       end while loop?
     end
 
-    def as_dictator(&block)
+    def as_dictator(memcache_client, &block)
       duration = dictatorship_length || (iteration_length * 10)
       log.debug { "become dictator for up to #{duration} seconds" }
-      seize_leadership duration
+      seize_leadership(memcache_client, duration)
       yield
-      raise "lost leadership while being dictator for #{duration} seconds" unless leader?
-      seize_leadership
+      raise "lost leadership while being dictator for #{duration} seconds" unless leader?(memcache_client)
+      seize_leadership(memcache_client)
     end
 
-    def seize_leadership(*args)
+    def seize_leadership(memcache_client, *args)
       start_iteration(*args) {|duration| memcache_client.set(token, uri, duration) }
     end
 
-    def perform_leader_duties
+    def perform_leader_duties(memcache_client)
       with_errors_logged('leader duties') do
         # The DRb thread handles the requests to the leader.
         # This method performs the bucket managing.
         log.info { "has been elected leader" }
         before_perform_leader_duties
         # keeping leader state as long as buckets are being initialized
-        as_dictator { initialize_buckets }
+        as_dictator(memcache_client) { initialize_buckets }
 
         while !buckets.empty?
           # keeping leader state as long as buckets are available by renominating before
           # nomination times out
-          as_dictator { update_buckets } unless restart_wanted?
+          as_dictator(memcache_client) { update_buckets } unless restart_wanted?(memcache_client)
         end
       end
 
       with_errors_logged('termination handling') do
-        if restart_wanted?
+        if restart_wanted?(memcache_client)
           log.info "restart triggered"
-          as_dictator { populate_followers_to_stop }
+          as_dictator(memcache_client) { populate_followers_to_stop }
           # keeping leader state as long as there are followers to stop
           while !followers_to_stop.empty?
             log.info "waiting fo workers to stop: #{followers_to_stop}"
             relax(until_next_iteration / 2)
-            seize_leadership
+            seize_leadership(memcache_client)
           end
           log.info "leader exiting due to trigger"
           exit 0
@@ -129,7 +131,8 @@ module Politics
     end
 
     def bucket_request(requestor_uri, context)
-      if leader?
+      memcache_client = client_for(memcache_config)
+      if leader?(memcache_client)
         log.debug "delivering bucket request"
         bucket_spec = next_bucket(requestor_uri, context)
         if !bucket_spec[0] && @followers_to_stop.include?(requestor_uri)
@@ -162,27 +165,27 @@ module Politics
       true
     end
 
-    def leader
+    def leader(memcache_client)
       2.times do
-        break if leader_uri
+        break if leader_uri(memcache_client)
         log.debug "could not determine leader - relaxing until next iteration"
         relax until_next_iteration
       end
-      raise "cannot determine leader" unless leader_uri
-      DRbObject.new(nil, leader_uri)
+      raise "cannot determine leader" unless leader_uri(memcache_client)
+      DRbObject.new(nil, leader_uri(memcache_client))
     end
 
     def find_workers
       raise "Please provide a method ”find_workers” returning a list of all other worker URIs"
     end
 
-    def restart_wanted?
+    def restart_wanted?(memcache_client)
       memcache_client.get(restart_flag)
     end
 
     private
 
-    attr_reader :iteration_end, :memcache_client
+    attr_reader :iteration_end, :memcache_config
 
     def with_errors_logged(task)
       yield
@@ -243,9 +246,9 @@ module Politics
       "#{group_name}_restart"
     end
 
-    def internal_cleanup
-      log.debug("uri: #{uri}, leader_uri: #{leader_uri}, until_next_iteration: #{until_next_iteration}")
-      if leader?
+    def internal_cleanup(memcache_client)
+      log.debug("uri: #{uri}, leader_uri: #{leader_uri(memcache_client)}, until_next_iteration: #{until_next_iteration}")
+      if leader?(memcache_client)
         memcache_client.delete(token)
         memcache_client.delete(restart_flag)
       end
@@ -261,7 +264,7 @@ module Politics
 
     # Nominate ourself as leader by contacting the memcached server
     # and attempting to add the token with our name attached.
-    def nominate
+    def nominate(memcache_client)
       log.debug("try to nominate")
       start_iteration {|duration| memcache_client.add(token, uri, duration) }
     end
@@ -272,14 +275,14 @@ module Politics
       @leader_uri = nil
     end
 
-    def leader_uri
+    def leader_uri(memcache_client)
       @leader_uri ||= memcache_client.get(token)
     end
 
     # Check to see if we are leader by looking at the process name
     # associated with the token.
-    def leader?
-      until_next_iteration > 0 && uri == leader_uri
+    def leader?(memcache_client)
+      until_next_iteration > 0 && uri == leader_uri(memcache_client)
     end
 
     # Easy to mock or monkey-patch if another MemCache client is preferred.

data/spec/static_queue_worker_spec.rb

@@ -268,14 +268,14 @@ describe Worker do
   describe "when determining if restart is wanted" do
     it "should return true if the restart flag is set in memcache" do
       expect(memcache_client).to receive(:get).with('worker_restart').and_return true
-      expect(worker).to be_restart_wanted
+      expect(worker).to be_restart_wanted(memcache_client)
     end
 
     it "should return false if the restart flag is not set in memcache" do
       expect(memcache_client).to receive(:get).with('worker_restart').and_return false
-      expect(worker).not_to be_restart_wanted
+      expect(worker).not_to be_restart_wanted(memcache_client)
       expect(memcache_client).to receive(:get).with('worker_restart').and_return nil
-      expect(worker).not_to be_restart_wanted
+      expect(worker).not_to be_restart_wanted(memcache_client)
     end
   end
 
@@ -291,7 +291,7 @@ describe Worker do
 
     it "performs before_perform_leader_duties callback" do
       expect(worker).to receive(:before_perform_leader_duties)
-      worker.perform_leader_duties
+      worker.perform_leader_duties(memcache_client)
     end
 
     it "has a before_perform_leader_duties callback" do
@@ -299,10 +299,10 @@ describe Worker do
     end
 
     it "should initialize buckets as dictator" do
-      expect(worker).to receive(:seize_leadership).with(666).ordered
+      expect(worker).to receive(:seize_leadership).with(memcache_client, 666).ordered
       expect(worker).to receive(:initialize_buckets).ordered
       expect(worker).to receive(:seize_leadership).ordered
-      worker.perform_leader_duties
+      worker.perform_leader_duties(memcache_client)
     end
 
     describe "as long as there are buckets" do
@@ -313,32 +313,32 @@ describe Worker do
 
       it "should update buckets periodically" do
         expect(worker).to receive(:update_buckets).exactly(4).times
-        worker.perform_leader_duties
+        worker.perform_leader_duties(memcache_client)
       end
 
       it "should relax half of the time to the next iteration" do
         allow(worker).to receive(:until_next_iteration).and_return(6)
         expect(worker).to receive(:relax).with(3).exactly(4).times
-        worker.perform_leader_duties
+        worker.perform_leader_duties(memcache_client)
       end
 
       it "should seize the leadership periodically" do
         expect(worker).to receive(:seize_leadership).at_least(4).times
-        worker.perform_leader_duties
+        worker.perform_leader_duties(memcache_client)
       end
 
       it "should seize the leadership periodically even if restart is wanted" do
         allow(worker).to receive(:restart_wanted?).and_return true
         allow(worker).to receive(:exit)
         expect(worker).to receive(:seize_leadership).at_least(4).times
-        worker.perform_leader_duties
+        worker.perform_leader_duties(memcache_client)
       end
 
       it "should not update buckets if restart is wanted" do
         allow(worker).to receive(:restart_wanted?).and_return true
         allow(worker).to receive(:exit)
         expect(worker).not_to receive(:update_buckets)
-        worker.perform_leader_duties
+        worker.perform_leader_duties(memcache_client)
       end
     end
 
@@ -356,7 +356,7 @@ describe Worker do
         it "populates the followers_to_stop list before evaluating it" do
           expect(worker).to receive(:populate_followers_to_stop).ordered.once
           expect(worker).to receive(:followers_to_stop).ordered.and_return []
-          worker.perform_leader_duties
+          worker.perform_leader_duties(memcache_client)
         end
 
         context "as long as there are followers to stop" do
@@ -369,12 +369,12 @@ describe Worker do
           it "relaxes half of the time to the next iteration" do
             allow(worker).to receive(:until_next_iteration).and_return(6)
             expect(worker).to receive(:relax).with(3).exactly(2).times
-            worker.perform_leader_duties
+            worker.perform_leader_duties(memcache_client)
           end
 
           it "seizes the leadership periodically" do
             expect(worker).to receive(:seize_leadership).at_least(2).times
-            worker.perform_leader_duties
+            worker.perform_leader_duties(memcache_client)
           end
         end
 
@@ -385,7 +385,7 @@ describe Worker do
 
           it "exits" do
             expect(worker).to receive(:exit).with(0)
-            worker.perform_leader_duties
+            worker.perform_leader_duties(memcache_client)
           end
         end
       end
@@ -398,7 +398,7 @@ describe Worker do
         it "does not populate the followers_to_stop list if restart is not wanted" do
           allow(worker).to receive(:restart_wanted?).and_return false
           expect(worker).not_to receive(:populate_followers_to_stop)
-          worker.perform_leader_duties
+          worker.perform_leader_duties(memcache_client)
         end
       end
     end
@@ -413,22 +413,22 @@ describe Worker do
 
     it "should set itself to leader" do
       expect(memcache_client).to receive(:set).with(anything(), 'myself', anything())
-      worker.seize_leadership
+      worker.seize_leadership(memcache_client)
     end
 
     it "should seize the leadership for the amount of seconds given" do
       expect(memcache_client).to receive(:set).with(anything(), anything(), 666)
-      worker.seize_leadership 666
+      worker.seize_leadership memcache_client, 666
     end
 
     it "should seize the leadership for iteration_length if no duration is given" do
       expect(memcache_client).to receive(:set).with(anything(), anything(), 123)
-      worker.seize_leadership
+      worker.seize_leadership(memcache_client)
     end
 
     it "should seize the leadership for the worker's group" do
       expect(memcache_client).to receive(:set).with('dcc-group', anything(), anything())
-      worker.seize_leadership
+      worker.seize_leadership(memcache_client)
     end
 
     it "should have the next iteration exactly when the seized leadership ends" do
@@ -436,13 +436,13 @@ describe Worker do
       allow(Time).to receive(:now).and_return now
       end_of_leadership = now + 666
 
-      worker.seize_leadership 666
+      worker.seize_leadership memcache_client, 666
       expect(worker.until_next_iteration).to eq(666)
 
-      worker.seize_leadership
+      worker.seize_leadership(memcache_client)
       expect(worker.until_next_iteration).to eq(123)
 
-      worker.seize_leadership 6
+      worker.seize_leadership memcache_client, 6
       expect(worker.until_next_iteration).to eq(6)
     end
   end
@@ -483,24 +483,24 @@ describe Worker do
     it "should return a drb object with the leader uri" do
       allow(worker).to receive(:leader_uri).and_return("leader's uri")
       expect(DRbObject).to receive(:new).with(nil, "leader's uri").and_return "leader"
-      expect(worker.leader).to eq("leader")
+      expect(worker.leader(memcache_client)).to eq("leader")
     end
 
     it "should try three times to get the leader on anarchy (no leader)" do
       expect(worker).to receive(:leader_uri).at_least(3).times.and_return nil
-      worker.leader rescue nil
+      worker.leader(memcache_client) rescue nil
     end
 
     it "should raise an error when leader cannot be determined during anarchy" do
       allow(worker).to receive(:leader_uri).and_return nil
-      expect {worker.leader}.to raise_error(/cannot determine leader/)
+      expect {worker.leader(memcache_client)}.to raise_error(/cannot determine leader/)
     end
 
     it "should sleep until next iteration before retrying to get leader" do
       allow(worker).to receive(:leader_uri).and_return nil
       allow(worker).to receive(:until_next_iteration).and_return 666
       expect(worker).to receive(:relax).with(666).exactly(2).times
-      worker.leader rescue nil
+      worker.leader(memcache_client) rescue nil
     end
   end
 
@@ -517,12 +517,12 @@ describe Worker do
 
       it "should remove the leadership token from memcache" do
         expect(memcache_client).to receive(:delete).with('the group_token')
-        worker.send(:internal_cleanup)
+        worker.send(:internal_cleanup, memcache_client)
       end
 
       it "should remove the restart wanted flag from memcache" do
         expect(memcache_client).to receive(:delete).with('the group_restart')
-        worker.send(:internal_cleanup)
+        worker.send(:internal_cleanup, memcache_client)
       end
     end
 
@@ -533,7 +533,7 @@ describe Worker do
 
       it "should not remove anything from memcache" do
         expect(memcache_client).not_to receive(:delete)
-        worker.send(:internal_cleanup)
+        worker.send(:internal_cleanup, memcache_client)
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: infopark-politics
 version: !ruby/object:Gem::Version
-  version: 0.8.4
+  version: 0.9.0
 platform: ruby
 authors:
 - Mike Perham
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-15 00:00:00.000000000 Z
+date: 2015-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec