copycopter_client 1.0.0.beta1

data/lib/copycopter_client/sync.rb

@@ -0,0 +1,145 @@
+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
+        logger.info("Starting poller")
+        @pending = true
+        at_exit { sync }
+        Thread.new { poll }
+      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")
+        while @pending
+          sleep(0.1)
+        end
+      end
+    end
+
+    private
+
+    attr_reader :client, :polling_delay, :logger
+
+    def poll
+      until @stop
+        sync
+        sleep(polling_delay)
+      end
+    rescue InvalidApiKey => error
+      logger.error(error.message)
+    end
+
+    def sync
+      begin
+        downloaded_blurbs = client.download
+        lock { @blurbs = downloaded_blurbs }
+        with_queued_changes do |queued|
+          client.upload(queued)
+        end
+      rescue ConnectionError => error
+        logger.error(error.message)
+      end
+    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?
+      $0.include?("ApplicationSpawner") || $0 =~ /unicorn.*master/
+    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/lib/copycopter_client/version.rb

@@ -0,0 +1,8 @@
+module CopycopterClient
+  # Client version
+  VERSION = "1.0.0.beta1"
+
+  # API version being used to communicate with the server
+  API_VERSION = "2.0"
+end
+

data/lib/copycopter_client.rb

@@ -0,0 +1,58 @@
+require 'copycopter_client/version'
+require 'copycopter_client/configuration'
+
+# Top-level interface to the Copycopter client.
+#
+# Most applications should only need to use the {.configure}
+# method, which will setup all the pieces and begin synchronization when
+# appropriate.
+module CopycopterClient
+  class << self
+    # @return [Client] instance used to communicate with the Copycopter server.
+    # This is set when {.configure} is called.
+    attr_accessor :client
+
+    # @return [Configuration] current client configuration
+    # Must act like a hash and return sensible values for all Copycopter
+    # configuration options. Usually set when {.configure} is called.
+    attr_accessor :configuration
+
+    # @return [Sync] instance used to synchronize changes.
+    # This is set when {.configure} is called.
+    attr_accessor :sync
+  end
+
+  # Issues a new deploy, marking all draft blurbs as published.
+  # This is called when the copycopter:deploy rake task is invoked.
+  def self.deploy
+    client.deploy
+  end
+
+  # Starts the polling process.
+  # This is called from Unicorn worker processes.
+  def self.start_sync
+    sync.start
+  end
+
+  # Call this method to modify defaults in your initializers.
+  #
+  # @example
+  #   CopycopterClient.configure do |config|
+  #     config.api_key = '1234567890abcdef'
+  #     config.secure  = false
+  #   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)
+    configuration.apply if apply
+  end
+end
+
+if defined?(Rails)
+  require 'copycopter_client/rails'
+end
+

data/lib/tasks/copycopter_client_tasks.rake

@@ -0,0 +1,6 @@
+namespace :copycopter do
+  desc "Notify Copycopter of a new deploy."
+  task :deploy => :environment do
+    CopycopterClient.deploy
+  end
+end

data/spec/copycopter_client/client_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+
+describe CopycopterClient do
+  def build_client(config = {})
+    config[:logger] ||= FakeLogger.new
+    default_config = CopycopterClient::Configuration.new.to_hash
+    CopycopterClient::Client.new(default_config.update(config))
+  end
+
+  def add_project
+    api_key = 'xyz123'
+    FakeCopycopterApp.add_project(api_key)
+  end
+
+  def build_client_with_project(config = {})
+    project = add_project
+    config[:api_key] = project.api_key
+    build_client(config)
+  end
+
+  describe "opening a connection" do
+    let(:config) { CopycopterClient::Configuration.new }
+    let(:http) { Net::HTTP.new(config.host, config.port) }
+
+    before do
+      Net::HTTP.stubs(:new => http)
+    end
+
+    it "should timeout when connecting" do
+      project = add_project
+      client = build_client(:api_key => project.api_key, :http_open_timeout => 4)
+      client.download
+      http.open_timeout.should == 4
+    end
+
+    it "should timeout when reading" do
+      project = add_project
+      client = build_client(:api_key => project.api_key, :http_read_timeout => 4)
+      client.download
+      http.read_timeout.should == 4
+    end
+
+    it "uses ssl when secure" do
+      project = add_project
+      client = build_client(:api_key => project.api_key, :secure => true)
+      client.download
+      http.use_ssl.should == true
+    end
+
+    it "doesn't use ssl when insecure" do
+      project = add_project
+      client = build_client(:api_key => project.api_key, :secure => false)
+      client.download
+      http.use_ssl.should == false
+    end
+
+    it "wraps HTTP errors with ConnectionError" do
+      errors = [
+        Timeout::Error.new,
+        Errno::EINVAL.new,
+        Errno::ECONNRESET.new,
+        EOFError.new,
+        Net::HTTPBadResponse.new,
+        Net::HTTPHeaderSyntaxError.new,
+        Net::ProtocolError.new
+      ]
+
+      errors.each do |original_error|
+        http.stubs(:get).raises(original_error)
+        client = build_client_with_project
+        expect { client.download }.
+          to raise_error(CopycopterClient::ConnectionError) { |error|
+            error.message.
+              should == "#{original_error.class.name}: #{original_error.message}"
+          }
+      end
+    end
+
+    it "handles 500 errors from downloads with ConnectionError" do
+      client = build_client(:api_key => 'raise_error')
+      expect { client.download }.to raise_error(CopycopterClient::ConnectionError)
+    end
+
+    it "handles 500 errors from uploads with ConnectionError" do
+      client = build_client(:api_key => 'raise_error')
+      expect { client.upload({}) }.to raise_error(CopycopterClient::ConnectionError)
+    end
+
+    it "handles 404 errors from downloads with ConnectionError" do
+      client = build_client(:api_key => 'bogus')
+      expect { client.download }.to raise_error(CopycopterClient::InvalidApiKey)
+    end
+
+    it "handles 404 errors from uploads with ConnectionError" do
+      client = build_client(:api_key => 'bogus')
+      expect { client.upload({}) }.to raise_error(CopycopterClient::InvalidApiKey)
+    end
+  end
+
+  it "downloads published blurbs for an existing project" do
+    project = add_project
+    project.update({
+      'draft' => {
+        'key.one'   => "unexpected one",
+        'key.three' => "unexpected three"
+      },
+      'published' => {
+        'key.one' => "expected one",
+        'key.two' => "expected two"
+      }
+    })
+
+    blurbs = build_client(:api_key => project.api_key, :public => true).download
+
+    blurbs.should == {
+      'key.one' => 'expected one',
+      'key.two' => 'expected two'
+    }
+  end
+
+  it "logs that it performed a download" do
+    logger = FakeLogger.new
+    client = build_client_with_project(:logger => logger)
+    client.download
+    logger.should have_entry(:info, "Downloaded translations")
+  end
+
+  it "downloads draft blurbs for an existing project" do
+    project = add_project
+    project.update({
+      'draft' => {
+        'key.one' => "expected one",
+        'key.two' => "expected two"
+      },
+      'published' => {
+        'key.one'   => "unexpected one",
+        'key.three' => "unexpected three"
+      }
+    })
+
+    blurbs = build_client(:api_key => project.api_key, :public => false).download
+
+    blurbs.should == {
+      'key.one' => 'expected one',
+      'key.two' => 'expected two'
+    }
+  end
+
+  it "uploads defaults for missing blurbs in an existing project" do
+    project = add_project
+
+    blurbs = {
+      'key.one' => 'expected one',
+      'key.two' => 'expected two'
+    }
+
+    client = build_client(:api_key => project.api_key, :public => true)
+    client.upload(blurbs)
+
+    project.reload.draft.should == blurbs
+  end
+
+  it "logs that it performed an upload" do
+    logger = FakeLogger.new
+    client = build_client_with_project(:logger => logger)
+    client.upload({})
+    logger.should have_entry(:info, "Uploaded missing translations")
+  end
+
+  it "deploys from the top-level constant" do
+    client = build_client
+    CopycopterClient.client = client
+    client.stubs(:deploy)
+
+    CopycopterClient.deploy
+
+    client.should have_received(:deploy)
+  end
+
+  it "deploys" do
+    project = add_project
+    project.update({
+      'draft' => {
+        'key.one' => "expected one",
+        'key.two' => "expected two"
+      },
+      'published' => {
+        'key.one'   => "unexpected one",
+        'key.two'   => "unexpected one",
+      }
+    })
+    logger = FakeLogger.new
+    client = build_client(:api_key => project.api_key, :logger => logger)
+
+    client.deploy
+
+    project.reload.published.should == {
+      'key.one'   => "expected one",
+      'key.two'   => "expected two"
+    }
+    logger.should have_entry(:info, "Deployed")
+  end
+
+  it "handles deploy errors" do
+    expect { build_client.deploy }.to raise_error(CopycopterClient::InvalidApiKey)
+  end
+end
+

data/spec/copycopter_client/configuration_spec.rb

@@ -0,0 +1,252 @@
+require 'spec_helper'
+
+describe CopycopterClient::Configuration do
+  Spec::Matchers.define :have_config_option do |option|
+    match do |config|
+      config.should respond_to(option)
+
+      if instance_variables.include?('@default')
+        config.send(option).should == @default
+      end
+
+      if @overridable
+        value = 'a value'
+        config.send(:"#{option}=", value)
+        config.send(option).should == value
+      end
+    end
+
+    chain :default do |default|
+      @default = default
+    end
+
+    chain :overridable do
+      @overridable = true
+    end
+  end
+
+  it { should have_config_option(:proxy_host).              overridable.default(nil) }
+  it { should have_config_option(:proxy_port).              overridable.default(nil) }
+  it { should have_config_option(:proxy_user).              overridable.default(nil) }
+  it { should have_config_option(:proxy_pass).              overridable.default(nil) }
+  it { should have_config_option(:environment_name).        overridable.default(nil) }
+  it { should have_config_option(:client_version).          overridable.default(CopycopterClient::VERSION) }
+  it { should have_config_option(:client_name).             overridable.default('Copycopter Client') }
+  it { should have_config_option(:client_url).              overridable.default('http://copycopter.com') }
+  it { should have_config_option(:secure).                  overridable.default(false) }
+  it { should have_config_option(:host).                    overridable.default('copycopter.com') }
+  it { should have_config_option(:http_open_timeout).       overridable.default(2) }
+  it { should have_config_option(:http_read_timeout).       overridable.default(5) }
+  it { should have_config_option(:port).                    overridable }
+  it { should have_config_option(:development_environments).overridable }
+  it { should have_config_option(:api_key).                 overridable }
+  it { should have_config_option(:polling_delay).           overridable.default(300) }
+  it { should have_config_option(:framework).               overridable }
+  it { should have_config_option(:fallback_backend).        overridable }
+
+  it "should provide default values for secure connections" do
+    config = CopycopterClient::Configuration.new
+    config.secure = true
+    config.port.should == 443
+    config.protocol.should == 'https'
+  end
+
+  it "should provide default values for insecure connections" do
+    config = CopycopterClient::Configuration.new
+    config.secure = false
+    config.port.should == 80
+    config.protocol.should == 'http'
+  end
+
+  it "should not cache inferred ports" do
+    config = CopycopterClient::Configuration.new
+    config.secure = false
+    config.port
+    config.secure = true
+    config.port.should == 443
+  end
+
+  it "should act like a hash" do
+    config = CopycopterClient::Configuration.new
+    hash = config.to_hash
+    [:api_key, :environment_name, :host, :http_open_timeout,
+      :http_read_timeout, :client_name, :client_url, :client_version, :port,
+      :protocol, :proxy_host, :proxy_pass, :proxy_port, :proxy_user, :secure,
+      :development_environments, :logger, :framework, :fallback_backend].each do |option|
+      hash[option].should == config[option]
+    end
+    hash[:public].should == config.public?
+  end
+
+  it "should be mergable" do
+    config = CopycopterClient::Configuration.new
+    hash = config.to_hash
+    config.merge(:key => 'value').should == hash.merge(:key => 'value')
+  end
+
+  it "should use development and staging as development environments by default" do
+    config = CopycopterClient::Configuration.new
+    config.development_environments.should =~ %w(development staging)
+  end
+
+  it "should use test and cucumber as test environments by default" do
+    config = CopycopterClient::Configuration.new
+    config.test_environments.should =~ %w(test cucumber)
+  end
+
+  it "should be test in a test environment" do
+    config = CopycopterClient::Configuration.new
+    config.test_environments = %w(test)
+    config.environment_name = 'test'
+    config.should be_test
+  end
+
+  it "should be public in a public environment" do
+    config = CopycopterClient::Configuration.new
+    config.development_environments = %w(development)
+    config.environment_name = 'production'
+    config.should be_public
+  end
+
+  it "should not be public in a development environment" do
+    config = CopycopterClient::Configuration.new
+    config.development_environments = %w(staging)
+    config.environment_name = 'staging'
+    config.should_not be_public
+  end
+
+  it "should be public without an environment name" do
+    config = CopycopterClient::Configuration.new
+    config.should be_public
+  end
+
+  it "should yield and save a configuration when configuring" do
+    yielded_configuration = nil
+    CopycopterClient.configure(false) do |config|
+      yielded_configuration = config
+    end
+
+    yielded_configuration.should be_kind_of(CopycopterClient::Configuration)
+    CopycopterClient.configuration.should == yielded_configuration
+  end
+
+  it "doesn't apply the configuration when asked not to" do
+    logger = FakeLogger.new
+    CopycopterClient.configure(false) { |config| config.logger = logger }
+    CopycopterClient.configuration.should_not be_applied
+    logger.entries[:info].should be_empty
+  end
+
+  it "should not remove existing config options when configuring twice" do
+    first_config = nil
+    CopycopterClient.configure(false) do |config|
+      first_config = config
+    end
+    CopycopterClient.configure(false) do |config|
+      config.should == first_config
+    end
+  end
+
+  it "starts out unapplied" do
+    CopycopterClient::Configuration.new.should_not be_applied
+  end
+
+  it "logs to $stdout by default" do
+    logger = FakeLogger.new
+    Logger.stubs(:new => logger)
+
+    config = CopycopterClient::Configuration.new
+    Logger.should have_received(:new).with($stdout)
+    config.logger.original_logger.should == logger
+  end
+
+  it "generates environment info without a framework" do
+    subject.environment_name = 'production'
+    subject.environment_info.should == "[Ruby: #{RUBY_VERSION}] [Env: production]"
+  end
+
+  it "generates environment info with a framework" do
+    subject.environment_name = 'production'
+    subject.framework = 'Sinatra: 1.0.0'
+    subject.environment_info.
+      should == "[Ruby: #{RUBY_VERSION}] [Sinatra: 1.0.0] [Env: production]"
+  end
+
+  it "prefixes log entries" do
+    logger = FakeLogger.new
+    config = CopycopterClient::Configuration.new
+
+    config.logger = logger
+
+    prefixed_logger = config.logger
+    prefixed_logger.should be_a(CopycopterClient::PrefixedLogger)
+    prefixed_logger.original_logger.should == logger
+  end
+end
+
+share_examples_for "applied configuration" do
+  let(:backend) { stub('i18n-backend') }
+  let(:sync)    { stub('sync', :start => nil) }
+  let(:client)  { stub('client') }
+  let(:logger)  { FakeLogger.new }
+  subject { CopycopterClient::Configuration.new }
+
+  before do
+    CopycopterClient::I18nBackend.stubs(:new => backend)
+    CopycopterClient::Client.stubs(:new => client)
+    CopycopterClient::Sync.stubs(:new => sync)
+    subject.logger = logger
+  end
+
+  it { should be_applied }
+
+  it "builds and assigns an I18n backend" do
+    CopycopterClient::Client.should have_received(:new).with(subject.to_hash)
+    CopycopterClient::Sync.should have_received(:new).with(client, subject.to_hash)
+    CopycopterClient::I18nBackend.should have_received(:new).with(sync, subject.to_hash)
+    I18n.backend.should == backend
+  end
+
+  it "logs that it's ready" do
+    logger.should have_entry(:info, "Client #{CopycopterClient::VERSION} ready")
+  end
+
+  it "logs environment info" do
+    logger.should have_entry(:info, "Environment Info: #{subject.environment_info}")
+  end
+
+  it "stores the client" do
+    CopycopterClient.client.should == client
+  end
+
+  it "stores the sync" do
+    CopycopterClient.sync.should == sync
+  end
+end
+
+describe CopycopterClient::Configuration, "applied when testing" do
+  it_should_behave_like "applied configuration"
+
+  before do
+    subject.environment_name = 'test'
+    subject.apply
+  end
+
+  it "doesn't start sync" do
+    sync.should have_received(:start).never
+  end
+end
+
+describe CopycopterClient::Configuration, "applied when not testing" do
+  it_should_behave_like "applied configuration"
+
+  before do
+    subject.environment_name = 'development'
+    subject.apply
+  end
+
+  it "starts sync" do
+    sync.should have_received(:start)
+  end
+end
+