contentful-scheduler-custom 1.5.5 → 1.5.7.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 488a4c42e0d829618efde8fdaf18953c81bafe63
-  data.tar.gz: 0c92afbe94d2639d6dd1e9e9618224cdfb1850db
+  metadata.gz: db750774a8a2cfe5bc4ed62675d333d2aed6f54e
+  data.tar.gz: 0bd0169f942a00076035eeee33847b59cab31967
 SHA512:
-  metadata.gz: bf1e2dc8b595901ee953edafd1e58ae965230791e32f0faf9a64aae8fd3451107c63aea1889923ace033381ab9458ca39e21b8ccb3bf88593d83c71e740c7043
-  data.tar.gz: 6ef9ca2783f080851ef7d122c0cee760f362cea97f4b384bb13407101a2695991fb6624510ab0c552b4286548bc4ab366d3890d3484682a2c74906eb1402d1c7
+  metadata.gz: eb7537a86727e84ce6b7a27fdb47642a77533a7306ccbf43e749f9751f016d20df4017ebb053d65b441f44410a91b1ced8b8153e16616ed96534193933d36269
+  data.tar.gz: 499937e363723d4df684f7dd95a46d7f0185f02b0cf80e7e2cdaec6651e33c3fccf57c1b471761849adddb6d7cdc7b52d41beffa82aacaa3d183fd76739d5c52

data/.gitignore

@@ -9,5 +9,3 @@
 /tmp/
 .DS_Store
 dump.rdb
-/.idea/
-/example/.rakeTasks

data/CHANGELOG.md

@@ -2,14 +2,25 @@
 
 ## Unreleased
 
-## 1.4.0
-* Contentful Scheduler now supports future publishing for any existing enteries and
-publishing ContentBlocks first before publishing the page.
+## 0.5.0
+### Added
+* Added support for scheduled unpublishing. [#10](https://github.com/contentful/contentful-scheduler.rb/issues/10)
+
+## 0.4.0
+### Fixed
+* Fixed User Agent Header to comply with specification.
+
+### Added
+* Added authentication mechanisms. [#9](https://github.com/contentful/contentful-scheduler.rb/issues/9)
+
+## 0.3.0
+### Added
+* Added possibility to republish already published content. [#5](https://github.com/contentful/contentful-scheduler.rb/issues/5)
 
 ## 0.2.1
 
 ### Fixed
-* Fix time parsing.
+* Fixed time parsing.
 
 ## 0.2.0
 

data/README.md

@@ -7,17 +7,18 @@ Scheduling Server for Contentful entries.
 
 ## What does `contentful-scheduler` do?
 The aim of `contentful-scheduler` is to have developers setting up their Contentful
-entries for scheduled publishing.
+entries for scheduled publishing and unpublishing.
 
 ## How does it work
-`contentful-scheduler` provides a web endpoint to receive webhook calls from Contentful,
-every time the endpoint recieves a call it looks for the value of the field defined in the configuration,
-if the value is a time in the future it will schedule the entry for publishing at the specified time.
+`contentful-scheduler` provides a web endpoint to receive webhook calls from Contentful.
+
+Every time the endpoint recieves a call it looks for the value of the field defined in the configuration.
+If the value is a time in the future it will schedule the entry for publishing or unpublishing at the specified time.
+
 A background worker based on the popular `resque` gem will then proceed to actually make the publish call
-against the Content Management API at the due time. For this the Entries you wish to publish require a
-customizable Date field, which we advice to call `publishDate`, this field can be configured inside your
-`Rakefile` and is specific per-space(supports multiple spaces), also please make sure contentBlocks are valid
-as per logic contentBlocks are published first then the page is published, so if there is any contentBlocks missing publishing won't work.
+against the Content Management API at the due time. For this the Entries you wish to publish or unpublish require a
+customizable Date field, which we advice to call `publishDate` for the publishing action and `unpublishDate` for the unpublishing action,
+this field can be configured inside your `Rakefile` and is specific per-space.
 
 You can add multiple spaces to your configuration, making it useful if you have a milti-space setup.
 
@@ -30,7 +31,7 @@ You can add multiple spaces to your configuration, making it useful if you have
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'contentful-scheduler-custom'
+gem 'contentful-scheduler'
 ```
 
 And then execute:
@@ -39,7 +40,7 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install contentful-scheduler-custom
+    $ gem install contentful-scheduler
 
 ## Usage
 
@@ -55,7 +56,7 @@ If you want to roll out your own, you need to follow the next steps:
 ```ruby
 source 'https://rubygems.org'
 
-gem 'contentful-scheduler-custom', '~>1.4'
+gem 'contentful-scheduler', '~> 0.1'
 gem 'contentful-management', '~> 1.0'
 gem 'resque', '~> 1.0'
 gem 'resque-scheduler', '~> 4.0'
@@ -90,15 +91,11 @@ config = {
   spaces: {
     'YOUR_SPACE_ID' => {
       publish_field: 'publishDate', # It specifies the field ID for your Publish Date in your Content Type
-      management_token: 'YOUR_TOKEN'
-    },
-    'YOUR_SPACE_ID' => {
-      publish_field: 'publishDate', # It specifies the field ID for your Publish Date in your Content Type
-      management_token: 'YOUR_TOKEN'
-     },
-    'YOUR_SPACE_ID' => {
-      publish_field: 'publishDate', # It specifies the field ID for your Publish Date in your Content Type
-      management_token: 'YOUR_TOKEN'
+      unpublish_field: 'unpublishDate', # Optional - It specifies the field ID for your Unpublish Date in your Content Type
+      management_token: 'YOUR_TOKEN',
+      auth: { # This is optional
+        # ... content in this section will be explained in a separate section ...
+      }
     }
   },
 }
@@ -159,85 +156,114 @@ Under the space settings menu choose webhook and add a new webhook pointing to `
 
 Keep in mind that if you modify the defaults, the URL should be changed to the values specified in the configuration.
 
-## Running in Heroku
+## Authentication
 
-Heroku offers various Redis plugins, select the one of your liking, add the credentials into your configuration, and proceed to
-`git heroku push master`.
+You may want to provide an additional layer of security to your scheduler server, therefore an additional option to add space based authentication is provided.
 
-This will get your application set up and running. It will require 4 dynos, so a free plan isn't enough for it to run.
+There are two available authentication methods. Static string matching and lambda validations, which will be explained in the next section.
 
-To run the `monitor` process, you'll require to run it from a different application pointing to the same Redis instance.
+Any of both mechanisms require you to add additional headers to your webhook set up, which can be done through the [Contentful Web App](https://app.contentful.com),
+or through the [CMA](https://www.contentful.com/developers/docs/references/content-management-api/#/reference/webhooks/webhook/create-update-a-webhook/console/ruby).
 
-Make sure to change the `Procfile`'s `web` process to the following:
+### Authentication via static token matching
 
-```
-web: PORT=$PORT bundle exec env rake contentful:scheduler
-```
+The simplest authentication mechanism, is to provide a static set of valid strings that are considered valid when found in a determined header.
 
-That will allow Heroku to set it's own Port according to their policy.
+For example:
 
-The URL for the webhook then will be on port 80, so you should change it to: `http://YOUR_APPLICATION/scheduler`.
+```ruby
+config = {
+  # ... the rest of the config ...
+  spaces: {
+    'my_space' => {
+      # ... the rest of the space specific configuration ...
+      auth: {
+        key: 'X-Webhook-Server-Auth-Header',
+        valid_tokens: ['some_valid_static_token']
+      }
+    }
+  }
+}
+```
 
-## Running in Production Mode
+The above example, whenever your webhook sends the `X-Webhook-Server-Auth-Header` with a value of `some_valid_static_token`,
+it will accept the request and queue your webhook for processing.
 
-After verifying that application is working fine in development mode(run "foreman start" for development mode)
+You can provide multiple or a single token. If a single token is provided, it's not necessary to include it in an array.
 
-Run the following commands
+### Authentication via lambda
 
-1. sudo foreman export -p5000 --app stp --user username_to_start_from systemd /etc/systemd/system/
+A more complicated solution, but far more secure, is the ability to execute a lambda as the validator function.
+This allows you define a function for authentication. This function can call an external authentication service,
+make checks against a database or do internal processing.
 
-Output will be like this:
+The function must return a truthy/falsey value in order for the authentication to be successful/unsuccessful.
 
-[foreman export] cleaning up directory: /etc/systemd/system//graphical.target.wants
-[foreman export] writing: stp-web@.service
-[foreman export] creating: stp-web.target.wants
-[foreman export] symlinking: stp-web.target.wants/stp-web@5000.service -> ../stp-web@.service
-[foreman export] writing: stp-web.target
-[foreman export] writing: stp-celery@.service
-[foreman export] creating: stp-celery.target.wants
-[foreman export] symlinking: stp-celery.target.wants/stp-celery@5100.service -> ../stp-celery@.service
-[foreman export] writing: stp-celery.target
-[foreman export] writing: stp.target
+For example, we validate that the token provided is either `foo` or `bar`:
 
-2. cat /etc/systemd/system/stp-web@.service | head -n 10
+```ruby
+config = {
+  # ... the rest of the config ...
+  spaces: {
+    'my_space' => {
+      # ... the rest of the space specific configuration ...
+      auth: {
+        key: 'X-Webhook-Server-Auth-Header',
+        validation: -> (value) { /^(foo|bar)$/ =~ value }
+      }
+    }
+  }
+}
+```
 
-Output will be like this:
+Or a more complicated example, checking if the header is a valid OAuth token, and then making a request to our OAuth database.
+For this example we'll consider you have a table called `tokens` and are using [DataMapper](https://datamapper.org) as a ORM,
+and have a `valid?` method checking if the token is not expired.
 
-[Unit]
-PartOf=stp-web.target
+```ruby
+config = {
+  # ... the rest of the config ...
+  spaces: {
+    'my_space' => {
+      # ... the rest of the space specific configuration ...
+      auth: {
+        key: 'X-Webhook-Server-Auth-Header',
+        validation: proc do |value|
+          return false unless /^Bearer \w+/ =~ value
 
-[Service]
-User=username_to_start_from 
-WorkingDirectory=/srv/stp/
-Environment=PORT=%i
-... HERE OTHER DIRICTIVES FROM YOUR .env file ...
-Environment=DEBUG=0
-...
+          token = Token.first(token: value.gsub('Bearer ', ''))
 
+          return false if token.nil?
 
-3. Start only gunicorn on port 5700:
+          token.valid?
+        end
+      }
+    }
+  }
+}
+```
 
-   systemctl start stp-web@5700.service
+If you have multiple spaces and all share the same auth strategy, you can extract the authentication method to a variable,
+and assign it to all the applicable spaces in order to reduce the code duplication.
 
-4. Start whole target:
+## Running in Heroku
 
-   systemctl start stp.target
+Heroku offers various Redis plugins, select the one of your liking, add the credentials into your configuration, and proceed to
+`git heroku push master`.
 
-5. Enable whole target (start on OS boot):
+This will get your application set up and running. It will require 4 dynos, so a free plan isn't enough for it to run.
 
-   systemctl enable stp.target
+To run the `monitor` process, you'll require to run it from a different application pointing to the same Redis instance.
 
-6. Restarting daemon
+Make sure to change the `Procfile`'s `web` process to the following:
 
-   sudo systemctl daemon-reload
-   
-   sudo systemctl restart stp.target
-   
-7. Optional 
+```
+web: PORT=$PORT bundle exec env rake contentful:scheduler
+```
 
-   You can also simply define port when call foreman export -pXXXX, but it should be multiple of 1000,
-   e.g. 1000, 2000, 3000, 45000 etc.
+That will allow Heroku to set it's own Port according to their policy.
 
+The URL for the webhook then will be on port 80, so you should change it to: `http://YOUR_APPLICATION/scheduler`.
 
 ## Contributing
 

data/contentful-scheduler.gemspec

@@ -21,8 +21,8 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "contentful-webhook-listener", "~> 0.2"
   spec.add_runtime_dependency "contentful-management", "~> 1.8"
-  spec.add_runtime_dependency "resque", "~> 1.27.4"
-  spec.add_runtime_dependency "resque-scheduler", "~> 4.2.1"
+  spec.add_runtime_dependency "resque", "~> 1.0"
+  spec.add_runtime_dependency "resque-scheduler", "~> 4.0"
   spec.add_runtime_dependency "redis", "~> 3.0"
   spec.add_runtime_dependency "chronic", "~> 0.10"
 

data/example/Gemfile

@@ -1,8 +1,7 @@
 source 'https://rubygems.org'
 
-gem 'contentful-scheduler-custom', '~>1.4'
+gem 'contentful-scheduler', '~> 0.1'
 gem 'contentful-management', '~> 1.0'
 gem 'resque', '~> 1.0'
-gem 'resque-scheduler', '4.2.1'
+gem 'resque-scheduler', '~> 4.0'
 gem 'rake'
-gem 'foreman', '~> 0.84.0'

data/example/Procfile

@@ -1,4 +1,4 @@
-web: PORT=$PORT bundle exec env rake contentful:scheduler
+web: env bundle exec rake contentful:scheduler
 monitor: env bundle exec rackup
 resque: env bundle exec rake resque:work
-resque_scheduler: env bundle exec rake resque:scheduler
+resque_scheduler: env bundle exec rake resque:scheduler

data/example/Rakefile

@@ -1,22 +1,23 @@
 require 'contentful/scheduler'
+require 'logger' # Optional
 
 $stdout.sync = true
 
 config = {
   logger: Logger.new(STDOUT), # Defaults to NullLogger
-  port: 8080, # Defaults to 8081
+  port: 32123, # Defaults to 32123
   endpoint: '/scheduler', # Defaults to /scheduler
   redis: {
-    host: 'scheduler-redis-db',
-    port: '6379',
-    password: 'password'
+    host: 'YOUR_REDIS_HOST',
+    port: 'YOUR_REDIS_PORT',
+    password: 'YOUR_REDIS_PASSWORD'
   },
   spaces: {
-    'qbra4qai2ti2' => {
+    'YOUR_SPACE_ID' => {
       publish_field: 'publishDate', # It specifies the field ID for your Publish Date in your Content Type
-      management_token: 'CFPAT-45f0c4258aa9b32e8a8b6ccebf64136386b31f3ec435cc17f540368d5416de02'
+      management_token: 'YOUR_TOKEN'
     }
-  },
+  }
 }
 
 namespace :contentful do

data/example/config.ru

@@ -3,9 +3,9 @@ require 'resque/server'
 require 'resque/scheduler/server'
 
 config = {
-  host: 'scheduler-redis-db',
-  port: '6379',
-  password: 'password'
+  host: 'YOUR_REDIS_HOST',
+  port: 'YOUR_REDIS_PORT',
+  password: 'YOUR_REDIS_PASSWORD'
 }
 Resque.redis = config
 

data/lib/contentful/scheduler/auth.rb

@@ -0,0 +1,64 @@
+module Contentful
+  module Scheduler
+    class Auth
+      attr_reader :webhook
+
+      def initialize(webhook)
+        @webhook = webhook
+      end
+
+      def auth
+        return true if auth_config.nil?
+
+        return verify_key_value_config if key_value_config?
+        return verify_lambda_config if lambda_config?
+
+        false
+      end
+
+      private
+
+      def key_value_config?
+        auth_config.key?(:key) && auth_config.key?(:valid_tokens)
+      end
+
+      def verify_key_value_config
+        value = webhook.raw_headers[auth_config[:key]]
+
+        return false if value.nil?
+
+        valid_tokens = auth_config[:valid_tokens]
+
+        return valid_tokens.include?(value) if valid_tokens.is_a?(::Array)
+        valid_tokens == value
+      end
+
+      def lambda_config?
+        auth_config.key?(:key) && auth_config.key?(:validation)
+      end
+
+      def verify_lambda_config
+        value = webhook.raw_headers[auth_config[:key]]
+
+        return false if value.nil?
+
+        validation = auth_config[:validation]
+
+        return false unless validation.is_a?(::Proc)
+
+        validation[value]
+      end
+
+      def auth_config
+        ::Contentful::Scheduler.config
+          .fetch(:spaces, {})
+          .fetch(space_id, {})
+          .fetch(:auth, nil)
+      end
+
+      def space_id
+        webhook.space_id
+      end
+    end
+  end
+end

data/lib/contentful/scheduler/controller.rb

@@ -1,4 +1,5 @@
 require 'contentful/webhook/listener'
+require_relative 'auth'
 require_relative 'queue'
 
 module Contentful
@@ -7,6 +8,11 @@ module Contentful
       def create
         return unless webhook.entry?
 
+        if !Auth.new(webhook).auth
+          logger.warn "Skipping - Authentication failed for Space: #{webhook.space_id} - Entry: #{webhook.id}"
+          return
+        end
+
         logger.info "Queueing - Space: #{webhook.space_id} - Entry: #{webhook.id}"
 
         Queue.instance(logger).update_or_create(webhook)
@@ -18,6 +24,11 @@ module Contentful
       def delete
         return unless webhook.entry?
 
+        if !Auth.new(webhook).auth
+          logger.warn "Skipping - Authentication failed for Space: #{webhook.space_id} - Entry: #{webhook.id}"
+          return
+        end
+
         logger.info "Unqueueing - Space: #{webhook.space_id} - Entry: #{webhook.id}"
 
         Queue.instance(logger).remove(webhook)
@@ -25,6 +36,9 @@ module Contentful
       alias_method :unpublish, :delete
       alias_method :archive, :delete
       alias_method :publish, :delete
+      alias_method :save, :delete
+      alias_method :auto_save, :delete
+      alias_method :unarchive, :delete
     end
   end
 end

data/lib/contentful/scheduler/queue.rb

@@ -15,17 +15,16 @@ module Contentful
 
       def update_or_create(webhook)
         if publishable?(webhook)
-          success = update_or_create_for_publish(webhook)
+          successPublish = update_or_create_for_publish(webhook)
           updateContentBlocks(webhook, 'publish')
-          log_event_success(webhook, success, 'publish', 'added to')
+          log_event_success(webhook, successPublish, 'publish', 'added to')
         end
 
         if unpublishable?(webhook)
-          success = update_or_create_for_unpublish(webhook)
+          successUnpublish = update_or_create_for_unpublish(webhook)
           updateContentBlocks(webhook, 'unpublish')
-          log_event_success(webhook, success, 'unpublish', 'added to')
+          log_event_success(webhook, successUnpublish, 'unpublish', 'added to')
         end
-
       end
 
       def update_or_create_for_publish(webhook)
@@ -55,8 +54,8 @@ module Contentful
       end
 
       def remove(webhook)
-        remove_publish(webhook)
         remove_unpublish(webhook)
+        remove_publish(webhook)
       end
 
       def remove_publish(webhook)
@@ -75,11 +74,87 @@ module Contentful
         log_event_success(webhook, success, 'publish', 'removed from')
       end
 
+      def remove_unpublish(webhook)
+        return unless unpublishable?(webhook)
+        return unless in_unpublish_queue?(webhook)
+
+        success = Resque.remove_delayed(
+          ::Contentful::Scheduler::Tasks::Unpublish,
+          webhook.space_id,
+          webhook.id,
+          ::Contentful::Scheduler.config[:management_token]
+        )
+
+        removeContentBlocks(webhook, 'unpublish')
+
+        log_event_success(webhook, success, 'unpublish', 'removed from')
+      end
+
+      def log_event_success(webhook, success, event_kind, action)
+        if success
+          logger.info "Webhook {id: #{webhook.id}, space_id: #{webhook.space_id}} successfully #{action} the #{event_kind} queue"
+        else
+          logger.warn "Webhook {id: #{webhook.id}, space_id: #{webhook.space_id}} couldn't be #{action} the #{event_kind} queue"
+        end
+      end
+
+      def publishable?(webhook)
+        return false unless spaces.key?(webhook.space_id)
+
+        if webhook_publish_field?(webhook)
+          return !webhook_publish_field(webhook).nil? && publish_is_future?(webhook)
+        end
+
+        false
+      end
+
+      def unpublishable?(webhook)
+        return false unless spaces.key?(webhook.space_id)
+
+        if webhook_unpublish_field?(webhook)
+          return !webhook_unpublish_field(webhook).nil? && unpublish_is_future?(webhook)
+        end
+
+        false
+      end
+
+      def publish_is_future?(webhook)
+        publish_date(webhook) > Time.now.utc
+      end
+
+      def unpublish_is_future?(webhook)
+        unpublish_date(webhook) > Time.now.utc
+      end
+
+      def in_publish_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 in_unpublish_queue?(webhook)
+        Resque.peek(::Contentful::Scheduler::Tasks::Unpublish, 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 unpublish_date(webhook)
+        date_field = webhook_unpublish_field(webhook)
+        date_field = date_field[date_field.keys[0]] if date_field.is_a? Hash
+        Chronic.parse(date_field).utc
+      end
+
       def updateContentBlocks(webhook, type)
         if isContentBlockAvailable(webhook)
           webhook.fields['contentBlocks']['fi-FI'].each do |sys|
             success = Resque.enqueue_at(
-              publish_date(webhook),
+              getPublishOrUnpublishDate(webhook, type),
               getScheduleType(type),
               webhook.space_id,
               sys['sys']['id'],
@@ -94,14 +169,6 @@ module Contentful
         end
       end
 
-      def getScheduleType(type)
-        if type == 'unpublish'
-          return ::Contentful::Scheduler::Tasks::Unpublish
-        else
-          return ::Contentful::Scheduler::Tasks::Publish
-        end
-      end
-
       def removeContentBlocks(webhook, type)
         if isContentBlockAvailable(webhook)
           webhook.fields['contentBlocks']['fi-FI'].each do |sys|
@@ -124,72 +191,20 @@ module Contentful
         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? && publish_is_future?(webhook)
-        end
-
-        false
-      end
-
-      def publish_is_future?(webhook)
-        publish_date(webhook) > Time.now.utc
-      end
-
-      def in_publish_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 remove_unpublish(webhook)
-        return unless unpublishable?(webhook)
-        return unless in_unpublish_queue?(webhook)
-
-        success = Resque.remove_delayed(
-          ::Contentful::Scheduler::Tasks::Unpublish,
-          webhook.space_id,
-          webhook.id,
-          ::Contentful::Scheduler.config[:management_token]
-        )
-
-        removeContentBlocks(webhook, 'unpublish')
-
-        log_event_success(webhook, success, 'unpublish', 'removed from')
-      end
-
-      def in_unpublish_queue?(webhook)
-        Resque.peek(::Contentful::Scheduler::Tasks::Unpublish, 0, -1).any? do |job|
-          job['args'][0] == webhook.space_id && job['args'][1] == webhook.id
+      def getScheduleType(type)
+        if type == 'publish'
+          ::Contentful::Scheduler::Tasks::Publish
+        else
+          ::Contentful::Scheduler::Tasks::Unpublish
         end
       end
 
-      def unpublish_is_future?(webhook)
-        unpublish_date(webhook) > Time.now.utc
-      end
-
-      def unpublishable?(webhook)
-        return false unless spaces.key?(webhook.space_id)
-
-        if webhook_unpublish_field?(webhook)
-          return !webhook_unpublish_field(webhook).nil? && unpublish_is_future?(webhook)
+      def getPublishOrUnpublishDate(webhook, type)
+        if type == 'publish'
+          publish_date(webhook)
+        else
+          unpublish_date(webhook)
         end
-
-        false
-      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 unpublish_date(webhook)
-        date_field = webhook_unpublish_field(webhook)
-        date_field = date_field[date_field.keys[0]] if date_field.is_a? Hash
-        Chronic.parse(date_field).utc
       end
 
       def spaces
@@ -212,14 +227,6 @@ module Contentful
         webhook.fields[spaces[webhook.space_id][:unpublish_field]]
       end
 
-      def log_event_success(webhook, success, event_kind, action)
-        if success
-          logger.info "Webhook {id: #{webhook.id}, space_id: #{webhook.space_id}} successfully #{action} the #{event_kind} queue"
-        else
-          logger.warn "Webhook {id: #{webhook.id}, space_id: #{webhook.space_id}} couldn't be #{action} the #{event_kind} queue"
-        end
-      end
-
       private
 
       def initialize(logger)

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

@@ -10,7 +10,7 @@ module Contentful
           client = ::Contentful::Management::Client.new(
             token,
             raise_errors: true,
-            application_name: 'contentful-scheduler',
+            application_name: 'contentful.scheduler',
             application_version: Contentful::Scheduler::VERSION
           )
           client.entries.find(space_id, entry_id).publish

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

@@ -10,7 +10,7 @@ module Contentful
           client = ::Contentful::Management::Client.new(
             token,
             raise_errors: true,
-            application_name: 'contentful-scheduler',
+            application_name: 'contentful.scheduler',
             application_version: Contentful::Scheduler::VERSION
           )
           client.entries.find(space_id, entry_id).unpublish
@@ -18,4 +18,4 @@ module Contentful
       end
     end
   end
-end
+end

data/lib/contentful/scheduler/version.rb

@@ -1,5 +1,5 @@
 module Contentful
   module Scheduler
-    VERSION = "1.5.5"
+    VERSION = "1.5.7.1.1"
   end
 end

data/spec/contentful/scheduler/auth_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Contentful::Scheduler::Auth do
+  before :each do
+    Contentful::Scheduler.config = base_config
+  end
+
+  describe 'auth' do
+    context 'when no auth is provided' do
+      it 'always returns true' do
+        webhook = WebhookDouble.new('id', 'no_auth')
+        expect(described_class.new(webhook).auth).to be_truthy
+      end
+    end
+
+    context 'when providing token array auth' do
+      it 'false when key not found' do
+        webhook = WebhookDouble.new('id', 'valid_token_array')
+        expect(described_class.new(webhook).auth).to be_falsey
+      end
+
+      it 'false when key found but value not matched' do
+        webhook = WebhookDouble.new('id', 'valid_token_array', {}, {}, {'auth' => 'not_valid'})
+        expect(described_class.new(webhook).auth).to be_falsey
+      end
+
+      it 'true when key found and value matched' do
+        webhook = WebhookDouble.new('id', 'valid_token_array', {}, {}, {'auth' => 'test_1'})
+        expect(described_class.new(webhook).auth).to be_truthy
+      end
+    end
+
+    context 'when providing token string auth' do
+      it 'false when key not found' do
+        webhook = WebhookDouble.new('id', 'valid_token_string')
+        expect(described_class.new(webhook).auth).to be_falsey
+      end
+
+      it 'false when key found but value not matched' do
+        webhook = WebhookDouble.new('id', 'valid_token_string', {}, {}, {'auth' => 'not_valid'})
+        expect(described_class.new(webhook).auth).to be_falsey
+      end
+
+      it 'true when key found and value matched' do
+        webhook = WebhookDouble.new('id', 'valid_token_string', {}, {}, {'auth' => 'test_2'})
+        expect(described_class.new(webhook).auth).to be_truthy
+      end
+    end
+
+    context 'when providing lambda auth' do
+      it 'false when key not found' do
+        webhook = WebhookDouble.new('id', 'lambda_auth')
+        expect(described_class.new(webhook).auth).to be_falsey
+      end
+
+      it 'false when key found but value not matched' do
+        webhook = WebhookDouble.new('id', 'lambda_auth', {}, {}, {'auth' => 'not_valid'})
+        expect(described_class.new(webhook).auth).to be_falsey
+      end
+
+      it 'true when key found and value matched' do
+        webhook = WebhookDouble.new('id', 'lambda_auth', {}, {}, {'auth' => 'test'})
+        expect(described_class.new(webhook).auth).to be_truthy
+      end
+    end
+  end
+end

data/spec/contentful/scheduler/controller_spec.rb

@@ -9,6 +9,10 @@ describe Contentful::Scheduler::Controller do
   let(:queue) { ::Contentful::Scheduler::Queue.instance }
   subject { described_class.new server, logger, timeout }
 
+  before :each do
+    Contentful::Scheduler.config = base_config
+  end
+
   describe 'events' do
     [:create, :save, :auto_save, :unarchive].each do |event|
       it "creates or updates webhook metadata in publish queue on #{event}" do
@@ -42,5 +46,19 @@ describe Contentful::Scheduler::Controller do
         end
       end
     end
+
+    describe 'auth' do
+      context 'on auth failure' do
+        let(:body) { {sys: { id: 'invalid_auth', space: { sys: { id: 'valid_token_string' } } }, fields: {} } }
+
+        it 'will stop the queueing process' do
+          expect(queue).not_to receive(:update_or_create)
+
+          headers['X-Contentful-Topic'] = "ContentfulManagement.Entry.save"
+          request = RequestDummy.new(headers, body)
+          subject.respond(request, MockResponse.new).join
+        end
+      end
+    end
   end
 end

data/spec/contentful/scheduler/queue_spec.rb

@@ -260,4 +260,4 @@ describe Contentful::Scheduler::Queue do
       end
     end
   end
-end
+end

data/spec/contentful/scheduler/tasks/publish_spec.rb

@@ -29,7 +29,7 @@ describe Contentful::Scheduler::Tasks::Publish do
       expect(::Contentful::Management::Client).to receive(:new).with(
         'foo',
         raise_errors: true,
-        application_name: 'contentful-scheduler',
+        application_name: 'contentful.scheduler',
         application_version: Contentful::Scheduler::VERSION
       ) { mock_client }
       expect(mock_client).to receive(:entries) { mock_entries }
@@ -39,4 +39,4 @@ describe Contentful::Scheduler::Tasks::Publish do
       described_class.perform('foo', 'bar', ::Contentful::Scheduler.config[:spaces]['foo'][:management_token])
     end
   end
-end
+end

data/spec/contentful/scheduler/tasks/unpublish_spec.rb

@@ -21,22 +21,22 @@ describe Contentful::Scheduler::Tasks::Unpublish do
   let(:mock_entry) { MockEntry.new }
 
   before :each do
-    ::Contentful::Scheduler.class_variable_set(:@@config, {management_token: 'foobar'})
+    ::Contentful::Scheduler.config = base_config
   end
 
   describe 'class methods' do
     it '::perform' do
       expect(::Contentful::Management::Client).to receive(:new).with(
-        'foobar',
+        'foo',
         raise_errors: true,
-        application_name: 'contentful-scheduler',
+        application_name: 'contentful.scheduler',
         application_version: Contentful::Scheduler::VERSION
       ) { mock_client }
       expect(mock_client).to receive(:entries) { mock_entries }
       expect(mock_entries).to receive(:find).with('foo', 'bar') { mock_entry }
       expect(mock_entry).to receive(:unpublish)
 
-      described_class.perform('foo', 'bar', ::Contentful::Scheduler.config[:management_token])
+      described_class.perform('foo', 'bar', ::Contentful::Scheduler.config[:spaces]['foo'][:management_token])
     end
   end
 end

data/spec/spec_helper.rb

@@ -120,4 +120,4 @@ end
 RSpec.configure do |config|
   config.filter_run :focus => true
   config.run_all_when_everything_filtered = true
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contentful-scheduler-custom
 version: !ruby/object:Gem::Version
-  version: 1.5.5
+  version: 1.5.7.1.1
 platform: ruby
 authors:
 - Contentful GmbH (David Litvak Bruno0
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-11 00:00:00.000000000 Z
+date: 2018-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: contentful-webhook-listener
@@ -44,28 +44,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.27.4
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.27.4
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: resque-scheduler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.2.1
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.2.1
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -196,18 +196,19 @@ files:
 - README.md
 - Rakefile
 - contentful-scheduler.gemspec
-- example/Dockerfile
 - example/Gemfile
 - example/Procfile
 - example/Rakefile
 - example/config.ru
 - lib/contentful/scheduler.rb
+- lib/contentful/scheduler/auth.rb
 - lib/contentful/scheduler/controller.rb
 - lib/contentful/scheduler/queue.rb
 - lib/contentful/scheduler/tasks.rb
 - lib/contentful/scheduler/tasks/publish.rb
 - lib/contentful/scheduler/tasks/unpublish.rb
 - lib/contentful/scheduler/version.rb
+- spec/contentful/scheduler/auth_spec.rb
 - spec/contentful/scheduler/controller_spec.rb
 - spec/contentful/scheduler/queue_spec.rb
 - spec/contentful/scheduler/tasks/publish_spec.rb
@@ -239,6 +240,7 @@ signing_key:
 specification_version: 4
 summary: Customizable Scheduler for Contentful Entries.
 test_files:
+- spec/contentful/scheduler/auth_spec.rb
 - spec/contentful/scheduler/controller_spec.rb
 - spec/contentful/scheduler/queue_spec.rb
 - spec/contentful/scheduler/tasks/publish_spec.rb

data/example/Dockerfile

@@ -1,25 +0,0 @@
-FROM ruby:2.5
-MAINTAINER Bugs Bunny <bbunny@rubyplus.com>
-
-
-
-# Install gems
-ENV APP_HOME /app
-ENV HOME /root
-RUN mkdir $APP_HOME
-RUN chmod -R 777 /app
-RUN chmod -R 777 /root
-
-
-WORKDIR $APP_HOME
-COPY Gemfile* $APP_HOME/
-RUN bundle install
-
-# Upload source
-COPY . $APP_HOME
-
-# Start server
-ENV PORT 8080
-EXPOSE 8080
-USER 1001
-CMD ["foreman", "start"]