activehook 0.1.0 → 0.1.3

data/lib/activehook/server/base.rb

@@ -0,0 +1,19 @@
+ActiveHook.mode = :server
+
+require 'redis'
+require 'json'
+require 'uri'
+require 'net/http'
+require 'connection_pool'
+require 'activehook/config'
+require 'activehook/redis'
+require 'activehook/errors'
+require 'activehook/hook'
+require 'activehook/log'
+require 'activehook/server/config'
+require 'activehook/server/launcher'
+require 'activehook/server/manager'
+require 'activehook/server/queue'
+require 'activehook/server/retry'
+require 'activehook/server/send'
+require 'activehook/server/worker'

data/lib/activehook/server/config.rb

@@ -0,0 +1,32 @@
+module ActiveHook
+  module Server
+    class Config < ActiveHook::BaseConfig
+      OTHER_DEFAULTS = {
+        workers: 2,
+        queue_threads: 2,
+        retry_threads: 1
+      }.freeze
+
+      attr_accessor :workers, :queue_threads, :retry_threads
+
+      def initialize
+        super
+        OTHER_DEFAULTS.each { |key, value| send("#{key}=", value) }
+      end
+
+      def worker_options
+        {
+          queue_threads: queue_threads,
+          retry_threads: retry_threads
+        }
+      end
+
+      def manager_options
+        {
+          workers: workers,
+          options: worker_options
+        }
+      end
+    end
+  end
+end

data/lib/activehook/server/launcher.rb

@@ -0,0 +1,47 @@
+module ActiveHook
+  module Server
+    # Handles the start of the ActiveHook server via command line
+    #
+    class Launcher
+      def initialize(argv)
+        @argv = argv
+      end
+
+      # Parses commmand line options and starts the Manager object
+      #
+      def start
+        start_message
+        setup_options
+        boot_manager
+      end
+
+      private
+
+      def start_message
+        ActiveHook.log.info('ActiveHook Server 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("* Server config:  #{arg}")
+          end
+
+          o.on('-h', '--help', 'Prints this help') { puts o && exit }
+        end
+        parser.parse!(@argv)
+      end
+
+      def boot_manager
+        manager = ActiveHook::Server::Manager.new(ActiveHook.config.manager_options)
+        manager.start
+      end
+    end
+  end
+end

data/lib/activehook/server/manager.rb

@@ -0,0 +1,64 @@
+module ActiveHook
+  module Server
+    # The Manager controls our Worker processes. We use it to instruct each
+    # of them to start and shutdown.
+    #
+    class Manager
+      attr_accessor :workers, :options
+      attr_reader :forks
+
+      def initialize(options = {})
+        options.each { |key, value| send("#{key}=", value) }
+        @master = Process.pid
+        at_exit { shutdown }
+      end
+
+      # Instantiates new Worker objects, setting them with our options. We
+      # follow up by booting each of our Workers. Our Manager is then put to
+      # sleep so that our Workers can do their thing.
+      #
+      def start
+        validate!
+        start_messages
+        create_workers
+        sleep
+      end
+
+      # Shutsdown our Worker processes.
+      #
+      def shutdown
+        @forks.each { |w| Process.kill('SIGTERM', w[:pid].to_i) }
+        Process.kill('SIGTERM', @master)
+        exit
+      end
+
+      private
+
+      # Create the specified number of workers and starts them
+      #
+      def create_workers
+        @forks = []
+        @workers.times do |id|
+          pid = fork { Worker.new(@options.merge(id: id)).start }
+          @forks << { id: id, pid: pid }
+        end
+      end
+
+      # Information about the start process
+      #
+      def start_messages
+        ActiveHook.log.info("* Workers: #{@workers}")
+        ActiveHook.log.info("* Threads: #{@options[:queue_threads]} queue, #{@options[:retry_threads]} retry")
+      end
+
+      # Validates our data before starting our Workers. Also instantiates our
+      # connection pool by pinging Redis.
+      #
+      def validate!
+        raise Errors::Server, 'Cound not connect to Redis.' unless ActiveHook.redis.with { |c| c.ping && c.quit }
+        raise Errors::Server, 'Workers must be an Integer.' unless @workers.is_a?(Integer)
+        raise Errors::Server, 'Options must be a Hash.' unless @options.is_a?(Hash)
+      end
+    end
+  end
+end

data/lib/activehook/{workers → server}/queue.rb

@@ -1,10 +1,15 @@
-require 'activehook/workers/base'
-require 'activehook/post'
-
-
 module ActiveHook
-  module Workers
-    class Queue < Base
+  module Server
+    # The Queue object processes any hooks that are queued into our Redis server.
+    # It will perform a 'blocking pop' on our hook list until one is added.
+    #
+    class Queue
+      def initialize
+        @done = false
+      end
+
+      # Starts our queue process. This will run until instructed to stop.
+      #
       def start
         until @done
           json = retrieve_hook
@@ -12,18 +17,26 @@ module ActiveHook
         end
       end
 
+      # Shutsdown our queue process.
+      #
+      def shutdown
+        @done = true
+      end
+
       private
 
+      # Performs a 'blocking pop' on our redis queue list.
+      #
       def retrieve_hook
-        json = ActiveHook.redis.with { |c| c.brpop('ah:queue', @time) }
+        json = ActiveHook.redis.with { |c| c.brpop('ah:queue') }
         json.last if json
       end
     end
 
     class HookRunner
       def initialize(json)
-        @hook = ActiveHook::Hook.new(JSON.parse(json))
-        @post = ActiveHook::POST.new(uri: @hook.uri, payload: @hook.payload)
+        @hook = Hook.new(JSON.parse(json))
+        @post = Send.new(uri: @hook.uri, payload: @hook.secure_payload)
         start
       end
 

data/lib/activehook/{workers → server}/retry.rb

@@ -1,8 +1,10 @@
-require 'activehook/workers/base'
-
 module ActiveHook
-  module Workers
-    class Retry < Base
+  module Server
+    class Retry
+      def initialize
+        @done = false
+      end
+
       def start
         until @done
           retries = retrieve_retries
@@ -11,6 +13,10 @@ module ActiveHook
         end
       end
 
+      def shutdown
+        @done = true
+      end
+
       private
 
       def retrieve_retries
@@ -33,12 +39,11 @@ module ActiveHook
     class RetryRunner
       def initialize(json)
         @json = json
-        @hook = ActiveHook::Hook.new(JSON.parse(@json))
+        @hook = Hook.new(JSON.parse(@json))
         start
       end
 
       def start
-        @hook.bump_retry
         @hook.perform
       end
     end

data/lib/activehook/server/send.rb

@@ -0,0 +1,70 @@
+module ActiveHook
+  REQUEST_HEADERS = {
+    "Content-Type" => "application/json",
+    "Accept"       => "application/json",
+    "User-Agent"   => "ActiveHook/#{ActiveHook::VERSION}"
+  }.freeze
+
+  module Server
+    class Send
+      attr_accessor :payload
+      attr_reader :response_time, :uri, :status, :response
+
+      def initialize(options = {})
+        options.each { |key, value| send("#{key}=", value) }
+      end
+
+      def start
+        @status = post_hook
+        log_status
+      end
+
+      def uri=(uri)
+        @uri = URI.parse(uri)
+      end
+
+      def success?
+        @status == :success
+      end
+
+      private
+
+      def post_hook
+        http = Net::HTTP.new(uri.host, uri.port)
+        measure_response_time do
+          @response = http.post(uri.path, payload, REQUEST_HEADERS)
+        end
+        response_status(@response)
+      rescue
+        :error
+      end
+
+      def measure_response_time
+        start = Time.now
+        yield
+        finish = Time.now
+        @response_time = "| #{((finish - start) * 1000.0).round(3)} ms"
+      end
+
+      def response_status(response)
+        case response.code.to_i
+        when (200..204)
+          :success
+        when (400..499)
+          :bad_request
+        when (500..599)
+          :server_problems
+        end
+      end
+
+      def log_status
+        msg = "POST | #{uri} | #{status.upcase} #{response_time}"
+        if status == :success
+          ActiveHook.log.info(msg)
+        else
+          ActiveHook.log.err(msg)
+        end
+      end
+    end
+  end
+end

data/lib/activehook/server/worker.rb

@@ -0,0 +1,78 @@
+module ActiveHook
+  module Server
+    # The Worker manages our two main processes - Queue and Retry. Each of these
+    # processes is alloted a number of threads. These threads are then forked.
+    # Each worker object maintains control of these threads through the aptly
+    # named start and shutdown methods.
+    #
+    class Worker
+      attr_accessor :queue_threads, :retry_threads, :id
+
+      def initialize(options = {})
+        options.each { |key, value| send("#{key}=", value) }
+        @pid = Process.pid
+        @threads = []
+        @_threads_real = []
+        at_exit { shutdown }
+      end
+
+      # Starts our new worker.
+      #
+      def start
+        validate!
+        start_message
+        build_threads
+        start_threads
+      end
+
+      # Shutsdown our worker as well as its threads.
+      #
+      def shutdown
+        shutdown_message
+        @threads.each(&:shutdown)
+        @_threads_real.each(&:exit)
+      end
+
+      private
+
+      # Forks the worker and creates the actual threads (@_threads_real) for
+      # our Queue and Retry objects. We then start them and join them to the
+      # main process.
+      #
+      def start_threads
+        @threads.each do |thread|
+          @_threads_real << Thread.new { thread.start }
+        end
+        @_threads_real.map(&:join)
+      end
+
+      # Instantiates our Queue and Retry objects based on the number of threads
+      # specified for each process type. We store these objects as an array in
+      # @threads.
+      #
+      def build_threads
+        @queue_threads.times { @threads << Queue.new }
+        @retry_threads.times { @threads << Retry.new }
+      end
+
+      # Information about the start process
+      #
+      def start_message
+        ActiveHook.log.info("* Worker #{@id} started, pid: #{@pid}")
+      end
+
+      # Information about the shutdown process
+      #
+      def shutdown_message
+        ActiveHook.log.info("* Worker #{@id} shutdown, pid: #{@pid}")
+      end
+
+      # Validates our data before starting the worker.
+      #
+      def validate!
+        raise Errors::Worker, 'Queue threads must be an Integer.' unless @queue_threads.is_a?(Integer)
+        raise Errors::Worker, 'Retry threads must be an Integer.' unless @retry_threads.is_a?(Integer)
+      end
+    end
+  end
+end

data/lib/activehook/validate.rb

@@ -0,0 +1,29 @@
+module ActiveHook
+  class Validate
+    attr_accessor :id, :key
+
+    def initialize(options = {})
+      options.each { |key, value| send("#{key}=", value) }
+    end
+
+    def perform
+      validate!
+      @key == find_key
+    rescue
+      false
+    end
+
+    private
+
+    def find_key
+      ActiveHook.redis.with do |conn|
+        conn.zrangebyscore('ah:validation', @id.to_i, @id.to_i).first
+      end
+    end
+
+    def validate!
+      raise Errors::Validation, 'ID must be an integer.' unless @id.is_a?(Integer)
+      raise Errors::Validation, 'Key must be a a string.' unless @key.is_a?(String) && @key.length > 6
+    end
+  end
+end

data/lib/activehook/version.rb

@@ -1,3 +1,4 @@
 module ActiveHook
-  VERSION = "0.1.0"
+  VERSION = '0.1.3'
+  CODENAME = 'Fat Sparrow'
 end

data/lib/activehook.rb

@@ -1,9 +1,8 @@
-require 'connection_pool'
-require 'json'
-require 'uri'
-require 'activehook/config'
-require 'activehook/errors'
-require 'activehook/hook'
-require 'activehook/log'
-require 'activehook/redis'
 require 'activehook/version'
+require 'byebug'
+
+module ActiveHook
+  class << self
+    attr_accessor :mode
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activehook
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.3
 platform: ruby
 authors:
 - Nicholas Sweeting
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-20 00:00:00.000000000 Z
+date: 2016-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -38,6 +38,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -112,7 +140,8 @@ description: Fast and simple webhook microservice for Ruby.
 email:
 - nsweeting@gmail.com
 executables:
-- activehook
+- activehook-server
+- activehook-app
 extensions: []
 extra_rdoc_files: []
 files:
@@ -121,26 +150,38 @@ files:
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
+- Procfile
 - README.md
 - Rakefile
 - activehook.gemspec
-- bin/activehook
+- bin/activehook-app
+- bin/activehook-server
 - bin/console
 - bin/setup
 - lib/activehook.rb
-- lib/activehook/cli.rb
+- lib/activehook/app/base.rb
+- lib/activehook/app/config.rb
+- lib/activehook/app/config.ru
+- lib/activehook/app/launcher.rb
+- lib/activehook/app/middleware.rb
+- lib/activehook/client/base.rb
+- lib/activehook/client/config.rb
+- lib/activehook/client/recieve.rb
 - lib/activehook/config.rb
 - lib/activehook/errors.rb
 - lib/activehook/hook.rb
 - lib/activehook/log.rb
-- lib/activehook/post.rb
 - lib/activehook/redis.rb
-- lib/activehook/server.rb
+- lib/activehook/server/base.rb
+- lib/activehook/server/config.rb
+- lib/activehook/server/launcher.rb
+- lib/activehook/server/manager.rb
+- lib/activehook/server/queue.rb
+- lib/activehook/server/retry.rb
+- lib/activehook/server/send.rb
+- lib/activehook/server/worker.rb
+- lib/activehook/validate.rb
 - lib/activehook/version.rb
-- lib/activehook/workers/base.rb
-- lib/activehook/workers/manager.rb
-- lib/activehook/workers/queue.rb
-- lib/activehook/workers/retry.rb
 homepage: https://github.com/nsweeting/activehook
 licenses:
 - MIT

data/bin/activehook

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

data/lib/activehook/cli.rb

@@ -1,32 +0,0 @@
-require 'activehook/server'
-
-module ActiveHook
-  class CLI
-    def initialize(argv)
-      setup_options(argv)
-    end
-
-    def start
-      server = ActiveHook::Server.new
-      server.start
-    end
-
-    private
-
-    def setup_options(argv)
-      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("Loaded configuration from #{arg}")
-        end
-
-        o.on('-h', '--help', 'Prints this help') do
-          puts o && exit
-        end
-      end
-      parser.parse!(argv)
-    end
-  end
-end

data/lib/activehook/post.rb

@@ -1,71 +0,0 @@
-require 'net/http'
-require 'uri'
-
-module ActiveHook
-  class POST
-    HEADERS = {
-      "Content-Type" => "application/json",
-      "Accept"       => "application/json",
-      "User-Agent"   => "ActiveHook/#{ActiveHook::VERSION}"
-    }.freeze
-
-    attr_accessor :payload
-    attr_reader :response_time, :uri, :status, :response
-
-    def initialize(options = {})
-      options.each { |key, value| send("#{key}=", value) }
-    end
-
-    def start
-      @status = post_hook
-      log_status
-    end
-
-    def uri=(uri)
-      @uri = URI.parse(uri)
-    end
-
-    def success?
-      status == :success
-    end
-
-    private
-
-    def post_hook
-      http = Net::HTTP.new(uri.host, uri.port)
-      measure_response_time do
-        @response = http.post(uri.path, payload.to_json, HEADERS)
-      end
-      response_status(@response)
-    rescue
-      :error
-    end
-
-    def measure_response_time
-      start = Time.now
-      yield
-      finish = Time.now
-      @response_time = "| #{((finish - start) * 1000.0).round(3)} ms"
-    end
-
-    def response_status(response)
-      case response.code.to_i
-      when (200..204)
-        :success
-      when (400..499)
-        :bad_request
-      when (500..599)
-        :server_problems
-      end
-    end
-
-    def log_status
-      msg = "POST | #{uri} | #{status.upcase} #{response_time}"
-      if status == :success
-        ActiveHook.log.info(msg)
-      else
-        ActiveHook.log.err(msg)
-      end
-    end
-  end
-end

data/lib/activehook/server.rb

@@ -1,19 +0,0 @@
-require 'activehook/workers/manager'
-
-module ActiveHook
-  class Server
-    def initialize
-      at_exit { shutdown }
-    end
-
-    def start
-      @manager = Workers::Manager.new(ActiveHook.config.worker_options)
-      @manager.start
-      sleep
-    end
-
-    def shutdown
-      @manager.shutdown
-    end
-  end
-end