copycopter_client 1.0.2 → 1.0.3

data/spec/copycopter_client/request_sync_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe CopycopterClient::RequestSync do
 
-  let(:sync) { {} }
+  let(:cache) { {} }
   let(:response) { 'response' }
   let(:env) { 'env' }
   let(:app) { stub('app', :call => response) }
-  before { sync.stubs(:flush => nil, :download => nil) }
-  subject { CopycopterClient::RequestSync.new(app, :sync => sync) }
+  before { cache.stubs(:flush => nil, :download => nil) }
+  subject { CopycopterClient::RequestSync.new(app, :cache => cache) }
 
   it "invokes the upstream app" do
     result = subject.call(env)
@@ -17,11 +17,11 @@ describe CopycopterClient::RequestSync do
 
   it "flushes defaults" do
     subject.call(env)
-    sync.should have_received(:flush)
+    cache.should have_received(:flush)
   end
 
   it "downloads new copy" do
     subject.call(env)
-    sync.should have_received(:download)
+    cache.should have_received(:download)
   end
 end

data/spec/support/fake_client.rb

@@ -7,7 +7,7 @@ class FakeClient
   end
 
   attr_reader :uploaded, :uploads, :downloads
-  attr_accessor :delay
+  attr_accessor :delay, :error
 
   def []=(key, value)
     @data[key] = value
@@ -15,6 +15,7 @@ class FakeClient
 
   def download
     wait_for_delay
+    raise_error_if_present
     @downloads += 1
     yield @data.dup
     nil
@@ -22,6 +23,7 @@ class FakeClient
 
   def upload(data)
     wait_for_delay
+    raise_error_if_present
     @uploaded.update(data)
     @uploads += 1
   end
@@ -39,5 +41,9 @@ class FakeClient
   def wait_for_delay
     sleep(delay) if delay
   end
+
+  def raise_error_if_present
+    raise error if error
+  end
 end
 

data/spec/support/fake_resque_job.rb

@@ -1,11 +1,18 @@
 class FakeResqueJob
-  attr_accessor :sync
-  def initialize(hash)
-    @key = hash[:key]
-    @value = hash[:value]
+  def initialize(&action)
+    @action = action || lambda {}
   end
+
+  def fork_and_perform
+    fork do
+      perform
+      exit!
+    end
+    Process.wait
+  end
+
   def perform
-    sync[@key] = @value
+    @action.call
     true
   end
 end

data/spec/support/writing_cache.rb

@@ -0,0 +1,17 @@
+class WritingCache
+  def flush
+    File.open(path, "w") do |file|
+      file.write(object_id.to_s)
+    end
+  end
+
+  def written?
+    IO.read(path) == object_id.to_s
+  end
+
+  private
+
+  def path
+    File.join(PROJECT_ROOT, 'tmp', 'written_cache')
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: copycopter_client
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 1
   - 0
-  - 2
-  version: 1.0.2
+  - 3
+  version: 1.0.3
 platform: ruby
 authors: 
 - thoughtbot
@@ -15,11 +15,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-10 00:00:00 -05:00
+date: 2011-06-21 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  type: :runtime
+  name: i18n
+  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -31,11 +32,11 @@ dependencies:
         - 5
         - 0
         version: 0.5.0
+  type: :runtime
   version_requirements: *id001
-  name: i18n
-  prerelease: false
 - !ruby/object:Gem::Dependency 
-  type: :runtime
+  name: json
+  prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -45,9 +46,8 @@ dependencies:
         segments: 
         - 0
         version: "0"
+  type: :runtime
   version_requirements: *id002
-  name: json
-  prerelease: false
 description: 
 email: support@thoughtbot.com
 executables: []
@@ -62,24 +62,28 @@ files:
 - Rakefile
 - init.rb
 - AddTrustExternalCARoot.crt
+- lib/copycopter_client/cache.rb
 - lib/copycopter_client/client.rb
 - lib/copycopter_client/configuration.rb
 - lib/copycopter_client/errors.rb
 - lib/copycopter_client/i18n_backend.rb
+- lib/copycopter_client/poller.rb
 - lib/copycopter_client/prefixed_logger.rb
+- lib/copycopter_client/process_guard.rb
 - lib/copycopter_client/rails.rb
 - lib/copycopter_client/railtie.rb
 - lib/copycopter_client/request_sync.rb
-- lib/copycopter_client/sync.rb
 - lib/copycopter_client/version.rb
 - lib/copycopter_client.rb
 - lib/tasks/copycopter_client_tasks.rake
+- spec/copycopter_client/cache_spec.rb
 - spec/copycopter_client/client_spec.rb
 - spec/copycopter_client/configuration_spec.rb
 - spec/copycopter_client/i18n_backend_spec.rb
+- spec/copycopter_client/poller_spec.rb
 - spec/copycopter_client/prefixed_logger_spec.rb
+- spec/copycopter_client/process_guard_spec.rb
 - spec/copycopter_client/request_sync_spec.rb
-- spec/copycopter_client/sync_spec.rb
 - spec/spec_helper.rb
 - spec/support/client_spec_helpers.rb
 - spec/support/defines_constants.rb
@@ -91,6 +95,7 @@ files:
 - spec/support/fake_resque_job.rb
 - spec/support/fake_unicorn.rb
 - spec/support/middleware_stack.rb
+- spec/support/writing_cache.rb
 - features/rails.feature
 - features/step_definitions/copycopter_server_steps.rb
 - features/step_definitions/rails_steps.rb
@@ -126,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: copycopter_client
-rubygems_version: 1.6.1
+rubygems_version: 1.4.1
 signing_key: 
 specification_version: 3
 summary: Client for the Copycopter content management service

data/lib/copycopter_client/sync.rb

@@ -1,182 +0,0 @@
-require 'thread'
-require 'copycopter_client/client'
-
-module CopycopterClient
-  # Manages synchronization of copy between {I18nBackend} and {Client}. Acts
-  # like a Hash. Applications using the client will not need to interact with
-  # this class directly.
-  #
-  # Responsible for:
-  # * Starting and running the background polling thread
-  # * Locking down access to data used by both threads
-  class Sync
-    # Usually instantiated when {Configuration#apply} is invoked.
-    # @param client [Client] the client used to fetch and upload data
-    # @param options [Hash]
-    # @option options [Fixnum] :polling_delay the number of seconds in between each synchronization with the server
-    # @option options [Logger] :logger where errors should be logged
-    def initialize(client, options)
-      @client        = client
-      @blurbs        = {}
-      @polling_delay = options[:polling_delay]
-      @stop          = false
-      @queued        = {}
-      @mutex         = Mutex.new
-      @logger        = options[:logger]
-      @pending       = false
-    end
-
-    # Starts the polling thread. The polling thread doesn't run in test environments.
-    #
-    # If this sync was created from a master spawner (as in the case for
-    # phusion passenger), it will instead register after fork hooks so that the
-    # poller starts in each spawned process.
-    def start
-      if spawner?
-        register_spawn_hooks
-      else
-        register_job_hooks
-        logger.info("Starting poller")
-        @pending = true
-        at_exit { sync }
-        unless Thread.new { poll }
-          logger.error("Couldn't start poller thread")
-        end
-      end
-    end
-
-    # Stops the polling thread after the next run.
-    def stop
-      @stop = true
-    end
-
-    # Returns content for the given blurb.
-    # @param key [String] the key of the desired blurb
-    # @return [String] the contents of the blurb
-    def [](key)
-      lock { @blurbs[key] }
-    end
-
-    # Sets content for the given blurb. The content will be pushed to the
-    # server on the next poll.
-    # @param key [String] the key of the blurb to update
-    # @param value [String] the new contents of the blurb
-    def []=(key, value)
-      lock { @queued[key] = value }
-    end
-
-    # Keys for all blurbs stored on the server.
-    # @return [Array<String>] keys
-    def keys
-      lock { @blurbs.keys }
-    end
-
-    # Waits until the first download has finished.
-    def wait_for_download
-      if @pending
-        logger.info("Waiting for first sync")
-        logger.flush if logger.respond_to?(:flush)
-        while @pending
-          sleep(0.1)
-        end
-      end
-    end
-
-    def flush
-      with_queued_changes do |queued|
-        client.upload(queued)
-      end
-    rescue ConnectionError => error
-      logger.error(error.message)
-    end
-
-    def download
-      client.download do |downloaded_blurbs|
-        downloaded_blurbs.reject! { |key, value| value == "" }
-        lock { @blurbs = downloaded_blurbs }
-      end
-    rescue ConnectionError => error
-      logger.error(error.message)
-    end
-
-    private
-
-    attr_reader :client, :polling_delay, :logger
-
-    def poll
-      until @stop
-        sync
-        logger.flush if logger.respond_to?(:flush)
-        sleep(polling_delay)
-      end
-    rescue InvalidApiKey => error
-      logger.error(error.message)
-    end
-
-    def sync
-      download
-      flush
-    ensure
-      @pending = false
-    end
-
-    def with_queued_changes
-      changes_to_push = nil
-      lock do
-        unless @queued.empty?
-          changes_to_push = @queued
-          @queued = {}
-        end
-      end
-      yield(changes_to_push) if changes_to_push
-    end
-
-    def lock(&block)
-      @mutex.synchronize(&block)
-    end
-
-    def spawner?
-      passenger_spawner? || unicorn_spawner?
-    end
-
-    def passenger_spawner?
-      $0.include?("ApplicationSpawner")
-    end
-
-    def unicorn_spawner?
-      $0.include?("unicorn") && !caller.any? { |line| line.include?("worker_loop") }
-    end
-
-    def register_job_hooks
-      if defined?(Resque)
-        logger.info("Registered Resque after_perform hook")
-        Resque::Job.class_eval do
-          alias_method :perform_without_copycopter, :perform
-          def perform
-            job_was_performed = perform_without_copycopter
-            CopycopterClient.flush
-            job_was_performed
-          end
-        end
-      end
-    end
-
-    def register_spawn_hooks
-      if defined?(PhusionPassenger)
-        logger.info("Registered Phusion Passenger fork hook")
-        PhusionPassenger.on_event(:starting_worker_process) do |forked|
-          start
-        end
-      elsif defined?(Unicorn::HttpServer)
-        logger.info("Registered Unicorn fork hook")
-        Unicorn::HttpServer.class_eval do
-          alias_method :worker_loop_without_copycopter, :worker_loop
-          def worker_loop(worker)
-            CopycopterClient.start_sync
-            worker_loop_without_copycopter(worker)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/copycopter_client/sync_spec.rb

@@ -1,415 +0,0 @@
-require 'spec_helper'
-
-describe CopycopterClient::Sync do
-  include DefinesConstants
-
-  let(:client) { FakeClient.new }
-
-  def build_sync(config = {})
-    config[:logger] ||= FakeLogger.new
-    default_config = CopycopterClient::Configuration.new.to_hash
-    sync = CopycopterClient::Sync.new(client, default_config.update(config))
-    @syncs << sync
-    sync
-  end
-
-  before do
-    @syncs = []
-    @original_process_name = $0
-  end
-
-  after do
-    $0 = @original_process_name
-    @syncs.each { |sync| sync.stop }
-  end
-
-  it "syncs when the process terminates" do
-    api_key = "12345"
-    FakeCopycopterApp.add_project api_key
-    pid = fork do
-      config = { :logger => FakeLogger.new, :polling_delay => 86400, :api_key => api_key }
-      default_config = CopycopterClient::Configuration.new.to_hash.update(config)
-      real_client = CopycopterClient::Client.new(default_config)
-      sync = CopycopterClient::Sync.new(real_client, default_config)
-      sync.start
-      sleep 2
-      sync['test.key'] = 'value'
-      Signal.trap("INT") { exit }
-      sleep
-    end
-    sleep 3
-    Process.kill("INT", pid)
-    Process.wait
-    project = FakeCopycopterApp.project(api_key)
-    project.draft['test.key'].should == 'value'
-  end
-
-  it "provides access to downloaded data" do
-    client['en.test.key']       = 'expected'
-    client['en.test.other_key'] = 'expected'
-
-    sync = build_sync
-
-    sync.start
-
-    sync['en.test.key'].should == 'expected'
-    sync.keys.should =~ %w(en.test.key en.test.other_key)
-  end
-
-  it "it polls after being started" do
-    sync = build_sync(:polling_delay => 1)
-    sync.start
-
-    sync['test.key'].should be_nil
-
-    client['test.key'] = 'value'
-    sleep(2)
-
-    sync['test.key'].should == 'value'
-  end
-
-  it "stops polling when stopped" do
-    sync = build_sync(:polling_delay => 1)
-    sync.start
-
-    sync['test.key'].should be_nil
-
-    sync.stop
-
-    client['test.key'] = 'value'
-    sleep(2)
-
-    sync['test.key'].should be_nil
-  end
-
-  it "doesn't upload without changes" do
-    sync = build_sync(:polling_delay => 1)
-    sync.start
-    sleep(2)
-    client.should_not be_uploaded
-  end
-
-  it "uploads changes when polling" do
-    sync = build_sync(:polling_delay => 1)
-    sync.start
-
-    sync['test.key'] = 'test value'
-    sleep(2)
-
-    client.uploaded.should == { 'test.key' => 'test value' }
-  end
-
-  it "uploads changes when flushed" do
-    sync = build_sync
-    sync['test.key'] = 'test value'
-
-    sync.flush
-
-    client.uploaded.should == { 'test.key' => 'test value' }
-  end
-
-  it "downloads changes" do
-    client['test.key'] = 'test value'
-    sync = build_sync
-
-    sync.download
-
-    sync['test.key'].should == 'test value'
-  end
-
-  it "handles connection errors when flushing" do
-    failure = "server is napping"
-    logger = FakeLogger.new
-    client.stubs(:upload).raises(CopycopterClient::ConnectionError.new(failure))
-    sync = build_sync(:logger => logger)
-    sync['upload.key'] = 'upload'
-
-    sync.flush
-
-    logger.should have_entry(:error, failure)
-  end
-
-  it "handles connection errors when downloading" do
-    failure = "server is napping"
-    logger = FakeLogger.new
-    client.stubs(:download).raises(CopycopterClient::ConnectionError.new(failure))
-    sync = build_sync(:logger => logger)
-
-    sync.download
-
-    logger.should have_entry(:error, failure)
-  end
-
-  it "handles connection errors when polling" do
-    failure = "server is napping"
-    logger = FakeLogger.new
-    client.stubs(:upload).raises(CopycopterClient::ConnectionError.new(failure))
-    sync = build_sync(:polling_delay => 1, :logger => logger)
-
-    sync['upload.key'] = 'upload'
-    sync.start
-    sleep(2)
-
-    logger.should have_entry(:error, failure),
-                  logger.entries.inspect
-
-    client['test.key'] = 'test value'
-    sleep(2)
-
-    sync['test.key'].should == 'test value'
-  end
-
-  it "handles an invalid api key" do
-    failure = "server is napping"
-    logger = FakeLogger.new
-    client.stubs(:upload).raises(CopycopterClient::InvalidApiKey.new(failure))
-    sync = build_sync(:polling_delay => 1, :logger => logger)
-
-    sync['upload.key'] = 'upload'
-    sync.start
-    sleep(2)
-
-    logger.should have_entry(:error, failure),
-                  logger.entries.inspect
-
-    client['test.key'] = 'test value'
-    sleep(2)
-
-    sync['test.key'].should be_nil
-  end
-
-  it "starts after spawning when using passenger" do
-    logger = FakeLogger.new
-    passenger = define_constant('PhusionPassenger', FakePassenger.new)
-    passenger.become_master
-    sync = build_sync(:polling_delay => 1, :logger => logger)
-
-    sync.start
-    sleep(2)
-
-    client.should_not be_downloaded
-    logger.should have_entry(:info, "Registered Phusion Passenger fork hook")
-
-    passenger.spawn
-    sleep(2)
-
-    client.should be_downloaded
-    logger.should have_entry(:info, "Starting poller"),
-                  "Got entries: #{logger.entries.inspect}"
-  end
-
-  it "flushes after running a resque job" do
-    define_constant('Resque', Module.new)
-    job = define_constant('Resque::Job', FakeResqueJob).new(:key => 'test.key', :value => 'all your base')
-
-    api_key = "12345"
-    FakeCopycopterApp.add_project api_key
-    logger = FakeLogger.new
-
-    config = { :logger => logger, :polling_delay => 86400, :api_key => api_key }
-    default_config = CopycopterClient::Configuration.new.to_hash.update(config)
-    real_client = CopycopterClient::Client.new(default_config)
-    sync = CopycopterClient::Sync.new(real_client, default_config)
-    sync.stubs(:at_exit)
-    CopycopterClient.sync = sync
-    job.sync = sync
-
-    sync.start
-    sleep(2)
-
-    logger.should have_entry(:info, "Registered Resque after_perform hook")
-
-    if fork
-      Process.wait
-    else
-      job.perform
-      exit!
-    end
-    sleep(2)
-
-    project = FakeCopycopterApp.project(api_key)
-    project.draft['test.key'].should == 'all your base'
-  end
-
-  it "starts after spawning when using unicorn" do
-    logger = FakeLogger.new
-    define_constant('Unicorn', Module.new)
-    unicorn = define_constant('Unicorn::HttpServer', FakeUnicornServer).new
-    unicorn.become_master
-    sync = build_sync(:polling_delay => 1, :logger => logger)
-    CopycopterClient.sync = sync
-
-    sync.start
-    sleep(2)
-
-    client.should_not be_downloaded
-    logger.should have_entry(:info, "Registered Unicorn fork hook")
-
-    unicorn.spawn
-    sleep(2)
-
-    client.should be_downloaded
-    logger.should have_entry(:info, "Starting poller")
-  end
-
-  it "blocks until the first download is complete" do
-    logger = FakeLogger.new
-    logger.stubs(:flush)
-    client.delay = 1
-    sync = build_sync(:logger => logger)
-
-    sync.start
-
-    finished = false
-    Thread.new do
-      sync.wait_for_download
-      finished = true
-    end
-
-    logger.should have_entry(:info, "Waiting for first sync")
-    logger.should have_received(:flush)
-    finished.should == false
-
-    sleep(3)
-
-    finished.should == true
-  end
-
-  it "doesn't block if the first download fails" do
-    client.delay = 1
-    client.stubs(:upload).raises(StandardError.new("Failure"))
-    sync = build_sync
-
-    sync['test.key'] = 'value'
-    sync.start
-
-    finished = false
-    Thread.new do
-      sync.wait_for_download
-      finished = true
-    end
-
-    finished.should == false
-
-    sleep(4)
-
-    finished.should == true
-  end
-
-  it "doesn't block before starting" do
-    logger = FakeLogger.new
-    sync = build_sync(:polling_delay => 3, :logger => logger)
-
-    finished = false
-    Thread.new do
-      sync.wait_for_download
-      finished = true
-    end
-
-    sleep(1)
-
-    finished.should == true
-    logger.should_not have_entry(:info, "Waiting for first sync")
-  end
-
-  it "logs an error if the background thread can't start" do
-    Thread.stubs(:new => nil)
-    logger = FakeLogger.new
-
-    build_sync(:logger => logger).start
-
-    logger.should have_entry(:error, "Couldn't start poller thread")
-  end
-
-  it "flushes the log when polling" do
-    logger = FakeLogger.new
-    logger.stubs(:flush)
-    sync = build_sync(:polling_delay => 1, :logger =>  logger)
-
-    sync.start
-    sleep(2)
-
-    logger.should have_received(:flush).at_least_once
-  end
-
-  it "doesn't return blank copy" do
-    client['en.test.key'] = ''
-    sync = build_sync(:polling_delay => 1)
-
-    sync.start
-    sleep(2)
-
-    sync['en.test.key'].should be_nil
-  end
-
-  describe "given locked mutex" do
-    RSpec::Matchers.define :finish_after_unlocking do |mutex|
-      match do |thread|
-        sleep(0.1)
-
-        if thread.status === false
-          violated("finished before unlocking")
-        else
-          mutex.unlock
-          sleep(0.1)
-
-          if thread.status === false
-            true
-          else
-            violated("still running after unlocking")
-          end
-        end
-      end
-
-      def violated(failure)
-        @failure_message = failure
-        false
-      end
-
-      failure_message_for_should do
-        @failure_message
-      end
-    end
-
-    let(:mutex) { Mutex.new }
-    let(:sync) { build_sync(:polling_delay => 0.1) }
-
-    before do
-      mutex.lock
-      Mutex.stubs(:new => mutex)
-    end
-
-    it "synchronizes read access to keys between threads" do
-      Thread.new { sync['test.key'] }.should finish_after_unlocking(mutex)
-    end
-
-    it "synchronizes read access to the key list between threads" do
-      Thread.new { sync.keys }.should finish_after_unlocking(mutex)
-    end
-
-    it "synchronizes write access to keys between threads" do
-      Thread.new { sync['test.key'] = 'value' }.should finish_after_unlocking(mutex)
-    end
-  end
-
-  it "starts from the top-level constant" do
-    sync = build_sync
-    CopycopterClient.sync = sync
-    sync.stubs(:start)
-
-    CopycopterClient.start_sync
-
-    sync.should have_received(:start)
-  end
-
-  it "flushes from the top level" do
-    sync = build_sync
-    CopycopterClient.sync = sync
-    sync.stubs(:flush)
-
-    CopycopterClient.flush
-
-    sync.should have_received(:flush)
-  end
-end
-