logstash-input-http 2.2.2 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cbc7e81f1a5fc2c27958a9f46a7d393d1501d322
-  data.tar.gz: c254a7c14edd9f9ba1556cbe80d65654df407485
+  metadata.gz: 369d5bdf4eb3849fe8c1c22be51872b77f306e99
+  data.tar.gz: 7f4c99931dd5bbbd45afc51dd689bc3ddaf21291
 SHA512:
-  metadata.gz: 283e1fd41c4c9be3707800bf842752ba3cf55c93ff574ab3578112e88d9b4c85b6433d00c7035683132bab2a8501883c5083ee51c6ea5b8f49d0c6a82e59db97
-  data.tar.gz: 239407e99e311d48694844a16e35ee89adff91e5c6a861b96ac8264aeebc403773717d56ede69fb68a123e2ebd3c01a1f7bc032f6376bbd4ab9617d352d7fc80
+  metadata.gz: 8101c5b9b09393a672d4807bad8980265e5592dc9ba979e6cd70798ff02cd07919be12a9f1a6dfd5608447fe44aa5849f5a262eae417c93928c01a2564889678
+  data.tar.gz: 4b8f65d565b7b49dfc0d31b09665fda3361b775b3816bddde7a2cd4e51f925333ae52f486176bf1b903c529b3fc22b194dc2e8f76678d852ef5dda8f68b9369c

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+# 2.2.3
+  - fix hanging tests
+  - added some meta documents to the repository like contributing guide and github templates
 # 2.2.2
   - Depend on logstash-core-plugin-api instead of logstash-core, removing the need to mass update plugins on major releases of logstash
 # 2.2.1

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012–2015 Elasticsearch <http://www.elastic.co>
+Copyright (c) 2012–2016 Elasticsearch <http://www.elastic.co>
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/README.md

@@ -1,7 +1,6 @@
 # Logstash Plugin
 
-[![Build
-Status](http://build-eu-00.elastic.co/view/LS%20Plugins/view/LS%20Inputs/job/logstash-plugin-input-http-unit/badge/icon)](http://build-eu-00.elastic.co/view/LS%20Plugins/view/LS%20Inputs/job/logstash-plugin-input-http-unit/)
+[![Travis Build Status](https://travis-ci.org/logstash-plugins/logstash-input-http.svg)](https://travis-ci.org/logstash-plugins/logstash-input-http)
 
 This is a plugin for [Logstash](https://github.com/elastic/logstash).
 
@@ -56,7 +55,12 @@ gem "logstash-filter-awesome", :path => "/your/local/logstash-filter-awesome"
 ```
 - Install plugin
 ```sh
+# Logstash 2.3 and higher
+bin/logstash-plugin install --no-verify
+
+# Prior to Logstash 2.3
 bin/plugin install --no-verify
+
 ```
 - Run Logstash with your plugin
 ```sh
@@ -74,7 +78,12 @@ gem build logstash-filter-awesome.gemspec
 ```
 - Install the plugin from the Logstash home
 ```sh
-bin/plugin install /your/local/plugin/logstash-filter-awesome.gem
+# Logstash 2.3 and higher
+bin/logstash-plugin install --no-verify
+
+# Prior to Logstash 2.3
+bin/plugin install --no-verify
+
 ```
 - Start Logstash and proceed to test the plugin
 

data/logstash-input-http.gemspec

@@ -1,9 +1,9 @@
 Gem::Specification.new do |s|
   s.name = 'logstash-input-http'
-  s.version         = '2.2.2'
+  s.version         = '2.2.3'
   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/plugin install gemname. This gem is not a stand-alone program"
+  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"
   s.authors = ["Elastic"]
   s.email = 'info@elastic.co'
   s.homepage = "http://www.elastic.co/guide/en/logstash/current/index.html"

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["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["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["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["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["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["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["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["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["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["message_body"]).to eq("Hello")
+        expect(event["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["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["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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-input-http
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 2.2.3
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-03-24 00:00:00.000000000 Z
+date: 2016-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -128,7 +128,7 @@ dependencies:
     - - ">="
       - !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/plugin install gemname. This gem is not a stand-alone program
+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: []
 extensions: []
@@ -166,7 +166,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.4.8
+rubygems_version: 2.6.3
 signing_key:
 specification_version: 4
 summary: Logstash Input plugin that receives HTTP requests