copycopter_client 1.0.2 → 1.0.3

data/lib/copycopter_client/cache.rb

@@ -0,0 +1,106 @@
+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 locking down access to data used by both threads.
+  class Cache
+    # Usually instantiated when {Configuration#apply} is invoked.
+    # @param client [Client] the client used to fetch and upload data
+    # @param options [Hash]
+    # @option options [Logger] :logger where errors should be logged
+    def initialize(client, options)
+      @client     = client
+      @blurbs     = {}
+      @queued     = {}
+      @mutex      = Mutex.new
+      @logger     = options[:logger]
+      @started    = false
+      @downloaded = false
+    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 flush.
+    # @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 download")
+        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
+      @started = true
+      client.download do |downloaded_blurbs|
+        downloaded_blurbs.reject! { |key, value| value == "" }
+        lock { @blurbs = downloaded_blurbs }
+      end
+    rescue ConnectionError => error
+      logger.error(error.message)
+    ensure
+      @downloaded = true
+    end
+
+    # Downloads and then flushes
+    def sync
+      download
+      flush
+    end
+
+    private
+
+    attr_reader :client, :logger
+
+    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 pending?
+      @started && !@downloaded
+    end
+  end
+end

data/lib/copycopter_client/configuration.rb

@@ -1,7 +1,9 @@
 require 'logger'
 require 'copycopter_client/i18n_backend'
 require 'copycopter_client/client'
-require 'copycopter_client/sync'
+require 'copycopter_client/cache'
+require 'copycopter_client/process_guard'
+require 'copycopter_client/poller'
 require 'copycopter_client/prefixed_logger'
 require 'copycopter_client/request_sync'
 
@@ -156,20 +158,22 @@ module CopycopterClient
     #
     # Called automatically when {CopycopterClient.configure} is called in the application.
     #
-    # This creates the {Client}, {Sync}, and {I18nBackend} and puts them together.
+    # This creates the {Client}, {Cache}, and {I18nBackend} and puts them together.
     #
-    # When {#test?} returns +false+, the sync will be started.
+    # When {#test?} returns +false+, the poller will be started.
     def apply
       client = Client.new(to_hash)
-      sync = Sync.new(client, to_hash)
-      I18n.backend = I18nBackend.new(sync)
+      cache = Cache.new(client, to_hash)
+      poller = Poller.new(cache, to_hash)
+      process_guard = ProcessGuard.new(cache, poller, to_hash)
+      I18n.backend = I18nBackend.new(cache)
       CopycopterClient.client = client
-      CopycopterClient.sync = sync
-      middleware.use(RequestSync, :sync => sync) if middleware && development?
+      CopycopterClient.cache = cache
+      middleware.use(RequestSync, :cache => cache) if middleware && development?
       @applied = true
       logger.info("Client #{VERSION} ready")
       logger.info("Environment Info: #{environment_info}")
-      sync.start unless test?
+      process_guard.start unless test?
     end
 
     def port

data/lib/copycopter_client/errors.rb

@@ -1,6 +1,6 @@
 module CopycopterClient
   # Raised when an error occurs while contacting the Copycopter server. This is
-  # raised by {Client} and generally rescued by {Sync}. The application will
+  # raised by {Client} and generally rescued by {Cache}. The application will
   # not encounter this error. Polling will continue even if this error is raised.
   class ConnectionError < StandardError
   end

data/lib/copycopter_client/i18n_backend.rb

@@ -14,9 +14,9 @@ module CopycopterClient
     include I18n::Backend::Simple::Implementation
 
     # Usually instantiated when {Configuration#apply} is invoked.
-    # @param sync [Sync] must act like a hash, returning and accept blurbs by key.
-    def initialize(sync)
-      @sync = sync
+    # @param cache [Cache] must act like a hash, returning and accept blurbs by key.
+    def initialize(cache)
+      @cache = cache
     end
 
     # Translates the given local and key. See the I18n API documentation for details.
@@ -34,14 +34,14 @@ module CopycopterClient
     # Returns locales availabile for this Copycopter project.
     # @return [Array<String>] available locales
     def available_locales
-      sync_locales = sync.keys.map { |key| key.split('.').first }
-      (sync_locales + super).uniq.map { |locale| locale.to_sym }
+      cached_locales = cache.keys.map { |key| key.split('.').first }
+      (cached_locales + super).uniq.map { |locale| locale.to_sym }
     end
 
     # Stores the given translations.
     #
     # Updates will be visible in the current process immediately, and will
-    # propagate to Copycopter during the next sync.
+    # propagate to Copycopter during the next flush.
     #
     # @param [String] locale the locale (ie "en") to store translations for
     # @param [Hash] data nested key-value pairs to be added as blurbs
@@ -56,8 +56,8 @@ module CopycopterClient
     def lookup(locale, key, scope = [], options = {})
       parts = I18n.normalize_keys(locale, key, scope, options[:separator])
       key_with_locale = parts.join('.')
-      content = sync[key_with_locale] || super
-      sync[key_with_locale] = "" if content.nil?
+      content = cache[key_with_locale] || super
+      cache[key_with_locale] = "" if content.nil?
       content
     end
 
@@ -68,13 +68,13 @@ module CopycopterClient
         end
       elsif data.respond_to?(:to_str)
         key = ([locale] + scope).join('.')
-        sync[key] = data.to_str
+        cache[key] = data.to_str
       end
     end
 
     def load_translations(*filenames)
       super
-      sync.wait_for_download
+      cache.wait_for_download
     end
 
     def default(locale, object, subject, options = {})
@@ -82,11 +82,11 @@ module CopycopterClient
       if content.respond_to?(:to_str)
         parts = I18n.normalize_keys(locale, object, options[:scope], options[:separator])
         key = parts.join('.')
-        sync[key] = content.to_str
+        cache[key] = content.to_str
       end
       content
     end
 
-    attr_reader :sync
+    attr_reader :cache
   end
 end

data/lib/copycopter_client/poller.rb

@@ -0,0 +1,44 @@
+require 'thread'
+require 'copycopter_client/cache'
+
+module CopycopterClient
+  # Starts a background thread that continually resynchronizes with the remote
+  # server using the given {Cache} after a set delay.
+  class Poller
+    # @param options [Hash]
+    # @option options [Logger] :logger where errors should be logged
+    # @option options [Fixnum] :polling_delay how long to wait in between requests
+    def initialize(cache, options)
+      @cache         = cache
+      @polling_delay = options[:polling_delay]
+      @logger        = options[:logger]
+      @stop          = false
+    end
+
+    def start
+      Thread.new { poll } or logger.error("Couldn't start poller thread")
+    end
+
+    def stop
+      @stop = true
+    end
+
+    private
+
+    attr_reader :cache, :logger, :polling_delay
+
+    def poll
+      until @stop
+        cache.sync
+        logger.flush if logger.respond_to?(:flush)
+        delay
+      end
+    rescue InvalidApiKey => error
+      logger.error(error.message)
+    end
+
+    def delay
+      sleep(polling_delay)
+    end
+  end
+end

data/lib/copycopter_client/process_guard.rb

@@ -0,0 +1,92 @@
+module CopycopterClient
+  # Starts the poller from a worker process, or register hooks for a spawner
+  # process (such as in Unicorn or Passenger). Also registers hooks for exiting
+  # processes and completing background jobs. Applications using the client
+  # will not need to interact with this class directly.
+  class ProcessGuard
+    # @param options [Hash]
+    # @option options [Logger] :logger where errors should be logged
+    def initialize(cache, poller, options)
+      @cache  = cache
+      @poller = poller
+      @logger = options[:logger]
+    end
+
+    # Starts the poller or registers hooks
+    def start
+      if spawner?
+        register_spawn_hooks
+      else
+        register_exit_hooks
+        register_job_hooks
+        start_polling
+      end
+    end
+
+    private
+
+    def start_polling
+      @poller.start
+    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_spawn_hooks
+      if defined?(PhusionPassenger)
+        register_passenger_hook
+      elsif defined?(Unicorn::HttpServer)
+        register_unicorn_hook
+      end
+    end
+
+    def register_passenger_hook
+      @logger.info("Registered Phusion Passenger fork hook")
+      PhusionPassenger.on_event(:starting_worker_process) do |forked|
+        start_polling
+      end
+    end
+
+    def register_unicorn_hook
+      @logger.info("Registered Unicorn fork hook")
+      poller = @poller
+      Unicorn::HttpServer.class_eval do
+        alias_method :worker_loop_without_copycopter, :worker_loop
+        define_method :worker_loop do |worker|
+          poller.start
+          worker_loop_without_copycopter(worker)
+        end
+      end
+    end
+
+    def register_exit_hooks
+      at_exit do
+        @cache.flush
+      end
+    end
+
+    def register_job_hooks
+      if defined?(Resque::Job)
+        @logger.info("Registered Resque after_perform hook")
+        cache = @cache
+        Resque::Job.class_eval do
+          alias_method :perform_without_copycopter, :perform
+          define_method :perform do
+            job_was_performed = perform_without_copycopter
+            cache.flush
+            job_was_performed
+          end
+        end
+      end
+    end
+  end
+end

data/lib/copycopter_client/request_sync.rb

@@ -5,18 +5,18 @@ module CopycopterClient
   class RequestSync
     # @param app [Rack] the upstream app into whose responses to inject the editor
     # @param options [Hash]
-    # @option options [Sync] :sync agent that should be flushed after each request
+    # @option options [Cache] :cache agent that should be flushed after each request
     def initialize(app, options)
       @app  = app
-      @sync = options[:sync]
+      @cache = options[:cache]
     end
 
-    # Invokes the upstream Rack application and flushes the sync after each
+    # Invokes the upstream Rack application and flushes the cache after each
     # request.
     def call(env)
-      @sync.download
+      @cache.download
       response = @app.call(env)
-      @sync.flush
+      @cache.flush
       response
     end
   end

data/lib/copycopter_client/version.rb

@@ -1,6 +1,6 @@
 module CopycopterClient
   # Client version
-  VERSION = "1.0.2"
+  VERSION = "1.0.3"
 
   # API version being used to communicate with the server
   API_VERSION = "2.0"

data/lib/copycopter_client.rb

@@ -17,9 +17,13 @@ module CopycopterClient
     # configuration options. Usually set when {.configure} is called.
     attr_accessor :configuration
 
-    # @return [Sync] instance used to synchronize changes.
+    # @return [Cache] instance used to synchronize changes.
     # This is set when {.configure} is called.
-    attr_accessor :sync
+    attr_accessor :cache
+
+    # @return [Poller] instance used to poll for changes.
+    # This is set when {.configure} is called.
+    attr_accessor :poller
   end
 
   # Issues a new deploy, marking all draft blurbs as published.
@@ -29,15 +33,13 @@ module CopycopterClient
   end
 
   # Starts the polling process.
-  # This is called from Unicorn worker processes.
-  def self.start_sync
-    sync.start
+  def self.start_poller
+    poller.start
   end
 
   # Flush queued changed synchronously
-  # This is called from the Resque after perform "hook"
   def self.flush
-    sync.flush
+    cache.flush
   end
 
   # Call this method to modify defaults in your initializers.

data/spec/copycopter_client/cache_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+describe CopycopterClient::Cache do
+  let(:client) { FakeClient.new }
+
+  def build_cache(config = {})
+    config[:logger] ||= FakeLogger.new
+    default_config = CopycopterClient::Configuration.new.to_hash
+    CopycopterClient::Cache.new(client, default_config.update(config))
+  end
+
+  it "provides access to downloaded data" do
+    client['en.test.key']       = 'expected'
+    client['en.test.other_key'] = 'expected'
+
+    cache = build_cache
+
+    cache.download
+
+    cache['en.test.key'].should == 'expected'
+    cache.keys.should =~ %w(en.test.key en.test.other_key)
+  end
+
+  it "doesn't upload without changes" do
+    cache = build_cache
+    cache.flush
+    client.should_not be_uploaded
+  end
+
+  it "uploads changes when flushed" do
+    cache = build_cache
+    cache['test.key'] = 'test value'
+
+    cache.flush
+
+    client.uploaded.should == { 'test.key' => 'test value' }
+  end
+
+  it "downloads changes" do
+    client['test.key'] = 'test value'
+    cache = build_cache
+
+    cache.download
+
+    cache['test.key'].should == 'test value'
+  end
+
+  it "downloads and uploads when synced" do
+    cache = build_cache
+    client['test.key'] = 'test value'
+    cache['other.key'] = 'other value'
+
+    cache.sync
+
+    client.uploaded.should == { 'other.key' => 'other value' }
+    cache['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))
+    cache = build_cache(:logger => logger)
+    cache['upload.key'] = 'upload'
+
+    cache.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))
+    cache = build_cache(:logger => logger)
+
+    cache.download
+
+    logger.should have_entry(:error, failure)
+  end
+
+  it "blocks until the first download is complete" do
+    logger = FakeLogger.new
+    logger.stubs(:flush)
+    client.delay = 0.5
+    cache = build_cache(:logger => logger)
+
+    Thread.new { cache.download }
+
+    finished = false
+    Thread.new do
+      cache.wait_for_download
+      finished = true
+    end
+
+    sleep(1)
+
+    finished.should == true
+    logger.should have_entry(:info, "Waiting for first download")
+    logger.should have_received(:flush)
+  end
+
+  it "doesn't block if the first download fails" do
+    client.delay = 0.5
+    client.error = StandardError.new("Failure")
+    cache = build_cache
+
+    Thread.new { cache.download }
+
+    finished = false
+    Thread.new do
+      cache.wait_for_download
+      finished = true
+    end
+
+    sleep(1)
+
+    expect { cache.download }.to raise_error(StandardError, "Failure")
+    finished.should == true
+  end
+
+  it "doesn't block before downloading" do
+    logger = FakeLogger.new
+    cache = build_cache(:logger => logger)
+
+    finished = false
+    Thread.new do
+      cache.wait_for_download
+      finished = true
+    end
+
+    sleep(1)
+
+    finished.should == true
+    logger.should_not have_entry(:info, "Waiting for first download")
+  end
+
+  it "doesn't return blank copy" do
+    client['en.test.key'] = ''
+    cache = build_cache
+
+    cache.download
+
+    cache['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(:cache) { build_cache }
+
+    before do
+      mutex.lock
+      Mutex.stubs(:new => mutex)
+    end
+
+    it "synchronizes read access to keys between threads" do
+      Thread.new { cache['test.key'] }.should finish_after_unlocking(mutex)
+    end
+
+    it "synchronizes read access to the key list between threads" do
+      Thread.new { cache.keys }.should finish_after_unlocking(mutex)
+    end
+
+    it "synchronizes write access to keys between threads" do
+      Thread.new { cache['test.key'] = 'value' }.should finish_after_unlocking(mutex)
+    end
+  end
+
+  it "flushes from the top level" do
+    cache = build_cache
+    CopycopterClient.cache = cache
+    cache.stubs(:flush)
+
+    CopycopterClient.flush
+
+    cache.should have_received(:flush)
+  end
+end
+