ruby-smpp 0.3.0 → 0.4.0

data/Gemfile

@@ -0,0 +1,5 @@
+source 'http://rubygems.org'
+
+gem "jeweler"
+gem "rake"
+gem "eventmachine"

data/Gemfile.lock

@@ -0,0 +1,22 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    eventmachine (0.12.10)
+    gemcutter (0.6.1)
+    git (1.2.5)
+    jeweler (1.4.0)
+      gemcutter (>= 0.1.0)
+      git (>= 1.2.5)
+      rubyforge (>= 2.0.0)
+    json_pure (1.4.6)
+    rake (0.8.7)
+    rubyforge (2.0.4)
+      json_pure (>= 1.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  eventmachine
+  jeweler
+  rake

data/Rakefile

@@ -1,4 +1,4 @@
-require 'rubygems'
+require File.expand_path('../config/environment', __FILE__)
 require 'rake'
 
 begin

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/config/environment.rb

@@ -0,0 +1,2 @@
+require "rubygems"
+require "bundler/setup"

data/lib/smpp.rb

@@ -10,6 +10,7 @@ require 'logger'
 $:.unshift(File.dirname(__FILE__))
 require 'smpp/base.rb'
 require 'smpp/transceiver.rb'
+require 'smpp/receiver.rb'
 require 'smpp/optional_parameter'
 require 'smpp/pdu/base.rb'
 require 'smpp/pdu/bind_base.rb'

data/lib/smpp/pdu/bind_receiver.rb

@@ -0,0 +1,4 @@
+class Smpp::Pdu::BindReceiver < Smpp::Pdu::BindBase
+  @command_id = BIND_RECEIVER
+  handles_cmd BIND_RECEIVER
+end

data/lib/smpp/pdu/bind_receiver_response.rb

@@ -0,0 +1,4 @@
+class Smpp::Pdu::BindReceiverResponse < Smpp::Pdu::BindRespBase
+  @command_id = BIND_RECEIVER_RESP
+  handles_cmd BIND_RECEIVER_RESP
+end

data/lib/smpp/pdu/deliver_sm.rb

@@ -27,7 +27,7 @@ class Smpp::Pdu::DeliverSm < Smpp::Pdu::Base
     @data_coding             = options[:data_coding]?options[:data_coding]:3 # iso-8859-1
     @sm_default_msg_id       = options[:sm_default_msg_id]?options[:sm_default_msg_id]:0
     @short_message           = short_message
-    payload                  = @udh ? @udh + @short_message : @short_message 
+    payload                  = @udh ? @udh.to_s + @short_message : @short_message 
     @sm_length               = payload.length
 
     #fields set for delivery report
@@ -46,6 +46,18 @@ class Smpp::Pdu::DeliverSm < Smpp::Pdu::Base
     super(DELIVER_SM, 0, seq, pdu_body)
   end
 
+  def total_parts
+    @udh ? @udh[4] : 0
+  end
+
+  def part
+    @udh ? @udh[5] : 0
+  end
+
+  def message_id
+    @udh ? @udh[3] : 0
+  end
+
   def self.from_wire_data(seq, status, body)
     options = {}
     # brutally unpack it
@@ -85,7 +97,10 @@ class Smpp::Pdu::DeliverSm < Smpp::Pdu::Base
       end
     end
 
-
+    # Check to see if body has a 5 bit header
+    if short_message.unpack("c")[0] == 5
+      options[:udh] = short_message.slice!(0..5).unpack("CCCCCC")
+    end
 
     #Note: if the SM is a delivery receipt (esm_class=4) then the short_message _may_ be in this format:  
     # "id:Smsc2013 sub:1 dlvrd:1 submit date:0610171515 done date:0610171515 stat:0 err:0 text:blah"

data/lib/smpp/receiver.rb

@@ -0,0 +1,80 @@
+
+# The SMPP Receiver maintains a unidirectional connection to an SMSC.
+# Provide a config hash with connection options to get started. 
+# See the sample_gateway.rb for examples of config values.
+# The receiver accepts a delegate object that may implement 
+# the following (all optional) methods:
+#
+#   mo_received(receiver, pdu)
+#   delivery_report_received(receiver, pdu)
+#   bound(receiver)
+#   unbound(receiver)
+
+class Smpp::Receiver < Smpp::Base
+
+  def initialize(config, delegate)
+    super(config)
+    @delegate = delegate
+    
+    ed = @config[:enquire_link_delay_secs] || 5
+    comm_inactivity_timeout = 2 * ed
+  rescue Exception => ex
+    logger.error "Exception setting up receiver: #{ex} at #{ex.backtrace.join("\n")}"
+    raise
+  end
+
+  # a PDU is received. Parse it and invoke delegate methods.
+  def process_pdu(pdu)
+    case pdu
+    when Pdu::DeliverSm
+      write_pdu(Pdu::DeliverSmResponse.new(pdu.sequence_number))
+      logger.debug "ESM CLASS #{pdu.esm_class}"
+      if pdu.esm_class != 4
+        # MO message
+        if @delegate.respond_to?(:mo_received)
+          @delegate.mo_received(self, pdu)
+        end
+      else
+        # Delivery report
+        if @delegate.respond_to?(:delivery_report_received)
+          @delegate.delivery_report_received(self, pdu)
+        end
+      end     
+    when Pdu::BindReceiverResponse
+      case pdu.command_status
+      when Pdu::Base::ESME_ROK
+        logger.debug "Bound OK."
+        @state = :bound
+        if @delegate.respond_to?(:bound)
+          @delegate.bound(self)
+        end
+      when Pdu::Base::ESME_RINVPASWD
+        logger.warn "Invalid password."
+        # scheduele the connection to close, which eventually will cause the unbound() delegate 
+        # method to be invoked.
+        close_connection
+      when Pdu::Base::ESME_RINVSYSID
+        logger.warn "Invalid system id."
+        close_connection
+      else
+        logger.warn "Unexpected BindReceiverResponse. Command status: #{pdu.command_status}"
+        close_connection
+      end
+    else
+      super
+    end 
+  end
+
+  # Send BindReceiverResponse PDU.
+  def send_bind
+    raise IOError, 'Receiver already bound.' unless unbound?
+    pdu = Pdu::BindReceiver.new(
+        @config[:system_id], 
+        @config[:password],
+        @config[:system_type], 
+        @config[:source_ton], 
+        @config[:source_npi], 
+        @config[:source_address_range])
+    write_pdu(pdu)
+  end
+end

data/ruby-smpp.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ruby-smpp}
-  s.version = "0.3.0"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ray Krueger", "August Z. Flatby"]
-  s.date = %q{2010-06-14}
+  s.date = %q{2011-01-06}
   s.description = %q{Ruby implementation of the SMPP protocol, based on EventMachine. SMPP is a protocol that allows ordinary people outside the mobile network to exchange SMS messages directly with mobile operators.}
   s.email = %q{raykrueger@gmail.com}
   s.extra_rdoc_files = [
@@ -21,10 +21,13 @@ Gem::Specification.new do |s|
     ".gitignore",
      "CHANGELOG",
      "CONTRIBUTORS.txt",
+     "Gemfile",
+     "Gemfile.lock",
      "LICENSE",
      "README.rdoc",
      "Rakefile",
      "VERSION",
+     "config/environment.rb",
      "examples/PDU1.example",
      "examples/PDU2.example",
      "examples/sample_gateway.rb",
@@ -34,6 +37,8 @@ Gem::Specification.new do |s|
      "lib/smpp/optional_parameter.rb",
      "lib/smpp/pdu/base.rb",
      "lib/smpp/pdu/bind_base.rb",
+     "lib/smpp/pdu/bind_receiver.rb",
+     "lib/smpp/pdu/bind_receiver_response.rb",
      "lib/smpp/pdu/bind_resp_base.rb",
      "lib/smpp/pdu/bind_transceiver.rb",
      "lib/smpp/pdu/bind_transceiver_response.rb",
@@ -48,11 +53,17 @@ Gem::Specification.new do |s|
      "lib/smpp/pdu/submit_sm_response.rb",
      "lib/smpp/pdu/unbind.rb",
      "lib/smpp/pdu/unbind_response.rb",
+     "lib/smpp/receiver.rb",
      "lib/smpp/server.rb",
      "lib/smpp/transceiver.rb",
      "lib/sms.rb",
      "ruby-smpp.gemspec",
+     "test/delegate.rb",
      "test/optional_parameter_test.rb",
+     "test/pdu_parsing_test.rb",
+     "test/receiver_test.rb",
+     "test/responsive_delegate.rb",
+     "test/server.rb",
      "test/smpp_test.rb",
      "test/submit_sm_test.rb"
   ]
@@ -63,7 +74,12 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.6}
   s.summary = %q{Ruby implementation of the SMPP protocol, based on EventMachine.}
   s.test_files = [
-    "test/optional_parameter_test.rb",
+    "test/delegate.rb",
+     "test/optional_parameter_test.rb",
+     "test/pdu_parsing_test.rb",
+     "test/receiver_test.rb",
+     "test/responsive_delegate.rb",
+     "test/server.rb",
      "test/smpp_test.rb",
      "test/submit_sm_test.rb",
      "examples/sample_gateway.rb",

data/test/delegate.rb

@@ -0,0 +1,28 @@
+# the delagate receives callbacks when interesting things happen on the connection
+class Delegate
+
+  def mo_received(transceiver, pdu)
+    puts "** mo_received"
+  end
+
+  def delivery_report_received(transceiver, pdu)
+    puts "** delivery_report_received"
+  end
+
+  def message_accepted(transceiver, mt_message_id, pdu)
+    puts "** message_sent"
+  end
+
+  def message_rejected(transceiver, mt_message_id, pdu)
+    puts "** message_rejected"
+  end
+
+  def bound(transceiver)
+    puts "** bound"
+  end
+
+  def unbound(transceiver)
+    puts "** unbound"
+    EventMachine::stop_event_loop
+  end
+end

data/test/pdu_parsing_test.rb

@@ -0,0 +1,84 @@
+require 'rubygems'
+require 'test/unit'
+require File.expand_path(File.dirname(__FILE__) + "../../lib/smpp")
+
+class PduParsingTest < Test::Unit::TestCase
+
+  def test_recieve_single_message
+    raw_data = <<-EOF
+    0000 003d 0000 0005 0000 0000 0000 0002
+    0001 0134 3437 3830 3330 3239 3833 3700
+    0101 3434 3738 3033 3032 3938 3337 0000
+    0000 0000 0000 0000 0454 6573 74
+    EOF
+
+    pdu = create_pdu(raw_data)
+    assert_equal Smpp::Pdu::DeliverSm, pdu.class
+    assert_equal "447803029837", pdu.source_addr
+    assert_equal "447803029837", pdu.destination_addr
+    assert_nil pdu.udh
+    assert_equal "Test", pdu.short_message
+  end
+
+  def test_recieve_part_one_of_multi_part_message
+    part_one_message = <<-EOF
+    0000 00d8 0000 0005 0000 0000 0000 0001
+    0001 0134 3437 3937 3334 3238 3634 3400
+    0101 3434 3739 3736 3232 3430 3137 0000
+    0000 0000 0000 0000 9f05 0003 b402 0154
+    6869 7320 6973 2061 206c 6f6e 6720 6d65
+    7373 6167 6520 746f 2074 6573 7420 7768
+    6574 6865 7220 6f72 206e 6f74 2077 6520
+    6765 7420 7468 6520 6865 6164 6572 2069
+    6e66 6f20 7669 6120 7468 6520 534d 5343
+    2074 6861 7420 7765 2077 6f75 6c64 2072
+    6571 7569 7265 2074 6f20 6265 2061 626c
+    6520 746f 2072 6563 6f6d 706f 7365 206c
+    6f6e 6720 6d65 7373 6167 6573 2069 6e20
+    6861 7368 626c 7565
+    EOF
+
+    pdu = create_pdu(part_one_message)
+    assert_equal Smpp::Pdu::DeliverSm, pdu.class
+    assert_equal "447973428644", pdu.source_addr
+    assert_equal "447976224017", pdu.destination_addr
+    assert_equal [5, 0, 3, 180, 2, 1], pdu.udh
+
+    assert_equal 2, pdu.total_parts, "Have total parts of the message"
+    assert_equal 1, pdu.part, "Correctly show the part"
+    assert_equal 180, pdu.message_id
+
+    assert_equal "This is a long message to test whether or not we get the header info via the SMSC that we would require to be able to recompose long messages in hashblue", pdu.short_message
+  end
+
+  def test_recieve_part_two_of_multi_part_message
+    part_one_message = <<-EOF
+    0000 0062 0000 0005 0000 0000 0000 0002
+    0001 0134 3437 3937 3334 3238 3634 3400
+    0101 3434 3739 3736 3232 3430 3137 0000
+    0000 0000 0000 0000 2905 0003 b402 0220
+    616e 6420 7072 6f76 6964 6520 6120 676f
+    6f64 2075 7365 7220 6578 7065 7269 656e
+    6365
+    EOF
+
+    pdu = create_pdu(part_one_message)
+    assert_equal Smpp::Pdu::DeliverSm, pdu.class
+    assert_equal "447973428644", pdu.source_addr
+    assert_equal "447976224017", pdu.destination_addr
+    assert_equal [5, 0, 3, 180, 2, 2], pdu.udh
+
+    assert_equal 2, pdu.total_parts, "Have total parts of the message"
+    assert_equal 2, pdu.part, "Correctly show the part"
+    assert_equal 180, pdu.message_id
+
+    assert_equal " and provide a good user experience", pdu.short_message
+  end
+
+  protected
+  def create_pdu(raw_data)
+    hex_data = [raw_data.chomp.gsub(" ","").gsub(/\n/,"")].pack("H*")
+    Smpp::Pdu::Base.create(hex_data)
+  end
+
+end

data/test/receiver_test.rb

@@ -0,0 +1,197 @@
+require 'rubygems'
+require 'test/unit'
+require 'smpp'
+
+class ReceiverTest < Test::Unit::TestCase
+
+  class RecordingDelegate
+    attr_reader :received_pdus, :received_delivery_report_pdus, :states
+    def initialize
+      @received_pdus, @received_delivery_report_pdus, @states = [], [], []
+    end
+    def mo_received(receiver, pdu)
+      @received_pdus << pdu
+    end
+    def delivery_report_received(receiver, pdu)
+      @received_delivery_report_pdus << pdu
+    end
+    def bound(receiver)
+      @states << :bound
+    end
+  end
+
+  def test_receiving_bind_receiver_response_with_ok_status_should_become_bound
+    receiver = build_receiver
+    bind_receiver_response = Smpp::Pdu::BindReceiverResponse.new(nil, Smpp::Pdu::Base::ESME_ROK, 1)
+
+    receiver.process_pdu(bind_receiver_response)
+
+    assert receiver.bound?
+  end
+
+  def test_receiving_bind_receiver_response_with_ok_status_should_invoke_bound_on_delegate
+    delegate = RecordingDelegate.new
+    receiver = build_receiver(delegate)
+    bind_receiver_response = Smpp::Pdu::BindReceiverResponse.new(nil, Smpp::Pdu::Base::ESME_ROK, 1)
+
+    receiver.process_pdu(bind_receiver_response)
+
+    assert_equal [:bound], delegate.states
+  end
+
+  def test_receiving_bind_receiver_response_with_ok_status_should_not_error_if_method_doesnt_exist_on_delegate
+    delegate = Object.new
+    receiver = build_receiver(delegate)
+    bind_receiver_response = Smpp::Pdu::BindReceiverResponse.new(nil, Smpp::Pdu::Base::ESME_ROK, 1)
+
+    assert_nothing_raised { receiver.process_pdu(bind_receiver_response) }
+  end
+
+  def test_receiving_bind_receiver_response_with_error_status_should_not_become_bound
+    receiver = build_receiver
+    bind_receiver_response = Smpp::Pdu::BindReceiverResponse.new(nil, Smpp::Pdu::Base::ESME_RBINDFAIL, 1)
+
+    receiver.process_pdu(bind_receiver_response)
+
+    assert receiver.unbound?
+  end
+
+  def test_receiving_bind_receiver_response_with_error_status_should_not_invoke_bound_on_delegate
+    delegate = RecordingDelegate.new
+    receiver = build_receiver(delegate)
+    bind_receiver_response = Smpp::Pdu::BindReceiverResponse.new(nil, Smpp::Pdu::Base::ESME_RBINDFAIL, 1)
+
+    receiver.process_pdu(bind_receiver_response)
+
+    assert_equal [], delegate.states
+  end
+
+  def test_receiving_bind_receiver_response_with_error_status_should_close_connection
+    receiver = build_receiver
+    bind_receiver_response = Smpp::Pdu::BindReceiverResponse.new(nil, Smpp::Pdu::Base::ESME_RBINDFAIL, 1)
+
+    receiver.process_pdu(bind_receiver_response)
+
+    assert_equal 1, receiver.close_connections
+  end
+
+  def test_receiving_deliver_sm_should_send_deliver_sm_response
+    receiver = build_receiver
+    deliver_sm = Smpp::Pdu::DeliverSm.new("from", "to", "message")
+
+    receiver.process_pdu(deliver_sm)
+
+    first_sent_data = receiver.sent_data.first
+    assert_not_nil first_sent_data
+    actual_response = Smpp::Pdu::Base.create(first_sent_data)
+    expected_response = Smpp::Pdu::DeliverSmResponse.new(deliver_sm.sequence_number)
+    assert_equal expected_response.to_human, actual_response.to_human
+  end
+
+  def test_receiving_deliver_sm_should_invoke_mo_received_on_delegate
+    delegate = RecordingDelegate.new
+    receiver = build_receiver(delegate)
+    deliver_sm = Smpp::Pdu::DeliverSm.new("from", "to", "message")
+
+    receiver.process_pdu(deliver_sm)
+
+    first_received_pdu = delegate.received_pdus.first
+    assert_not_nil first_received_pdu
+    assert_equal deliver_sm.to_human, first_received_pdu.to_human
+  end
+
+  def test_receiving_deliver_sm_should_not_error_if_mo_received_method_doesnt_exist_on_delegate
+    delegate = Object.new
+    receiver = build_receiver(delegate)
+    deliver_sm = Smpp::Pdu::DeliverSm.new("from", "to", "message")
+
+    assert_nothing_raised { receiver.process_pdu(deliver_sm) }
+  end
+
+  def test_receiving_deliver_sm_for_esm_class_4_should_invoke_delivery_report_received_on_delegate
+    delegate = RecordingDelegate.new
+    receiver = build_receiver(delegate)
+    deliver_sm = Smpp::Pdu::DeliverSm.new("from", "to", "message", :esm_class => 4)
+
+    receiver.process_pdu(deliver_sm)
+
+    first_received_delivery_report_pdu = delegate.received_delivery_report_pdus.first
+    assert_not_nil first_received_delivery_report_pdu
+    assert_equal deliver_sm.to_human, first_received_delivery_report_pdu.to_human
+  end
+
+  def test_receiving_deliver_sm_should_not_error_if_received_delivery_report_method_doesnt_exist_on_delegate
+    delegate = Object.new
+    receiver = build_receiver(delegate)
+    deliver_sm = Smpp::Pdu::DeliverSm.new("from", "to", "message", :esm_class => 4)
+
+    assert_nothing_raised { receiver.process_pdu(deliver_sm) }
+  end
+
+  private
+
+  def build_receiver(delegate = nil)
+    receiver = Smpp::Receiver.new(1, {}, delegate)
+    class << receiver
+      attr_reader :sent_data, :close_connections
+      def send_data(data)
+        @sent_data = (@sent_data || []) + [data]
+      end
+      def close_connection
+        @close_connections = (@close_connections || 0) + 1
+      end
+    end
+    receiver
+  end
+
+end
+
+require 'server'
+require 'delegate'
+
+class SmppTest < Test::Unit::TestCase
+  
+  def config
+    Server::config
+  end
+  
+  def test_transceiver_should_bind_and_unbind_then_stop
+    EventMachine.run {
+      EventMachine.start_server "localhost", 9000, Server::Unbind
+      EventMachine.connect "localhost", 9000, Smpp::Receiver, config, Delegate.new
+    }
+    # should not hang here: the server's response should have caused the client to terminate
+  end
+
+  def test_bind_receiver
+    pdu1 = Smpp::Pdu::BindReceiver.new(
+      config[:system_id],
+      config[:password],
+      config[:system_type],
+      config[:source_ton],
+      config[:source_npi],
+      config[:source_address_range]
+    )
+
+    pdu2 = Smpp::Pdu::Base.create(pdu1.data)
+
+    assert_instance_of(Smpp::Pdu::BindReceiver, pdu2)
+    assert_equal(pdu1.system_id, pdu2.system_id)
+    assert_equal(pdu1.password, pdu2.password)
+    assert_equal(pdu1.system_type, pdu2.system_type)
+    assert_equal(pdu1.addr_ton, pdu2.addr_ton)
+    assert_equal(pdu1.addr_npi, pdu2.addr_npi)
+    assert_equal(pdu1.address_range, pdu2.address_range)
+    assert_equal(pdu1.sequence_number, pdu2.sequence_number)
+    assert_equal(pdu1.command_status, pdu2.command_status)
+  end
+
+  def test_bind_receiver_response
+    pdu1 = Smpp::Pdu::BindReceiverResponse.new(nil, Smpp::Pdu::Base::ESME_ROK, config[:system_id])
+    pdu2 = Smpp::Pdu::Base.create(pdu1.data)
+    assert_instance_of(Smpp::Pdu::BindReceiverResponse, pdu2)
+    assert_equal(pdu1.system_id, pdu2.system_id)
+    assert_equal(pdu1.sequence_number, pdu2.sequence_number)
+    assert_equal(pdu1.command_status, pdu2.command_status)
+  end
+end

data/test/responsive_delegate.rb

@@ -0,0 +1,53 @@
+#TODO This should be made prettier with mocha
+class ResponsiveDelegate
+  attr_reader :seq, :event_counter
+
+  def initialize
+    @seq = 0
+    @event_counter = nil
+  end
+  def seq
+    @seq += 1
+  end
+  def count_function
+    func = caller(1)[0].split("`")[1].split("'")[0].to_sym
+    @event_counter = {} unless @event_counter.is_a?(Hash)
+    @event_counter[func] = 0 if @event_counter[func].nil?
+    @event_counter[func]+=1
+  end
+
+  def mo_received(transceiver, pdu)
+    count_function
+    puts "** mo_received"
+  end
+
+  def delivery_report_received(transceiver, pdu)
+    count_function
+    puts "** delivery_report_received"
+  end
+
+  def message_accepted(transceiver, mt_message_id, pdu)
+    count_function
+    puts "** message_sent"
+    #sending messages from delegate to escape making a fake message sender - not nice :(
+    $tx.send_mt(self.seq, 1, 2, "short_message @ message_accepted")
+  end
+
+  def message_rejected(transceiver, mt_message_id, pdu)
+    count_function
+    puts "** message_rejected"
+    $tx.send_mt(self.seq, 1, 2, "short_message @ message_rejected")
+  end
+
+  def bound(transceiver)
+    count_function
+    puts "** bound"
+    $tx.send_mt(self.seq, 1, 2, "short_message @ bound")
+  end
+
+  def unbound(transceiver)
+    count_function
+    puts "** unbound"
+    EventMachine::stop_event_loop
+  end
+end

data/test/server.rb

@@ -0,0 +1,56 @@
+# a server which immediately requests the client to unbind
+module Server
+  def self.config
+    {
+      :host => 'localhost',
+      :port => 2775,
+      :system_id => 'foo',
+      :password => 'bar',
+      :system_type => '',
+      :source_ton  => 0,
+      :source_npi => 1,
+      :destination_ton => 1,
+      :destination_npi => 1,
+      :source_address_range => '',
+      :destination_address_range => ''
+    }
+  end
+
+  module Unbind
+    def receive_data(data)
+      send_data Smpp::Pdu::Unbind.new.data
+    end
+  end
+
+  module SubmitSmResponse
+    def receive_data(data)
+      # problem: our Pdu's should have factory methods for "both ways"; ie. when created
+      # by client, and when created from wire data.
+      send_data Smpp::Pdu::SubmitSmResponse.new(1, 2, "100").data
+    end
+  end
+
+  module SubmitSmResponseWithErrorStatus
+    attr_reader :state #state=nil => bind => state=bound => send =>state=sent => unbind => state=unbound
+    def receive_data(data)
+      if @state.nil?
+        @state = 'bound'
+        pdu = Smpp::Pdu::Base.create(data)
+        response_pdu = Smpp::Pdu::BindTransceiverResponse.new(pdu.sequence_number,Smpp::Pdu::Base::ESME_ROK,Server::config[:system_id])
+        send_data response_pdu.data
+      elsif @state == 'bound'
+        @state = 'sent'
+        pdu = Smpp::Pdu::Base.create(data)
+        pdu.to_human
+        send_data Smpp::Pdu::SubmitSmResponse.new(pdu.sequence_number, Smpp::Pdu::Base::ESME_RINVDSTADR, pdu.body).data
+        #send_data Smpp::Pdu::SubmitSmResponse.new(1, 2, "100").data
+      elsif @state == 'sent'
+        @state = 'unbound'
+        send_data Smpp::Pdu::Unbind.new.data
+      else
+        raise "unexpected state"
+      end
+    end
+  end
+
+end

data/test/smpp_test.rb

@@ -1,147 +1,9 @@
 require 'rubygems'
 require 'test/unit'
 require 'smpp'
-
-# a server which immediately requests the client to unbind
-module Server
-  def self.config
-    {
-      :host => 'localhost',
-      :port => 2775,
-      :system_id => 'foo',
-      :password => 'bar',
-      :system_type => '',
-      :source_ton  => 0,
-      :source_npi => 1,
-      :destination_ton => 1,
-      :destination_npi => 1,
-      :source_address_range => '',
-      :destination_address_range => ''
-    }
-  end
-
-  module Unbind
-    def receive_data(data)
-      send_data Smpp::Pdu::Unbind.new.data
-    end
-  end
-
-  module SubmitSmResponse
-    def receive_data(data)
-      # problem: our Pdu's should have factory methods for "both ways"; ie. when created
-      # by client, and when created from wire data.
-      send_data Smpp::Pdu::SubmitSmResponse.new(1, 2, "100").data
-    end
-  end
-
-  module SubmitSmResponseWithErrorStatus
-    attr_reader :state #state=nil => bind => state=bound => send =>state=sent => unbind => state=unbound
-    def receive_data(data)
-      if @state.nil?
-        @state = 'bound'
-        pdu = Smpp::Pdu::Base.create(data)
-        response_pdu = Smpp::Pdu::BindTransceiverResponse.new(pdu.sequence_number,Smpp::Pdu::Base::ESME_ROK,Server::config[:system_id])
-        send_data response_pdu.data
-      elsif @state == 'bound'
-        @state = 'sent'
-        pdu = Smpp::Pdu::Base.create(data)
-        pdu.to_human
-        send_data Smpp::Pdu::SubmitSmResponse.new(pdu.sequence_number, Smpp::Pdu::Base::ESME_RINVDSTADR, pdu.body).data
-        #send_data Smpp::Pdu::SubmitSmResponse.new(1, 2, "100").data
-      elsif @state == 'sent'
-        @state = 'unbound'
-        send_data Smpp::Pdu::Unbind.new.data
-      else
-        raise "unexpected state"
-      end
-    end
-  end
-
-end
-
-
-# the delagate receives callbacks when interesting things happen on the connection
-class Delegate
-
-  def mo_received(transceiver, pdu)
-    puts "** mo_received"
-  end
-
-  def delivery_report_received(transceiver, pdu)
-    puts "** delivery_report_received"
-  end
-
-  def message_accepted(transceiver, mt_message_id, pdu)
-    puts "** message_sent"
-  end
-
-  def message_rejected(transceiver, mt_message_id, pdu)
-    puts "** message_rejected"
-  end
-
-  def bound(transceiver)
-    puts "** bound"
-  end
-
-  def unbound(transceiver)
-    puts "** unbound"
-    EventMachine::stop_event_loop
-  end
-end
-
-#TODO This should be made prettier with mocha
-class ResponsiveDelegate
-  attr_reader :seq, :event_counter
-
-  def initialize
-    @seq = 0
-    @event_counter = nil
-  end
-  def seq
-    @seq += 1
-  end
-  def count_function
-    func = caller(1)[0].split("`")[1].split("'")[0].to_sym
-    @event_counter = {} unless @event_counter.is_a?(Hash)
-    @event_counter[func] = 0 if @event_counter[func].nil?
-    @event_counter[func]+=1
-  end
-
-  def mo_received(transceiver, pdu)
-    count_function
-    puts "** mo_received"
-  end
-  
-  def delivery_report_received(transceiver, pdu)
-    count_function
-    puts "** delivery_report_received"
-  end
-  
-  def message_accepted(transceiver, mt_message_id, pdu)
-    count_function
-    puts "** message_sent"
-    #sending messages from delegate to escape making a fake message sender - not nice :(
-    $tx.send_mt(self.seq, 1, 2, "short_message @ message_accepted")
-  end
-
-  def message_rejected(transceiver, mt_message_id, pdu)
-    count_function
-    puts "** message_rejected"
-    $tx.send_mt(self.seq, 1, 2, "short_message @ message_rejected")
-  end
-  
-  def bound(transceiver)
-    count_function
-    puts "** bound"
-    $tx.send_mt(self.seq, 1, 2, "short_message @ bound")
-  end
-  
-  def unbound(transceiver)
-    count_function
-    puts "** unbound"
-    EventMachine::stop_event_loop
-  end
-end
+require 'server'
+require 'delegate'
+require 'responsive_delegate'
 
 class Poller
   def start

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 3
+  - 4
   - 0
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Ray Krueger
@@ -15,13 +15,13 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-14 00:00:00 -05:00
+date: 2011-01-06 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: eventmachine
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  type: :runtime
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
@@ -30,8 +30,8 @@ dependencies:
         - 10
         - 0
         version: 0.10.0
-  type: :runtime
-  version_requirements: *id001
+  prerelease: false
+  requirement: *id001
 description: Ruby implementation of the SMPP protocol, based on EventMachine. SMPP is a protocol that allows ordinary people outside the mobile network to exchange SMS messages directly with mobile operators.
 email: raykrueger@gmail.com
 executables: []
@@ -46,10 +46,13 @@ files:
 - .gitignore
 - CHANGELOG
 - CONTRIBUTORS.txt
+- Gemfile
+- Gemfile.lock
 - LICENSE
 - README.rdoc
 - Rakefile
 - VERSION
+- config/environment.rb
 - examples/PDU1.example
 - examples/PDU2.example
 - examples/sample_gateway.rb
@@ -59,6 +62,8 @@ files:
 - lib/smpp/optional_parameter.rb
 - lib/smpp/pdu/base.rb
 - lib/smpp/pdu/bind_base.rb
+- lib/smpp/pdu/bind_receiver.rb
+- lib/smpp/pdu/bind_receiver_response.rb
 - lib/smpp/pdu/bind_resp_base.rb
 - lib/smpp/pdu/bind_transceiver.rb
 - lib/smpp/pdu/bind_transceiver_response.rb
@@ -73,11 +78,17 @@ files:
 - lib/smpp/pdu/submit_sm_response.rb
 - lib/smpp/pdu/unbind.rb
 - lib/smpp/pdu/unbind_response.rb
+- lib/smpp/receiver.rb
 - lib/smpp/server.rb
 - lib/smpp/transceiver.rb
 - lib/sms.rb
 - ruby-smpp.gemspec
+- test/delegate.rb
 - test/optional_parameter_test.rb
+- test/pdu_parsing_test.rb
+- test/receiver_test.rb
+- test/responsive_delegate.rb
+- test/server.rb
 - test/smpp_test.rb
 - test/submit_sm_test.rb
 has_rdoc: true
@@ -111,7 +122,12 @@ signing_key:
 specification_version: 3
 summary: Ruby implementation of the SMPP protocol, based on EventMachine.
 test_files: 
+- test/delegate.rb
 - test/optional_parameter_test.rb
+- test/pdu_parsing_test.rb
+- test/receiver_test.rb
+- test/responsive_delegate.rb
+- test/server.rb
 - test/smpp_test.rb
 - test/submit_sm_test.rb
 - examples/sample_gateway.rb