logstash-output-tcp 6.1.1 → 6.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c907232f3196c96261615180d8c1fc85c7973dc94c31fbd5161bf657f9c32adb
-  data.tar.gz: 2787199dc0aa9904ae4387a97d7f8add642b8cbd5af37929a263604c0d15c1d1
+  metadata.gz: dd2acefd6c26058e3e2afc94abb73de74e2816ca57a6379229909434ad4c72e9
+  data.tar.gz: 38633ca4cf74d5360fa3644b9624cb21db997e9cda5ff8846f5ca510b811c133
 SHA512:
-  metadata.gz: e0a8adce0cb539e83d1305c5d52931710041d7f4d7b8e42098f141bfca50980f80c39bef88116de710463044b6cfb5a14e0a32d3e32c3058d76990bb5bbd5d3b
-  data.tar.gz: 754a94a8b98ed57b77390091ed6dc05538d28d6aea75e4e5c30a438c34696fe80f9cb56503ed1a81ee2832fccee347122fbb07afb755ea01d2070c2ce4384b21
+  metadata.gz: ef785946ab821ca9347ef5fd04e17909ef573155ce790955640b875582a268363c436c3fa6a6c8c8cc19d086a6a9e6d5b8452448be59fbd80328481a7e0f292e
+  data.tar.gz: ac1c3b27079ecb0bb91eaa4a11eea17a1f79d4b6d935e72d82085b34f6731ee2ed6e6240250e4c18429b669d1430875d8ef958aa4c009ae71bb75d3e73f6a414

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## 6.1.2
+  - Changed the client mode to write using the non-blocking method. [#52](https://github.com/logstash-plugins/logstash-output-tcp/pull/52)
+
 ## 6.1.1
   - Fixes an issue where payloads larger than a connection's current TCP window could be silently truncated [#49](https://github.com/logstash-plugins/logstash-output-tcp/pull/49)
 

data/lib/logstash/outputs/tcp.rb

@@ -200,20 +200,17 @@ class LogStash::Outputs::Tcp < LogStash::Outputs::Base
     @codec.on_event do |event, payload|
       begin
         client_socket = connect unless client_socket
-
-        writable_io = nil
-        while writable_io.nil? || writable_io.any? == false
-          readable_io, writable_io, _ = IO.select([client_socket],[client_socket])
-
-          # don't expect any reads, but a readable socket might
-          # mean the remote end closed, so read it and throw it away.
-          # we'll get an EOFError if it happens.
-          readable_io.each { |readable| readable.sysread(16384) }
-        end
-
         while payload && payload.bytesize > 0
-          written_bytes_size = client_socket.syswrite(payload)
-          payload = payload.byteslice(written_bytes_size..-1)
+          begin
+            written_bytes_size = client_socket.write_nonblock(payload)
+            payload = payload.byteslice(written_bytes_size..-1)
+          rescue IO::WaitReadable
+            IO.select([client_socket])
+            retry
+          rescue IO::WaitWritable
+            IO.select(nil, [client_socket])
+            retry
+          end
         end
       rescue => e
         log_warn "client socket failed:", e, host: @host, port: @port, socket: (client_socket ? client_socket.to_s : nil)

data/logstash-output-tcp.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 
   s.name            = 'logstash-output-tcp'
-  s.version         = '6.1.1'
+  s.version         = '6.1.2'
   s.licenses        = ['Apache License (2.0)']
   s.summary         = "Writes events over a TCP socket"
   s.description     = "This gem is a Logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/logstash-plugin install gemname. This gem is not a stand-alone program"

data/spec/outputs/tcp_spec.rb

@@ -108,6 +108,33 @@ describe LogStash::Outputs::Tcp do
     end
   end
 
+  context "client mode" do
+    before { subject.register }
+
+    let(:config) { super().merge 'mode' => 'client' }
+
+    it 'writes payload data' do
+      Thread.start { sleep 0.25; subject.receive event }
+
+      socket = server.accept
+      read = socket.sysread(100)
+
+      expect( read.size ).to be > 0
+      expect( read ).to eq(JSON.generate(event))
+    end
+
+    it 'writes payload data in multiple operations' do
+      full_payload = JSON.generate(event)
+      Thread.start { sleep 0.25; subject.receive event }
+
+      socket = server.accept
+      first_read = socket.sysread((full_payload.length / 2))
+      second_read = socket.sysread(((full_payload.length / 2) + 1))
+
+      expect( "#{first_read}#{second_read}" ).to eq(full_payload)
+    end
+  end
+
   context "when enabling SSL" do
     let(:config) { super().merge("ssl_enable" => true, 'codec' => 'plain') }
     context "and not providing a certificate/key pair" do
@@ -227,5 +254,58 @@ describe LogStash::Outputs::Tcp do
 
       end
     end
+
+    context "and protocol is TLSv1.3" do
+      let(:key_file) { File.join(FIXTURES_PATH, 'plaintext/instance.key') }
+      let(:crt_file) { File.join(FIXTURES_PATH, 'plaintext/instance.crt') }
+      let(:config) { super().merge("ssl_cert" => crt_file, "ssl_key" => key_file) }
+
+      let(:secure_server) do
+        ssl_context = OpenSSL::SSL::SSLContext.new
+        ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(crt_file))
+        ssl_context.key = OpenSSL::PKey::RSA.new(File.read(key_file), nil)
+        ssl_context.min_version = OpenSSL::SSL::TLS1_3_VERSION
+        OpenSSL::SSL::SSLServer.new(server, ssl_context)
+      end
+
+      before(:each) do
+        subject.register
+      end
+
+      after(:each) do
+        secure_server.close rescue nil
+      end
+
+      let(:message) { "a" }
+      let(:buffer) { "" }
+
+      # This test confirms that this plugin is able to write to a TLS socket
+      # multiple times.
+      # Previous implementation performed an IO.select first and called sysread
+      # if select signaled the socket was ready to read.
+      # For TLS1_3, due to control messages it may happen that the underlying
+      # socket is marked as readable but there is no new data available,
+      # causing a read to block forever.
+      # This test will raise a Timeout exception with the old implementation.
+      it 'successfully writes two messages' do
+        thread = Thread.start do
+          expect {
+            client = secure_server.accept
+            Timeout::timeout(5) do
+              buffer << client.sysread(1) # read first message
+              subject.receive(message)
+              buffer << client.sysread(1) # read second message
+              client.close
+            end
+          }.to_not raise_error
+        end
+        sleep 0.1 until thread.status == "sleep" # wait for TCP port to open
+        subject.receive(message) # send first message to unblock call to `accept`
+        thread.join(2)
+
+        expect(buffer).to eq(message * 2)
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-output-tcp
 version: !ruby/object:Gem::Version
-  version: 6.1.1
+  version: 6.1.2
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-21 00:00:00.000000000 Z
+date: 2023-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -171,7 +171,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: Writes events over a TCP socket