pushr-core 1.0.0.pre.1

data/lib/pushr/daemon/app.rb

@@ -0,0 +1,71 @@
+module Pushr
+  module Daemon
+    class App
+      @apps = {}
+
+      class << self
+        attr_reader :apps
+
+        def load
+          Configuration.all.each do |config|
+            @apps["#{config.app}:#{config.name}"] = App.new(config) if config.enabled == true
+          end
+        end
+
+        def total_connections
+          @apps.values.map(&:connections).inject(0, :+)
+        end
+
+        def start
+          @apps.values.map(&:start)
+        end
+
+        def stop
+          @apps.values.map(&:stop)
+        end
+      end
+
+      def initialize(config)
+        @config = config
+        @handlers = []
+        @provider = nil
+      end
+
+      def connections
+        @config.connections
+      end
+
+      def start
+        @provider = load_provider(@config.name, @config)
+
+        @config.connections.times do |i|
+          connection = @provider.connectiontype.new(@config, i + 1)
+          connection.connect
+
+          handler = DeliveryHandler.new("pushr:#{@config.app}:#{@config.name}", connection, @config.app, i + 1)
+          handler.start
+          @handlers << handler
+        end
+      end
+
+      def stop
+        @handlers.map(&:stop)
+        @provider.stop
+      end
+
+      protected
+
+      def load_provider(klass, options)
+        begin
+          middleware = Pushr::Daemon.const_get("#{klass}".camelize)
+        rescue NameError
+          message = "Could not find matching push provider for #{klass.inspect}. " \
+                    "You may need to install an additional gem (such as push-#{klass})."
+          raise LoadError, message
+        end
+
+        middleware.new(options)
+      end
+    end
+  end
+end

data/lib/pushr/daemon/delivery_error.rb

@@ -0,0 +1,19 @@
+module Pushr
+  module Daemon
+    class DeliveryError < StandardError
+      attr_reader :code, :message, :description, :source, :notify
+
+      def initialize(code, message, description, source, notify = true)
+        @code = code
+        @message = message
+        @description = description
+        @source = source
+        @notify = notify
+      end
+
+      def message
+        "Unable to deliver message #{@message.inspect}, received #{@source} error #{@code} (#{@description})"
+      end
+    end
+  end
+end

data/lib/pushr/daemon/delivery_handler.rb

@@ -0,0 +1,41 @@
+module Pushr
+  module Daemon
+    class DeliveryHandler
+      attr_reader :name
+
+      def initialize(queue_name, connection, name, i)
+        @queue_name = queue_name
+        @connection = connection
+        @name = "#{name}: DeliveryHandler #{i}"
+        Pushr::Daemon.logger.info "[#{@name}] listening to #{@queue_name}"
+      end
+
+      def start
+        Thread.new do
+          loop do
+            handle_next
+            break if @stop
+          end
+        end
+      end
+
+      def stop
+        @stop = true
+      end
+
+      protected
+
+      def handle_next
+        message = Pushr::Message.next(@queue_name)
+        return if message.nil?
+
+        Pushr::Core.instrument('message', app: message.app, type: message.type) do
+          @connection.write(message)
+          Pushr::Daemon.logger.info("[#{@connection.name}] Message delivered to #{message.device}")
+        end
+      rescue => e
+        Pushr::Daemon.logger.error(e)
+      end
+    end
+  end
+end

data/lib/pushr/daemon/feedback_handler.rb

@@ -0,0 +1,38 @@
+module Pushr
+  module Daemon
+    class FeedbackHandler
+      attr_reader :name, :processor, :processor_path
+
+      def initialize(processor_path)
+        @name = 'FeedbackHandler'
+        @processor_path = processor_path
+      end
+
+      def start
+        return unless @processor_path
+        require "#{Dir.pwd}/#{@processor_path}"
+        @processor = Pushr::FeedbackProcessor.new
+
+        Thread.new do
+          loop do
+            handle_next
+            break if @stop
+          end
+        end
+      end
+
+      def stop
+        @stop = true
+      end
+
+      protected
+
+      def handle_next
+        feedback = Pushr::Feedback.next
+        @processor.process(feedback) if feedback
+      rescue => e
+        Pushr::Daemon.logger.error(e)
+      end
+    end
+  end
+end

data/lib/pushr/daemon/logger.rb

@@ -0,0 +1,57 @@
+module Pushr
+  module Daemon
+    class Logger
+      def initialize(options)
+        @options = options
+
+        if @options[:foreground]
+          STDOUT.sync = true
+          @logger = ::Logger.new(STDOUT)
+        else
+          log_dir = File.join(Dir.pwd, 'log')
+          FileUtils.mkdir_p(log_dir)
+          log = File.open(File.join(log_dir, 'pushr.log'), 'a')
+          log.sync = true
+          @logger = ::Logger.new(log)
+        end
+
+        @logger.level = ::Logger::INFO
+        @logger.formatter = proc do |severity, datetime, progname, msg|
+          "[#{datetime}] #{severity}: #{msg}\n"
+        end
+      end
+
+      def info(msg)
+        log(::Logger::INFO, msg)
+      end
+
+      def error(msg)
+        error_notification(msg)
+        log(::Logger::ERROR, msg, 'ERROR')
+      end
+
+      def warn(msg)
+        log(::Logger::WARN, msg, 'WARNING')
+      end
+
+      private
+
+      def log(level, msg, prefix = nil)
+        if msg.is_a?(Exception)
+          msg = "#{msg.class.name}, #{msg.message}: #{msg.backtrace.join("\n") if msg.backtrace}"
+        end
+        @logger.add(level, msg)
+      end
+
+      def error_notification(e)
+        if do_error_notification?(e) && defined?(Airbrake)
+          Airbrake.notify_or_ignore(e)
+        end
+      end
+
+      def do_error_notification?(e)
+        @options[:error_notification] && ((e.is_a?(DeliveryError) && e.notify) || e.is_a?(Exception))
+      end
+    end
+  end
+end

data/lib/pushr/feedback.rb

@@ -0,0 +1,37 @@
+module Pushr
+  class Feedback
+    include ActiveModel::Validations
+    validates :app, presence: true
+    validates :device, presence: true
+    validates :follow_up, presence: true
+    validates :failed_at, presence: true
+
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+
+    def save
+      if valid?
+        Pushr::Core.redis { |conn| conn.rpush('pushr:feedback', to_json) }
+        return true
+      else
+        return false
+      end
+    end
+
+    def self.next(timeout = 3)
+      Pushr::Core.redis do |conn|
+        feedback = conn.blpop('pushr:feedback', timeout: timeout)
+        return instantiate(feedback[1]) if feedback
+      end
+    end
+
+    def self.instantiate(config)
+      hsh = ::MultiJson.load(config)
+      klass = hsh['type'].split('::').reduce(Object) { |a, e| a.const_get e }
+      klass.new(hsh)
+    end
+  end
+end

data/lib/pushr/message.rb

@@ -0,0 +1,36 @@
+module Pushr
+  class Message
+    include ActiveModel::Validations
+
+    validates :app, presence: true
+
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+
+    def save
+      if valid?
+        Pushr::Core.redis { |conn| conn.rpush("pushr:#{app}:#{self.class::POSTFIX}", to_json) }
+        return true
+      else
+        return false
+      end
+    end
+
+    def self.next(queue_name, timeout = 3)
+      Pushr::Core.redis do |conn|
+        message = conn.blpop(queue_name, timeout: timeout)
+        return instantiate(message[1]) if message
+      end
+    end
+
+    def self.instantiate(message)
+      return nil unless message
+      hsh = ::MultiJson.load(message)
+      klass = hsh['type'].split('::').reduce(Object) { |a, e| a.const_get e }
+      klass.new(hsh)
+    end
+  end
+end

data/lib/pushr/redis_connection.rb

@@ -0,0 +1,38 @@
+require 'connection_pool'
+require 'redis'
+require 'redis/namespace'
+
+module Pushr
+  class RedisConnection
+    def self.create(options = {})
+      url = options[:url] || determine_redis_provider || 'redis://localhost:6379/0'
+      driver = options[:driver] || 'ruby'
+      # need a connection for Fetcher and Retry
+      # size = options[:size] || (Pushr.server? ? (Pushr.options[:concurrency] + 2) : 5)
+      size = options[:size] || 5
+      namespace = options[:namespace] || Pushr::Core.options[:namespace]
+
+      ConnectionPool.new(timeout: 1, size: size) do
+        build_client(url, namespace, driver)
+      end
+    end
+
+    def self.build_client(url, namespace, driver)
+      client = Redis.connect(url: url, driver: driver)
+      if namespace
+        Redis::Namespace.new(namespace, redis: client)
+      else
+        client
+      end
+    end
+    private_class_method :build_client
+
+    # Not public
+    def self.determine_redis_provider
+      return ENV['PUSHR_URL'] if ENV['PUSHR_URL']
+      return ENV['REDISTOGO_URL'] if ENV['REDISTOGO_URL']
+      provider = ENV['REDIS_PROVIDER'] || 'REDIS_URL'
+      ENV[provider]
+    end
+  end
+end

data/lib/pushr/version.rb

@@ -0,0 +1,3 @@
+module Pushr
+  VERSION = '1.0.0.pre.1'
+end

data/spec/lib/pushr/configuration_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Pushr::Configuration do
+
+  before(:each) do
+    Pushr::Core.configure do |config|
+      config.redis = ConnectionPool.new(size: 1, timeout: 1) { MockRedis.new }
+    end
+  end
+
+  describe 'all' do
+    it 'returns all configurations' do
+      expect(Pushr::Configuration.all).to eql([])
+    end
+  end
+
+  describe 'create' do
+    it 'should create a configuration' do
+      config = Pushr::ConfigurationDummy.new(app: 'app_name', connections: 2, enabled: true)
+      expect(config.key).to eql('app_name:dummy')
+    end
+  end
+
+  describe 'save' do
+    let(:config) { Pushr::ConfigurationDummy.new(app: 'app_name', connections: 2, enabled: true) }
+    let(:config_invalid) { Pushr::ConfigurationDummy.new }
+    it 'should return true' do
+      expect(config.save).to eql true
+    end
+
+    it 'should return false' do
+      expect(config_invalid.save).to eql false
+    end
+
+    it 'should save a configuration' do
+      config.save
+      expect(Pushr::Configuration.all.count).to eql(1)
+    end
+  end
+
+  describe 'find' do
+    let!(:config) { Pushr::ConfigurationDummy.new(app: 'app_name', connections: 2, enabled: true) }
+    it 'should find a configuration' do
+      config.save
+      expect(Pushr::Configuration.find(config.key)).to be_kind_of(Pushr::ConfigurationDummy)
+    end
+  end
+
+  describe 'delete' do
+    let!(:config) { Pushr::ConfigurationDummy.new(app: 'app_name', connections: 2, enabled: true) }
+    it 'should remove a configuration' do
+      config.save
+      expect(Pushr::Configuration.all.count).to eql(1)
+      config.delete
+      expect(Pushr::Configuration.all.count).to eql(0)
+    end
+  end
+end

data/spec/lib/pushr/daemon/app_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'pushr/daemon'
+
+describe Pushr::Daemon::App do
+
+  before(:each) do
+    Pushr::Core.configure do |config|
+      config.redis = ConnectionPool.new(size: 1, timeout: 1) { MockRedis.new }
+    end
+
+    logger = double('logger')
+    allow(logger).to receive(:info)
+    allow(logger).to receive(:error)
+    allow(logger).to receive(:warn)
+    Pushr::Daemon.logger = logger
+  end
+
+  let(:config) { Pushr::ConfigurationDummy.new(app: 'app_name', connections: 1, enabled: true) }
+  describe 'self' do
+    before(:each) do
+      config.save
+      Pushr::Daemon::App.load
+    end
+
+    it 'should load show total_connections' do
+      expect(Pushr::Daemon::App.total_connections).to eql(1)
+    end
+
+    it 'should load app' do
+      expect(Pushr::Daemon::App.apps.count).to eql(1)
+    end
+
+    it 'should start/stop app' do
+      Pushr::Daemon::App.start
+      Pushr::Daemon::App.stop
+    end
+  end
+
+  describe 'class' do
+    it 'should start configuration' do
+      expect_any_instance_of(Pushr::Daemon::DeliveryHandler).to receive(:start)
+      config.save
+      app = Pushr::Daemon::App.new(config)
+      app.start
+      app.stop
+    end
+
+    it 'should not start configuration' do
+      config = Pushr::InvalidConfigurationDummy.new(app: 'app_name', connections: 2, enabled: true)
+      config.save
+      app = Pushr::Daemon::App.new(config)
+      expect { app.start }.to raise_error(LoadError)
+    end
+  end
+end