rpush 5.2.0 → 6.0.1

data/lib/rpush/daemon/apnsp8/delivery.rb

@@ -8,6 +8,7 @@ module Rpush
       class Delivery < Rpush::Daemon::Delivery
         RETRYABLE_CODES = [ 429, 500, 503 ]
         CLIENT_JOIN_TIMEOUT = 60
+        DEFAULT_MAX_CONCURRENT_STREAMS = 100
 
         def initialize(app, http2_client, token_provider, batch)
           @app = app
@@ -85,7 +86,11 @@ module Rpush
         def remote_max_concurrent_streams
           # 0x7fffffff is the default value from http-2 gem (2^31)
           if @client.remote_settings[:settings_max_concurrent_streams] == 0x7fffffff
-            0
+            # Ideally we'd fall back to `#local_settings` here, but `NetHttp2::Client`
+            # doesn't expose that attr from the `HTTP2::Client` it wraps. Instead, we
+            # chose a hard-coded value matching the default local setting from the
+            # `HTTP2::Client` class
+            DEFAULT_MAX_CONCURRENT_STREAMS
           else
             @client.remote_settings[:settings_max_concurrent_streams]
           end
@@ -144,6 +149,7 @@ module Rpush
           headers['apns-priority'] = '10'
           headers['apns-topic'] = @app.bundle_id
           headers['authorization'] = "bearer #{jwt_token}"
+          headers['apns-push-type'] = 'background' if notification.content_available?
 
           headers.merge notification_data(notification)[HTTP2_HEADERS_KEY] || {}
         end

data/lib/rpush/daemon/string_helpers.rb

@@ -2,7 +2,7 @@ module Rpush
   module Daemon
     module StringHelpers
       def pluralize(count, singular, plural = nil)
-        if count == 1 || count =~ /^1(\.0+)?$/
+        if count == 1
           word = singular
         else
           word = plural || singular.pluralize

data/lib/rpush/daemon/webpush/delivery.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "webpush"
+
+module Rpush
+  module Daemon
+    module Webpush
+
+      # Webpush::Request handles all the encryption / signing.
+      # We just override #perform to inject the http instance that is managed
+      # by Rpush.
+      #
+      class Request < ::Webpush::Request
+        def perform(http)
+          req = Net::HTTP::Post.new(uri.request_uri, headers)
+          req.body = body
+          http.request(uri, req)
+        end
+      end
+
+      class Delivery < Rpush::Daemon::Delivery
+
+        OK = [ 200, 201, 202 ].freeze
+        TEMPORARY_FAILURES = [ 429, 500, 502, 503, 504 ].freeze
+
+        def initialize(app, http, notification, batch)
+          @app = app
+          @http = http
+          @notification = notification
+          @batch = batch
+        end
+
+        def perform
+          response = send_request
+          process_response response
+        rescue SocketError, SystemCallError => error
+          mark_retryable(@notification, Time.now + 10.seconds, error)
+          raise
+        rescue StandardError => error
+          mark_failed(error)
+          raise
+        ensure
+          @batch.notification_processed
+        end
+
+        private
+
+        def send_request
+          # The initializer is inherited from Webpush::Request and looks like
+          # this:
+          #
+          # initialize(message: '', subscription:, vapid:, **options)
+          #
+          # where subscription is a hash of :endpoint and :keys, and vapid
+          # holds the vapid public and private keys and the :subject (which is
+          # an email address).
+          Request.new(
+            message: @notification.message,
+            subscription: @notification.subscription,
+            vapid: @app.vapid,
+            ttl: @notification.time_to_live,
+            urgency: @notification.urgency
+          ).perform(@http)
+        end
+
+        def process_response(response)
+          case response.code.to_i
+          when *OK
+            mark_delivered
+          when *TEMPORARY_FAILURES
+            retry_delivery(response)
+          else
+            fail_delivery(response)
+          end
+        end
+
+        def retry_delivery(response)
+          time = deliver_after_header(response)
+          if time
+            mark_retryable(@notification, time)
+          else
+            mark_retryable_exponential(@notification)
+          end
+          log_info("Webpush endpoint responded with a #{response.code} error. #{retry_message}")
+        end
+
+        def fail_delivery(response)
+          fail_message = fail_message(response)
+          log_error("#{@notification.id} failed: #{fail_message}")
+          fail Rpush::DeliveryError.new(response.code.to_i, @notification.id, fail_message)
+        end
+
+        def deliver_after_header(response)
+          Rpush::Daemon::RetryHeaderParser.parse(response.header['retry-after'])
+        end
+
+        def retry_message
+          deliver_after = @notification.deliver_after.strftime('%Y-%m-%d %H:%M:%S')
+          "Notification #{@notification.id} will be retried after #{deliver_after} (retry #{@notification.retries})."
+        end
+
+        def fail_message(response)
+          msg = Rpush::Daemon::HTTP_STATUS_CODES[response.code.to_i]
+          if explanation = response.body.to_s[0..200].presence
+            msg += ": #{explanation}"
+          end
+          msg
+        end
+
+      end
+    end
+  end
+end
+

data/lib/rpush/daemon/webpush.rb

@@ -0,0 +1,10 @@
+module Rpush
+  module Daemon
+    module Webpush
+      extend ServiceConfigMethods
+
+      dispatcher :http
+    end
+  end
+end
+

data/lib/rpush/daemon.rb

@@ -68,6 +68,9 @@ require 'rpush/daemon/adm'
 require 'rpush/daemon/pushy'
 require 'rpush/daemon/pushy/delivery'
 
+require 'rpush/daemon/webpush/delivery'
+require 'rpush/daemon/webpush'
+
 module Rpush
   module Daemon
     class << self

data/lib/rpush/version.rb

@@ -1,8 +1,8 @@
 module Rpush
   module VERSION
-    MAJOR = 5
-    MINOR = 2
-    TINY = 0
+    MAJOR = 6
+    MINOR = 0
+    TINY = 1
     PRE = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".").freeze

data/spec/functional/apns2_spec.rb

@@ -42,6 +42,7 @@ describe 'APNs http2 adapter' do
     app.certificate = TEST_CERT
     app.name = 'test'
     app.environment = 'development'
+    app.bundle_id = 'com.example.app'
     app.save!
     app
   end
@@ -75,7 +76,13 @@ describe 'APNs http2 adapter' do
         :post,
         "/3/device/#{fake_device_token}",
         { body: "{\"aps\":{\"alert\":\"test\",\"sound\":\"default\",\"content-available\":1}}",
-          headers: {} }
+          headers: {
+            'apns-expiration' => '0',
+            'apns-priority' => '10',
+            'apns-topic' => 'com.example.app',
+            'apns-push-type' => 'background'
+          }
+        }
       )
       .and_return(fake_http2_request)
 
@@ -104,7 +111,12 @@ describe 'APNs http2 adapter' do
           "/3/device/#{fake_device_token}",
           { body: "{\"aps\":{\"alert\":\"test\",\"sound\":\"default\","\
                   "\"content-available\":1},\"some_field\":\"some value\"}",
-            headers: { 'apns-topic' => bundle_id }
+            headers: {
+              'apns-topic' => bundle_id,
+              'apns-expiration' => '0',
+              'apns-priority' => '10',
+              'apns-push-type' => 'background'
+            }
           }
         ).and_return(fake_http2_request)
 

data/spec/functional/retry_spec.rb

@@ -39,4 +39,4 @@ describe 'Retries' do
     notification.reload
     expect(notification.delivered).to eq(false)
   end
-end
+end if redis?

data/spec/functional/webpush_spec.rb

@@ -0,0 +1,31 @@
+require 'functional_spec_helper'
+
+describe 'Webpush' do
+  let(:code) { 201 }
+  let(:response) { instance_double('Net::HTTPResponse', code: code, body: '') }
+  let(:http) { instance_double('Net::HTTP::Persistent', request: response, shutdown: nil) }
+  let(:app) { Rpush::Webpush::App.create!(name: 'MyApp', vapid_keypair: VAPID_KEYPAIR) }
+
+  let(:device_reg) {
+    { endpoint: 'https://webpush-provider.example.org/push/some-id',
+      expirationTime: nil,
+      keys: {'auth' => 'DgN9EBia1o057BdhCOGURA', 'p256dh' => 'BAtxJ--7vHq9IVm8utUB3peJ4lpxRqk1rukCIkVJOomS83QkCnrQ4EyYQsSaCRgy_c8XPytgXxuyAvRJdnTPK4A'} }
+  }
+  let(:notification) { Rpush::Webpush::Notification.create!(app: app, registration_ids: [device_reg], data: { message: 'test' }) }
+
+  before do
+    allow(Net::HTTP::Persistent).to receive_messages(new: http)
+  end
+
+  it 'deliveres a notification successfully' do
+    expect { Rpush.push }.to change { notification.reload.delivered }.to(true)
+  end
+
+  context 'when delivery failed' do
+    let(:code) { 404 }
+    it 'marks a notification as failed' do
+      expect { Rpush.push }.to change { notification.reload.failed }.to(true)
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -3,7 +3,7 @@ def client
   (ENV['CLIENT'] || :active_record).to_sym
 end
 
-if !ENV['TRAVIS'] || (ENV['TRAVIS'] && ENV['QUALITY'] == 'true')
+if !ENV['CI'] || (ENV['CI'] && ENV['QUALITY'] == 'true')
   begin
     require './spec/support/simplecov_helper'
     include SimpleCovHelper
@@ -46,6 +46,8 @@ path = File.join(File.dirname(__FILE__), 'support')
 TEST_CERT = File.read(File.join(path, 'cert_without_password.pem'))
 TEST_CERT_WITH_PASSWORD = File.read(File.join(path, 'cert_with_password.pem'))
 
+VAPID_KEYPAIR = Webpush.generate_key.to_hash.merge(subject: 'rpush-test@example.org').to_json
+
 def after_example_cleanup
   Rpush.logger = nil
   Rpush::Daemon.store = nil

data/spec/support/active_record_setup.rb

@@ -6,14 +6,15 @@ SPEC_ADAPTER = ENV['ADAPTER'] || 'postgresql'
 SPEC_ADAPTER = 'jdbc' + SPEC_ADAPTER if jruby
 
 require 'yaml'
-db_config = YAML.load_file(File.expand_path("config/database.yml", File.dirname(__FILE__)))
+db_config_path = File.expand_path("config/database.yml", File.dirname(__FILE__))
+db_config = YAML.load(ERB.new(File.read(db_config_path)).result)
 
 if db_config[SPEC_ADAPTER].nil?
   puts "No such adapter '#{SPEC_ADAPTER}'. Valid adapters are #{db_config.keys.join(', ')}."
   exit 1
 end
 
-if ENV['TRAVIS']
+if ENV['CI']
   db_config[SPEC_ADAPTER]['username'] = 'postgres'
 else
   require 'etc'
@@ -62,7 +63,7 @@ migrations = [
   Rpush420Updates
 ]
 
-unless ENV['TRAVIS']
+unless ENV['CI']
   migrations.reverse_each do |m|
     begin
       m.down

data/spec/support/config/database.yml

@@ -2,10 +2,10 @@
 
 postgresql:
   adapter: postgresql
-  database: rpush_test
-  host: localhost
-  username: postgres
-  password: ""
+  database: <%= ENV.fetch('POSTGRES_DB', 'rpush_test') %>
+  host: <%= ENV.fetch('POSTGRES_HOST', 'localhost') %>
+  username: <%= ENV.fetch('POSTGRES_USER', 'postgres') %>
+  password: <%= ENV.fetch('PGPASSWORD', '') %>
 
 jdbcpostgresql:
   adapter: jdbcpostgresql

data/spec/support/simplecov_helper.rb

@@ -10,7 +10,7 @@ module SimpleCovHelper
 
       formatters = [SimpleCov::Formatter::QualityFormatter]
 
-      if ENV['TRAVIS']
+      if ENV['CI']
         require 'codeclimate-test-reporter'
 
         if CodeClimate::TestReporter.run?

data/spec/unit/client/active_record/apns/notification_spec.rb

@@ -8,7 +8,7 @@ describe Rpush::Client::ActiveRecord::Apns::Notification do
 
   it "should validate the length of the binary conversion of the notification" do
     notification = described_class.new
-    notification.app = Rpush::Apns2::App.create(name: 'test', environment: 'development')
+    notification.app = Rpush::Apns2::App.create(name: 'test', environment: 'development', certificate: TEST_CERT)
     notification.device_token = "a" * 108
     notification.alert = ""
 

data/spec/unit/client/active_record/apns2/app_spec.rb

@@ -1,4 +1,5 @@
 require 'unit_spec_helper'
 
 describe Rpush::Client::ActiveRecord::Apns2::App do
+  it_behaves_like 'Rpush::Client::Apns::App'
 end if active_record?

data/spec/unit/client/active_record/apns2/notification_spec.rb

@@ -8,7 +8,7 @@ describe Rpush::Client::ActiveRecord::Apns2::Notification do
 
   it "should validate the length of the binary conversion of the notification" do
     notification = described_class.new
-    notification.app = Rpush::Apns2::App.create(name: 'test', environment: 'development')
+    notification.app = Rpush::Apns2::App.create(name: 'test', environment: 'development', certificate: TEST_CERT)
     notification.device_token = "a" * 108
     notification.alert = ""
 

data/spec/unit/client/active_record/apnsp8/notification_spec.rb

@@ -0,0 +1,28 @@
+require "unit_spec_helper"
+
+describe Rpush::Client::ActiveRecord::Apnsp8::Notification do
+  subject(:notification) { described_class.new }
+
+  it_behaves_like 'Rpush::Client::Apns::Notification'
+  it_behaves_like 'Rpush::Client::ActiveRecord::Notification'
+
+  it "should validate the length of the binary conversion of the notification", :aggregate_failures do
+    notification = described_class.new
+    notification.app = Rpush::Apnsp8::App.create(apn_key: "1",
+                                                 apn_key_id: "2",
+                                                 name: 'test',
+                                                 environment: 'development',
+                                                 team_id: "3",
+                                                 bundle_id: "4")
+    notification.device_token = "a" * 108
+    notification.alert = ""
+
+    notification.alert << "a" until notification.payload.bytesize == 4096
+    expect(notification.valid?).to be_truthy
+    expect(notification.errors[:base]).to be_empty
+
+    notification.alert << "a"
+    expect(notification.valid?).to be_falsey
+    expect(notification.errors[:base].include?("APN notification cannot be larger than 4096 bytes. Try condensing your alert and device attributes.")).to be_truthy
+  end
+end if active_record?

data/spec/unit/client/active_record/webpush/app_spec.rb

@@ -0,0 +1,6 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::ActiveRecord::Webpush::App do
+  it_behaves_like 'Rpush::Client::Webpush::App'
+  it_behaves_like 'Rpush::Client::ActiveRecord::App'
+end if active_record?

data/spec/unit/client/active_record/webpush/notification_spec.rb

@@ -0,0 +1,6 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::ActiveRecord::Webpush::Notification do
+  it_behaves_like 'Rpush::Client::Webpush::Notification'
+  it_behaves_like 'Rpush::Client::ActiveRecord::Notification'
+end if active_record?

data/spec/unit/client/redis/apns/notification_spec.rb

@@ -7,7 +7,7 @@ describe Rpush::Client::Redis::Apns::Notification do
 
   it "should validate the length of the binary conversion of the notification" do
     notification = described_class.new
-    notification.app = Rpush::Apns2::App.create(name: 'test', environment: 'development')
+    notification.app = Rpush::Apns2::App.create(name: 'test', environment: 'development', certificate: TEST_CERT)
     notification.device_token = "a" * 108
     notification.alert = ""
 

data/spec/unit/client/redis/apns2/notification_spec.rb

@@ -7,7 +7,7 @@ describe Rpush::Client::Redis::Apns2::Notification do
 
   it "should validate the length of the binary conversion of the notification" do
     notification = described_class.new
-    notification.app = Rpush::Apns2::App.create(name: 'test', environment: 'development')
+    notification.app = Rpush::Apns2::App.create(name: 'test', environment: 'development', certificate: TEST_CERT)
     notification.device_token = "a" * 108
     notification.alert = ""
 

data/spec/unit/client/redis/apnsp8/notification_spec.rb

@@ -0,0 +1,29 @@
+require "unit_spec_helper"
+
+describe Rpush::Client::Redis::Apnsp8::Notification do
+  after do
+    Rpush::Apnsp8::App.all.select { |a| a.environment == "development" && a.apn_key == "1" }.each(&:destroy)
+  end
+
+  it_behaves_like "Rpush::Client::Apns::Notification"
+
+  it "should validate the length of the binary conversion of the notification", :aggregate_failures do
+    notification = described_class.new
+    notification.app = Rpush::Apnsp8::App.create(apn_key: "1",
+                                                 apn_key_id: "2",
+                                                 name: 'test',
+                                                 environment: 'development',
+                                                 team_id: "3",
+                                                 bundle_id: "4")
+    notification.device_token = "a" * 108
+    notification.alert = ""
+
+    notification.alert << "a" until notification.payload.bytesize == 4096
+    expect(notification.valid?).to be_truthy
+    expect(notification.errors[:base]).to be_empty
+
+    notification.alert << "a"
+    expect(notification.valid?).to be_falsey
+    expect(notification.errors[:base].include?("APN notification cannot be larger than 4096 bytes. Try condensing your alert and device attributes.")).to be_truthy
+  end
+end if redis?

data/spec/unit/client/redis/webpush/app_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Webpush::App do
+  it_behaves_like 'Rpush::Client::Webpush::App'
+end if redis?

data/spec/unit/client/redis/webpush/notification_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Webpush::Notification do
+  it_behaves_like 'Rpush::Client::Webpush::Notification'
+end if redis?

data/spec/unit/client/shared/apns/notification.rb

@@ -165,6 +165,21 @@ shared_examples 'Rpush::Client::Apns::Notification' do
     end
   end
 
+  describe 'content_available?' do
+    context 'if not set' do
+      it 'should be false' do
+        expect(notification.content_available?).to be_falsey
+      end
+    end
+
+    context 'if set' do
+      it 'should be true' do
+        notification.content_available = true
+        expect(notification.content_available?).to be_truthy
+      end
+    end
+  end
+
   describe 'url-args' do
     it 'includes url-args in the payload' do
       notification.url_args = ['url-arg-1']

data/spec/unit/client/shared/webpush/app.rb

@@ -0,0 +1,33 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Webpush::App' do
+  describe 'validates' do
+    subject { described_class.new }
+
+    it 'validates presence of name' do
+      is_expected.not_to be_valid
+      expect(subject.errors[:name]).to eq ["can't be blank"]
+    end
+
+    it 'validates presence of vapid_keypair' do
+      is_expected.not_to be_valid
+      expect(subject.errors[:vapid_keypair]).to eq ["can't be blank"]
+    end
+
+    it 'should require the vapid keypair to have subject, public and private key' do
+      subject.vapid_keypair = {}.to_json
+      is_expected.not_to be_valid
+      expect(subject.errors[:vapid_keypair].sort).to eq [
+        'must have a private_key entry',
+        'must have a public_key entry',
+        'must have a subject entry',
+      ]
+    end
+
+    it 'should require valid json for the keypair' do
+      subject.vapid_keypair = 'invalid'
+      is_expected.not_to be_valid
+      expect(subject.errors[:vapid_keypair].sort).to eq [ 'must be valid JSON' ]
+    end
+  end
+end

data/spec/unit/client/shared/webpush/notification.rb

@@ -0,0 +1,83 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Webpush::Notification' do
+  subject(:notification) { described_class.new }
+
+  describe 'notification attributes' do
+    describe 'data' do
+      subject { described_class.new(data: { message: 'test', urgency: 'normal' } ) }
+      it 'has a message' do
+        expect(subject.message).to eq "test"
+      end
+      it 'has an urgency' do
+        expect(subject.urgency).to eq "normal"
+      end
+    end
+
+    describe 'subscription' do
+      let(:subscription){ { endpoint: 'https://push.example.org/foo', keys: {'foo' => 'bar'}} }
+      subject { described_class.new(registration_ids: [subscription]) }
+
+      it "has a subscription" do
+        expect(subject.subscription).to eq({ endpoint: 'https://push.example.org/foo', keys: {foo: 'bar'} })
+      end
+    end
+  end
+
+
+  describe 'validates' do
+    let(:app) { Rpush::Webpush::App.create!(name: 'MyApp', vapid_keypair: VAPID_KEYPAIR) }
+
+    describe 'data' do
+      subject { described_class.new(app: app, registration_ids: [{endpoint: 'https://push.example.org/foo', keys: {'foo' => 'bar'}}]) }
+      it 'validates presence' do
+        is_expected.not_to be_valid
+        expect(subject.errors[:data]).to eq ["can't be blank"]
+      end
+
+      it "has a 'data' payload limit of 4096 bytes" do
+        subject.data = { message: 'a' * 4096 }
+        is_expected.not_to be_valid
+        expected_errors = ["Notification payload data cannot be larger than 4096 bytes."]
+        expect(subject.errors[:base]).to eq expected_errors
+      end
+    end
+
+    describe 'registration_ids' do
+      subject { described_class.new(app: app, data: { message: 'test' }) }
+      it 'validates presence' do
+        is_expected.not_to be_valid
+        expect(subject.errors[:registration_ids]).to eq ["can't be blank"]
+      end
+
+      it 'limits the number of registration ids to exactly 1' do
+        subject.registration_ids = [{endpoint: 'string', keys: { 'a' => 'hash' }}] * 2
+        is_expected.not_to be_valid
+        expected_errors = ["Number of registration_ids cannot be larger than 1."]
+        expect(subject.errors[:base]).to eq expected_errors
+      end
+
+      it 'validates the structure of the registration' do
+        subject.registration_ids = ['a']
+        is_expected.not_to be_valid
+        expect(subject.errors[:base]).to eq [
+          "Registration must have :endpoint (String) and :keys (Hash) keys"
+        ]
+
+        subject.registration_ids = [{endpoint: 'string', keys: { 'a' => 'hash' }}]
+        is_expected.to be_valid
+      end
+    end
+
+    describe 'time_to_live' do
+      subject { described_class.new(app: app, data: { message: 'test' }, registration_ids: [{endpoint: 'https://push.example.org/foo', keys: {'foo' => 'bar'}}]) }
+
+      it 'should be > 0' do
+        subject.time_to_live = -1
+        is_expected.not_to be_valid
+        expect(subject.errors[:time_to_live]).to eq ['must be greater than 0']
+      end
+    end
+
+  end
+end

data/spec/unit/daemon/apnsp8/delivery_spec.rb

@@ -0,0 +1,53 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Apnsp8::Delivery do
+  subject(:delivery) { described_class.new(app, http2_client, token_provider, batch) }
+
+  let(:app) { double(bundle_id: 'MY BUNDLE ID') }
+  let(:notification1) { double('Notification 1', data: {}, as_json: {}).as_null_object }
+  let(:notification2) { double('Notification 2', data: {}, as_json: {}).as_null_object }
+
+  let(:token_provider) { double(token: 'MY JWT TOKEN') }
+  let(:max_concurrent_streams) { 100 }
+  let(:remote_settings) { { settings_max_concurrent_streams: max_concurrent_streams } }
+  let(:http_request) { double(on: nil) }
+  let(:http2_client) do
+    double(
+      stream_count: 0,
+      call_async: nil,
+      join: nil,
+      prepare_request: http_request,
+      remote_settings: remote_settings
+    )
+  end
+
+  let(:batch) { double(mark_delivered: nil, all_processed: nil) }
+  let(:logger) { double(info: nil) }
+
+  before do
+    allow(batch).to receive(:each_notification) do |&blk|
+      [notification1, notification2].each(&blk)
+    end
+    allow(Rpush).to receive_messages(logger: logger)
+  end
+
+  describe '#perform' do
+    context 'with an HTTP2 client where max concurrent streams is not set' do
+      let(:max_concurrent_streams) { 0x7fffffff }
+
+      it 'does not fall into an infinite loop on notifications after the first' do
+        start = Time.now
+        thread = Thread.new { delivery.perform }
+
+        loop do
+          break unless thread.alive?
+
+          if Time.now - start > 0.5
+            thread.kill
+            fail 'Stuck in an infinite loop'
+          end
+        end
+      end
+    end
+  end
+end