copy_tuner_client 0.0.1

data/lib/copy_tuner_client/poller.rb

@@ -0,0 +1,44 @@
+require 'thread'
+require 'copy_tuner_client/cache'
+
+module CopyTunerClient
+  # 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/copy_tuner_client/prefixed_logger.rb

@@ -0,0 +1,45 @@
+module CopyTunerClient
+  class PrefixedLogger
+    attr_reader :prefix, :original_logger
+
+    def initialize(prefix, logger)
+      @prefix          = prefix
+      @original_logger = logger
+    end
+
+    def info(message = nil, &block)
+      log(:info, message, &block)
+    end
+
+    def debug(message = nil, &block)
+      log(:debug, message, &block)
+    end
+
+    def warn(message = nil, &block)
+      log(:warn, message, &block)
+    end
+
+    def error(message = nil, &block)
+      log(:error, message, &block)
+    end
+
+    def fatal(message = nil, &block)
+      log(:fatal, message, &block)
+    end
+
+    def flush
+      original_logger.flush if original_logger.respond_to?(:flush)
+    end
+
+    private
+
+    def log(severity, message, &block)
+      prefixed_message = "#{prefix} #{thread_info} #{message}"
+      original_logger.send(severity, prefixed_message, &block)
+    end
+
+    def thread_info
+      "[P:#{Process.pid}] [T:#{Thread.current.object_id}]"
+    end
+  end
+end

data/lib/copy_tuner_client/process_guard.rb

@@ -0,0 +1,92 @@
+module CopyTunerClient
+  # 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_copy_tuner, :worker_loop
+        define_method :worker_loop do |worker|
+          poller.start
+          worker_loop_without_copy_tuner(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_copy_tuner, :perform
+          define_method :perform do
+            job_was_performed = perform_without_copy_tuner
+            cache.flush
+            job_was_performed
+          end
+        end
+      end
+    end
+  end
+end

data/lib/copy_tuner_client/rails.rb

@@ -0,0 +1,21 @@
+module CopyTunerClient
+  # Responsible for Rails initialization
+  module Rails
+    # Sets up the logger, environment, name, project root, and framework name
+    # for Rails applications. Must be called after framework initialization.
+    def self.initialize
+      CopyTunerClient.configure(false) do |config|
+        config.environment_name = ::Rails.env
+        config.logger           = ::Rails.logger
+        config.framework        = "Rails: #{::Rails::VERSION::STRING}"
+        config.middleware       = ::Rails.configuration.middleware
+      end
+    end
+  end
+end
+
+if defined?(Rails::Railtie)
+  require 'copy_tuner_client/railtie'
+else
+  CopyTunerClient::Rails.initialize
+end

data/lib/copy_tuner_client/railtie.rb

@@ -0,0 +1,12 @@
+module CopyTunerClient
+  # Connects to integration points for Rails 3 applications
+  class Railtie < ::Rails::Railtie
+    initializer :initialize_copy_tuner_rails, :after => :before_initialize do
+      CopyTunerClient::Rails.initialize
+    end
+
+    rake_tasks do
+      load "tasks/copy_tuner_client_tasks.rake"
+    end
+  end
+end

data/lib/copy_tuner_client/request_sync.rb

@@ -0,0 +1,39 @@
+module CopyTunerClient
+  # Rack middleware that synchronizes with CopyTuner during each request.
+  #
+  # This is injected into the Rails middleware stack in development environments.
+  class RequestSync
+    # @param app [Rack] the upstream app into whose responses to inject the editor
+    # @param options [Hash]
+    # @option options [Cache] :cache agent that should be flushed after each request
+    def initialize(app, options)
+      @app  = app
+      @cache = options[:cache]
+      @interval = options[:interval] || 1.minutes
+      @last_synced = Time.now.utc
+    end
+
+    # Invokes the upstream Rack application and flushes the cache after each
+    # request.
+    def call(env)
+      @cache.download unless asset_request?(env) or in_interval?
+      response = @app.call(env)
+      @cache.flush    unless asset_request?(env) or in_interval?
+      update_last_synced unless in_interval?
+      response
+    end
+
+    private
+    def asset_request?(env)
+      env['PATH_INFO'] =~ /^\/assets/
+    end
+
+    def in_interval?
+      @last_synced + @interval > Time.now.utc
+    end
+
+    def update_last_synced
+      @last_synced = Time.now.utc
+    end
+  end
+end

data/lib/copy_tuner_client/version.rb

@@ -0,0 +1,7 @@
+module CopyTunerClient
+  # Client version
+  VERSION = '0.0.1'
+
+  # API version being used to communicate with the server
+  API_VERSION = '2.0'.freeze
+end

data/lib/copy_tuner_client.rb

@@ -0,0 +1,75 @@
+require 'copy_tuner_client/version'
+require 'copy_tuner_client/configuration'
+
+# Top-level interface to the CopyTuner client.
+#
+# Most applications should only need to use the {.configure}
+# method, which will setup all the pieces and begin synchronization when
+# appropriate.
+module CopyTunerClient
+  class << self
+    # @return [Configuration] current client configuration
+    # Must act like a hash and return sensible values for all CopyTuner
+    # configuration options. Usually set when {.configure} is called.
+    attr_accessor :configuration
+
+    # @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.
+  # This is called when the copy_tuner:deploy rake task is invoked.
+  def self.deploy
+    client.deploy
+  end
+
+  # Issues a new export, returning yaml representation of blurb cache.
+  # This is called when the copy_tuner:export rake task is invoked.
+  def self.export
+    cache.export
+  end
+
+  # Starts the polling process.
+  def self.start_poller
+    poller.start
+  end
+
+  # Flush queued changed synchronously
+  def self.flush
+    cache.flush
+  end
+
+  def self.cache
+    CopyTunerClient.configuration.cache
+  end
+
+  def self.client
+    CopyTunerClient.configuration.client
+  end
+
+  # Call this method to modify defaults in your initializers.
+  #
+  # @example
+  #   CopyTunerClient.configure do |config|
+  #     config.api_key = '1234567890abcdef'
+  #     config.host = 'your-copy-tuner-server.herokuapp.com'
+  #     config.secure = true
+  #   end
+  #
+  # @param apply [Boolean] (internal) whether the configuration should be applied yet.
+  #
+  # @yield [Configuration] the configuration to be modified
+  def self.configure(apply = true)
+    self.configuration ||= Configuration.new
+    yield configuration
+
+    if apply
+      configuration.apply
+    end
+  end
+end
+
+if defined? Rails
+  require 'copy_tuner_client/rails'
+end

data/lib/tasks/copy_tuner_client_tasks.rake

@@ -0,0 +1,20 @@
+namespace :copy_tuner do
+  desc "Notify CopyTuner of a new deploy."
+  task :deploy => :environment do
+    CopyTunerClient.deploy
+    puts "Successfully marked all blurbs as published."
+  end
+
+  desc "Export CopyTuner blurbs to yaml."
+  task :export => :environment do
+    CopyTunerClient.cache.sync
+
+    if yml = CopyTunerClient.export
+      PATH = "config/locales/copy_tuner.yml"
+      File.new("#{Rails.root}/#{PATH}", 'w').write(yml)
+      puts "Successfully exported blurbs to #{PATH}."
+    else
+      puts "No blurbs have been cached."
+    end
+  end
+end

data/spec/copy_tuner_client/cache_spec.rb

@@ -0,0 +1,273 @@
+require 'spec_helper'
+
+describe CopyTunerClient::Cache do
+  let(:client) { FakeClient.new }
+
+  def build_cache(config = {})
+    config[:logger] ||= FakeLogger.new
+    default_config = CopyTunerClient::Configuration.new.to_hash
+    CopyTunerClient::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(CopyTunerClient::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(CopyTunerClient::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
+    CopyTunerClient.configure do |config|
+      config.cache = cache
+    end
+    cache.stubs(:flush)
+
+    CopyTunerClient.flush
+
+    cache.should have_received(:flush)
+  end
+
+  describe "#export" do
+    before do
+      save_blurbs
+      @cache = build_cache
+      @cache.download
+    end
+
+    let(:save_blurbs) {}
+
+    it "can be invoked from the top-level constant" do
+      CopyTunerClient.configure do |config|
+        config.cache = @cache
+      end
+      @cache.stubs(:export)
+
+      CopyTunerClient.export
+
+      @cache.should have_received(:export)
+    end
+
+    it "returns no yaml with no blurb keys" do
+      @cache.export.should == nil
+    end
+
+    context "with single-level blurb keys" do
+      let(:save_blurbs) do
+        client['key']       = 'test value'
+        client['other_key'] = 'other test value'
+      end
+
+      it "returns blurbs as yaml" do
+        exported = YAML.load(@cache.export)
+        exported['key'].should == 'test value'
+        exported['other_key'].should == 'other test value'
+      end
+    end
+
+    context "with multi-level blurb keys" do
+      let(:save_blurbs) do
+        client['en.test.key']       = 'en test value'
+        client['en.test.other_key'] = 'en other test value'
+        client['fr.test.key']       = 'fr test value'
+      end
+
+      it "returns blurbs as yaml" do
+        exported = YAML.load(@cache.export)
+        exported['en']['test']['key'].should == 'en test value'
+        exported['en']['test']['other_key'].should == 'en other test value'
+        exported['fr']['test']['key'].should == 'fr test value'
+      end
+    end
+
+    context "with conflicting blurb keys" do
+      let(:save_blurbs) do
+        client['en.test']     = 'test value'
+        client['en.test.key'] = 'other test value'
+      end
+
+      it "retains the new key" do
+        exported = YAML.load(@cache.export)
+        exported['en']['test']['key'].should == 'other test value'
+      end
+    end
+  end
+end