copy_tuner_client 0.4.5 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ee5536e5d0fc51ab6b81a083012470abf8613093
-  data.tar.gz: d1d020eba3c032c6ea69064de37bad95716dad73
+SHA256:
+  metadata.gz: bea0580a939cf024f1fdf8591aaa72956c1e3aeabdea1609a8f97d3ebb544890
+  data.tar.gz: 9beccd0ea02ef6ee6b5283ce60ac442b1d6bcd3c5876907bcacb899ce5fbabf8
 SHA512:
-  metadata.gz: e93195318a86dd584dc10cf3a2c3fac2bb8deb312ad262272b18b970c7a44e0c27a70c1d12b0badb9d373a52ab0eb4d10f7a7744ce3556f7741c359db97a9387
-  data.tar.gz: ee74c4a2962b530f349921f91d39d36b7de70feb241f4eaa86cf7ed09b46e08899d09d997c45f9cdd585e7e1edd320dbf9adbf61d37e2bb6e962f64f092c2450
+  metadata.gz: 5efb8eb5d2ca1db876223bf4ab29307caf2104f83cff25d4583f74e409cbb30252b7cc9b6b6f28a4c2ca0d8e73671e6014ec04a8dd137b98b20b2cfd3b4099e2
+  data.tar.gz: 17b5e90d9091dc0b95bbba213d5645a25b250f9c44e8ef6dd302447ec7de2e0d49b07c3fb022d0748ae8fdbf857716573daf8488db2f3ce033a110ef376c34bd

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.4.6
+- changes
+  - Performance imporovement (sync with server asynchronously)
+  - Add config.middleware_position
+
 ## 0.4.5
 - changes
   - Fix deprecated css.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    copy_tuner_client (0.4.5)
+    copy_tuner_client (0.4.6)
       i18n (>= 0.5.0)
       json
 

data/lib/copy_tuner_client.rb

@@ -12,10 +12,6 @@ module CopyTunerClient
     # 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.
@@ -30,11 +26,6 @@ module CopyTunerClient
     cache.export
   end
 
-  # Starts the polling process.
-  def self.start_poller
-    poller.start
-  end
-
   # Flush queued changed synchronously
   def self.flush
     cache.flush
@@ -48,6 +39,10 @@ module CopyTunerClient
     CopyTunerClient.configuration.client
   end
 
+  def self.poller
+    CopyTunerClient.configuration.poller
+  end
+
   # Call this method to modify defaults in your initializers.
   #
   # @example

data/lib/copy_tuner_client/cache.rb

@@ -13,15 +13,16 @@ module CopyTunerClient
     # @param options [Hash]
     # @option options [Logger] :logger where errors should be logged
     def initialize(client, options)
-      @blurbs = {}
       @client = client
-      @downloaded = false
       @logger = options[:logger]
       @mutex = Mutex.new
-      @queued = {}
-      @started = false
       @exclude_key_regexp = options[:exclude_key_regexp]
       @locales = Array(options[:locales]).map(&:to_s)
+      # mutable states
+      @blurbs = {}
+      @queued = {}
+      @started = false
+      @downloaded = false
     end
 
     # Returns content for the given blurb.

data/lib/copy_tuner_client/client.rb

@@ -47,13 +47,15 @@ module CopyTunerClient
       connect(s3_host) do |http|
         request = Net::HTTP::Get.new(uri(download_resource))
         request['If-None-Match'] = @etag
+        log 'Start downloading translations'
+        t = Time.now
         response = http.request(request)
-
+        t_ms = ((Time.now - t) * 1000).to_i
         if check response
-          log 'Downloaded translations'
+          log "Downloaded translations (#{t_ms}ms)"
           yield JSON.parse(response.body)
         else
-          log 'No new translations'
+          log "No new translations (#{t_ms}ms)"
         end
 
         @etag = response['ETag']

data/lib/copy_tuner_client/configuration.rb

@@ -93,6 +93,9 @@ module CopyTunerClient
     # @return [Boolean] disable middleware setting
     attr_accessor :disable_middleware
 
+    # {before: OtherMiddleware} or {after: OtherMiddleware}
+    attr_accessor :middleware_position
+
     # @return [Boolean] disable download translation for test enviroment
     attr_accessor :disable_test_translation
 
@@ -105,6 +108,8 @@ module CopyTunerClient
     # @return [Client] instance used to communicate with a CopyTuner Server.
     attr_accessor :client
 
+    attr_accessor :poller
+
     # @return [Boolean] To enable inline-translation-mode, set true.
     attr_accessor :inline_translation
 
@@ -230,16 +235,25 @@ module CopyTunerClient
 
       self.client ||= Client.new(to_hash)
       self.cache ||= Cache.new(client, to_hash)
-      poller = Poller.new(cache, to_hash)
-      process_guard = ProcessGuard.new(cache, poller, to_hash)
+      @poller = Poller.new(cache, to_hash)
+      process_guard = ProcessGuard.new(cache, @poller, to_hash)
       I18n.backend = I18nBackend.new(cache)
 
       if enable_middleware?
         logger.info "Using copytuner sync middleware"
-        middleware.use RequestSync, :cache => cache, :interval => sync_interval, :ignore_regex => sync_ignore_path_regex
-        middleware.use CopyTunerClient::CopyrayMiddleware
+        request_sync_options = {:poller => @poller, :cache => cache, :interval => sync_interval, :ignore_regex => sync_ignore_path_regex}
+        if middleware_position.is_a?(Hash) && middleware_position[:before]
+          middleware.insert_before middleware_position[:before], RequestSync, request_sync_options
+          middleware.insert_before middleware_position[:before], CopyTunerClient::CopyrayMiddleware
+        elsif middleware_position.is_a?(Hash) && middleware_position[:after]
+          middleware.insert_after middleware_position[:after], RequestSync, request_sync_options
+          middleware.insert_after middleware_position[:after], CopyTunerClient::CopyrayMiddleware
+        else
+          middleware.use RequestSync, request_sync_options
+          middleware.use CopyTunerClient::CopyrayMiddleware
+        end
       else
-        logger.info "[[[Warn]]] Not useing copytuner sync middleware" unless middleware
+        logger.info "[[[Warn]]] Not using copytuner sync middleware" unless middleware
       end
 
       @applied = true

data/lib/copy_tuner_client/poller.rb

@@ -1,5 +1,6 @@
 require 'thread'
 require 'copy_tuner_client/cache'
+require 'copy_tuner_client/queue_with_timeout'
 
 module CopyTunerClient
   # Starts a background thread that continually resynchronizes with the remote
@@ -12,16 +13,34 @@ module CopyTunerClient
       @cache         = cache
       @polling_delay = options[:polling_delay]
       @logger        = options[:logger]
-      @stop          = false
+      @command_queue = CopyTunerClient::QueueWithTimeout.new
+      @mutex         = Mutex.new
+      @thread        = nil
     end
 
     def start
-      @logger.info 'start poller'
-      Thread.new { poll } or logger.error("Couldn't start poller thread")
+      @mutex.synchronize do
+        if @thread.nil?
+          @logger.info 'start poller thread'
+          @thread = Thread.new { poll } or logger.error("Couldn't start poller thread")
+        end
+      end
     end
 
     def stop
-      @stop = true
+      @mutex.synchronize do
+        @command_queue.uniq_push(:stop)
+        @thread.join if @thread
+        @thread = nil
+      end
+    end
+
+    def start_sync
+      @command_queue.uniq_push(:sync)
+    end
+
+    def wait_for_download
+      @cache.wait_for_download
     end
 
     private
@@ -29,17 +48,19 @@ module CopyTunerClient
     attr_reader :cache, :logger, :polling_delay
 
     def poll
-      until @stop
+      loop do
         cache.sync
         logger.flush if logger.respond_to?(:flush)
-        delay
+        begin
+          command = @command_queue.pop_with_timeout(polling_delay)
+          break if command == :stop
+        rescue ThreadError
+          # timeout
+        end
       end
+      @logger.info 'stop poller thread'
     rescue InvalidApiKey => error
       logger.error(error.message)
     end
-
-    def delay
-      sleep(polling_delay)
-    end
   end
 end

data/lib/copy_tuner_client/queue_with_timeout.rb

@@ -0,0 +1,50 @@
+module CopyTunerClient
+  # https://spin.atomicobject.com/2014/07/07/ruby-queue-pop-timeout/
+  class QueueWithTimeout
+    def initialize
+      @mutex = Mutex.new
+      @queue = []
+      @received = ConditionVariable.new
+    end
+
+    def <<(x)
+      @mutex.synchronize do
+        @queue << x
+        @received.signal
+      end
+    end
+
+    def uniq_push(x)
+      @mutex.synchronize do
+        unless @queue.member?(x)
+          @queue << x
+          @received.signal
+        end
+      end
+    end
+
+    def pop(non_block = false)
+      pop_with_timeout(non_block ? 0 : nil)
+    end
+
+    def pop_with_timeout(timeout = nil)
+      @mutex.synchronize do
+        if timeout.nil?
+          # wait indefinitely until there is an element in the queue
+          while @queue.empty?
+            @received.wait(@mutex)
+          end
+        elsif @queue.empty? && timeout != 0
+          # wait for element or timeout
+          timeout_time = timeout + Time.now.to_f
+          while @queue.empty? && (remaining_time = timeout_time - Time.now.to_f) > 0
+            @received.wait(@mutex, remaining_time)
+          end
+        end
+        #if we're still empty after the timeout, raise exception
+        raise ThreadError, "queue empty" if @queue.empty?
+        @queue.shift
+      end
+    end
+  end
+end

data/lib/copy_tuner_client/request_sync.rb

@@ -16,10 +16,12 @@ module CopyTunerClient
     # @option options [Cache] :cache agent that should be flushed after each request
     def initialize(app, options)
       @app = app
+      @poller = options[:poller]
       @cache = options[:cache]
       @interval = options[:interval]
       @ignore_regex = options[:ignore_regex]
       @last_synced = options[:last_synced]
+      @first = true
     end
 
     attr_accessor :last_synced
@@ -30,9 +32,16 @@ module CopyTunerClient
       if /^\/copytuner/ =~ ::Rack::Request.new(env).path_info
         dup._call(env)
       else
-        @cache.download unless cancel_sync?(env)
+        first_request = @first
+        if first_request
+          @first = false
+          @cache.download
+        end
+
+        cancel_sync = cancel_sync?(env)
         response = @app.call(env)
-        @cache.flush    unless cancel_sync?(env)
+        @poller.start_sync unless first_request || cancel_sync
+
         update_last_synced unless in_interval?
         response
       end
@@ -140,5 +149,9 @@ module CopyTunerClient
     def update_last_synced
       @last_synced = Time.now.utc
     end
+
+    def logger
+      CopyTunerClient.configuration.logger
+    end
   end
 end

data/lib/copy_tuner_client/version.rb

@@ -1,6 +1,6 @@
 module CopyTunerClient
   # Client version
-  VERSION = '0.4.5'.freeze
+  VERSION = '0.4.6'.freeze
 
   # API version being used to communicate with the server
   API_VERSION = '2.0'.freeze

data/spec/copy_tuner_client/poller_spec.rb

@@ -95,14 +95,4 @@ describe CopyTunerClient::Poller do
 
     expect(logger).to have_received(:flush).at_least_once
   end
-
-  it "starts from the top-level constant" do
-    poller = build_poller
-    CopyTunerClient.poller = poller
-    poller.stubs(:start)
-
-    CopyTunerClient.start_poller
-
-    expect(poller).to have_received(:start)
-  end
 end

data/spec/copy_tuner_client/request_sync_spec.rb

@@ -1,91 +1,81 @@
 require 'spec_helper'
 
 describe CopyTunerClient::RequestSync do
-
+  let(:poller) { {} }
   let(:cache) { {} }
   let(:response) { 'response' }
   let(:env) { 'env' }
   let(:app) { stub('app', :call => response) }
-  before { cache.stubs(:flush => nil, :download => nil) }
-  subject { CopyTunerClient::RequestSync.new(app, :cache => cache, :interval => 0) }
+  before do
+    cache.stubs(:flush => nil, :download => nil)
+    poller.stubs(:start_sync => nil)
+  end
+  subject { CopyTunerClient::RequestSync.new(app, :poller => poller, :cache => cache, :interval => 0) }
 
   it "invokes the upstream app" do
     result = subject.call(env)
     expect(app).to have_received(:call).with(env)
     expect(result).to eq(response)
   end
-
-  it "flushes defaults" do
-    subject.call(env)
-    expect(cache).to have_received(:flush)
-  end
-
-  it "downloads new copy" do
-    subject.call(env)
-    expect(cache).to have_received(:download)
-  end
 end
 
 describe CopyTunerClient::RequestSync, 'serving assets' do
   let(:env) do
     { "PATH_INFO" => '/assets/choper.png' }
   end
+  let(:poller) { {} }
   let(:cache) { {} }
   let(:response) { 'response' }
   let(:app) { stub('app', :call => response) }
-  before { cache.stubs(:flush => nil, :download => nil) }
-  subject { CopyTunerClient::RequestSync.new(app, :cache => cache, :interval => 0) }
+  before do
+    cache.stubs(:flush => nil, :download => nil)
+    poller.stubs(:start_sync => nil)
+  end
+  subject { CopyTunerClient::RequestSync.new(app, :poller => poller, :cache => cache, :interval => 0) }
 
-  it "does not flush defaults" do
+  it "don't start sync" do
     subject.call(env)
-    expect(cache).to have_received(:flush).never
-  end
-  it "does not download new copy" do
+    expect(cache).to have_received(:download).once
     subject.call(env)
-    expect(cache).to have_received(:download).never
+    expect(poller).to have_received(:start_sync).never
   end
 end
 
 describe CopyTunerClient::RequestSync do
+  let(:poller) { {} }
   let(:cache) { {} }
   let(:response) { 'response' }
   let(:env) { 'env' }
   let(:app) { stub('app', :call => response) }
-  before { cache.stubs(:flush => nil, :download => nil) }
+  subject { CopyTunerClient::RequestSync.new(app, :poller => poller, :cache => cache, :interval => 10) }
+  before do
+    cache.stubs(:flush => nil, :download => nil)
+    poller.stubs(:start_sync => nil)
+  end
 
-  context 'in interval request' do
-    subject { CopyTunerClient::RequestSync.new(app, :cache => cache, :interval => 10, :last_synced => Time.now) }
-    it "does not flush defaults" do
-      subject.call(env)
-      expect(cache).to have_received(:flush).never
-    end
-    it "does not download new copy" do
+  context "first request" do
+    it "download" do
       subject.call(env)
-      expect(cache).to have_received(:download).never
+      expect(cache).to have_received(:download).once
     end
   end
 
-  context 'over interval request' do
-    subject { CopyTunerClient::RequestSync.new(app, :cache => cache, :interval => 10, :last_synced => Time.now - 60) }
-    it "flushes defaults" do
+  context 'in interval request' do
+    it "does not start sync for the second time" do
       subject.call(env)
-      expect(cache).to have_received(:flush)
-    end
-    it "downloads new copy" do
+      expect(cache).to have_received(:download).once
       subject.call(env)
-      expect(cache).to have_received(:download)
+      expect(poller).to have_received(:start_sync).never
     end
   end
 
-  context "first request" do
-    subject { CopyTunerClient::RequestSync.new(app, :cache => cache, :interval => 10) }
-    it "flushes defaults" do
+  context 'over interval request' do
+    it "start sync for the second time" do
       subject.call(env)
-      expect(cache).to have_received(:flush)
-    end
-    it "downloads new copy" do
+      expect(cache).to have_received(:download).once
+      subject.last_synced = Time.now - 60
       subject.call(env)
-      expect(cache).to have_received(:download)
+      expect(poller).to have_received(:start_sync).once
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: copy_tuner_client
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.4.6
 platform: ruby
 authors:
 - SonicGarden
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-21 00:00:00.000000000 Z
+date: 2018-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -263,6 +263,7 @@ files:
 - lib/copy_tuner_client/poller.rb
 - lib/copy_tuner_client/prefixed_logger.rb
 - lib/copy_tuner_client/process_guard.rb
+- lib/copy_tuner_client/queue_with_timeout.rb
 - lib/copy_tuner_client/rails.rb
 - lib/copy_tuner_client/request_sync.rb
 - lib/copy_tuner_client/simple_form_extention.rb
@@ -319,7 +320,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2.2
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Client for the CopyTuner copy management service