rock-queue-smpp 0.1.0

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'spec/rake/spectask'
+require 'date'
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/lib'
+require 'rock-queue/tasks'
+ 
+GEM = "rock-queue"
+GEM_VERSION = "0.1.5"
+AUTHOR = "Grzegorz Kazulak"
+EMAIL = "gregorz.kazulak@gmail.com"
+HOMEPAGE = "http://github.com/grzegorzkazulak/rock-queue"
+SUMMARY = "A unified interface for various messaging queues"
+ 
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["LICENSE"]
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = %w(LICENSE Rakefile) + Dir.glob("{lib,specs}/**/*")
+end
+ 
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+ 
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+ 
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+ 
+desc "Run all examples (or a specific spec with TASK=spec/some_file.rb)"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_opts  = ["-cfs"]
+  t.spec_files = begin
+    if ENV["TASK"] 
+      ENV["TASK"].split(',').map { |task| "spec/**/#{task}_spec.rb" }
+    else
+      FileList['spec/**/*_spec.rb']
+    end
+  end
+end

data/lib/rock-queue/active_record_helper.rb

@@ -0,0 +1,28 @@
+require 'active_record'
+
+module RockQueue
+  module ActiveRecordHelper
+    def self.included(base) 
+      base.extend ClassMethods 
+      base.send(:include, InstanceMethods) 
+    end
+    
+    module ClassMethods
+      def perform(*args)
+        args = args.first
+        id = args.shift
+        method = args.shift
+        find(id).send(method, *args)
+      end
+    end
+    
+    module InstanceMethods 
+      def async(method, *args)
+        config = RockQueue::Config.settings
+        rq = RockQueue::Base.new config.adapter, {:server => config.host, :port => config.port}
+        rq.push self.class, id, method, *args
+      end
+    end 
+    
+  end
+end

data/lib/rock-queue/adapters/beanstalkd.rb

@@ -0,0 +1,21 @@
+begin
+  require "beanstalk-client"
+rescue
+  puts "You need `beanstalk-client` gem to use the Beanstalkd rock-queue interface"
+  exit
+end
+
+module RockQueue
+  class Beanstalkd
+    
+    attr_reader :obj
+    
+    def initialize(options = {})
+      @obj = Beanstalk::Pool.new(["#{options[:server]}:#{options[:port]}"])
+    end
+  
+    def pop
+      loop
+    end 
+  end
+end

data/lib/rock-queue/adapters/delayed_job.rb

@@ -0,0 +1,24 @@
+begin
+  require "delayed_job"
+rescue
+  puts "You need `delayed_job` gem to use the Delayed Job rock-queue interface"
+  exit
+end
+
+module RockQueue
+  class DelayedJob
+    
+    attr_reader :obj
+    
+    def initialize(options = {})
+    end
+    
+    def push(value, options)
+      Delayed::Job.enqueue value
+    end
+  
+    def pop
+      
+    end 
+  end
+end

data/lib/rock-queue/adapters/resque.rb

@@ -0,0 +1,35 @@
+begin
+  require 'resque'
+rescue
+  puts "You need `resque` gem to use the Resque rock-queue interface"
+  exit
+end
+
+module RockQueue
+  class ResqueQueue
+    
+    attr_reader :obj
+    
+    # Contructor of Resque adapter
+    def initialize(options)
+      Resque.redis = "#{options[:server]}:#{options[:port]}"
+    end
+    
+    # Push item from Resque queue
+    def push(value, args)
+      if !defined?(value.queue)
+        value.class_eval do 
+          @queue = :default
+        end
+      end
+      Resque.enqueue value, args
+    end
+
+    # Retrieve item from Resque queue
+    def pop
+      job = Resque.reserve :default
+      [job.payload_class, job.args] if job   
+    end 
+    
+  end
+end

data/lib/rock-queue/config.rb

@@ -0,0 +1,30 @@
+module RockQueue
+  class Config
+    
+    attr_accessor :adapter, :host, :port, :smpp_settings
+    
+    # Return the instance
+    def self.instance
+      @__instance__ ||= new
+    end
+
+    # Yields a singleton instance of RockQueue::Config so you can specify config
+    # information like server address, port etc.
+    def self.settings
+      if block_given?
+        yield self.instance
+      else
+        self.instance
+      end
+    end
+    
+    def notifiers
+      if block_given?
+        yield Notifiers.instance
+      else
+        Notifiers.instance
+      end
+    end
+    
+  end
+end

data/lib/rock-queue/errors.rb

@@ -0,0 +1,5 @@
+module RockQueue
+  class AdapterNotSupported < RuntimeError; end
+  class NoClassError < RuntimeError; end
+  class QueueingServerNotRunning < RuntimeError; end
+end

data/lib/rock-queue/notifiers/abstract_notifier.rb

@@ -0,0 +1,2 @@
+# AbstractNotifier is a base class (interface) for all your notifiers.
+class AbstractNotifier; end

data/lib/rock-queue/notifiers/email_notifier.rb

@@ -0,0 +1,39 @@
+module RockQueue
+  
+  class EmailNotifier < AbstractNotifier
+  
+    def initialize(config)
+      $server_config = config
+    end
+    
+    # Notify by email  
+    def update(error)
+
+      begin
+        require 'mail'
+      rescue
+        puts "You need `mail` gem to use the Email Notifier"
+      end
+      
+      puts "Sending e-mail message: #{error.message}"
+
+      Mail.defaults do
+        smtp do
+          host $server_config[:server]
+          port $server_config[:port]
+          user $server_config[:username]
+          pass $server_config[:password] 
+        end
+      end
+
+      Mail.deliver do
+          from $server_config[:from]
+            to $server_config[:to]
+       subject "Processing error - '#{error.message}''"
+          body error.backtrace.join("\n")
+      end
+      
+    end
+
+  end
+end

data/lib/rock-queue/notifiers.rb

@@ -0,0 +1,23 @@
+require "observer"
+
+module RockQueue
+  class Notifiers
+    include Observable 
+    
+    # Return the instance of notifiers registry.
+    def self.instance
+      @__instance__ ||= new
+    end
+    
+    # Registers the observer. You have to pass the instance of your notifier.
+    def register(instance)
+      add_observer instance
+    end
+    
+    # Notifies all the observers
+    def notify(message)
+      changed
+      notify_observers message
+    end
+  end
+end

data/lib/rock-queue/queue_object.rb

@@ -0,0 +1,34 @@
+module RockQueue
+
+  # Queue object wrapper
+  class QueueObject
+    
+    DEFAULT_FAIL_LIMIT = 3
+    
+    attr_reader :object, :args, :fails
+    
+    # Constructor of queue objects wrapper
+    def initialize(object, args)
+      @object = object
+      @args   = args
+      @fails  = Array.new
+    end
+  
+    # Add processing fail
+    def add_fail(exception)
+      @fails << exception
+      if @fails.length < DEFAULT_FAIL_LIMIT
+        return true
+      else
+        RockQueue::Notifiers.instance.notify(exception)
+      end
+    end
+  
+    # Get sleep time after fail
+    def get_sleep_time
+      2 ** @fails.length
+    end
+    
+  end
+
+end

data/lib/rock-queue/tasks.rb

@@ -0,0 +1,11 @@
+require 'rock-queue'
+
+namespace :rock_queue do
+  desc "Start a Rock Queue worker"
+  task :work do
+    worker = RockQueue::Worker.new
+    worker.verbose = ENV['VERBOSE']
+    puts "=> Rock-queue worker initialized (#{worker})"
+    worker.work
+  end
+end

data/lib/rock-queue/web/views/dashboard.erb

@@ -0,0 +1 @@
+RockQueue Web Interface

data/lib/rock-queue/web.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'sinatra/base'
+require 'erb'
+
+module RockQueue
+  class Web < Sinatra::Base
+    
+    configure do
+      current_dir = File.dirname(File.expand_path(__FILE__))
+      set :views,  "#{current_dir}/web/views"
+      set :public, "#{current_dir}/web/public"
+      set :static, true
+      set :raise_errors, true
+    end
+    
+    get '/' do
+      redirect '/dashboard'
+    end
+    
+    get '/dashboard' do
+      erb :dashboard
+    end
+    
+  end
+end

data/lib/rock-queue/worker.rb

@@ -0,0 +1,52 @@
+module RockQueue
+  class Worker
+    # Whether the worker should log basic info to STDOUT
+    attr_accessor :verbose
+
+    # Initialize connection to queue server
+    def initialize
+      puts "=> Initializing..."
+      config = RockQueue::Config.settings
+      @queue = RockQueue::Base.new config.adapter, {
+              :server => config.host,
+              :port   => config.port
+      }
+    end
+
+    # Main worker loop where all jobs are beeing pulled of the queue. 
+    # This is also a place where every job starts and ends it's lifecycle.
+    def work
+      config = RockQueue::Config.settings
+      puts "=> Worker ready. Hold your horses!"
+      loop do
+        EventMachine::run do
+          @@tx = EventMachine::connect(
+                  config.smpp_config[:host],
+                  config.smpp_config[:port],
+                  Smpp::Transceiver,
+                  config.smpp_config,
+                  self    # delegate that will receive callbacks on MOs and DRs and other events
+          )
+          $stdout.flush
+          @queue.receive do |queue|
+            if queue
+              # code that actually performs the action
+              begin
+                args = queue.args.first
+                args.empty? ? queue.object.perform : queue.object.perform(args)
+              rescue Object => e
+                # Add failed processing and retry
+                if queue.add_fail(e)
+                  sleep(queue.get_sleep_time)
+                  puts "=> Processing fail! Retrying #{queue.fails.length}"
+                  retry
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/rock-queue.rb

@@ -0,0 +1,77 @@
+$:.unshift File.expand_path(File.dirname(__FILE__))
+require 'logger'
+
+module RockQueue
+
+  autoload :Config,                   'rock-queue/config'
+  
+  autoload :AbstractNotifier,         'rock-queue/notifiers/abstract_notifier'
+  autoload :Notifiers,                'rock-queue/notifiers'
+  autoload :EmailNotifier,            'rock-queue/notifiers/email_notifier'
+  
+  autoload :Worker,                   'rock-queue/worker'
+  autoload :QueueObject,              'rock-queue/queue_object'
+  
+  # Adapters
+  autoload :Beanstalkd,               'rock-queue/adapters/beanstalkd'
+  autoload :ResqueQueue,              'rock-queue/adapters/resque'
+  autoload :DelayedJob,               'rock-queue/adapters/delayed_job'
+  
+  autoload :AdapterNotSupported,      'rock-queue/errors'
+  autoload :NoClassError,             'rock-queue/errors'
+  autoload :QueueingServerNotRunning, 'rock-queue/errors'
+  autoload :ActiveRecordHelper,       'rock-queue/active_record_helper'
+  
+  attr_reader :adapter
+  
+  class Base   
+    
+    # Initializes the whole thing and makes the connection to the 
+    # queueing server using selected adapter (passed as lowercased symbol)
+    def initialize(adapter, *options)
+      # Any better way to do this? :-)
+      options = options.first
+      if options.include?(:server) && options.include?(:port)
+      case adapter
+        when :beanstalkd
+          @adapter = Beanstalkd.new(options)
+        when :resque
+          @adapter = ResqueQueue.new(options)
+        when :delayed_job
+          @adapter = DelayedJob.new(options)
+      end
+      else
+        raise ArgumentError
+      end
+    end
+    
+    
+    # Pushes the value (in our case it should always be an object)
+    # onto the queue using previously selected adapter
+    def push(value, *args)
+      @adapter.push(value, args)
+    end
+    
+    
+    # Pulls the data off the queue. There are two ways to do so:
+    # - Call receive with no block (gets you a single item)
+    # - Pass a block to it (creates and endles loop that constantly pulls items from the queue as they become available)
+    # All calls to the queueing server are made through the previosuly selected adaper.
+    def receive
+      if block_given?
+        obj, args = @adapter.pop
+        if obj
+          yield QueueObject.new(obj, args)
+        end
+      else
+        raise 'No block given'
+      end
+    end
+    
+    
+    def method_missing(sym, *args, &block)
+       @adapter.send sym, *args, &block
+    end
+
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: rock-queue-smpp
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Grzegorz Kazulak, Matt Van Veenendaal
+autorequire: rock-queue
+bindir: bin
+cert_chain: []
+
+date: 2009-11-17 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Fork of Rock-Queue to run an SMPP Gateway
+email: m@mattvv.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+files: 
+- LICENSE
+- Rakefile
+- lib/rock-queue/active_record_helper.rb
+- lib/rock-queue/adapters/beanstalkd.rb
+- lib/rock-queue/adapters/delayed_job.rb
+- lib/rock-queue/adapters/resque.rb
+- lib/rock-queue/config.rb
+- lib/rock-queue/errors.rb
+- lib/rock-queue/notifiers/abstract_notifier.rb
+- lib/rock-queue/notifiers/email_notifier.rb
+- lib/rock-queue/notifiers.rb
+- lib/rock-queue/queue_object.rb
+- lib/rock-queue/tasks.rb
+- lib/rock-queue/web/views/dashboard.erb
+- lib/rock-queue/web.rb
+- lib/rock-queue/worker.rb
+- lib/rock-queue.rb
+has_rdoc: true
+homepage: http://github.com/mattvv/rock-queue-rmpp
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Fork of Rock-Queue to run an SMPP Gateway
+test_files: []
+