activehook 0.1.0 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ec5f569ad2e4d49a1726c2d19a90ce2b7648af1f
-  data.tar.gz: b2de4d8bc94e5ae5d52a1e377d6722196a8c7916
+  metadata.gz: f3a59808084220469fb34637c67bf5e9f262e631
+  data.tar.gz: 791adea3103be50f0b47ae4a1bcc85456271279b
 SHA512:
-  metadata.gz: 2148e1300b59027bb0c169308a51e5cdc756f3f4f61a1478794a461fe49dec8b0459df1b8ea6950b3ce45713dbc127424ad4b300bb5b37ea968d697577bd6495
-  data.tar.gz: 9eed68184e55a437fcece72ead80cd5a2b178d02afbd280f1ce4fdb48d935749fe2be7524e35300860a9c610a4c4ad376bdf4c8a6eb98aca3411103ddff0bb3a
+  metadata.gz: 40f0470b5c5239cc3f7ea56cb20c458239d72ada5180327ac45356ab32357ee0770d66a8c23691619ba4d2eeca3dff0df0e133154384803ed90189b0f450a2a9
+  data.tar.gz: e9cd328d156e39b4d9478fb3aa8740d5999404629ac0adae3a8c0c67b8e55071168a98ba8c7c843b6e46a34b8c9d47ac95b5d0e1dae3b920f831e605342c1524

data/Procfile

@@ -0,0 +1,2 @@
+web: bundle exec activehook-app -p test/config/puma.rb
+worker: bundle exec activehook-server

data/README.md

@@ -3,7 +3,11 @@
 
 Fast and simple webhook microservice for Ruby. **Please consider it under development at the moment.**
 
-ActiveHook provides a scalable solution to your applications webhook sending needs. Its Redis-backed, with support for forking and threading - letting it send an enormous amount of webhooks in short order. Basically a much more focused version of a job processor such as Sidekiq, DelayedJob, Resque, etc.
+ActiveHook provides a scalable solution to your applications webhook sending needs. Its Redis-backed, with support for forking and threading - letting it send an enormous amount of webhooks in short order. Basically a much more focused version of a job processor such as Sidekiq, DelayedJob, Resque, etc. It includes the following:
+
+- A server for the purpose of sending webhooks.
+- A mixin module for the purpose of recieving and validating webhooks.
+- A piece of Rack middleware for the purpose of performing validation.
 
 ## Installation
 
@@ -23,38 +27,155 @@ Or install it yourself as:
 
 ## Getting Started
 
-Before starting, ensure you have a functioning Redis server available. ActiveHook runs as a seperate server beyond Rails, Sinatra, etc. To start the server simply type the following in your console.
+Before starting, ensure you have a functioning Redis server available.
+
+ActiveHook can be run in a few different ways.
+
+#### Server Mode
 
-    $ bundle exec activehook -c config/initializers/activehook.rb
+ In order to send webhooks, we operate ActiveHook in server mode. This will be run as a seperate service beyond your web application (Rails, Sinatra, etc). To start the server simply type the following in your console.
 
-By providing a path to a configuration file, we can setup ActiveHook with plain old ruby. Below is a list of currently available options:
+    $ bundle exec activehook-server -c config/activehook.rb
+
+By providing a path to a configuration file, we can setup ActiveHook with plain old ruby. Below is a list of currently available server options:
 
 ```ruby
+# ActiveHook server configuration
 ActiveHook.configure do |config|
   #Your redis server url
   config.redis_url = ENV['REDIS_URL']
   #The number of redis connections to provide
-  config.redis_pool = 5
+  config.redis_pool = 10
   #The number of forked workers to create for the server
   config.workers = 2
   #The number of queue threads to provide for each worker
-  config.queue_threads = 5
+  config.queue_threads = 2
   #The number of retry threads to provide for each worker
-  config.retry_threads = 2
-  #The maximum amount of retries to attempt for failed webhooks
-  config.retry_max = 3
-  #The amount of time between each retry attempt
-  config.retry_time = 3600
+  config.retry_threads = 1
+end
+```
+
+#### App Mode
+
+In order to create webhooks, we operate ActiveHook in app mode. Like above, we need to provide information on Redis. We will also need to provide a path in our web application that can be used for validation. With Rails, we should place this configuration with our initializers.
+
+```ruby
+#IMPORTANT!
+require 'activehook/app/base'
+
+# ActiveHook app configuration
+ActiveHook.configure do |config|
+  #Your redis server url
+  config.redis_url = ENV['REDIS_URL']
+  #The number of redis connections to provide
+  config.redis_pool = 5
+  #The route to our webhook validator
+  config.validation_path = '/hooks/validate'
 end
 ```
 
-Queuing a webhook for processing is easy. From within our application, all we have to do is:
+With our app setup, we can create webhooks for processing. From within our application, all we have to do is:
 
 ```ruby
 ActiveHook::Hook.new(uri: 'http://example.com/webhook', payload: { msg: 'My first webhook!' })
 ```
 
-That's it! We provide a valid string URI, as well hash payload. ActiveHooks queue threads will then attempt to send the webhook. If the webhook fails to be delivered, it will be sent to the retry queue. Delivery will be reattempted at the specified intervals, and eventually dropped if all attempts fail.
+That's it! We provide a valid string URI, as well hash payload. ActiveHooks server will then attempt to send the webhook. If the webhook fails to be delivered, it will be sent to the retry queue. Delivery will be reattempted at the specified intervals, and eventually dropped if all attempts fail.
+
+The default setting for failed webhooks is 3 more attempts at an interval of 3600 seconds (1 hour). You can change these values by including them in your hook initialization.
+
+```ruby
+ActiveHook::Hook.new(uri: 'http://example.com/webhook', payload: { msg: 'My first webhook!' }, retry_max: 3, retry_time: 3600)
+```
+
+We will go over app webhook validation after the following section...
+
+#### Client Mode
+
+ActiveHook provides a class as well as mixin module for the purposes of recieving webhooks and performing validation on them. The class should be used for personal projects and testing, while the mixin module can be integrated with other application gems.
+
+Using the class is easy. We should first add use the following config:
+
+```ruby
+#IMPORTANT!
+require 'activehook/client/base'
+
+# ActiveHook client configuration
+ActiveHook.configure do |config|
+  #Your validation uri
+  config.validation_uri = 'http://localhost:3000/hooks/validate'
+end
+```
+
+If we were using Rails we could then do the following:
+
+```ruby
+class WebhooksController < ApplicationController
+
+  def create
+    @webhook = ActiveHook::Recieve.new(webhook_params)
+    if @webhook.hook_valid?
+      #We can now do stuff with the Hash @webhook.payload
+    end
+  end
+
+  private
+
+  def webhook_params
+    params.require(:hook_id, :hook_key, :payload)
+  end
+end
+```
+
+Using the mixin module for our own classes would go like this:
+
+```ruby
+require 'activehook/client/base'
+
+module MyApp
+  class Webhook
+    include ActiveHook::Client::Recieve
+
+    #IMPORTANT! We will go over running the validation server next.
+    VALIDATION_URI = 'http://myapp.com/hooks/validate'
+  end
+end
+```
+
+This would allow us to perform the same validation actions as in our Rails example, except we could use:
+
+```ruby
+@webhook = MyApp::Webhook.new(webhook_params)
+if @webhook.hook_valid?
+  #We can now do stuff with the Hash @webhook.payload
+end
+```
+
+#### App Mode Validation
+
+Sending webhooks is one thing - ensuring they are from who we want is another.
+
+ActiveHook includes a piece of Rack middleware for the purpose of validation. When a client attempts to validate a webhook, they are sending a message back to your server. The message includes the hooks ID as well as key. These are are then cross-referenced. If they match, we provide the AOK.
+
+In Rails, we would add the middleware like this:
+
+```ruby
+# In config/application.rb
+config.middleware.use ActiveHook::App::Middleware
+```
+
+Or with Rackup files:
+
+```ruby
+# In config.ru
+use ActiveHook::App::Middleware
+```
+
+ActiveHook also provides a straight lightweight validation microservice. This simply runs the middleware with Puma on its own.
+
+    $ bundle exec activehook-app -p config/puma.rb -c config/activehook.rb
+
+We must provide a path to our Puma config file as well as our ActiveHook app config file. Please read more about Puma if you need help with this.
 
 ## Development
 

data/activehook.gemspec

@@ -14,11 +14,13 @@ Gem::Specification.new do |spec|
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.executables   = %w( activehook )
+  spec.executables   = %w( activehook-server activehook-app )
   spec.require_paths = %w( lib )
 
-  spec.add_runtime_dependency "redis", "~> 3.3"
-  spec.add_runtime_dependency "connection_pool", "~> 2.2"
+  spec.add_runtime_dependency     "redis", "~> 3.3"
+  spec.add_runtime_dependency     "connection_pool", "~> 2.2"
+  spec.add_runtime_dependency     "puma", "~> 3.4"
+  spec.add_runtime_dependency     "rack"
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"

data/bin/activehook-app

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'activehook'
+require 'activehook/app/base'
+
+app = ActiveHook::App::Launcher.new(ARGV)
+app.start

data/bin/activehook-server

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'activehook'
+require 'activehook/server/base'
+
+server = ActiveHook::Server::Launcher.new(ARGV)
+server.start

data/lib/activehook/app/base.rb

@@ -0,0 +1,17 @@
+ActiveHook.mode = :app
+
+require 'puma'
+require 'rack'
+require 'redis'
+require 'json'
+require 'connection_pool'
+require 'activehook/config'
+require 'activehook/log'
+require 'activehook/redis'
+require 'activehook/errors'
+require 'activehook/hook'
+require 'activehook/validate'
+require 'activehook/version'
+require 'activehook/app/config'
+require 'activehook/app/launcher'
+require 'activehook/app/middleware'

data/lib/activehook/app/config.rb

@@ -0,0 +1,17 @@
+module ActiveHook
+  module App
+    class Config < ActiveHook::BaseConfig
+      OTHER_DEFAULTS = {
+        validation_path: '/hooks/validate',
+        creation_path: '/hooks'
+      }.freeze
+
+      attr_accessor :validation_path, :creation_path
+
+      def initialize
+        super
+        OTHER_DEFAULTS.each { |key, value| send("#{key}=", value) }
+      end
+    end
+  end
+end

data/lib/activehook/app/config.ru

@@ -0,0 +1,6 @@
+require 'activehook'
+require 'activehook/app/base'
+require 'byebug'
+
+use ActiveHook::App::Middleware
+run -> (env) { [200, {"Content-Type" => "text/html"}, ["Hello World!"]] }

data/lib/activehook/app/launcher.rb

@@ -0,0 +1,51 @@
+module ActiveHook
+  module App
+    # Handles the start of the ActiveHook web via command line
+    #
+    class Launcher
+      def initialize(argv)
+        @argv = argv
+        @puma_config = nil
+      end
+
+      def start
+        start_message
+        setup_options
+        boot_puma
+      end
+
+      private
+
+      def start_message
+        ActiveHook.log.info('ActiveHook App starting!')
+        ActiveHook.log.info("* Version #{VERSION}, codename: #{CODENAME}")
+      end
+
+      # Parses the arguments passed through the command line.
+      #
+      def setup_options
+        parser = OptionParser.new do |o|
+          o.banner = 'Usage: bundle exec bin/activehook [options]'
+
+          o.on('-c', '--config PATH', 'Load PATH for config file') do |arg|
+            load(arg)
+            ActiveHook.log.info("* App config:  #{arg}")
+          end
+
+          o.on('-p', '--puma config PATH', 'Load PATH for puma config file') do |arg|
+            @puma_config = arg
+            ActiveHook.log.info("* Puma config: #{arg}")
+          end
+
+          o.on('-h', '--help', 'Prints this help') { puts o && exit }
+        end
+        parser.parse!(@argv)
+      end
+
+      def boot_puma
+        ActiveHook.log.info('* Booting Puma...')
+        exec("bundle exec puma -C #{@puma_config} --dir lib/activehook/app/")
+      end
+    end
+  end
+end

data/lib/activehook/app/middleware.rb

@@ -0,0 +1,70 @@
+module ActiveHook
+  module App
+    class Middleware
+      class << self
+        attr_accessor :valid, :invalid, :not_created, :created
+      end
+
+      @invalid      = ->(_env) { [400, { "Content-Type" => "application/json" }, [{ valid: false }.to_json]] }
+      @valid        = ->(_env) { [200, { "Content-Type" => "application/json" }, [{ valid: true }.to_json]] }
+      @not_created  = ->(_env) { [400, { "Content-Type" => "application/json" }, [{ status: false }.to_json]] }
+      @created      = ->(_env) { [200, { "Content-Type" => "application/json" }, [{ status: true }.to_json]] }
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @env = env
+        @req = Rack::Request.new(env)
+
+        if validation_request? then valid?
+        elsif creation_request? then create?
+        else @app.call(@env)
+        end
+      end
+
+      def validation_request?
+        @req.path == ActiveHook.config.validation_path && @req.get?
+      end
+
+      def creation_request?
+        @req.path == ActiveHook.config.creation_path && @req.post?
+      end
+
+      def valid?
+        if Validation.new(@req.params).start
+          self.class.valid.call(@env)
+        else
+          self.class.invalid.call(@env)
+        end
+      end
+
+      def create?
+        if Creation.new(@req.params).start
+          self.class.created.call(@env)
+        else
+          self.class.not_created.call(@env)
+        end
+      end
+    end
+
+    Validation = Struct.new(:params) do
+      def start
+        hook = { id: params['id'].to_i, key: params['key'] }
+        ActiveHook::Validate.new(hook).perform
+      rescue
+        false
+      end
+    end
+
+    Creation = Struct.new(:params) do
+      def start
+        hook = { uri: params['uri'], payload: JSON.parse(params['payload']) }
+        ActiveHook::Hook.new(hook).perform
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/activehook/client/base.rb

@@ -0,0 +1,8 @@
+ActiveHook.mode = :client
+
+require 'uri'
+require 'json'
+require 'net/http'
+require 'activehook/config'
+require 'activehook/client/config'
+require 'activehook/client/recieve'

data/lib/activehook/client/config.rb

@@ -0,0 +1,16 @@
+module ActiveHook
+  module Client
+    class Config < ActiveHook::BaseConfig
+      OTHER_DEFAULTS = {
+        validation_uri: 'http://localhost:3000/hooks/validate'
+      }.freeze
+
+      attr_accessor :validation_uri
+
+      def initialize
+        super
+        OTHER_DEFAULTS.each { |key, value| send("#{key}=", value) }
+      end
+    end
+  end
+end

data/lib/activehook/client/recieve.rb

@@ -0,0 +1,55 @@
+module ActiveHook
+  module Client
+    module Recieve
+
+      REQUEST_HEADERS = {
+        "Content-Type" => "application/json",
+        "Accept"       => "application/json",
+        "User-Agent"   => "ActiveHook/#{ActiveHook::VERSION}"
+      }.freeze
+
+      attr_accessor :hook_id, :hook_key
+      attr_reader :payload
+
+      def hook_valid?
+        @hook_valid ||= validate_hook
+      end
+
+      def payload=(payload)
+        @payload = JSON.parse(payload)
+      rescue
+        nil
+      end
+
+      def validated_payload
+        raise StandardError, 'Webhook is invalid.' unless hook_valid?
+        @payload
+      end
+
+      private
+
+      def hook_uri
+        @hook_uri ||= URI.parse(self.class::VALIDATION_URI)
+      end
+
+      def validate_hook
+        http = Net::HTTP.new(hook_uri.host, hook_uri.port)
+        response = http.post(hook_uri.path, hook_json, REQUEST_HEADERS)
+        response.code.to_i == 200 ? true : false
+      rescue
+        false
+      end
+
+      def hook_json
+        { id: @hook_id,
+          key: @hook_key }.to_json
+      end
+    end
+  end
+
+  class Recieve
+    include ActiveHook::Client::Recieve
+
+    VALIDATION_URI = (ActiveHook.config.validation_uri).freeze
+  end
+end

data/lib/activehook/config.rb

@@ -6,7 +6,17 @@ module ActiveHook
     end
 
     def config
-      @config ||= Config.new
+      @config ||= build_config
+    end
+
+    def build_config
+      klass =
+        case ActiveHook.mode
+        when :server then ActiveHook::Server::Config
+        when :client then ActiveHook::Client::Config
+        else ActiveHook::App::Config
+        end
+      klass.new
     end
 
     def reset
@@ -15,33 +25,22 @@ module ActiveHook
     end
   end
 
-  class Config
-    DEFAULTS = {
+  class BaseConfig
+    BASE_DEFAULTS = {
       redis_url: ENV['REDIS_URL'],
-      redis_pool: 5,
-      workers: 2,
-      queue_threads: 4,
-      retry_threads: 2,
-      retry_max: 3,
-      retry_time: 3600,
+      redis_pool: 5
     }.freeze
 
-    attr_accessor :redis_url, :redis_pool, :retry_max, :retry_time,
-                  :workers, :queue_threads, :retry_threads
+    attr_accessor :redis_url, :redis_pool
 
     def initialize
-      DEFAULTS.each { |key, value| send("#{key}=", value) }
-    end
-
-    def retry_max_time
-      @retry_max_time ||= retry_max * retry_time
+      BASE_DEFAULTS.each { |key, value| send("#{key}=", value) }
     end
 
-    def worker_options
+    def redis
       {
-        worker_count: workers,
-        queue_threads: queue_threads,
-        retry_threads: retry_threads
+        size: redis_pool,
+        url: redis_url
       }
     end
   end

data/lib/activehook/errors.rb

@@ -4,5 +4,7 @@ module ActiveHook
     class Hook < StandardError; end
     class HTTP < StandardError; end
     class Send < StandardError; end
+    class Server < StandardError; end
+    class Worker < StandardError; end
   end
 end

data/lib/activehook/hook.rb

@@ -2,7 +2,7 @@ require 'securerandom'
 
 module ActiveHook
   class Hook
-    attr_accessor :uri, :payload, :id, :created_at, :retry_at, :fail_at
+    attr_accessor :uri, :payload, :id, :key, :retry_max, :retry_time, :created_at
 
     def initialize(options = {})
       options = defaults.merge(options)
@@ -10,47 +10,65 @@ module ActiveHook
     end
 
     def perform
-      valid?
+      validate!
       ActiveHook.redis.with do |conn|
-        conn.pipelined do
-          conn.lpush('ah:queue', to_json)
-          conn.incr('ah:total_queued')
-        end
+        @id = conn.incr('ah:total_queued')
+        conn.lpush('ah:queue', to_json)
+        conn.zadd('ah:validation', @id, @key)
       end
     end
 
-    def bump_retry
-      @retry_at = Time.now.to_i + ActiveHook.config.retry_time
+    def retry?
+      fail_at > Time.now.to_i
     end
 
-    def retry?
-      @fail_at.to_i > Time.now.to_i
+    def retry_at
+      Time.now.to_i + @retry_time.to_i
+    end
+
+    def fail_at
+      @created_at.to_i + retry_max_time
+    end
+
+    def retry_max_time
+      @retry_time.to_i * @retry_max.to_i
     end
 
     def to_json
       { id: @id,
+        key: @key,
         created_at: @created_at,
-        retry_at: @retry_at,
-        fail_at: @fail_at,
+        retry_time: @retry_time,
+        retry_max: @retry_max,
         uri: @uri,
         payload: @payload }.to_json
     end
 
+    def secure_payload
+      { hook_id: @id,
+        hook_key: @key,
+        payload: @payload }.to_json
+    end
+
+    def valid?
+      HookValidator.new(id: @id, key: @key).server_valid?
+    end
+
     private
 
     def defaults
-      { id: SecureRandom.uuid,
+      { key: SecureRandom.uuid,
         created_at: Time.now.to_i,
-        retry_at: Time.now.to_i + ActiveHook.config.retry_time,
-        fail_at: Time.now.to_i + ActiveHook.config.retry_max_time }
+        retry_time: 3600,
+        retry_max: 3 }
     end
 
-    def valid?
+    def validate!
       raise Errors::Hook, 'Payload must be a Hash.' unless @payload.is_a?(Hash)
       raise Errors::Hook, 'URI is not a valid format.' unless @uri =~ /\A#{URI::regexp}\z/
       raise Errors::Hook, 'Created at must be an Integer.' unless @created_at.is_a?(Integer)
-      raise Errors::Hook, 'Retry at must be an Integer.' unless @retry_at.is_a?(Integer)
-      raise Errors::Hook, 'Fail at must be an Integer.' unless @fail_at.is_a?(Integer)
+      raise Errors::Hook, 'Retry time must be an Integer.' unless @retry_time.is_a?(Integer)
+      raise Errors::Hook, 'Retry max must be an Integer.' unless @retry_max.is_a?(Integer)
     end
   end
 end

data/lib/activehook/log.rb

@@ -13,7 +13,7 @@ module ActiveHook
     def initialize
       @log = ::Logger.new(STDOUT)
       @log.formatter = proc do |_severity, datetime, _progname, msg|
-        "[ #{datetime} ] #{msg}\n"
+        "#{msg}\n"
       end
     end
 

data/lib/activehook/redis.rb

@@ -1,5 +1,3 @@
-require 'redis'
-
 module ActiveHook
   class << self
     attr_reader :connection_pool