http_streaming_client 0.8.6 → 0.8.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 607b852759a7216b85fa6d820d2bc70a2d50b475
-  data.tar.gz: 49b554701c78b290e3b7e337a1b8fbcc12f0f726
+  metadata.gz: 8308d062ebb595dddc19e1ce5232829fb92bd9ce
+  data.tar.gz: cfbe2c60d0b7b021cbe09d80bee4ef8114115039
 SHA512:
-  metadata.gz: c1d07b0e483dc0e81d83800d05d6170d28f00dad305f6e6f3644ffe96b9bac00ff203a7bd34fadf697245b10520cdb1e303b79442dc0bd6bd3a477bb52b99f63
-  data.tar.gz: a26cf37f5791d4701ca0f0bf74cdedb009fb1a6d1ee58934f15dfad8a12ffb8c3755a3854c95b496fc2ca22bae69c70e8a04d40c7ada2efd54f41c5ead6ca2d2
+  metadata.gz: 50ee772c4e19aec32f3a771b1686b8beadd9d7fb2038cf08b0b65792f7b070f26b1bf74519c4f85deea9462e2a93df0939888d3c1233a383a6b21286ce93a6c1
+  data.tar.gz: 323dec68b2c4d8730d4c9803358f142e721efc3aa2b08745625eacd4ea6b59351e2394a24ca739d5baa5ef64f1343f2060d538a7d3bc2c7f3b3fdded0f17d066

data/CHANGELOG

@@ -1,3 +1,11 @@
+http_streaming_client 0.8.8 (1.7.2014)
+========================================
+* Fixed Issue #1, memory leak due to accumulated messages within the buffer pipeline
+* Added automatic reconnection support and configuration options
+* Added automatic HTTP 301 redirect support
+* Added new unit tests for reconnect and for memory leak detection
+* Updated performance tests
+
 http_streaming_client 0.8.5 (12.10.2013)
 ========================================
 * Updates to support MRI ruby 2.0.0-p353

data/README.md

@@ -9,39 +9,69 @@ Ruby HTTP client with support for HTTP 1.1 streaming, GZIP and zlib compressed s
 
 MRI ruby-2.0.0-p353. If you need it, install via rvm: https://rvm.io/
 
-## Installation (local gem bundle/install)
+## Installation
 
-Execute the following to bundle the gem:
+Add this line to your application's Gemfile:
 
-    $ gem build http_streaming_client.gemspec
+    gem 'http_streaming_client'
 
-Then install the gem with:
+And then execute:
+
+    $ bundle install
+
+Or install it directly via gem with:
 
     $ gem install http_streaming_client
 
-## Installation (via Github)
+## Simple Example
 
-Add this line to your application's Gemfile:
+Twitter Firehose Sample Stream:
 
-    gem 'http_streaming_client', :git => 'git@github.com:adobe-research/http_streaming_client.git'
+```ruby
+require 'http_streaming_client'
 
-And then execute:
+twitter_stream_url = "https://stream.twitter.com/1.1/statuses/sample.json"
 
-    $ bundle install
+# Generate the HMAC-SHA1 Twitter OAuth authorization header
+authorization = HttpStreamingClient::Oauth::Twitter.generate_authorization(twitter_stream_url, "get", {}, OAUTH_CONSUMER_KEY, OAUTH_CONSUMER_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
 
-## Installation (via rubygems.org)
+# Configure the client
+client = HttpStreamingClient::Client.new(compression: true, reconnect: true, reconnect_interval: 10, reconnect_attempts: 60)
 
-Add this line to your application's Gemfile:
+# Open the connection and start processing messages
+response = client.get(twitter_stream_url, {:headers => {'Authorization' => "#{authorization}" }}) { |line|
+  logger.info "Received a line that we could parse into JSON if we want: #{line}"
+  client.interrupt if we_want_to_stop_receiving_messages?
+}
+```
 
-    gem 'http_streaming_client'
+For more examples, take a look at
 
-And then execute:
+* spec/client_spec.rb
+* tools/adobe_firehose.rb
+* tools/adobe_firehose_performance_test.rb
+* tools/twitter_firehose.rb
+* tools/twitter_firehose_performance_test.rb
 
-    $ bundle
+## Client Configuration Options
 
-Or install it yourself as:
+The following options are supported as hash option parameters for HttpStreamingClient::Client.new:
 
-    $ gem install http_streaming_client
+GZip Compression
+
+    compression: true/false (default: true)
+
+Automatic Socket Reconnect Functions
+
+    reconnect: true/false (default: false)
+
+Reconnect Interval
+
+    reconnect_interval: interval_seconds (default: 1 second)
+
+Maximum Reconnect Attempts
+
+    reconnect_attempts: num_attempts (default: 10)
 
 ## Logging
 
@@ -110,21 +140,6 @@ Individual test suites in the spec directory can be run via:
 
 An HTML coverage report is generated at the end of a full test run in the coverage directory.
 
-## Examples
-
-Take a look at
-
-* spec/client_spec.rb
-* tools/adobe_firehose.rb
-* tools/adobe_firehose_performance_test.rb
-* tools/twitter_firehose.rb
-* tools/twitter_firehose_performance_test.rb
-
-## TODO
-
-* connection management with reconnect functions
-* load/memory testing
-
 ## Fixed Issues
 
 * See [![CHANGELOG](CHANGELOG)](CHANGELOG)

data/lib/http_streaming_client/client.rb

@@ -40,10 +40,13 @@ module HttpStreamingClient
 
   class Client
 
-    attr_accessor :socket, :interrupted, :compression_requested
+    attr_accessor :socket, :interrupted, :compression_requested, :reconnect_requested, :reconnect_attempts, :reconnect_interval
 
     ALLOWED_MIME_TYPES = ["application/json", "text/plain", "text/html"]
 
+    MAX_RECONNECT_ATTEMPTS = 10
+    RECONNECT_INTERVAL_SEC = 1
+
     def self.logger
       HttpStreamingClient.logger
     end
@@ -56,8 +59,24 @@ module HttpStreamingClient
       logger.debug("Client.new: #{opts}")
       @socket = nil
       @interrupted = false
+
       @compression_requested = opts[:compression].nil? ? true : opts[:compression]
       logger.debug("compression is #{@compression_requested}")
+
+      @reconnect_requested = opts[:reconnect].nil? ? false : opts[:reconnect]
+      logger.debug("reconnect is #{@reconnect_requested}")
+
+      if @reconnect_requested then
+	@reconnect_count = 0
+
+	@reconnect_attempts = opts[:reconnect_attempts].nil? ? MAX_RECONNECT_ATTEMPTS : opts[:reconnect_attempts]
+	logger.debug("reconnect_attempts is #{@reconnect_attempts}")
+
+	@reconnect_interval = opts[:reconnect_interval].nil? ? RECONNECT_INTERVAL_SEC : opts[:reconnect_interval]
+	logger.debug("reconnect_interval is #{@reconnect_interval}")
+
+      end
+
     end
 
     def self.get(uri, opts = {}, &block)
@@ -132,199 +151,226 @@ module HttpStreamingClient
       headers = default_headers.merge(opts[:headers] || {})
       logger.debug "request headers: #{headers}"
 
-      socket = initialize_socket(uri, opts)
-      request = "#{method} #{uri.path}#{uri.query ? "?"+uri.query : nil} HTTP/1.1\r\n"
-      request << "Host: #{uri.host}\r\n"
-      headers.each do |k, v|
-	request << "#{k}: #{v}\r\n"
-      end
-      request << "\r\n"
-      if method == "POST"
-	request << body
-      end
+      begin
 
-      socket.write(request)
+	socket = initialize_socket(uri, opts)
 
-      response_head = {}
-      response_head[:headers] = {}
+	@reconnect_count = 0 if @reconnect_requested
 
-      socket.each_line do |line|
-	if line == "\r\n" then
-	  break
-	else
-	  header = line.split(": ")
-	  if header.size == 1
-	    header = header[0].split(" ")
-	    response_head[:version] = header[0]
-	    response_head[:code] = header[1].to_i
-	    response_head[:msg] = header[2]
-	    logger.debug "HTTP response code is #{response_head[:code]}"
-	  else
-	    response_head[:headers][camelize_header_name(header[0])] = header[1].strip
-	  end
+	request = "#{method} #{uri.path}#{uri.query ? "?"+uri.query : nil} HTTP/1.1\r\n"
+	request << "Host: #{uri.host}\r\n"
+	headers.each do |k, v|
+	  request << "#{k}: #{v}\r\n"
 	end
-      end
-
-      logger.debug "response headers:#{response_head[:headers]}"
-
-      if response_head[:code] == 301 then
-	location = response_head[:headers]["Location"]
-	raise InvalidRedirect, "Unable to find Location header for HTTP 301 response" if location.nil?
-	logger.debug "Received HTTP 301 redirect to #{location}, following..."
-	socket.close if !socket.nil? and !socket.closed?
-	opts.delete(:socket)
-	return request(method, location, opts, &block)
-      end
-
-      content_length = response_head[:headers]["Content-Length"].to_i
-      logger.debug "content-length: #{content_length}"
-
-      content_type = response_head[:headers]["Content-Type"].split(';').first
-      logger.debug "content-type: #{content_type}"
-
-      response_compression = false
-
-      if ALLOWED_MIME_TYPES.include?(content_type)
-	case response_head[:headers]["Content-Encoding"]
-	when "gzip"
-	  response_compression = true
+	request << "\r\n"
+	if method == "POST"
+	  request << body
 	end
-      else
-	raise InvalidContentType, "invalid response MIME type: #{content_type}"
-      end
 
-      if (response_head[:code] != 200)
-	s = "Received HTTP #{response_head[:code]} response"
-	logger.debug "request: #{request}"
-	response = socket.read(content_length)
-	logger.debug "response: #{response}"
-	raise HttpError.new(response_head[:code], "Received HTTP #{response_head[:code]} response", response_head[:headers])
-      end
+	socket.write(request)
+
+	response_head = {}
+	response_head[:headers] = {}
 
-      if response_head[:headers]["Transfer-Encoding"] == 'chunked'
-	partial = nil
-	decoder = nil
-	response = ""
-
-	if response_compression then
-	  logger.debug "response compression detected"
-	  if block_given? then
-	    decoder = HttpStreamingClient::Decoders::GZip.new { |line|
-	      logger.debug "read #{line.size} uncompressed bytes, decoder queue bytes:#{decoder.size}"
-	      block.call(line) unless @interrupted }
+	socket.each_line do |line|
+	  if line == "\r\n" then
+	    break
 	  else
-	    decoder = HttpStreamingClient::Decoders::GZip.new { |line|
-	      logger.debug "read #{line.size} uncompressed bytes, #{response.size} bytes total, decoder queue bytes:#{decoder.size}"
-	      response << line unless @interrupted }
+	    header = line.split(": ")
+	    if header.size == 1
+	      header = header[0].split(" ")
+	      response_head[:version] = header[0]
+	      response_head[:code] = header[1].to_i
+	      response_head[:msg] = header[2]
+	      logger.debug "HTTP response code is #{response_head[:code]}"
+	    else
+	      response_head[:headers][camelize_header_name(header[0])] = header[1].strip
+	    end
 	  end
 	end
 
-	while !socket.eof? && (line = socket.gets)
-	  chunkLeft = 0
+	logger.debug "response headers:#{response_head[:headers]}"
 
-	  if line.match /^0\r\n/ then
-	    logger.debug "received zero length chunk, chunked encoding EOF"
-	    logger.debug "EOF line: #{line}"
-	    break
-	  end
+	if response_head[:code] == 301 then
+	  location = response_head[:headers]["Location"]
+	  raise InvalidRedirect, "Unable to find Location header for HTTP 301 response" if location.nil?
+	  logger.debug "Received HTTP 301 redirect to #{location}, following..."
+	  socket.close if !socket.nil? and !socket.closed?
+	  opts.delete(:socket)
+	  return request(method, location, opts, &block)
+	end
 
-	  next if line == "\r\n"
+	content_length = response_head[:headers]["Content-Length"].to_i
+	logger.debug "content-length: #{content_length}"
 
-	  size = line.hex
-	  logger.debug "chunk size:#{size}"
+	content_type = response_head[:headers]["Content-Type"].split(';').first
+	logger.debug "content-type: #{content_type}"
 
-	  partial = socket.read(size)
-	  next if partial.nil?
+	response_compression = false
 
-	  remaining = size-partial.size
-	  logger.debug "read #{partial.size} bytes, #{remaining} bytes remaining"
-	  until remaining == 0
-	    partial << socket.read(remaining)
-	    remaining = size-partial.size
-	    logger.debug "read #{partial.size} bytes, #{remaining} bytes remaining"
+	if ALLOWED_MIME_TYPES.include?(content_type)
+	  case response_head[:headers]["Content-Encoding"]
+	  when "gzip"
+	    response_compression = true
 	  end
+	else
+	  raise InvalidContentType, "invalid response MIME type: #{content_type}"
+	end
+
+	if (response_head[:code] != 200)
+	  s = "Received HTTP #{response_head[:code]} response"
+	  logger.debug "request: #{request}"
+	  response = socket.read(content_length)
+	  logger.debug "response: #{response}"
+	  raise HttpError.new(response_head[:code], "Received HTTP #{response_head[:code]} response", response_head[:headers])
+	end
 
-	  return if @interrupted
+	if response_head[:headers]["Transfer-Encoding"] == 'chunked'
+	  partial = nil
+	  decoder = nil
+	  response = ""
 
 	  if response_compression then
-	    decoder << partial
-	  else
+	    logger.debug "response compression detected"
 	    if block_given? then
-	      yield partial
+	      decoder = HttpStreamingClient::Decoders::GZip.new { |line|
+		logger.debug "read #{line.size} uncompressed bytes, decoder queue bytes:#{decoder.size}"
+		block.call(line) unless @interrupted }
 	    else
-	      logger.debug "no block specified, returning chunk results and halting streaming response"
-	      response << partial
+	      decoder = HttpStreamingClient::Decoders::GZip.new { |line|
+		logger.debug "read #{line.size} uncompressed bytes, #{response.size} bytes total, decoder queue bytes:#{decoder.size}"
+		response << line unless @interrupted }
 	    end
 	  end
-	end
 
-	return response
-
-      else
-	# Not chunked transfer encoding, but potentially gzip'd, and potentially streaming with content-length = 0
-
-	if content_length > 0 then
-	  bits = socket.read(content_length)
-	  logger.debug "read #{content_length} bytes"
-	  return bits if !response_compression
-	  logger.debug "response compression detected"
-	  begin
-	    decoder = Zlib::GzipReader.new(StringIO.new(bits))
-	    return decoder.read
-	  rescue Zlib::Error
-	    raise DecoderError
-	  end
-	end
+	  while !socket.eof? && (line = socket.gets)
+	    chunkLeft = 0
 
-	if response_compression then
+	    if line.match /^0\r\n/ then
+	      logger.debug "received zero length chunk, chunked encoding EOF"
+	      logger.debug "EOF line: #{line}"
+	      break
+	    end
 
-	  logger.debug "response compression detected"
-	  decoder = nil
-	  response = ""
+	    next if line == "\r\n"
 
-	  if block_given? then
-	    decoder = HttpStreamingClient::Decoders::GZip.new { |line|
-	      logger.debug "read #{line.size} uncompressed bytes, decoder queue bytes:#{decoder.size}"
-	      block.call(line) unless @interrupted }
-	  else
-	    decoder = HttpStreamingClient::Decoders::GZip.new { |line|
-	      logger.debug "read #{line.size} uncompressed bytes, #{response.size} bytes total, decoder queue bytes:#{decoder.size}"
-	      response << line unless @interrupted }
-	  end
+	    size = line.hex
+	    logger.debug "chunk size:#{size}"
+
+	    partial = socket.read(size)
+	    next if partial.nil?
+
+	    remaining = size-partial.size
+	    logger.debug "read #{partial.size} bytes, #{remaining} bytes remaining"
+	    until remaining == 0
+	      partial << socket.read(remaining)
+	      remaining = size-partial.size
+	      logger.debug "read #{partial.size} bytes, #{remaining} bytes remaining"
+	    end
+
+	    return if @interrupted
 
-	  while (!socket.eof? and !(line = socket.read_nonblock(2048)).nil?)
-	    logger.debug "read compressed line, #{line.size} bytes"
-	    decoder << line
-	    break response if @interrupted
+	    if response_compression then
+	      decoder << partial
+	    else
+	      if block_given? then
+		yield partial
+	      else
+		logger.debug "no block specified, returning chunk results and halting streaming response"
+		response << partial
+		interrupt
+	      end
+	    end
 	  end
-	  logger.debug "EOF detected"
-	  decoder = nil
 
+	  logger.debug "socket EOF detected" if socket.eof?
+	  raise ReconnectRequest if @reconnect_requested
 	  return response
 
 	else
+	  # Not chunked transfer encoding, but potentially gzip'd, and potentially streaming with content-length = 0
+
+	  if content_length > 0 then
+	    bits = socket.read(content_length)
+	    logger.debug "read #{content_length} bytes"
+	    return bits if !response_compression
+	    logger.debug "response compression detected"
+	    begin
+	      decoder = Zlib::GzipReader.new(StringIO.new(bits))
+	      return decoder.read
+	    rescue Zlib::Error
+	      raise DecoderError
+	    end
+	  end
 
-	  response = ""
+	  if response_compression then
+
+	    logger.debug "response compression detected"
+	    decoder = nil
+	    response = ""
 
-	  while (!socket.eof? and !(line = socket.readline).nil?)
 	    if block_given? then
-	      yield line
-	      logger.debug "read #{line.size} bytes"
+	      decoder = HttpStreamingClient::Decoders::GZip.new { |line|
+		logger.debug "read #{line.size} uncompressed bytes, decoder queue bytes:#{decoder.size}"
+		block.call(line) unless @interrupted }
 	    else
-	      logger.debug "read #{line.size} bytes, #{response.size} bytes total"
-	      response << line
+	      decoder = HttpStreamingClient::Decoders::GZip.new { |line|
+		logger.debug "read #{line.size} uncompressed bytes, #{response.size} bytes total, decoder queue bytes:#{decoder.size}"
+		response << line unless @interrupted }
 	    end
-	    break if @interrupted
-	  end
 
-	  return response
+	    while (!socket.eof? and !(line = socket.read_nonblock(2048)).nil?)
+	      logger.debug "read compressed line, #{line.size} bytes"
+	      decoder << line
+	      break response if @interrupted
+	    end
+
+	    logger.debug "EOF detected"
+	    raise ReconnectRequest if @reconnect_requested
+	    return response
+
+	  else
+
+	    response = ""
+
+	    while (!socket.eof? and !(line = socket.readline).nil?)
+	      if block_given? then
+		yield line
+		logger.debug "read #{line.size} bytes"
+	      else
+		logger.debug "read #{line.size} bytes, #{response.size} bytes total"
+		response << line
+	      end
+	      break if @interrupted
+	    end
+
+	    raise ReconnectRequest if @reconnect_requested
+	    return response
+
+	  end
+	end
+      rescue => e
+	return if @interrupted
+	logger.debug "Error Detected: #{e}" unless e.instance_of? ReconnectRequest
+	decoder.close if !decoder.nil?
+	socket.close if !socket.nil? and !socket.closed?
+	opts.delete(:socket)
 
+	if @reconnect_requested then
+	  logger.info "Connection closed. Reconnect requested. Trying..."
+	  @reconnect_count = @reconnect_count + 1
+	  sleep @reconnect_interval
+	  retry if @reconnect_count < @reconnect_attempts
+	  logger.info "Maximum number of failed reconnect attempts reached (#{@reconnect_attempts}). Exiting."
 	end
+	
+	raise e unless e.instance_of? ReconnectRequest
       end
     ensure
       logger.debug "ensure socket closed"
       decoder.close if !decoder.nil?
       socket.close if !socket.nil? and !socket.closed?
+      opts.delete(:socket)
     end
 
     private
@@ -340,6 +386,8 @@ module HttpStreamingClient
 	uri = URI.parse(uri)
       end
 
+      logger.debug "Connecting to #{uri.host}:#{uri.port}..."
+
       @socket = TCPSocket.new(uri.host, uri.port)
 
       if uri.scheme.eql? "https"
@@ -351,6 +399,7 @@ module HttpStreamingClient
 	end
       end
 
+      logger.debug "Connected to #{uri.host}:#{uri.port}"
       opts.merge!({:socket => @socket})
       @interrupted = false
       return opts[:socket]

data/lib/http_streaming_client/decoders/gzip.rb

@@ -105,7 +105,7 @@ module HttpStreamingClient
 
       protected
 
-      class GZipBufferIO
+      class GZipBufferIO < IO
 
 	def logger
 	  HttpStreamingClient.logger

data/lib/http_streaming_client/errors.rb

@@ -29,9 +29,12 @@
 
 module HttpStreamingClient
 
+  
   class InvalidContentType < Exception; end
   
   class InvalidRedirect < Exception; end
+  
+  class ReconnectRequest < StandardError; end
 
   class HttpTimeOut < StandardError; end
 

data/lib/http_streaming_client/version.rb

@@ -28,5 +28,5 @@
 ###########################################################################
 
 module HttpStreamingClient
-  VERSION = "0.8.6"
+  VERSION = "0.8.8"
 end

data/spec/reconnect_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+
+describe HttpStreamingClient do
+
+  # currently disabled, requires a server that can be killed to simulate dropped connections
+
+  it "should receive exactly 10 messages, no reconnect" do
+  #it "should receive exactly 10 messages, no reconnect", :disabled => true do
+  
+    count = 0
+    client = HttpStreamingClient::Client.new(compression: false)
+    response = client.get("http://localhost:3000/outbounds/consumer/1") { |line|
+      logger.debug "line received: #{line}"
+      count = count + 1
+    }
+    expect(response).to be_true
+    expect(count).to be(10)
+  end
+  
+  it "should reconnect on any error or EOF" do
+
+    client = HttpStreamingClient::Client.new(compression: false, reconnect: true, reconnect_attempts: 5, reconnect_interval: 1)
+    count = 0
+    response = client.get("http://localhost:3000/outbounds/consumer/1") { |line|
+      logger.debug "line received: #{line}"
+      count = count + 1
+      client.interrupt if count > 20
+    }
+  end
+
+end

data/spec/spec_helper.rb

@@ -21,6 +21,8 @@ RSpec.configure do |config|
   HttpStreamingClient.logger.level = Logger::DEBUG
   HttpStreamingClient.logger.logfile = true
 
+  config.filter_run_excluding disabled: true
+
 end
 
 def logger

data/tools/adobe_firehose_performance_test.rb

@@ -15,8 +15,8 @@ authorization = HttpStreamingClient::Oauth::Adobe.generate_authorization(url, US
 puts "#{TOKENAPIHOST}:access token: #{authorization}"
 client = HttpStreamingClient::Client.new(compression: false)
 
-NUM_RECORDS_PER_BATCH = 1000
-MAX_RECORDS = 50000
+NUM_RECORDS_PER_BATCH = 5000
+MAX_RECORDS = 3600000
 
 count = 0
 totalSize = 0
@@ -25,6 +25,7 @@ startTime = nil
 lastTime = nil
 
 puts "starting performance test run: #{Time.new.to_s}"
+puts "stream: #{STREAMURL}"
 
 startTime = lastTime = Time.new 
 
@@ -69,6 +70,7 @@ response = client.get(STREAMURL, {:headers => {'Authorization' => "Bearer #{auth
     stats['interval_kbytes_per_sec'] = (intervalSize / intervalElapsedTime / 1024).round(2).to_s
 
     puts stats.to_json
+    STDOUT.flush
 
     lastTime = now
     intervalSize = 0

data/tools/twitter_firehose_performance_test.rb

@@ -24,6 +24,7 @@ startTime = nil
 lastTime = nil
 
 puts "starting performance test run: #{Time.new.to_s}"
+puts "stream: #{url}"
 
 startTime = lastTime = Time.new 
 
@@ -64,6 +65,7 @@ response = client.get(url, {:headers => {'Authorization' => "#{authorization}" }
     stats['interval_kbytes_per_sec'] = (intervalSize / intervalElapsedTime / 1024).round(2).to_s
 
     puts stats.to_json
+    STDOUT.flush
     
     lastTime = now
     intervalSize = 0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: http_streaming_client
 version: !ruby/object:Gem::Version
-  version: 0.8.6
+  version: 0.8.8
 platform: ruby
 authors:
 - David Tompkins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-03 00:00:00.000000000 Z
+date: 2014-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -128,6 +128,7 @@ files:
 - spec/adobe_spec.rb
 - spec/client_spec.rb
 - spec/oauth_spec.rb
+- spec/reconnect_spec.rb
 - spec/spec_helper.rb
 - spec/twitter_spec.rb
 - tools/adobe_firehose.rb
@@ -164,5 +165,6 @@ test_files:
 - spec/adobe_spec.rb
 - spec/client_spec.rb
 - spec/oauth_spec.rb
+- spec/reconnect_spec.rb
 - spec/spec_helper.rb
 - spec/twitter_spec.rb