logstash-input-http 3.0.1 → 3.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 534e946ab5a99a0cea05527407fb947a98cf5954
-  data.tar.gz: 27a938c700bf26c8974dcce09193bd68e8528073
+  metadata.gz: 60c60f0e309dd3a4cf01991820faf682b1d20b60
+  data.tar.gz: 8d10272305ecb4fbf7c13eeb527fbfc3a3b15c58
 SHA512:
-  metadata.gz: 74be876e68c810ef845ebae2d1ffedb286d1096db92413eeb337cbbfa170cc74f3f8d99f97bc730c57bd0ed2529f6438ff6a3cc1e6c5f53a276c94f6df00e768
-  data.tar.gz: 3b750c32d76e858e2526da40d8a98dc569eac41d2810f8c8433a8b2eb776b5fd951fc168eef6723491f97f578d3a2c4baa5a8624e92be7bed881e862b10c8c98
+  metadata.gz: c0251a7b4d3be7bdd20ab639fbb7c4947ff469cbfcecda0160fdca73dc19c28958f0429d5476e1d1fad697b70179120b73ca363fa86ce22a8de11d4e94b13515
+  data.tar.gz: a7110b84f71e5d5ca88e8b8cb5071dacdef98687c6b5d8e74e50180ee50b3c2e0d9b17962d96754a51dda909abdefcd68e3ae56b5dab25fb6c321028e2fa385e

data/CHANGELOG.md

@@ -1,3 +1,5 @@
+## 3.0.2
+  - Use a new class as redefined Puma::Server class as we need to mock one method and only need it for this plugin, but not for all parts using puma in logstash.Fixes https://github.com/logstash-plugins/logstash-input-http/issues/51.
 ## 3.0.1
   - Republish all the gems under jruby.
 ## 3.0.0

data/lib/logstash/inputs/http.rb

@@ -8,7 +8,15 @@ require "puma/minissl"
 require "base64"
 require "rack"
 
-class Puma::Server
+
+##
+# We keep the redefined method in a new http server class, this is because
+# in other parts of logstash we might be using puma as webserver, for example
+# in the sinatra part we need this method to actually return the REQUEST_PATH, 
+# so it can actually infer the right resource to use.
+# Fixes https://github.com/logstash-plugins/logstash-input-http/issues/51
+##
+class HTTPInputWebServer < Puma::Server
   # ensure this method doesn't mess up our vanilla request
   def normalize_env(env, client); end
 end
@@ -87,7 +95,7 @@ class LogStash::Inputs::Http < LogStash::Inputs::Base
   public
   def register
     require "logstash/util/http_compressed_requests"
-    @server = ::Puma::Server.new(nil) # we'll set the rack handler later
+    @server = ::HTTPInputWebServer.new(nil) # we'll set the rack handler later
     if @user && @password then
       token = Base64.strict_encode64("#{@user}:#{@password.value}")
       @auth_token = "Basic #{token}"

data/logstash-input-http.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'logstash-input-http'
-  s.version         = '3.0.1'
+  s.version         = '3.0.2'
   s.licenses = ['Apache License (2.0)']
   s.summary = "Logstash Input plugin that receives HTTP requests"
   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/inputs/http_spec.rb

@@ -16,149 +16,179 @@ describe LogStash::Inputs::Http do
   let(:queue) { Queue.new }
   let(:port) { rand(5000) + 1025 }
 
-  after :each do
-    subject.stop
-  end
-
   it_behaves_like "an interruptible input plugin" do
     let(:config) { { "port" => port } }
   end
 
-  describe "#run" do
+  after :each do
+    subject.stop
+  end
+
+  describe "request handling" do
     subject { LogStash::Inputs::Http.new }
     before :each do
       subject.register
-      Thread.new { subject.run(queue) }
+      t = Thread.new { subject.run(queue) }
+      sleep 0.01 until subject.instance_variable_get(:@server).running == 0
     end
+
     it "should include remote host in \"host\" property" do
       agent.post!("http://localhost:8080/meh.json",
-        :headers => { "content-type" => "text/plain" },
-        :body => "hello")
+                  :headers => { "content-type" => "text/plain" },
+                  :body => "hello")
       event = queue.pop
       expect(event.get("host")).to eq("127.0.0.1")
     end
-  end
 
-  context "with default codec" do
-    subject { LogStash::Inputs::Http.new("port" => port) }
-    context "when receiving a text/plain request" do
-      it "should process the request normally" do
-        subject.register
-        Thread.new { subject.run(queue) }
-        agent.post!("http://localhost:#{port}/meh.json",
-                    :headers => { "content-type" => "text/plain" },
-                    :body => "hello")
-        event = queue.pop
-        expect(event.get("message")).to eq("hello")
-      end
-    end
-    context "when receiving a deflate compressed text/plain request" do
-      it "should process the request normally" do
-        subject.register
-        Thread.new { subject.run(queue) }
-        agent.post!("http://localhost:#{port}/meh.json",
-                    :headers => { "content-type" => "text/plain", "content-encoding" => "deflate" },
-                    :body => Zlib::Deflate.deflate("hello"))
-        event = queue.pop
-        expect(event.get("message")).to eq("hello")
-      end
-    end
-    context "when receiving a deflate text/plain request that cannot be decompressed" do
-      let!(:response) do
-        subject.register
-        Thread.new { subject.run(queue) }
-        agent.post!("http://localhost:#{port}/meh.json",
-                    :headers => { "content-type" => "text/plain", "content-encoding" => "deflate" },
-                    :body => "hello")
-      end
-      it "should respond with 400" do
-        expect(response.status).to eq(400)
-      end
-      it "should respond with a decompression error" do
-        expect(response.read_body).to eq("Failed to decompress body")
+    context "with default codec" do
+      subject { LogStash::Inputs::Http.new("port" => port) }
+      context "when receiving a text/plain request" do
+        it "should process the request normally" do
+          agent.post!("http://localhost:#{port}/meh.json",
+                      :headers => { "content-type" => "text/plain" },
+                      :body => "hello")
+          event = queue.pop
+          expect(event.get("message")).to eq("hello")
+        end
+      end
+      context "when receiving a deflate compressed text/plain request" do
+        it "should process the request normally" do
+          agent.post!("http://localhost:#{port}/meh.json",
+                      :headers => { "content-type" => "text/plain", "content-encoding" => "deflate" },
+                      :body => Zlib::Deflate.deflate("hello"))
+          event = queue.pop
+          expect(event.get("message")).to eq("hello")
+        end
+      end
+      context "when receiving a deflate text/plain request that cannot be decompressed" do
+        it "should respond with 400" do
+          response = agent.post!("http://localhost:#{port}/meh.json",
+                                 :headers => { "content-type" => "text/plain", "content-encoding" => "deflate" },
+                                   :body => "hello")
+          expect(response.status).to eq(400)
+        end
+        it "should respond with a decompression error" do
+          response = agent.post!("http://localhost:#{port}/meh.json",
+                                 :headers => { "content-type" => "text/plain", "content-encoding" => "deflate" },
+                                   :body => "hello")
+          expect(response.read_body).to eq("Failed to decompress body")
+        end
+      end
+      context "when receiving a gzip compressed text/plain request" do
+        it "should process the request normally" do
+          z = StringIO.new ""
+          w = Zlib::GzipWriter.new z
+          w.write("hello")
+          w.finish
+          agent.post!("http://localhost:#{port}/meh.json",
+                      :headers => { "content-type" => "text/plain", "content-encoding" => "gzip" },
+                        :body => z.string)
+          event = queue.pop
+          expect(event.get("message")).to eq("hello")
+        end
+      end
+      context "when receiving a gzip text/plain request that cannot be decompressed" do
+        let(:response) do
+          agent.post!("http://localhost:#{port}/meh.json",
+                      :headers => { "content-type" => "text/plain", "content-encoding" => "gzip" },
+                      :body => "hello")
+        end
+        it "should respond with 400" do
+          expect(response.status).to eq(400)
+        end
+        it "should respond with a decompression error" do
+          expect(response.read_body).to eq("Failed to decompress body")
+        end
+      end
+      context "when receiving an application/json request" do
+        it "should parse the json body" do
+          agent.post!("http://localhost:#{port}/meh.json",
+                      :headers => { "content-type" => "application/json" },
+                      :body => { "message_body" => "Hello" }.to_json)
+          event = queue.pop
+          expect(event.get("message_body")).to eq("Hello")
+        end
       end
     end
-    context "when receiving a gzip compressed text/plain request" do
-      it "should process the request normally" do
-        subject.register
-        Thread.new { subject.run(queue) }
-        z = StringIO.new ""
-        w = Zlib::GzipWriter.new z
-        w.write("hello")
-        w.finish
-        agent.post!("http://localhost:#{port}/meh.json",
-                    :headers => { "content-type" => "text/plain", "content-encoding" => "gzip" },
-                    :body => z.string)
+    context "with json codec" do
+      subject { LogStash::Inputs::Http.new("port" => port, "codec" => "json") }
+      it "should parse the json body" do
+        agent.post!("http://localhost:#{port}/meh.json", :body => { "message" => "Hello" }.to_json)
         event = queue.pop
-        expect(event.get("message")).to eq("hello")
-      end
-    end
-    context "when receiving a gzip text/plain request that cannot be decompressed" do
-      let!(:response) do
-          subject.register
-          Thread.new { subject.run(queue) }
-          agent.post!("http://localhost:#{port}/meh.json",
-                    :headers => { "content-type" => "text/plain", "content-encoding" => "gzip" },
-                    :body => "hello")
-      end
-      it "should respond with 400" do
-        expect(response.status).to eq(400)
-      end
-      it "should respond with a decompression error" do
-        expect(response.read_body).to eq("Failed to decompress body")
+        expect(event.get("message")).to eq("Hello")
       end
     end
-    context "when receiving an application/json request" do
-      it "should parse the json body" do
-        subject.register
-        Thread.new { subject.run(queue) }
+
+    context "when using a custom codec mapping" do
+      subject { LogStash::Inputs::Http.new("port" => port,
+                                           "additional_codecs" => { "application/json" => "plain" }) }
+      it "should decode the message accordingly" do
+        body = { "message" => "Hello" }.to_json
         agent.post!("http://localhost:#{port}/meh.json",
                     :headers => { "content-type" => "application/json" },
-                    :body => { "message_body" => "Hello" }.to_json)
+                      :body => body)
         event = queue.pop
-        expect(event.get("message_body")).to eq("Hello")
+        expect(event.get("message")).to eq(body)
       end
     end
-  end
-
-  context "with json codec" do
-    subject { LogStash::Inputs::Http.new("port" => port, "codec" => "json") }
-    it "should parse the json body" do
-      subject.register
-      Thread.new { subject.run(queue) }
-      agent.post!("http://localhost:#{port}/meh.json", :body => { "message" => "Hello" }.to_json)
-      event = queue.pop
-      expect(event.get("message")).to eq("Hello")
-    end
-  end
-
-  context "when using a custom codec mapping" do
-    subject { LogStash::Inputs::Http.new("port" => port,
-                                         "additional_codecs" => { "application/json" => "plain" }) }
-    it "should decode the message accordingly" do
-      body = { "message" => "Hello" }.to_json
-      subject.register
-      Thread.new { subject.run(queue) }
-      agent.post!("http://localhost:#{port}/meh.json",
-                  :headers => { "content-type" => "application/json" },
-                  :body => body)
-      event = queue.pop
-      expect(event.get("message")).to eq(body)
-    end
-  end
 
-  context "when using custom headers" do
-    let(:custom_headers) { { 'access-control-allow-origin' => '*' } }
-    subject { LogStash::Inputs::Http.new("port" => port, "response_headers" => custom_headers) }
+    context "when using custom headers" do
+      let(:custom_headers) { { 'access-control-allow-origin' => '*' } }
+      subject { LogStash::Inputs::Http.new("port" => port, "response_headers" => custom_headers) }
 
-    describe "the response" do
-      it "should include the custom headers" do
-        subject.register
-        Thread.new { subject.run(queue) }
-        response = agent.post!("http://localhost:#{port}/meh", :body => "hello")
-        expect(response.headers.to_hash).to include(custom_headers)
+      describe "the response" do
+        it "should include the custom headers" do
+          response = agent.post!("http://localhost:#{port}/meh", :body => "hello")
+          expect(response.headers.to_hash).to include(custom_headers)
+        end
+      end
+    end
+    describe "basic auth" do
+      user = "test"; password = "pwd"
+      subject { LogStash::Inputs::Http.new("port" => port, "user" => user, "password" => password) }
+      let(:auth_token) { Base64.strict_encode64("#{user}:#{password}") }
+      context "when client doesn't present auth token" do
+        let!(:response) { agent.post!("http://localhost:#{port}/meh", :body => "hi") }
+        it "should respond with 401" do
+          expect(response.status).to eq(401)
+        end
+        it "should not generate an event" do
+          expect(queue).to be_empty
+        end
+      end
+      context "when client presents incorrect auth token" do
+        let!(:response) do
+          agent.post!("http://localhost:#{port}/meh",
+                      :headers => {
+                        "content-type" => "text/plain",
+                        "authorization" => "Basic meh"
+                      },
+                      :body => "hi")
+        end
+        it "should respond with 401" do
+          expect(response.status).to eq(401)
+        end
+        it "should not generate an event" do
+          expect(queue).to be_empty
+        end
+      end
+      context "when client presents correct auth token" do
+        let!(:response) do
+          agent.post!("http://localhost:#{port}/meh",
+                      :headers => {
+                        "content-type" => "text/plain",
+                        "authorization" => "Basic #{auth_token}"
+                      }, :body => "hi")
+        end
+        it "should respond with 200" do
+          expect(response.status).to eq(200)
+        end
+        it "should generate an event" do
+          expect(queue).to_not be_empty
+        end
       end
     end
+
   end
 
   context "with :ssl => false" do
@@ -184,53 +214,4 @@ describe LogStash::Inputs::Http do
       end
     end
   end
-  describe "basic auth" do
-    user = "test"; password = "pwd"
-    subject { LogStash::Inputs::Http.new("port" => port, "user" => user, "password" => password) }
-    let(:auth_token) { Base64.strict_encode64("#{user}:#{password}") }
-    before :each do
-      subject.register
-      Thread.new { subject.run(queue) }
-    end
-    context "when client doesn't present auth token" do
-      let!(:response) { agent.post!("http://localhost:#{port}/meh", :body => "hi") }
-      it "should respond with 401" do
-        expect(response.status).to eq(401)
-      end
-      it "should not generate an event" do
-        expect(queue).to be_empty
-      end
-    end
-    context "when client presents incorrect auth token" do
-      let!(:response) do
-        agent.post!("http://localhost:#{port}/meh",
-                    :headers => {
-                      "content-type" => "text/plain",
-                      "authorization" => "Basic meh"
-                    },
-                    :body => "hi")
-      end
-      it "should respond with 401" do
-        expect(response.status).to eq(401)
-      end
-      it "should not generate an event" do
-        expect(queue).to be_empty
-      end
-    end
-    context "when client presents correct auth token" do
-      let!(:response) do
-        agent.post!("http://localhost:#{port}/meh",
-                    :headers => {
-                      "content-type" => "text/plain",
-                      "authorization" => "Basic #{auth_token}"
-                    }, :body => "hi")
-      end
-      it "should respond with 200" do
-        expect(response.status).to eq(200)
-      end
-      it "should generate an event" do
-        expect(queue).to_not be_empty
-      end
-    end
-  end
 end

metadata

@@ -1,133 +1,133 @@
 --- !ruby/object:Gem::Specification
 name: logstash-input-http
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 3.0.2
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-05-09 00:00:00.000000000 Z
+date: 2016-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  name: logstash-core-plugin-api
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '2.0'
-  name: logstash-core-plugin-api
   prerelease: false
   type: :runtime
+- !ruby/object:Gem::Dependency
+  name: logstash-codec-plain
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
+        version: '0'
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  name: logstash-codec-plain
   prerelease: false
   type: :runtime
+- !ruby/object:Gem::Dependency
+  name: stud
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  name: stud
   prerelease: false
   type: :runtime
+- !ruby/object:Gem::Dependency
+  name: puma
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
+        version: '2.16'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.16.0
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '2.16'
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.16.0
-  name: puma
   prerelease: false
   type: :runtime
+- !ruby/object:Gem::Dependency
+  name: rack
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.16'
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 2.16.0
-- !ruby/object:Gem::Dependency
+        version: '1'
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1'
-  name: rack
   prerelease: false
   type: :runtime
+- !ruby/object:Gem::Dependency
+  name: logstash-devutils
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '1'
-- !ruby/object:Gem::Dependency
+        version: '0'
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  name: logstash-devutils
   prerelease: false
   type: :development
+- !ruby/object:Gem::Dependency
+  name: logstash-codec-json
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  name: logstash-codec-json
   prerelease: false
   type: :development
+- !ruby/object:Gem::Dependency
+  name: ftw
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  name: ftw
   prerelease: false
   type: :development
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 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
 email: info@elastic.co
 executables: []
@@ -156,19 +156,20 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.4.8
+rubygems_version: 2.4.6
 signing_key:
 specification_version: 4
 summary: Logstash Input plugin that receives HTTP requests
 test_files:
 - spec/inputs/http_spec.rb
+has_rdoc: