propono 1.7.0 → 2.0.0.rc1

data/lib/propono/components/post_subscription.rb

@@ -1,19 +0,0 @@
-module Propono
-  class PostSubscription
-    include Sns
-
-    def self.create(topic, endpoint)
-      new(topic, endpoint).create
-    end
-
-    def initialize(topic_id, endpoint)
-      @topic_id = topic_id
-      @endpoint = endpoint
-    end
-
-    def create
-      topic_arn = TopicCreator.find_or_create(@topic_id)
-      sns.subscribe(topic_arn, @endpoint, 'http')
-    end
-  end
-end

data/lib/propono/components/sns.rb

@@ -1,11 +0,0 @@
-require 'fog/aws'
-
-module Propono
-  module Sns
-    private
-
-    def sns
-      @sns ||= Fog::AWS::SNS.new(Propono.aws_options)
-    end
-  end
-end

data/lib/propono/components/sqs.rb

@@ -1,12 +0,0 @@
-require 'fog/aws'
-
-module Propono
-  module Sqs
-    private
-
-    def sqs
-      @sqs ||= Fog::AWS::SQS.new(Propono.aws_options)
-    end
-  end
-end
-

data/lib/propono/services/queue_creator.rb

@@ -1,29 +0,0 @@
-module Propono
-  class QueueCreatorError < ProponoError
-  end
-
-  class QueueCreator
-    include Sqs
-
-    def self.find_or_create(name)
-      new(name).find_or_create
-    end
-
-    def initialize(name)
-      @name = name
-    end
-
-    def find_or_create
-      urls = sqs.list_queues("QueueNamePrefix" => @name).body["QueueUrls"]
-      url = urls.select{|x|x =~ /#{@name}$/}.first
-
-      unless url
-        result = sqs.create_queue(@name)
-        body = result.body
-        url = body.fetch('QueueUrl') { raise QueueCreatorError.new("No QueueUrl returned from SQS") }
-      end
-
-      Queue.new(url)
-    end
-  end
-end

data/lib/propono/services/subscriber.rb

@@ -1,12 +0,0 @@
-module Propono
-
-  module Subscriber
-    def self.subscribe_by_queue(topic)
-      QueueSubscription.create(topic)
-    end
-
-    def self.subscribe_by_post(topic, endpoint)
-      PostSubscription.create(topic, endpoint)
-    end
-  end
-end

data/lib/propono/services/tcp_listener.rb

@@ -1,48 +0,0 @@
-require 'json'
-
-module Propono
-  class TcpListenerError < ProponoError
-  end
-
-  class TcpListener
-
-    def self.listen(&processor)
-      new(&processor).listen
-    end
-
-    def initialize(&processor)
-      raise TcpListenerError.new("Please provide a block to call for each message") unless block_given?
-      @processor = processor
-    end
-
-    def listen
-      loop { receive_and_process }
-    end
-
-    private
-
-    def receive_and_process
-      client = server.accept
-      tcp_data = client.recvfrom(1024)[0]
-      client.close
-      Thread.new { process_tcp_data(tcp_data) }
-    end
-
-    def process_tcp_data(tcp_data)
-      json = Propono::Utils.symbolize_keys JSON.parse(tcp_data)
-
-      # Legacy syntax is covered in the else statement
-      # This conditional and the else block will be removed in v1.
-      if json[:id]
-        @processor.call(json[:topic], json[:message], id: json[:id])
-      else
-        Propono.config.logger.info("Sending and receiving messages without ids is deprecated")
-        @processor.call(json[:topic], json[:message])
-      end
-    end
-
-    def server
-      @server ||= TCPServer.open(Propono.config.tcp_port)
-    end
-  end
-end

data/lib/propono/services/topic_creator.rb

@@ -1,23 +0,0 @@
-module Propono
-  class TopicCreatorError < ProponoError
-  end
-
-  class TopicCreator
-    include Sns
-
-    def self.find_or_create(topic_id)
-      new(topic_id).find_or_create
-    end
-
-    def initialize(topic_id)
-      @topic_id = topic_id
-    end
-
-    def find_or_create
-      result = sns.create_topic(@topic_id)
-      body = result.body
-      arn = body.fetch('TopicArn') { raise TopicCreatorError.new("No TopicArn returned from SNS") }
-      Topic.new(arn)
-    end
-  end
-end

data/lib/propono/services/udp_listener.rb

@@ -1,52 +0,0 @@
-require 'json'
-
-module Propono
-  class UdpListenerError < ProponoError
-  end
-
-  class UdpListener
-
-    def self.listen(&processor)
-      new(&processor).listen
-    end
-
-    def initialize(&processor)
-      raise UdpListenerError.new("Please provide a block to call for each message") unless block_given?
-      @processor = processor
-    end
-
-    def listen
-      loop { receive_and_process }
-    end
-
-    private
-
-    def receive_and_process
-      udp_data = socket.recvfrom(1024)[0]
-      Thread.new { process_udp_data(udp_data) }
-    end
-
-    def process_udp_data(udp_data)
-      json = Propono::Utils.symbolize_keys JSON.parse(udp_data)
-
-      # Legacy syntax is covered in the else statement
-      # This conditional and the else block will be removed in v1.
-      if json[:id]
-        @processor.call(json[:topic], json[:message], id: json[:id])
-      else
-        Propono.config.logger.info("Sending and receiving messages without ids is deprecated")
-        @processor.call(json[:topic], json[:message])
-      end
-    end
-
-    def socket
-      @socket ||= begin
-        socket = UDPSocket.new
-        socket.bind(Propono.config.udp_host, Propono.config.udp_port)
-        socket
-      end
-    end
-  end
-end
-
-

data/test/components/post_subscription_test.rb

@@ -1,29 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Propono
-  class PostSubscriptionTest < Minitest::Test
-    def test_create_topic
-      topic = 'foobar'
-      TopicCreator.expects(:find_or_create).with(topic)
-      PostSubscription.create(topic, "foobar")
-    end
-
-    def test_create_calls_create
-      arn = "arn123"
-      endpoint = "http://meducation.net/some_queue_name"
-
-      TopicCreator.stubs(find_or_create: arn)
-
-      sns = mock()
-      sns.expects(:subscribe).with(arn, endpoint, 'http')
-      subscription = PostSubscription.new("Some topic", endpoint)
-      subscription.stubs(sns: sns)
-      subscription.create
-    end
-
-    def test_it_correctly_uses_http_and_https
-      skip
-    end
-  end
-end
-

data/test/components/sns_test.rb

@@ -1,25 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Propono
-  class SnsTest < Minitest::Test
-    class SnsTestClass
-      include Sns
-    end
-
-    def setup
-      super
-      Propono.config.access_key = "test-access-key"
-      Propono.config.secret_key = "test-secret-key"
-      Propono.config.queue_region = "test-queue-region"
-    end
-
-    def test_sns
-      Fog::AWS::SNS.expects(:new)
-        .with(:aws_access_key_id     => 'test-access-key',
-              :aws_secret_access_key => 'test-secret-key',
-              :region                => 'test-queue-region')
-
-      SnsTestClass.new.send :sns
-    end
-  end
-end

data/test/components/sqs_test.rb

@@ -1,26 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Propono
-  class SqsTest < Minitest::Test
-    class SqsTestClass
-      include Sqs
-    end
-
-    def setup
-      super
-      Propono.config.access_key = "test-access-key"
-      Propono.config.secret_key = "test-secret-key"
-      Propono.config.queue_region = "us-east-1"
-    end
-
-    def test_sqs
-      Fog::AWS::SQS.expects(:new)
-        .with(:aws_access_key_id     => 'test-access-key',
-              :aws_secret_access_key => 'test-secret-key',
-              :region                => 'us-east-1')
-
-      SqsTestClass.new.send :sqs
-    end
-  end
-end
-

data/test/integration/tcp_to_sqs_test.rb

@@ -1,53 +0,0 @@
-require File.expand_path('../integration_test', __FILE__)
-
-module Propono
-  class TcpToSqsTest < IntegrationTest
-    def test_the_message_gets_there
-      topic = "propono-tests-tcp-to-sqs-topic"
-      message = "This is my message #{DateTime.now} #{rand()}"
-      flunks = []
-      message_received = false
-
-      Propono.config.tcp_host = "localhost"
-      Propono.config.tcp_port = 20009
-
-      Propono.drain_queue(topic)
-      Propono.subscribe_by_queue(topic)
-
-      sqs_thread = Thread.new do
-        begin
-          Propono.listen_to_queue(topic) do |sqs_message|
-            flunks << "Wrong message" unless message == sqs_message
-            sqs_thread.terminate
-            message_received = true
-          end
-        rescue => e
-          flunks << e.message
-        ensure
-          sqs_thread.terminate
-        end
-      end
-
-      Thread.new do
-        sleep(1) while !message_received
-        sleep(5) # Make sure all the message deletion clear up in the thread has happened
-        sqs_thread.terminate
-      end
-
-      tcp_thread = Thread.new do
-        Propono.listen_to_tcp do |tcp_topic, tcp_message|
-          Propono.publish(tcp_topic, tcp_message, async: false)
-          tcp_thread.terminate
-        end
-      end
-      sleep(1) # Make sure the listener has started
-
-      Propono.publish(topic, message, protocol: :tcp)
-      flunks << "Test Timeout" unless wait_for_thread(tcp_thread) && wait_for_thread(sqs_thread)
-      flunk(flunks.join("\n")) unless flunks.empty?
-    ensure
-      tcp_thread.terminate
-      sqs_thread.terminate
-    end
-  end
-end

data/test/integration/udp_proxy_test.rb

@@ -1,50 +0,0 @@
-require File.expand_path('../integration_test', __FILE__)
-
-module Propono
-  class UdpProxyTest < IntegrationTest
-    def test_the_message_gets_there
-      topic = "propono-tests-udp-proxy-topic"
-      text = "This is my message #{DateTime.now} #{rand()}"
-      flunks = []
-      message_received = false
-
-      Propono.config.udp_port = 20001
-
-      Propono.drain_queue(topic)
-      Propono.subscribe_by_queue(topic)
-
-      sqs_thread = Thread.new do
-        begin
-          Propono.listen_to_queue(topic) do |message, context|
-            flunks << "Wrong message" unless text == message
-            flunks << "Wrong id" unless context[:id] =~ Regexp.new("[a-z0-9]{6}-[a-z0-9]{6}")
-            message_received = true
-          end
-        rescue => e
-          flunks << e.message
-        ensure
-          sqs_thread.terminate
-        end
-      end
-
-      Thread.new do
-        sleep(1) while !message_received
-        sleep(5) # Make sure all the message deletion clear up in the thread has happened
-        sqs_thread.terminate
-      end
-
-      udp_thread = Thread.new do
-        Propono.proxy_udp
-      end
-
-      sleep(1) # Make sure the proxy has started
-
-      Propono::Publisher.publish(topic, text, protocol: :udp)
-      flunks << "Test timeout" unless wait_for_thread(sqs_thread)
-      flunk(flunks.join("\n")) unless flunks.empty?
-    ensure
-      udp_thread.terminate
-      sqs_thread.terminate
-    end
-  end
-end

data/test/integration/udp_to_sqs_test.rb

@@ -1,53 +0,0 @@
-require File.expand_path('../integration_test', __FILE__)
-
-module Propono
-  class UdpToSqsTest < IntegrationTest
-    def test_the_message_gets_there
-      topic = "propono-tests-udp-to-sqs-topic"
-      message = "This is my message #{DateTime.now} #{rand()}"
-      flunks = []
-      message_received = false
-
-      Propono.config.udp_port = 20002
-
-      Propono.drain_queue(topic)
-      Propono.subscribe_by_queue(topic)
-
-      sqs_thread = Thread.new do
-        begin
-          Propono.listen_to_queue(topic) do |sqs_message|
-            assert_equal message, sqs_message
-            sqs_thread.terminate
-            message_received = true
-          end
-        rescue => e
-          flunks << e.message
-        ensure
-          sqs_thread.terminate
-        end
-      end
-
-      Thread.new do
-        sleep(1) while !message_received
-        sleep(5) # Make sure all the message deletion clear up in the thread has happened
-        sqs_thread.terminate
-      end
-
-      udp_thread = Thread.new do
-        Propono.listen_to_udp do |udp_topic, udp_message|
-          Propono.publish(udp_topic, udp_message)
-          udp_thread.terminate
-        end
-      end
-
-      sleep(1) # Make sure the listener has started
-
-      Propono.publish(topic, message, protocol: :udp)
-      flunks << "Test Timeout" unless wait_for_thread(udp_thread) && wait_for_thread(sqs_thread)
-      flunk(flunks.join("\n")) unless flunks.empty?
-    ensure
-      udp_thread.terminate
-      sqs_thread.terminate
-    end
-  end
-end