contentful-scheduler-custom 1.4.0

data/example/config.ru

@@ -0,0 +1,13 @@
+require 'resque'
+require 'resque/server'
+require 'resque/scheduler/server'
+
+config = {
+  host: '127.0.0.1',
+  port: '6379',
+  password: '5D40001BB59A2EF2439A55DAB7E718609A3A93CC9D3FD414BB13A75933048CD7'
+}
+Resque.redis = config
+
+run Rack::URLMap.new \
+  "/" => Resque::Server.new

data/lib/contentful/scheduler.rb

@@ -0,0 +1,57 @@
+require 'resque'
+require 'redis'
+require 'logger'
+require 'contentful/webhook/listener'
+
+require_relative 'scheduler/controller'
+require_relative 'scheduler/version'
+
+module Contentful
+  module Scheduler
+    DEFAULT_PORT = 32123
+    DEFAULT_ENDPOINT = '/scheduler'
+    DEFAULT_LOGGER = ::Contentful::Webhook::Listener::Support::NullLogger.new
+
+    @@config = nil
+
+    def self.config=(config)
+      fail ':redis configuration missing' unless config.key?(:redis)
+      fail ':spaces configuration missing' unless config.key?(:spaces)
+      config[:spaces].each do |space, data|
+        fail ":management_token missing for space: #{space}" unless data.key?(:management_token)
+      end
+
+      config[:port] = (ENV.key?('PORT') ? ENV['PORT'].to_i : DEFAULT_PORT) unless config.key?(:port)
+      config[:logger] = DEFAULT_LOGGER unless config.key?(:logger)
+      config[:endpoint] = DEFAULT_ENDPOINT unless config.key?(:endpoint)
+
+      ::Resque.redis = config[:redis].dup
+      @@config ||= config
+    end
+
+    def self.config
+      @@config
+    end
+
+    def self.start(config = {})
+      fail "Scheduler not configured" if self.config.nil? && !block_given?
+
+      if block_given?
+        yield(config) if block_given?
+        self.config = config
+      end
+
+      ::Contentful::Webhook::Listener::Server.start do |config|
+        config[:port] = self.config[:port]
+        config[:logger] = self.config[:logger]
+        config[:endpoints] = [
+          {
+            endpoint: self.config[:endpoint],
+            controller: ::Contentful::Scheduler::Controller,
+            timeout: 0
+          }
+        ]
+      end.join
+    end
+  end
+end

data/lib/contentful/scheduler/controller.rb

@@ -0,0 +1,30 @@
+require 'contentful/webhook/listener'
+require_relative 'queue'
+
+module Contentful
+  module Scheduler
+    class Controller < ::Contentful::Webhook::Listener::Controllers::WebhookAware
+      def create
+        return unless webhook.entry?
+
+        logger.info "Queueing - Space: #{webhook.space_id} - Entry: #{webhook.id}"
+
+        Queue.instance(logger).update_or_create(webhook)
+      end
+      alias_method :save, :create
+      alias_method :auto_save, :create
+      alias_method :unarchive, :create
+
+      def delete
+        return unless webhook.entry?
+
+        logger.info "Unqueueing - Space: #{webhook.space_id} - Entry: #{webhook.id}"
+
+        Queue.instance(logger).remove(webhook)
+      end
+      alias_method :unpublish, :delete
+      alias_method :archive, :delete
+      alias_method :publish, :delete
+    end
+  end
+end

data/lib/contentful/scheduler/queue.rb

@@ -0,0 +1,147 @@
+require_relative "tasks"
+require 'chronic'
+require 'contentful/webhook/listener'
+
+module Contentful
+  module Scheduler
+    class Queue
+      @@instance = nil
+
+      attr_reader :config, :logger
+
+      def self.instance(logger = ::Contentful::Webhook::Listener::Support::NullLogger.new)
+        @@instance ||= new(logger)
+      end
+
+      def update_or_create(webhook)
+        return unless publishable?(webhook)
+        remove(webhook) if in_queue?(webhook)
+        return if already_published?(webhook)
+
+        success = Resque.enqueue_at(
+          publish_date(webhook),
+          ::Contentful::Scheduler::Tasks::Publish,
+          webhook.space_id,
+          webhook.id,
+          ::Contentful::Scheduler.config[:spaces][webhook.space_id][:management_token]
+        )
+
+        updateContentBlocks(webhook)
+
+        if success
+          logger.info "Webhook {id: #{webhook.id}, space_id: #{webhook.space_id}} successfully added to queue"
+        else
+          logger.warn "Webhook {id: #{webhook.id}, space_id: #{webhook.space_id}} couldn't be added to queue"
+        end
+      end
+
+      def remove(webhook)
+        return unless publishable?(webhook)
+        return unless in_queue?(webhook)
+
+        success = Resque.remove_delayed(
+          ::Contentful::Scheduler::Tasks::Publish,
+          webhook.space_id,
+          webhook.id,
+          ::Contentful::Scheduler.config[:management_token]
+        )
+
+        removeContentBlocks(webhook)
+
+        if success
+          logger.info "Webhook {id: #{webhook.id}, space_id: #{webhook.space_id}} successfully removed from queue"
+        else
+          logger.warn "Webhook {id: #{webhook.id}, space_id: #{webhook.space_id}} couldn't be removed from queue"
+        end
+      end
+
+      def updateContentBlocks(webhook)
+        if isContentBlockAvailable(webhook)
+          webhook.fields['contentBlocks']['fi-FI'].each do |sys|
+            success = Resque.enqueue_at(
+              publish_date(webhook),
+              ::Contentful::Scheduler::Tasks::Publish,
+              webhook.space_id,
+              sys['sys']['id'],
+              ::Contentful::Scheduler.config[:spaces][webhook.space_id][:management_token]
+            )
+            if success
+              logger.info "Webhook Content block {id: #{sys['sys']['id']}, space_id: #{webhook.space_id}} successfully added to queue"
+            else
+              logger.warn "Webhook Content block {id: #{sys['sys']['id']}, space_id: #{webhook.space_id}} couldn't be added to queue"
+            end
+          end
+        end
+      end
+
+      def removeContentBlocks(webhook)
+        if isContentBlockAvailable(webhook)
+          webhook.fields['contentBlocks']['fi-FI'].each do |sys|
+            success = Resque.remove_delayed(
+              ::Contentful::Scheduler::Tasks::Publish,
+              webhook.space_id,
+              sys['sys']['id'],
+              ::Contentful::Scheduler.config[:management_token]
+            )
+            if success
+              logger.info "Webhook Content Block {id: #{sys['sys']['id']}, space_id: #{webhook.space_id}} successfully removed from queue"
+            else
+              logger.warn "Webhook Content Block {id: #{sys['sys']['id']}, space_id: #{webhook.space_id}} couldn't be removed from queue"
+            end
+          end
+        end
+      end
+
+      def isContentBlockAvailable(webhook)
+        return !webhook.fields['contentBlocks'].nil?
+      end
+
+      def publishable?(webhook)
+        return false unless spaces.key?(webhook.space_id)
+
+        if webhook_publish_field?(webhook)
+          return !webhook_publish_field(webhook).nil?
+        end
+
+        false
+      end
+
+      def already_published?(webhook)
+        return true if publish_date(webhook) < Time.now.utc
+
+        false
+      end
+
+      def in_queue?(webhook)
+        Resque.peek(::Contentful::Scheduler::Tasks::Publish, 0, -1).any? do |job|
+          job['args'][0] == webhook.space_id && job['args'][1] == webhook.id
+        end
+      end
+
+      def publish_date(webhook)
+        date_field = webhook_publish_field(webhook)
+        date_field = date_field[date_field.keys[0]] if date_field.is_a? Hash
+        Chronic.parse(date_field).utc
+      end
+
+      def spaces
+        config[:spaces]
+      end
+
+      def webhook_publish_field?(webhook)
+        webhook.fields.key?(spaces.fetch(webhook.space_id, {})[:publish_field])
+      end
+
+      def webhook_publish_field(webhook)
+        webhook.fields[spaces[webhook.space_id][:publish_field]]
+      end
+
+      private
+
+      def initialize(logger)
+        @config = ::Contentful::Scheduler.config
+        @logger = logger
+      end
+    end
+  end
+end

data/lib/contentful/scheduler/tasks.rb

@@ -0,0 +1 @@
+require_relative 'tasks/publish'

data/lib/contentful/scheduler/tasks/publish.rb

@@ -0,0 +1,21 @@
+require 'contentful/management'
+
+module Contentful
+  module Scheduler
+    module Tasks
+      class Publish
+        @queue = :publish
+
+        def self.perform(space_id, entry_id, token)
+          client = ::Contentful::Management::Client.new(
+            token,
+            raise_errors: true,
+            application_name: 'contentful-scheduler',
+            application_version: Contentful::Scheduler::VERSION
+          )
+          client.entries.find(space_id, entry_id).publish
+        end
+      end
+    end
+  end
+end

data/lib/contentful/scheduler/version.rb

@@ -0,0 +1,5 @@
+module Contentful
+  module Scheduler
+    VERSION = "1.4.0"
+  end
+end

data/spec/contentful/scheduler/controller_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Contentful::Scheduler::Controller do
+  let(:server) { MockServer.new }
+  let(:logger) { Contentful::Webhook::Listener::Support::NullLogger.new }
+  let(:timeout) { 10 }
+  let(:headers) { {'X-Contentful-Topic' => '', 'X-Contentful-Webhook-Name' => 'SomeName'} }
+  let(:body) { {sys: { id: 'foo', space: { sys: { id: 'space_foo' } } }, fields: {} } }
+  let(:queue) { ::Contentful::Scheduler::Queue.instance }
+  subject { described_class.new server, logger, timeout }
+
+  describe 'events' do
+    [:create, :save, :auto_save, :unarchive].each do |event|
+      it "creates or updates webhook metadata in publish queue on #{event}" do
+        expect(queue).to receive(:update_or_create)
+
+        headers['X-Contentful-Topic'] = "ContentfulManagement.Entry.#{event}"
+        request = RequestDummy.new(headers, body)
+        subject.respond(request, MockResponse.new).join
+      end
+    end
+
+    [:delete, :unpublish, :archive, :publish].each do |event|
+      it "deletes webhook metadata in publish queue on #{event}" do
+        expect(queue).to receive(:remove)
+
+        headers['X-Contentful-Topic'] = "ContentfulManagement.Entry.#{event}"
+        request = RequestDummy.new(headers, body)
+        subject.respond(request, MockResponse.new).join
+      end
+    end
+
+    [:create, :save, :unarchive, :delete, :unpublish, :archive, :publish].each do |event|
+      ['Asset', 'ContentType'].each do |kind|
+        it "ignores #{kind} on #{event}" do
+          expect(queue).not_to receive(:remove)
+          expect(queue).not_to receive(:update_or_create)
+
+          headers['X-Contentful-Topic'] = "ContentfulManagement.#{kind}.#{event}"
+          request = RequestDummy.new(headers, body)
+          subject.respond(request, MockResponse.new).join
+        end
+      end
+    end
+  end
+end

data/spec/contentful/scheduler/queue_spec.rb

@@ -0,0 +1,257 @@
+require 'spec_helper'
+
+class WebhookDouble
+  attr_reader :id, :space_id, :sys, :fields
+  def initialize(id, space_id, sys = {}, fields = {})
+    @id = id
+    @space_id = space_id
+    @sys = sys
+    @fields = fields
+  end
+end
+
+describe Contentful::Scheduler::Queue do
+  let(:config) {
+    {
+      logger: ::Contentful::Scheduler::DEFAULT_LOGGER,
+      endpoint: ::Contentful::Scheduler::DEFAULT_ENDPOINT,
+      port: ::Contentful::Scheduler::DEFAULT_PORT,
+      redis: {
+        host: 'localhost',
+        port: 12341,
+        password: 'foobar'
+      },
+      spaces: {
+        'foo' => {
+          publish_field: 'my_field',
+          management_token: 'foo'
+        }
+      }
+    }
+  }
+
+  subject { described_class.instance }
+
+  before :each do
+    allow(Resque).to receive(:redis=)
+    described_class.class_variable_set(:@@instance, nil)
+    ::Contentful::Scheduler.config = config
+  end
+
+  describe 'singleton' do
+    it 'creates an instance if not initialized' do
+      queue = described_class.instance
+      expect(queue).to be_a described_class
+    end
+
+    it 'reuses same instance' do
+      queue = described_class.instance
+
+      expect(queue).to eq described_class.instance
+    end
+  end
+
+  describe 'attributes' do
+    it '.config' do
+      expect(subject.config).to eq config
+    end
+  end
+
+  describe 'instance methods' do
+    it '#spaces' do
+      expect(subject.spaces).to eq config[:spaces]
+    end
+
+    it '#webhook_publish_field?' do
+      expect(subject.webhook_publish_field?(
+        WebhookDouble.new('bar', 'foo', {}, {'my_field' => 'something'})
+      )).to be_truthy
+
+      expect(subject.webhook_publish_field?(
+        WebhookDouble.new('bar', 'foo', {}, {'not_my_field' => 'something'})
+      )).to be_falsey
+
+      expect(subject.webhook_publish_field?(
+        WebhookDouble.new('bar', 'not_foo', {}, {'not_my_field' => 'something'})
+      )).to be_falsey
+    end
+
+    it '#webhook_publish_field' do
+      expect(subject.webhook_publish_field(
+        WebhookDouble.new('bar', 'foo', {}, {'my_field' => 'something'})
+      )).to eq 'something'
+    end
+
+    describe '#publish_date' do
+      it 'works if date field not localized' do
+        expect(subject.publish_date(
+          WebhookDouble.new('bar', 'foo', {}, {'my_field' => '2011-04-04T22:00:00+00:00'})
+        )).to eq DateTime.new(2011, 4, 4, 22, 0, 0).to_time.utc
+      end
+
+      it 'works if date field localized by grabbing first available locale' do
+        expect(subject.publish_date(
+          WebhookDouble.new('bar', 'foo', {}, {'my_field' => {'en-US': '2011-04-04T22:00:00+00:00'}})
+        )).to eq DateTime.new(2011, 4, 4, 22, 0, 0).to_time.utc
+
+        expect(subject.publish_date(
+          WebhookDouble.new('bar', 'foo', {}, {'my_field' => {'en-CA': '2011-04-04T23:00:00Z'}})
+        )).to eq DateTime.new(2011, 4, 4, 23, 0, 0).to_time.utc
+      end
+    end
+
+    describe '#already_published?' do
+      it 'true if webhook publish_date is in past' do
+        expect(subject.already_published?(
+          WebhookDouble.new('bar', 'foo', {}, {'my_field' => '2011-04-04T22:00:00+00:00'})
+        )).to be_truthy
+      end
+
+      it 'false if sys.publishedAt is in past' do
+        expect(subject.already_published?(
+          WebhookDouble.new('bar', 'foo', {'publishedAt' =>  '2011-04-04T22:00:00+00:00'}, {'my_field' => '2099-04-04T22:00:00+00:00'})
+        )).to be_falsey
+      end
+
+      it 'false if sys.publishedAt is not present' do
+        expect(subject.already_published?(
+          WebhookDouble.new('bar', 'foo', {}, {'my_field' => '2099-04-04T22:00:00+00:00'})
+        )).to be_falsey
+      end
+
+      it 'false if sys.publishedAt is present but nil' do
+        expect(subject.already_published?(
+          WebhookDouble.new('bar', 'foo', {'publishedAt' => nil}, {'my_field' => '2099-04-04T22:00:00+00:00'})
+        )).to be_falsey
+      end
+    end
+
+    describe '#publishable?' do
+      it 'false if webhook space not present in config' do
+        expect(subject.publishable?(
+          WebhookDouble.new('bar', 'not_foo')
+        )).to be_falsey
+      end
+
+      it 'false if publish_field is not found' do
+        expect(subject.publishable?(
+          WebhookDouble.new('bar', 'foo')
+        )).to be_falsey
+      end
+
+      it 'false if publish_field is nil' do
+        expect(subject.publishable?(
+          WebhookDouble.new('bar', 'foo', {}, {'my_field' => nil})
+        )).to be_falsey
+      end
+
+      it 'true if publish_field is populated' do
+        expect(subject.publishable?(
+          WebhookDouble.new('bar', 'foo', {}, {'my_field' => '2011-04-04T22:00:00+00:00'})
+        )).to be_truthy
+      end
+    end
+
+    describe '#in_queue?' do
+      it 'false if not in queue' do
+        allow(Resque).to receive(:peek) { [] }
+        expect(subject.in_queue?(
+          WebhookDouble.new('bar', 'foo')
+        )).to be_falsey
+      end
+
+      it 'true if in queue' do
+        allow(Resque).to receive(:peek) { [{'args' => ['foo', 'bar']}] }
+        expect(subject.in_queue?(
+          WebhookDouble.new('bar', 'foo')
+        )).to be_truthy
+      end
+    end
+
+    describe '#update_or_create' do
+      it 'does nothing if webhook is unpublishable' do
+        expect(Resque).not_to receive(:enqueue_at)
+
+        subject.update_or_create(WebhookDouble.new('bar', 'not_foo'))
+      end
+
+      describe 'webhook is new' do
+        it 'queues' do
+          mock_redis = Object.new
+          allow(mock_redis).to receive(:client) { mock_redis }
+          allow(mock_redis).to receive(:id) { 'foo' }
+          allow(Resque).to receive(:peek) { [] }
+          allow(Resque).to receive(:redis) { mock_redis }
+
+          expect(Resque).to receive(:enqueue_at).with(
+            DateTime.strptime('2099-04-04T22:00:00+00:00').to_time.utc,
+            ::Contentful::Scheduler::Tasks::Publish,
+            'foo',
+            'bar',
+            'foo'
+          ) { true }
+
+          subject.update_or_create(WebhookDouble.new('bar', 'foo', {}, {'my_field' => '2099-04-04T22:00:00+00:00'}))
+        end
+
+        it 'does nothing if already published' do
+          allow(Resque).to receive(:peek) { [] }
+          expect(Resque).not_to receive(:enqueue_at)
+
+          subject.update_or_create(WebhookDouble.new('bar', 'foo', {}, {'my_field' => '2011-04-04T22:00:00+00:00'}))
+        end
+      end
+
+      describe 'webhook already in queue' do
+        it 'calls remove then queues again' do
+          mock_redis = Object.new
+          allow(mock_redis).to receive(:client) { mock_redis }
+          allow(mock_redis).to receive(:id) { 'foo' }
+          allow(Resque).to receive(:redis) { mock_redis }
+
+          allow(Resque).to receive(:peek) { [{'args' => ['foo', 'bar']}] }
+          expect(Resque).to receive(:enqueue_at).with(
+            DateTime.strptime('2099-04-04T22:00:00+00:00').to_time.utc,
+            ::Contentful::Scheduler::Tasks::Publish,
+            'foo',
+            'bar',
+            'foo'
+          ) { true }
+          expect(subject).to receive(:remove)
+
+          subject.update_or_create(WebhookDouble.new('bar', 'foo', {}, {'my_field' => '2099-04-04T22:00:00+00:00'}))
+        end
+
+        it 'removes old call if already published' do
+          allow(Resque).to receive(:peek) { [{'args' => ['foo', 'bar']}] }
+          expect(Resque).not_to receive(:enqueue_at)
+          expect(subject).to receive(:remove)
+
+          subject.update_or_create(WebhookDouble.new('bar', 'foo', {}, {'my_field' => '2011-04-04T22:00:00+00:00'}))
+        end
+      end
+    end
+
+    describe '#remove' do
+      it 'does nothing if webhook is unpublishable' do
+        expect(Resque).not_to receive(:remove_delayed)
+
+        subject.remove(WebhookDouble.new('bar', 'foo'))
+      end
+
+      it 'does nothing if webhook not in queue' do
+        allow(Resque).to receive(:peek) { [] }
+        expect(Resque).not_to receive(:remove_delayed)
+
+        subject.remove(WebhookDouble.new('bar', 'foo', {}, {'my_field' => '2011-04-04T22:00:00+00:00'}))
+      end
+
+      it 'removes if in queue' do
+        allow(Resque).to receive(:peek) { [{'args' => ['foo', 'bar']}] }
+        expect(Resque).to receive(:remove_delayed)
+
+        subject.remove(WebhookDouble.new('bar', 'foo', {}, {'my_field' => '2011-04-04T22:00:00+00:00'}))
+      end
+    end
+  end
+end