rocket_sms 0.1.1

data/lib/rocket_sms/message.rb

@@ -0,0 +1,30 @@
+module RocketSMS
+  class Message
+
+    attr_reader :params
+
+    def initialize(params)
+      @params = OpenStruct.new(params)
+      @params.pass ||= 0
+    end
+
+    def to_json
+      MultiJson.dump(@params.marshal_dump)
+    end
+
+    def add_pass
+      @params.pass += 1
+    end
+
+    def self.from_json(json)
+      params = MultiJson.load(json, symbolize_keys: true)
+      msg = Message.new(params)
+      return msg
+    end
+
+    def method_missing(sym, *args, &block)
+      @params.send(sym, *args, &block)
+    end
+
+  end
+end

data/lib/rocket_sms/scheduler.rb

@@ -0,0 +1,212 @@
+module RocketSMS
+
+  class Scheduler
+    include Singleton
+
+    attr_accessor :redis_url, :log_location
+
+    def initialize
+      @redis_url, @log_location = nil, nil
+      @active = true
+      @fast = false
+      @dids = {}
+      @transceivers = {}
+      @throughput = 0
+    end
+
+    def redis
+      @redis ||= EM::Hiredis.connect(@redis_url)
+    end
+
+    def logger
+      @logger ||= Logger.new(@log_location)
+    end
+
+    def log(msg, level = 'info')
+      if EM.reactor_running?
+        EM.defer{ logger.send(level, msg) }
+      else
+        logger.send(level, msg)
+      end
+    end
+
+    def queues
+      RocketSMS.queues
+    end
+
+    def start
+      EM.threadpool_size = 128
+      EM.set_max_timers(100_000)
+      EM.run do
+        log "Starting Scheduler"
+        configure
+        detect
+        # Trap exit-related signals
+        Signal.trap("INT") { |signal| stop(signal) }
+        Signal.trap("TERM") { |signal| stop(signal) }
+      end
+    end
+
+    def stop(signal = nil)
+      if @kill
+        log "Forcing Exit. Check your data for losses."
+        shutdown
+      else
+        log "Stopping. Waiting 5 seconds for pending operations to finish."
+        @kill = true
+        @active = false
+        EM::Timer.new(5){ shutdown }
+      end
+    end
+
+    def shutdown
+      log "Scheduler DOWN."
+      EM.stop
+    end
+
+    def configure
+      return unless @active
+      @configurator = EM::Timer.new(1){ configure }
+      redis.keys("gateway:transceivers:*") do |keys|
+        if keys
+          tids = keys.map{ |key| key.split(':')[2] }.uniq
+          @transceivers.keys.each{ |k| @transceivers.delete(k) unless tids.include?(k) }
+          tids.each do |tid|
+            redis.hget("gateway:transceivers:#{tid}","status") do |resp|
+              if resp == 'online'
+                redis.hget("gateway:transceivers:#{tid}", "throughput") do |payload|
+                  if payload
+                    throughput = payload.to_f
+                    log "Adding Transceiver #{tid}" if !@transceivers[tid]
+                    @transceivers[tid] = throughput
+                    set_throughput
+                  elsif @transceivers[tid]
+                    log "Removing Transceiver #{tid}" 
+                    @transceivers.delete(tid)
+                    set_throughput
+                  end
+                end
+              else
+                if @transceivers[tid]
+                  log "Removing Transceiver #{tid}"
+                  @transceivers.delete(tid)
+                  set_throughput
+                end
+              end
+            end
+          end
+        else
+          @transceivers = {}
+          @throughput = 0
+        end
+      end
+    end
+
+    def set_throughput
+      @throughput = @transceivers.keys.map{ |tid| @transceivers[tid] }.reduce(&:+).to_f
+    end
+
+    def detect
+      return unless @active
+      interval = @fast ? 0.001 : 1
+      @detector = EM::Timer.new(interval){ detect }
+      redis.multi
+      redis.zrange(queues[:mt][:pending], 0, 0, "WITHSCORES")
+      redis.zremrangebyrank(queues[:mt][:pending], 0, 0)
+      redis.exec do |response|
+        if response
+          (payload, score) = response[0]
+          if payload and score
+            @fast = true
+            now = Time.now.to_i
+            if score.to_i <= now
+              process_payload(payload)
+            else
+              redis.zadd(queues[:mt][:pending], score, payload)
+              @fast = false
+            end
+          else
+            @fast = false
+          end
+        end
+      end
+    end
+
+    def process_payload(msg_payload)
+      begin
+        message = Message.from_json(msg_payload)
+        if message.pass > 5
+          log "Message #{message.id} has exceeded maximum retries. Send it to Failed queue."
+          redis.lpush(queues[:mt][:failure], message.to_json)
+        else
+          did_number = message.sender
+          redis.get("gateway:dids:#{did_number}") do |payload|
+            if payload
+              log "Scheduling Message #{message.id} to be sent through DID #{did_number}"
+              schedule(message, payload)
+            else
+              log "The DID #{did_number} for message #{message.id} is not configured. Retrying."
+              retry_message(message)
+            end
+          end
+        end
+      rescue
+        log 'Invalid Message.'
+        redis.lpush(queues[:mt][:failure])
+      end
+    end
+
+    def schedule(message, did_payload)
+      if @active
+        if @transceivers.keys.empty? or @throughput == 0
+          retry_message(message)
+        else
+          did = Did.from_json(did_payload)
+          if !@dids[did.number]
+            @dids[did.number] = {}
+            @dids[did.number][:last_send] = Time.now.to_f + 1
+          end
+          interval = ((did.throughput.to_f)**-1)*1.1
+          last_send = @dids[did.number][:last_send]
+          if Time.now.to_f - last_send > interval
+            base_time = Time.now.to_f + 1
+          else
+            base_time = last_send
+          end
+          message.send_at = base_time + interval
+          message.expires_at = message.send_at + 50*interval
+          @dids[did.number][:last_send] = message.send_at
+          score = (message.send_at * 1000).to_i
+          transceiver_id = pick_transceiver
+          redis.zadd("gateway:transceivers:#{transceiver_id}:dispatch", score, message.to_json)
+        end
+      else
+        score = message.send_at.to_i + 15
+        redis.zadd(queues[:mt][:pending], score, message.to_json)
+      end
+    end
+
+    def pick_transceiver
+      tids = []
+      @transceivers.each do |k,v|
+        weight = (v.to_f/@throughput*100).to_i
+        weight.times{ tids << k }
+      end
+      tids.flatten!
+      tids.sample
+    end
+
+    def retry_message(message)
+      if message.pass > 5
+        log "Message #{message.id} has exceeded maximum retries. Send it to Failed queue."
+        redis.lpush(queues[:mt][:failure], message.to_json)
+      else
+        message.add_pass
+        score = Time.now.to_i + 15
+        redis.zadd(queues[:mt][:pending], score, message.to_json)
+      end
+    end
+
+  end
+
+end

data/lib/rocket_sms/transceiver.rb

@@ -0,0 +1,260 @@
+module RocketSMS
+
+  class Transceiver
+
+    def initialize(id, redis_url, log_location)
+      @id, @redis_url, @log_location = id, redis_url, log_location
+      @active = true
+      @online = false
+      @fast = false
+      @settings = {}
+      @mts = {}
+    end
+
+    def redis
+      @redis ||= EM::Hiredis.connect(@redis_url)
+    end
+
+    def dredis
+      @dredis ||= EM::Hiredis.connect(@redis_url)
+    end
+
+    def logger
+      @logger ||= Logger.new(@log_location)
+    end
+
+    def log(msg, level = 'info')
+      if EM.reactor_running?
+        EM.defer{ logger.send(level, msg) }
+      else
+        logger.send(level, msg)
+      end
+    end
+
+    def queues
+      RocketSMS.queues
+    end
+
+    def throughput
+      @settings && @settings[:throughput] ||= 1.0
+    end
+
+    def start
+      EM.threadpool_size = 128
+      EM.set_max_timers(100_000)
+      EM.run do
+        log "Starting Transceiver #{@id}"
+        # Set quantum to 10 milliseconds to support throughputs up to 100 MTs/sec
+        EM.set_quantum(10)
+        # Detect transceiver configuration from Redis.
+        configure
+        # Connect
+        connect
+        # Start detecting and dispatching MTs
+        dispatch
+        # Trap exit-related signals
+        Signal.trap("INT") { |signal| stop(signal) }
+        Signal.trap("TERM") { |signal| stop(signal) }
+      end
+    end
+
+    def stop(signal = nil)
+      if @kill
+        log "#{@id} - Forcing Exit. Check your data for losses."
+        shutdown
+      else
+        log "#{@id} - Stopping. Waiting for pending operations to finish."
+        @kill = true
+        @active = false
+        @connection.close_connection_after_writing if @connection
+        @dispatcher.cancel if @dispatcher
+        @configurator.cancel if @configurator
+        @reconnector.cancel if @reconnector
+        redis.del("gateways:transceivers:#{@id}")
+        cleanup
+      end
+    end
+
+    def shutdown
+      log "Transceiver #{@id} DOWN."
+      EM.stop
+    end
+
+    def cleanup
+      redis.zrangebyscore("gateway:transceivers:#{@id}:dispatch", '-inf', '+inf') do |payloads|
+        if payloads and !payloads.empty?
+          op = Proc.new do |payload, iter|
+            message = Message.from_json(payload)
+            message.send_at, message.expires_at = nil, nil
+            score = (Time.now.to_f*1000).to_i
+            redis.multi
+            redis.zrem("gateway:transceivers:#{@id}:dispatch", payload)
+            redis.zadd(queues[:mt][:pending], score, payload)
+            redis.exec do |resp|
+              iter.next
+            end
+          end
+          cb = Proc.new do |responses|
+            EM::Timer.new(3){ shutdown }
+          end
+          EM::Iterator.new(payloads).each(op,cb)
+        else
+          EM::Timer.new(3){ shutdown }
+        end
+      end
+    end
+
+    def configure
+      return unless @active
+      @configurator = EM::Timer.new(1){ configure }
+      redis.multi
+      redis.hget("gateway:transceivers:#{@id}", "throughput")
+      redis.hget("gateway:transceivers:#{@id}", "connection")
+      redis.exec do |response|
+        if response and !response.flatten.include?(nil)
+          throughput_payload = response[0]
+          connection_payload = response[1]
+          @settings[:throughput] = throughput_payload.to_f
+          @settings[:connection] = MultiJson.load(connection_payload, symbolize_keys: true)
+        else
+          stop
+        end
+      end
+    end
+
+    def connect
+      return unless @active
+      if @settings and @settings[:connection]
+        log "Connecting transceiver #{@id}."
+        @connection = EM.connect(
+          @settings[:connection][:host], 
+          @settings[:connection][:port], 
+          Smpp::Transceiver, 
+          @settings[:connection], 
+          self
+        )
+      else
+        EM::Timer.new(1){ connect }
+      end
+    end
+
+    def dispatch
+      return unless @active
+      interval = @fast ? ((throughput.to_f)**-1)*1.1 : 0.5
+      @dispatcher = EM::Timer.new(interval){ dispatch }
+      redis.multi
+      redis.zrange("gateway:transceivers:#{@id}:dispatch", 0, 0)
+      redis.zremrangebyrank("gateway:transceivers:#{@id}:dispatch", 0, 0)
+      redis.exec do |response|
+        if response
+          payload = response[0][0]
+          if payload
+            @fast = true
+            now = Time.now.to_f
+            message = Message.from_json(payload)
+            if message.send_at > now
+              score = (message.send_at * 1000).to_i
+              redis.zadd("gateway:transceivers:#{@id}:dispatch", score , payload)
+            elsif message.send_at <= now and now < message.expires_at
+              log "Message #{message.id} detected on #{@id}. Sending."
+              send_message(message)
+            elsif message.expires_at <= now
+              log "Message #{message.id} detected on #{@id} but has expired. Retrying."
+              message.add_pass
+              score = (( Time.now.to_f + 15 ) * 1000).to_i
+              redis.zadd(queues[:mt][:pending], score, message.to_json)
+              @dispatcher.cancel if @dispatcher
+              EM.next_tick{ dispatch }
+            end
+          else
+            @fast = false
+          end
+        end
+      end
+    end
+
+    def register
+      stat = @online ? 'online' : 'offline'
+      redis.hset("gateway:transceivers:#{@id}", 'status', stat)
+    end
+
+    def send_message(message)
+      begin
+        if @online
+          log "Sending Message #{message.id} through DID #{message.sender} via #{@id}."
+          @mts[message.id.to_s] = message
+          @connection.send_mt(message.id,message.sender,message.receiver,message.body)
+        else
+          log "#{@id} is not connected. Pushing message #{message.id} to dispatch queue."
+          score = (message.send_at * 1000).to_i
+          redis.zadd("gateway:transceivers:#{@id}:dispatch", score , payload)
+        end
+      rescue Exception
+        log "### Error Sending MT #{message.id} with DID #{message.sender} through Transceiver #{@id}. Retrying message."
+        message.add_pass
+        score = Time.now.to_i + 15
+        redis.zadd(queues[:mt][:pending], score, message.to_json)
+      end
+    end
+
+    def mo_received(transceiver, pdu)
+      log "#{@id} - Message Received"
+      ticket = { pdu: { source_addr: pdu.source_addr, short_message: pdu.short_message, destination_addr: pdu.destination_addr } }
+      EM.next_tick { redis.lpush(queues[:mo],MultiJson.dump(ticket)) }
+    end
+  
+    def delivery_report_received(transceiver, pdu)
+      log "#{@id} - DR Received"
+      ticket = { pdu: { source_addr: pdu.source_addr, short_message: pdu.short_message, destination_addr: pdu.destination_addr } }
+      EM.next_tick { redis.lpush(queues[:dr],MultiJson.dump(ticket)) }
+    end
+  
+    def message_accepted(transceiver, mt_message_id, pdu)
+      message = @mts.delete(mt_message_id.to_s)
+      if message
+        log "#{@id} - Message #{message.id} - Accepted"
+        message.accepted_at = Time.now.to_i
+        EM.next_tick { redis.lpush(queues[:mt][:success],message.to_json) }
+      else
+        log "#{@id} - Untracked MT Accepted #{mt_message_id}"
+      end
+    end
+  
+    def message_rejected(transceiver, mt_message_id, pdu)
+      message = @mts.delete(mt_message_id.to_s)
+      if message
+        log "#{@id} - Message #{message.id} - Rejected"
+        message.add_pass
+        message.rejected_at = Time.now.to_i
+        if message.pass <= 5
+          score = Time.now.to_i + 10
+          EM.next_tick{ redis.zadd(queues[:mt][:pending], score, message.to_json) }
+        else
+          EM.next_tick { redis.lpush(queues[:mt][:failure],message.to_json) }
+        end
+      else
+        log "#{@id} - Untracked MT Rejected #{mt_message_id}"
+      end
+    end
+  
+    def bound(transceiver)
+      log "#{@id} - Transceiver Bound"
+      @online = true
+      @reconnector = nil
+      register
+    end
+  
+    def unbound(transceiver)  
+      log "#{@id} - Transceiver Unbound"
+      if @active
+        log "#{@id} is not connected. Retrying in 10 seconds."
+        @reconnector.cancel if @reconnector
+        @reconnector = EM::Timer.new(10){ connect }
+      end
+      @online = false
+      register
+    end
+
+  end
+
+end