httpray 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 40bd4048bb72f0169b178246b13b20f86504eba4
+  data.tar.gz: 28642af4d6aeb959c948d24e6fb122e17cccb197
+SHA512:
+  metadata.gz: 5ea297d70ed2aaf3acf4dda9ad65248a0158a49340d509394c3ce7631497486ad930a035ad43a9b0686e26a6edae6886a20b36fa0828cbfdf7c37682bbb3bc3f
+  data.tar.gz: bb5d0f9279feeb73b69d2a13eb54ad0516ef7ff8bef36437a701761176cd66dec66c286daac11184e795bb747a0534e001a13335446f7dab6a1495cfd2b2d522

data/.gitignore

@@ -0,0 +1,54 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# vim temp files
+*.swp
+*.un~

data/.tool-versions

@@ -0,0 +1 @@
+ruby 2.1.5

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,18 @@
+PATH
+  remote: .
+  specs:
+    HTTPray (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  HTTPray!
+  bundler (>= 1.2)
+
+BUNDLED WITH
+   1.13.6

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 G Gordon Worley III
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+# httpray
+Non-blocking HTTP library for Ruby
+
+[![Gem Version](https://badge.fury.io/rb/HTTPray.svg)](https://badge.fury.io/rb/HTTPray)
+
+Started out the same as the [fire-and-forget](https://github.com/mattetti/fire-and-forget) gem but with a more exposed interface, TLS support, and a better name. Added ideas from [tcp_timeout](https://github.com/lann/tcp-timeout-ruby) and accidentally ended up creating a light-weight, non-blocking HTTP client.
+
+It differs from other Ruby HTTP libraries that support async because it doesn't use Threads, making HTTPray much less resource intensive to use since it instead directly implements HTTP/HTTPS 1.0 using `Socket` and `IO#select` for timeouts. You can optionally ask to be handed back the socket before it is closed in case you want to listen for a response, but that's not really what you're here for, and it creates a Fiber.
+
+Great for use with sending data to HTTP endpoints for which you are willing to accept a UDP-style best-effort approach, but with the added guarantee of TCP that the packets made it to the server. Only the server will know what it did with the data, though!
+
+## Install
+
+```ruby
+gem "httpray"
+```
+
+## Use
+
+```ruby
+require 'httpray'
+
+# def HTTParty.request!(method, uri, headers = {}, body = "", timeout = 1, ssl_context = nil)
+
+# send an HTTP request and don't listen for the response
+HTTPray.request(
+  "POST",
+  "https://your.diety/prayers",
+  {"Content-Type" => "application/prayer"},
+  "It's me, Margret",
+  1) # timeout in seconds
+
+# party with a response
+HTTPray.request("GET", "https://your.diety/answered_prayers") do |socket|
+  socket.gets
+end
+
+# party dangerously (you have to close your own socket!)
+socket = HTTPray.request!("GET", "https://your.diety/answered_prayers")
+puts socket.gets
+socket.close
+```
+
+## Help
+
+HTTPray has minimal convenience and sanitization features because I didn't need them. All that it does is fill in the Host, User-Agent, Accept, and Content-Length headers for you. The body must be a string, so convert it yourself first. The URI can be a `URI` or a `String` that will go through `URI.parse`. You're welcome. You can also pass an `OpenSSL::SSL::SSLContext` if you want more control over how TLS is used, but if you don't provide one it will be created for you if needed.
+
+Timeout support does not extend to the response since you just get back a `Socket`. You're own your own for how you want to handle that.
+
+If you want it to be easier to use, feel free to submit pull requests. As long as you don't break existing functionality I will probably accept them.
+
+## Tests
+
+There are some tests that exercise the code paths. You can run them with:
+
+```bash
+ruby -I . test/httparty_test.rb
+```
+
+Unfortunately they have to hit real network endpoints, so they won't work without a network.

data/httpray.gemspec

@@ -0,0 +1,21 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'httpray/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "httpray"
+  spec.version       = HTTPray::VERSION
+  spec.authors       = ["G Gordon Worley III"]
+  spec.email         = ["gworley3@gmail.com"]
+  spec.description   = %q{Fire-and-forget HTTP requests for Ruby}
+  spec.summary       = %q{Like UDP but for HTTP over TCP}
+  spec.homepage      = "https://github.com/gworley3/httpray"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.post_install_message = "HTT🙏  for mercy"
+end

data/lib/httpray/version.rb

@@ -0,0 +1,3 @@
+module HTTPray
+  VERSION = "1.0.2".freeze
+end

data/lib/httpray.rb

@@ -0,0 +1,76 @@
+require 'uri'
+require 'openssl'
+require 'socket'
+
+require_relative 'httpray/version'
+
+module HTTPray
+  class Timeout < StandardError; end
+
+  DEFAULT_HEADERS = {
+    "User-Agent" => "HTTPray #{VERSION}",
+    "Accept" => "*/*"
+  }.freeze
+
+  def self.request2!(method, uri, headers = {}, body = "", timeout = 1, ssl_context = nil)
+    uri = URI.parse(uri) unless URI === uri
+    address = Socket.getaddrinfo(uri.host, nil, Socket::AF_INET).first[3]
+    socket_address = Socket.pack_sockaddr_in(uri.port, address)
+
+    socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+    socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
+    begin
+      socket.connect_nonblock(socket_address)
+    rescue Errno::EINPROGRESS
+      if IO.select(nil, [socket], [socket], timeout)
+        begin
+          socket.connect_nonblock(socket_address)
+        rescue Errno::EISCONN
+          # connected
+        end
+      else
+        raise Timeout
+      end
+    end
+
+    original_socket = socket
+    if uri.scheme == "https"
+      ssl_context ||= OpenSSL::SSL::SSLContext.new
+      socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
+      socket.hostname = uri.host
+      socket.sync_close = true
+      socket.connect
+    end
+
+    headers = DEFAULT_HEADERS.merge(headers).merge(
+      "Host" => uri.host,
+      "Content-Length" => body.bytesize)
+
+    if IO.select(nil, [socket], [socket], 1)
+      socket.puts "#{method} #{uri.request_uri} HTTP/1.0\r\n"
+      headers.each do |header, value|
+        socket.puts "#{header}: #{value}\r\n"
+      end
+      socket.puts "\r\n"
+      socket.puts body
+
+      yield(socket) if block_given?
+    else
+      raise Timeout
+    end
+    return socket, original_socket
+  end
+
+  def self.request!(*args)
+    socket, _ = request2!(*args)
+    socket
+  end
+
+  def self.request(*args)
+    socket = request!(*args)
+    yield(socket) if block_given?
+  ensure
+    socket.close if socket && !socket.closed?
+  end
+end

data/test/httpray_test.rb

@@ -0,0 +1,56 @@
+require 'minitest/autorun'
+require 'lib/httpray'
+
+class HTTPrayTest < MiniTest::Unit::TestCase
+  def test_request_timesout_with_bad_address
+    assert_raises HTTPray::Timeout do
+      HTTPray.request("GET", "httppppp://httpbin.org/status/200")
+    end
+  end
+  def test_request_sends
+    HTTPray.request("GET", "http://httpbin.org/get")
+    assert true
+  end
+  def test_request_receives_response
+    HTTPray.request("GET", "http://httpbin.org/status/200") do |socket|
+      assert_equal "HTTP/1.1 200 OK\r\n", socket.gets
+    end
+  end
+  def test_secure_request_sends
+    HTTPray.request("GET", "https://httpbin.org/get")
+    assert true
+  end
+  def test_all_options_accepted
+    HTTPray.request(
+      "POST",
+      "https://httpbin.org/post",
+      {"Content-Type" => "application/x-www-form-urlencoded"},
+      "q=httpray",
+      5,
+      OpenSSL::SSL::SSLContext.new) do |socket|
+        assert_equal "HTTP/1.1 200 OK\r\n", socket.gets
+      end
+  end
+  def test_original_socket_closed_with_ssl
+    socket, original_socket = HTTPray.request2!(
+      "GET",
+      "https://httpbin.org/delay/10")
+    refute_same socket, original_socket
+    refute socket.closed?
+    refute original_socket.closed?
+    socket.close
+    assert socket.closed?
+    assert original_socket.closed?
+  end
+  def test_original_socket_closed_without_ssl
+    socket, original_socket = HTTPray.request2!(
+      "GET",
+      "http://httpbin.org/delay/10")
+    assert_same socket, original_socket
+    refute socket.closed?
+    refute original_socket.closed?
+    socket.close
+    assert socket.closed?
+    assert original_socket.closed?
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: httpray
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+platform: ruby
+authors:
+- G Gordon Worley III
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-14 00:00:00.000000000 Z
+dependencies: []
+description: Fire-and-forget HTTP requests for Ruby
+email:
+- gworley3@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".tool-versions"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- httpray.gemspec
+- lib/httpray.rb
+- lib/httpray/version.rb
+- test/httpray_test.rb
+homepage: https://github.com/gworley3/httpray
+licenses:
+- MIT
+metadata: {}
+post_install_message: "HTT\U0001F64F  for mercy"
+rdoc_options: []
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Like UDP but for HTTP over TCP
+test_files:
+- test/httpray_test.rb