alephant-broker 3.14.0 → 3.15.0

data/lib/alephant/broker/load_strategy/revalidate/strategy.rb

@@ -0,0 +1,86 @@
+require 'alephant/broker/cache'
+require 'alephant/broker/errors'
+require 'alephant/logger'
+require 'alephant/broker/load_strategy/revalidate/refresher'
+require 'alephant/broker/load_strategy/revalidate/fetcher'
+require 'faraday'
+
+module Alephant
+  module Broker
+    module LoadStrategy
+      module Revalidate
+        class Strategy
+          include Logger
+
+          STORAGE_ERRORS = [Alephant::Broker::Errors::ContentNotFound].freeze
+
+          def load(component_meta)
+            loaded_content = cached_object(component_meta)
+
+            update_content(component_meta) if loaded_content.expired?
+
+            data = loaded_content.to_h
+            data.fetch(:meta, {})[:status] = 200
+            data
+          rescue *STORAGE_ERRORS
+            update_content(component_meta)
+
+            {
+              content:      '',
+              content_type: 'text/html',
+              meta:         { status: 202 }
+            }
+          end
+
+          private
+
+          attr_reader :cache
+
+          def cache
+            @cache ||= Cache::Client.new
+          end
+
+          def cached_object(component_meta)
+            cache.get(component_meta.component_key) do
+              logger.info(msg: "#{self.class}#cached_object - No cache so loading and adding cache object")
+              Fetcher.new(component_meta).fetch
+            end
+          end
+
+          def update_content(component_meta)
+            Thread.new do
+              stored_content = fetch_stored_content(component_meta)
+
+              if stored_content && !stored_content.expired?
+                cache_new_content(component_meta, stored_content)
+              else
+                refresh_content(component_meta)
+              end
+            end
+          end
+
+          def fetch_stored_content(component_meta)
+            Fetcher.new(component_meta).fetch
+          rescue *STORAGE_ERRORS
+            nil
+          end
+
+          def cache_new_content(component_meta, new_content)
+            logger.info(event:  'NewContentFromS3',
+                        key:    component_meta.component_key,
+                        val:    new_content,
+                        method: "#{self.class}#refresh_content")
+
+            cache.set(component_meta.component_key, new_content)
+          end
+
+          def refresh_content(component_meta)
+            logger.info(msg: "#{self.class}#refresh_content - Loading new content from thread")
+
+            Refresher.new(component_meta).refresh
+          end
+        end
+      end
+    end
+  end
+end

data/lib/alephant/broker/load_strategy/s3/base.rb

@@ -58,7 +58,7 @@ module Alephant
           end
 
           def retrieve_object(component_meta)
-            cached = false
+            @cached = false
             s3.get s3_path(component_meta)
           rescue AWS::S3::Errors::NoSuchKey, InvalidCacheKey
             logger.metric "S3InvalidCacheKey"
@@ -87,7 +87,7 @@ module Alephant
 
           def headers(_component_meta)
             {
-              "X-Cache-Version" => Broker.config["elasticache_cache_version"].to_s,
+              "X-Cache-Version" => (Broker.config[:elasticache_cache_version] || Broker.config["elasticache_cache_version"]).to_s,
               "X-Cached"        => cached.to_s
             }
           end

data/lib/alephant/broker/response/asset.rb

@@ -9,7 +9,7 @@ module Alephant
         def initialize(component, request_env)
           @component = component
 
-          @status = self.class.component_not_modified(@component.headers, request_env) ? NOT_MODIFIED_STATUS_CODE : component.status
+          @status = self.class.component_not_modified(@component.headers, request_env) ? 304 : component.status
 
           super(@status, component.content_type, request_env)
 

data/lib/alephant/broker/response/base.rb

@@ -12,13 +12,12 @@ module Alephant
 
         attr_reader :content, :headers, :status
 
-        NOT_MODIFIED_STATUS_CODE = 304
-
         STATUS_CODE_MAPPING = {
-          200                      => "ok",
-          NOT_MODIFIED_STATUS_CODE => "",
-          404                      => "Not found",
-          500                      => "Error retrieving content"
+          200 => "ok",
+          202 => "Accepted",
+          304 => "",
+          404 => "Not found",
+          500 => "Error retrieving content"
         }.freeze
 
         def initialize(status = 200, content_type = "text/html", request_env = nil)
@@ -28,7 +27,7 @@ module Alephant
             "Access-Control-Allow-Headers" => "If-None-Match, If-Modified-Since",
             "Access-Control-Allow-Origin"  => "*"
           }
-          headers.merge!(Broker.config[:headers]) if Broker.config.key?(:headers)
+          @headers.merge!(Broker.config[:headers]) if Broker.config.key?(:headers)
           @status = status
 
           add_no_cache_headers if should_add_no_cache_headers?(status)
@@ -45,7 +44,7 @@ module Alephant
         private
 
         def should_add_no_cache_headers?(status)
-          status != 200 && status != NOT_MODIFIED_STATUS_CODE
+          status != 200 && status != 304
         end
 
         def add_no_cache_headers

data/lib/alephant/broker/response/batch.rb

@@ -12,7 +12,7 @@ module Alephant
         def initialize(components, batch_id, request_env)
           @components  = components
           @batch_id    = batch_id
-          @status      = self.class.component_not_modified(batch_response_headers, request_env) ? NOT_MODIFIED_STATUS_CODE : 200
+          @status      = self.class.component_not_modified(batch_response_headers, request_env) ? 304 : 200
 
           super(@status, "application/json", request_env)
 

data/lib/alephant/broker/version.rb

@@ -1,5 +1,5 @@
 module Alephant
   module Broker
-    VERSION = "3.14.0".freeze
+    VERSION = "3.15.0".freeze
   end
 end

data/spec/alephant/broker/cache/cached_object_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+RSpec.describe Alephant::Broker::Cache::CachedObject do
+  subject { described_class.new(s3_obj) }
+
+  let(:config)        { {} }
+  let(:last_modified) { Time.parse('Mon, 11 Apr 2016 10:39:57 GMT') }
+  let(:ttl)           { 15 }
+
+  let(:s3_obj) do
+    {
+      content:      'Test',
+      content_type: 'test/content',
+      meta:         {
+        :ttl                  => ttl,
+        :head_ETag            => '123',
+        :'head_Last-Modified' => last_modified.to_s
+      }
+    }
+  end
+
+  before do
+    allow_any_instance_of(Logger).to receive(:info)
+    allow(Alephant::Broker).to receive(:config).and_return(config)
+  end
+
+  describe '#updated' do
+    it 'extracts the #updated time from the S3 object' do
+      Timecop.freeze do
+        expect(subject.updated).to eq(last_modified)
+      end
+    end
+
+    context 'when there is no Last-Modified on the S3 object' do
+      let(:last_modified) { nil }
+
+      it 'sets #updated to now' do
+        now = Time.parse('Mon, 31 May 2016 12:00:00 GMT')
+
+        Timecop.freeze(now) do
+          expect(subject.updated).to eq(now)
+        end
+      end
+    end
+  end
+
+  describe '#ttl' do
+    it 'extracts the #ttl from the S3 object' do
+      expect(subject.ttl).to eq(ttl)
+    end
+
+    context 'when there is no TTL on the S3 object' do
+      let(:ttl) { nil }
+
+      context 'and a default cache TTL has been configured' do
+        let(:config) { { revalidate_cache_ttl: 100 } }
+
+        it 'sets the #ttl to the configured value' do
+          expect(subject.ttl).to eq(100)
+        end
+      end
+
+      context 'and a default cache TTL has NOT been configured' do
+        it 'sets the #ttl to a default (in code) value' do
+          expect(subject.ttl).to eq(described_class::DEFAULT_TTL)
+        end
+      end
+    end
+  end
+
+  describe '#update' do
+    let(:new_content) do
+      {
+        content:      'Test - NEW',
+        content_type: 'test/content',
+        meta:         {}
+      }
+    end
+
+    it 'updates #s3_obj' do
+      expect { subject.update(new_content) }
+        .to change { subject.s3_obj }
+        .from(s3_obj)
+        .to(new_content)
+    end
+  end
+
+  describe '#expired?' do
+    context 'when the object is "young"' do
+      it 'should be false' do
+        Timecop.freeze(last_modified) do
+          expect(subject.expired?).to be false
+        end
+      end
+    end
+
+    context 'when the object is "old"' do
+      it 'shoule be true' do
+        new_time = last_modified + subject.ttl + 100
+
+        Timecop.freeze(new_time) do
+          expect(subject.expired?).to be true
+        end
+      end
+    end
+  end
+end

data/spec/alephant/broker/load_strategy/http_spec.rb

@@ -4,15 +4,14 @@ describe Alephant::Broker::LoadStrategy::HTTP do
   subject { described_class.new(url_generator) }
 
   let(:component_meta) do
-    double(
-      "Alephant::Broker::ComponentMeta",
-      :cache_key => "cache_key",
-      :id        => "test",
-      :options   => {}
+    instance_double(Alephant::Broker::ComponentMeta,
+      :id            => "test",
+      :options       => {},
+      :component_key => "cache_key"
     )
   end
   let(:url_generator) { double(:generate => "http://foo.bar") }
-  let(:cache) { double("Alephant::Broker::Cache::Client") }
+  let(:cache) { instance_double(Alephant::Broker::Cache::Client) }
   let(:body) { "<h1>Batman!</h1>" }
   let(:content) do
     {
@@ -39,7 +38,6 @@ describe Alephant::Broker::LoadStrategy::HTTP do
     context "content not in cache" do
       before :each do
         allow(cache).to receive(:get).and_yield
-        allow(component_meta).to receive(:'cached=').with(false) { false }
       end
 
       context "and available over HTTP" do

data/spec/alephant/broker/load_strategy/revalidate/fetcher_spec.rb

@@ -0,0 +1,88 @@
+require "spec_helper"
+
+RSpec.describe Alephant::Broker::LoadStrategy::Revalidate::Fetcher do
+  subject { described_class.new(component_meta) }
+
+  let(:component_meta) do
+    Alephant::Broker::ComponentMeta.new("test", "test_batch", {})
+  end
+
+  let(:lookup_double)  { instance_double(Alephant::Lookup::LookupHelper) }
+  let(:storage_double) { instance_double(Alephant::Storage) }
+
+  before do
+    allow(Alephant::Lookup).to receive(:create).and_return(lookup_double)
+    allow(Alephant::Storage).to receive(:new).and_return(storage_double)
+    allow(Alephant::Broker).to receive(:config).and_return({})
+    allow_any_instance_of(Logger).to receive(:info)
+  end
+
+  describe "#fetch" do
+    context "when there is something in DynamoDB & S3" do
+      let(:content_body) { "<h1>w00t</h1>" }
+      let(:content_type) { "text/html" }
+
+      let(:content) do
+        instance_double(AWS::S3::S3Object,
+          :content_type => "test/content",
+          :read         => "Test",
+          :metadata     => {
+            "ttl"                => 30,
+            "head_ETag"          => "123",
+            "head_Last-Modified" => "Mon, 11 Apr 2016 10:39:57 GMT"
+          }
+        )
+      end
+
+      before do
+        allow(lookup_double)
+          .to receive(:read)
+          .and_return(spy(:location => "/foo/bar"))
+
+        allow(storage_double)
+          .to receive(:get)
+          .with("/foo/bar")
+          .and_return(content)
+      end
+
+      it "fetches and returns the content as a CachedObject" do
+        returned_data = subject.fetch
+        expect(returned_data.s3_obj).to eq(content)
+      end
+    end
+
+    context "when there is NO entry in DynamoDB" do
+      before do
+        allow(lookup_double)
+          .to receive(:read)
+          .and_return(spy(:location => nil))
+      end
+
+      it "raises an Alephant::Broker::Errors::ContentNotFound error" do
+        expect { subject.fetch }
+          .to raise_error(Alephant::Broker::Errors::ContentNotFound)
+      end
+    end
+
+    context "when there is an entry in DynamoDB" do
+      before do
+        allow(lookup_double)
+          .to receive(:read)
+          .and_return(spy(:location => "/foo/bar"))
+      end
+
+      context "but there is NO content in S3" do
+        before do
+          allow(storage_double)
+            .to receive(:get)
+            .and_raise(AWS::S3::Errors::NoSuchKey.new(nil, nil))
+        end
+
+        it "raises an Alephant::Broker::Errors::ContentNotFound error" do
+          expect { subject.fetch }
+            .to raise_error(Alephant::Broker::Errors::ContentNotFound)
+        end
+      end
+    end
+  end
+end

data/spec/alephant/broker/load_strategy/revalidate/refresher_spec.rb

@@ -0,0 +1,69 @@
+require "spec_helper"
+
+RSpec.describe Alephant::Broker::LoadStrategy::Revalidate::Refresher do
+  subject { described_class.new(component_meta) }
+
+  let(:component_meta) do
+    Alephant::Broker::ComponentMeta.new("test", "test_batch", {})
+  end
+
+  let(:sqs_double)        { instance_double(AWS::SQS, :queues => sqs_queues_double) }
+  let(:sqs_queue_double)  { instance_double(AWS::SQS::Queue) }
+  let(:sqs_queues_double) { instance_double(AWS::SQS::QueueCollection, :url_for => "example.com", :[] => sqs_queue_double) }
+
+  let(:config)  { { :aws_account_id => "12345", :sqs_queue_name => "bob" } }
+
+  let(:cache)              { subject.send(:cache) }
+  let(:cache_key)          { subject.send(:cache_key) }
+  let(:inflight_cache_key) { subject.send(:inflight_cache_key) }
+
+  before do
+    allow_any_instance_of(Logger).to receive(:info)
+    allow_any_instance_of(Logger).to receive(:debug)
+    allow(AWS::SQS).to receive(:new).and_return(sqs_double)
+    allow(Alephant::Broker).to receive(:config).and_return(config)
+  end
+
+  describe "#refresh" do
+    context "when there is already a 'inflight' message in the cache" do
+      before do
+        expect(cache)
+          .to receive(:get)
+          .with(subject.send(:inflight_cache_key))
+          .and_return("true")
+      end
+
+      it "does nothing" do
+        expect(cache).to_not receive(:set)
+
+        subject.refresh
+      end
+    end
+
+    context "when there is NOT already a 'inflight' message in the cache" do
+      before do
+        expect(cache)
+          .to receive(:get)
+          .with(inflight_cache_key)
+          .and_return(nil)
+      end
+
+      it "adds a message to the SQS queue, ",
+        "and puts a 'inflight' message in the cache" do
+        expect(cache).to receive(:set).with(inflight_cache_key, true, described_class::INFLIGHT_CACHE_TTL)
+        expect(sqs_queue_double).to receive(:send_message)
+
+        subject.refresh
+      end
+
+      context "there was a problem pushing a message onto the queue" do
+        it "does NOT put an 'inflight' message in the cache" do
+          expect(cache).to_not receive(:set)
+          expect(sqs_queue_double).to receive(:send_message).and_raise
+
+          expect { subject.refresh }.to raise_error
+        end
+      end
+    end
+  end
+end