loggregator_emitter 0.0.13.pre → 0.0.15.pre

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+Gemfile.lock

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    loggregator_emitter (0.0.13.pre)
+    loggregator_emitter (0.0.15.pre)
       beefcake (~> 0.3.7)
 
 GEM
@@ -15,7 +15,7 @@ GEM
       rspec-expectations (~> 2.14.0)
       rspec-mocks (~> 2.14.0)
     rspec-core (2.14.5)
-    rspec-expectations (2.14.2)
+    rspec-expectations (2.14.3)
       diff-lcs (>= 1.1.3, < 2.0)
     rspec-mocks (2.14.3)
 

data/lib/loggregator_emitter/emit.rb

@@ -3,31 +3,40 @@ require 'socket'
 module LoggregatorEmitter
   class Emitter
     def initialize(loggregator_server, source_type, source_id = nil)
-      host, port = loggregator_server.split(":")
-      raise RuntimeError, "Must provide valid loggregator server: #{loggregator_server}" if (host == nil || port == nil)
-      raise RuntimeError, "Must provide IP address for loggregator server: #{loggregator_server}" unless host.match(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/)
-      @sockaddr_in = Socket.sockaddr_in(port, host)
+      raise ArgumentError, "Must provide valid source type" unless valid_source_type?(source_type)
+
+      @host, @port = loggregator_server.split(/:([^:]*$)/)
+      raise ArgumentError, "Must provide valid loggregator server: #{loggregator_server}" if !valid_hostname || !valid_port
 
-      raise RuntimeError, "Must provide valid source type" unless valid_source_type?(source_type)
       @source_type = source_type
       @source_id = source_id && source_id.to_s
     end
 
     def emit(app_id, message)
-      if app_id
-        lm = create_log_message(app_id, message, LogMessage::MessageType::OUT)
-        send_message(lm)
-      end
+      emit_message(app_id, message, LogMessage::MessageType::OUT)
     end
 
     def emit_error(app_id, message)
+      emit_message(app_id, message, LogMessage::MessageType::ERR)
+    end
+
+    private
+
+    def valid_port
+      @port && @port.match(/^\d+$/)
+    end
+
+    def valid_hostname
+      @host && !@host.match(/:\/\//)
+    end
+
+    def emit_message(app_id, message, type)
       if app_id
-        lm = create_log_message(app_id, message, LogMessage::MessageType::ERR)
+        lm = create_log_message(app_id, message, type)
         send_message(lm)
       end
     end
 
-    private
     def create_log_message(app_id, message, type)
       lm = LogMessage.new()
       lm.time = Time.now
@@ -40,13 +49,13 @@ module LoggregatorEmitter
     end
 
     def send_message(lm)
-      s = UDPSocket.new
-      s.do_not_reverse_lookup = true
-
       result = lm.encode.buf
       result.unpack("C*")
 
-      s.sendmsg_nonblock(result, 0, @sockaddr_in)
+      addrinfo_udp = Addrinfo.udp(@host, @port)
+      s = addrinfo_udp.ipv4?() ? UDPSocket.new : UDPSocket.new(Socket::AF_INET6)
+      s.do_not_reverse_lookup = true
+      s.sendmsg_nonblock(result, 0, addrinfo_udp)
     end
 
     def valid_source_type?(source_type)

data/loggregator_emitter.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "loggregator_emitter"
-  spec.version       = '0.0.13.pre'
+  spec.version       = '0.0.15.pre'
   spec.authors       = ["Pivotal"]
   spec.email         = ["cf-eng@pivotallabs.com"]
   spec.description   = "Library to emit data to Loggregator"

data/spec/loggregator_emitter/emit_spec.rb

@@ -1,117 +1,128 @@
-require 'support/fake_loggregator_server'
-require 'loggregator_emitter'
+require "support/fake_loggregator_server"
+require "loggregator_emitter"
 
 describe LoggregatorEmitter do
-
-  describe 'configuring emitter' do
-    it 'can be configured' do
-      expect { LoggregatorEmitter::Emitter.new('0.0.0.0:12345', LogMessage::SourceType::DEA) }.not_to raise_error
-    end
-
-    it 'raises if loggregator_server is invalid' do
-      expect { LoggregatorEmitter::Emitter.new('0.0.0.0', LogMessage::SourceType::DEA) }.to raise_error(RuntimeError)
+  class FreePort
+    def self.next_free_port
+      @@next_free_port ||= 12345
+      @@next_free_port += 1
     end
+  end
+  let(:free_port) do
+    FreePort.next_free_port
+  end
 
-    it 'doesnt raise if source_type is valid' do
-      expect { LoggregatorEmitter::Emitter.new('0.0.0.0:12345', LogMessage::SourceType::DEA) }.not_to raise_error
-    end
+  describe "configuring emitter" do
+    describe "valid configurations" do
+      it "is valid with IP and proper source type" do
+        expect { LoggregatorEmitter::Emitter.new("0.0.0.0:12345", LogMessage::SourceType::DEA) }.not_to raise_error
+      end
 
-    it 'raises if source_type is invalid' do
-      expect { LoggregatorEmitter::Emitter.new('0.0.0.0:12345', 40) }.to raise_error(RuntimeError)
-    end
+      it "is valid with resolveable hostname and proper source type" do
+        expect { LoggregatorEmitter::Emitter.new("localhost:12345", LogMessage::SourceType::DEA) }.not_to raise_error
+      end
 
-    it 'raises if host is not ip is invalid' do
-      expect { LoggregatorEmitter::Emitter.new('localhost:12345', 40) }.to raise_error(RuntimeError)
+      it "is valid if a server name is given" do
+        expect { LoggregatorEmitter::Emitter.new("some-unknown-address:12345", LogMessage::SourceType::DEA) }.not_to raise_error
+      end
     end
 
-    it 'raises if host has protocol' do
-      expect { LoggregatorEmitter::Emitter.new('http://0.0.0.0:12345', 40) }.to raise_error(RuntimeError)
+    describe "invalid configurations" do
+      describe "error based on loggregator_server" do
+        it "raises if host has protocol" do
+          expect { LoggregatorEmitter::Emitter.new("http://0.0.0.0:12345", LogMessage::SourceType::DEA) }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe "error based on source_type" do
+        it "raises if source_type is invalid" do
+          expect { LoggregatorEmitter::Emitter.new("0.0.0.0:12345", 40) }.to raise_error(ArgumentError)
+        end
+      end
     end
   end
 
-  describe 'Sending To STDOUT' do
-    before(:each) do
-      @emitter = LoggregatorEmitter::Emitter.new('0.0.0.0:12345', LogMessage::SourceType::CLOUD_CONTROLLER, 42)
-    end
+  {"emit" => LogMessage::MessageType::OUT, "emit_error" => LogMessage::MessageType::ERR}.each do |emit_method, message_type|
+    describe "##{emit_method}" do
+      def make_emitter(host)
+        LoggregatorEmitter::Emitter.new("#{host}:#{free_port}", LogMessage::SourceType::CLOUD_CONTROLLER, 42)
+      end
 
-    it 'successfully writes protobuffer to a socket' do
-      server = FakeLoggregatorServer.new(12345)
-      server.start
+      before do
+        @server = FakeLoggregatorServer.new(free_port)
+        @server.start
+      end
 
-      @emitter.emit("my_app_id", 'Hello there!')
-      @emitter.emit("my_app_id", 'Hello again!')
-      @emitter.emit(nil, 'Hello again!')
+      it "successfully writes protobuffers using ipv4" do
+        emitter = make_emitter("0.0.0.0")
+        emitter.send(emit_method, "my_app_id", "Hello there!")
+        emitter.send(emit_method, "my_app_id", "Hello again!")
+        emitter.send(emit_method, nil, "Hello again!")
 
-      server.stop(2)
+        @server.wait_for_messages_and_stop(2)
 
-      messages = server.messages
+        messages = @server.messages
 
-      expect(messages.length).to eq 2
-      message = messages[0]
-      expect(message.message).to eq 'Hello there!'
-      expect(message.app_id).to eq "my_app_id"
-      expect(message.source_type).to eq LogMessage::SourceType::CLOUD_CONTROLLER
-      expect(message.source_id).to eq "42"
-      expect(message.message_type).to eq LogMessage::MessageType::OUT
+        expect(messages.length).to eq 2
+        message = messages[0]
+        expect(message.message).to eq "Hello there!"
+        expect(message.app_id).to eq "my_app_id"
+        expect(message.source_type).to eq LogMessage::SourceType::CLOUD_CONTROLLER
+        expect(message.source_id).to eq "42"
+        expect(message.message_type).to eq message_type
 
-      message = messages[1]
-      expect(message.message).to eq 'Hello again!'
-    end
-  end
+        message = messages[1]
+        expect(message.message).to eq "Hello again!"
+      end
 
-  describe 'Sending To STDOUT' do
-    before(:each) do
-      @emitter = LoggregatorEmitter::Emitter.new('0.0.0.0:12345', LogMessage::SourceType::CLOUD_CONTROLLER)
-    end
-
-    it 'successfully writes protobuffer to a socket' do
-      server = FakeLoggregatorServer.new(12345)
-      server.start
+      it "successfully writes protobuffers using ipv6" do
+        emitter = make_emitter("::1")
+        emitter.send(emit_method, "my_app_id", "Hello there!")
 
-      @emitter.emit_error("my_app_id", 'Hello there!')
-      @emitter.emit_error("my_app_id", 'Hello again!')
-      @emitter.emit_error(nil, 'Hello again!')
+        @server.wait_for_messages_and_stop(1)
 
-      server.stop(2)
+        messages = @server.messages
+        expect(messages.length).to eq 1
+        expect(messages[0].message).to eq "Hello there!"
+      end
 
-      messages = server.messages
+      it "successfully writes protobuffers using a dns name" do
+        emitter = make_emitter("localhost")
+        emitter.send(emit_method, "my_app_id", "Hello there!")
 
-      expect(messages.length).to eq 2
-      message = messages[0]
-      expect(message.message).to eq 'Hello there!'
-      expect(message.app_id).to eq "my_app_id"
-      expect(message.source_type).to eq LogMessage::SourceType::CLOUD_CONTROLLER
-      expect(message.message_type).to eq LogMessage::MessageType::ERR
+        @server.wait_for_messages_and_stop(1)
 
-      message = messages[1]
-      expect(message.message).to eq 'Hello again!'
+        messages = @server.messages
+        expect(messages.length).to eq 1
+        expect(messages[0].message).to eq "Hello there!"
+      end
     end
   end
 
   describe "source id" do
     let(:emit_message) do
-      server = FakeLoggregatorServer.new(12345)
+      server = FakeLoggregatorServer.new(free_port)
       server.start
 
-      @emitter.emit_error("my_app_id", 'Hello there!')
+      @emitter.emit_error("my_app_id", "Hello there!")
 
-      server.stop(2)
+      server.wait_for_messages_and_stop(2)
 
       server.messages[0]
     end
 
     it "can be nil" do
-      @emitter = LoggregatorEmitter::Emitter.new('0.0.0.0:12345', LogMessage::SourceType::CLOUD_CONTROLLER)
+      @emitter = LoggregatorEmitter::Emitter.new("0.0.0.0:#{free_port}", LogMessage::SourceType::CLOUD_CONTROLLER)
       expect(emit_message.source_id).to eq nil
     end
 
     it "can be passed in as a string" do
-      @emitter = LoggregatorEmitter::Emitter.new('0.0.0.0:12345', LogMessage::SourceType::CLOUD_CONTROLLER, "some_source_id")
+      @emitter = LoggregatorEmitter::Emitter.new("0.0.0.0:#{free_port}", LogMessage::SourceType::CLOUD_CONTROLLER, "some_source_id")
       expect(emit_message.source_id).to eq "some_source_id"
     end
 
     it "can be passed in as an integer" do
-      @emitter = LoggregatorEmitter::Emitter.new('0.0.0.0:12345', LogMessage::SourceType::CLOUD_CONTROLLER, 13)
+      @emitter = LoggregatorEmitter::Emitter.new("0.0.0.0:#{free_port}", LogMessage::SourceType::CLOUD_CONTROLLER, 13)
       expect(emit_message.source_id).to eq "13"
     end
   end

data/spec/support/fake_loggregator_server.rb

@@ -3,40 +3,49 @@ require 'loggregator_messages/log_message.pb'
 
 class FakeLoggregatorServer
 
-  attr_reader :messages, :port, :sock
+  attr_reader :messages, :port
 
   def initialize(port)
     @messages = []
     @port = port
-    @sock = UDPSocket.new
+
+    #this server starts listening on ipv4 and ipv6, so we make two sockets
+    @sockets = [UDPSocket.new, UDPSocket.new(Socket::AF_INET6)]
+    @threads = []
   end
 
   def start
-    @sock.bind('localhost', port)
-
-    @thread = Thread.new do
-      while true
-        begin
-          stuff = @sock.recv(65536)
-          messages << LogMessage.decode(stuff)
-        rescue Beefcake::Message::WrongTypeError, Beefcake::Message::RequiredFieldNotSetError,  Beefcake::Message::InvalidValueError => e
-          puts "ERROR"
-          puts e
-        end
-
-      end
-    end
+    bind_and_record(0, @sockets[0], "localhost")
+    bind_and_record(0, @sockets[1], "::1")
   end
 
-  def stop(number_expected_messages)
+  def wait_for_messages_and_stop(number_expected_messages)
     max_tries = 0
     while messages.length < number_expected_messages
       sleep 0.2
       max_tries += 1
       break if max_tries > 10
     end
-    @sock.close
 
-    Thread.kill(@thread)
+    @sockets.each { |socket| socket.close}
+    @threads.each { |thread| Thread.kill(thread) }
+  end
+
+  private
+
+  def bind_and_record(index, socket, server)
+    socket.bind(server, port)
+
+    @threads[index] = Thread.new do
+      while true
+        begin
+          stuff = socket.recv(65536)
+          messages << LogMessage.decode(stuff)
+        rescue Beefcake::Message::WrongTypeError, Beefcake::Message::RequiredFieldNotSetError, Beefcake::Message::InvalidValueError => e
+          puts "ERROR"
+          puts e
+        end
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: loggregator_emitter
 version: !ruby/object:Gem::Version
-  version: 0.0.13.pre
+  version: 0.0.15.pre
   prerelease: 7
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-07 00:00:00.000000000 Z
+date: 2013-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: beefcake