serve_byte_range 1.0.0 → 1.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/.github/workflows/ci.yml +31 -7
- data/.gitignore +3 -2
- data/.standard.yml +4 -0
- data/README.md +58 -0
- data/Rakefile +19 -6
- data/Steepfile +10 -0
- data/gemfiles/rack_2.gemfile +5 -0
- data/gemfiles/rack_3.gemfile +5 -0
- data/gemfiles/typecheck.gemfile +7 -0
- data/lib/serve_byte_range/sequence.rb +152 -0
- data/lib/serve_byte_range/version.rb +5 -1
- data/lib/serve_byte_range.rb +222 -43
- data/serve_byte_range.gemspec +9 -4
- data/sig/serve_byte_range/sequence.rbs +91 -0
- data/sig/serve_byte_range/version.rbs +5 -0
- data/sig/serve_byte_range.rbs +256 -0
- data/sig_shims/rack.rbs +9 -0
- data/test/byte_comparator_test.rb +46 -0
- data/test/range_server_test.rb +123 -6
- data/test/sequence_test.rb +224 -0
- data/test/support/byte_comparator.rb +47 -0
- data/test/support/bytes_assertions.rb +10 -0
- metadata +36 -48
- data/rbi/serve_byte_range.rbi +0 -208
|
@@ -0,0 +1,224 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require "bundler"
|
|
4
|
+
Bundler.setup
|
|
5
|
+
|
|
6
|
+
require_relative "../lib/serve_byte_range"
|
|
7
|
+
require "minitest"
|
|
8
|
+
require "minitest/autorun"
|
|
9
|
+
require_relative "support/bytes_assertions"
|
|
10
|
+
require "stringio"
|
|
11
|
+
|
|
12
|
+
class SequenceTest < Minitest::Test
|
|
13
|
+
include BytesAssertions
|
|
14
|
+
|
|
15
|
+
# Stands in for an object in remote storage which supports ranged GETs
|
|
16
|
+
RemoteObject = Struct.new(:bytes) do
|
|
17
|
+
def size
|
|
18
|
+
bytes.bytesize
|
|
19
|
+
end
|
|
20
|
+
|
|
21
|
+
def get_range(range)
|
|
22
|
+
bytes.byteslice(range)
|
|
23
|
+
end
|
|
24
|
+
end
|
|
25
|
+
|
|
26
|
+
def fetch(segment, range_in_segment)
|
|
27
|
+
(segment.is_a?(String) ? segment.byteslice(range_in_segment) : segment.get_range(range_in_segment)).b
|
|
28
|
+
end
|
|
29
|
+
|
|
30
|
+
def build_sequence_and_expected_bytes
|
|
31
|
+
rng = Random.new(Minitest.seed)
|
|
32
|
+
remote = RemoteObject.new(rng.bytes(200))
|
|
33
|
+
inner = ServeByteRange::Sequence.new("«inner — ✂»").add_segment(RemoteObject.new(rng.bytes(7)), size: 7, etag: "inner-v1")
|
|
34
|
+
|
|
35
|
+
seq = ServeByteRange::Sequence.new
|
|
36
|
+
seq.add_segment(remote, size: remote.size, etag: "v1")
|
|
37
|
+
seq << "«redacted — ✂»\n"
|
|
38
|
+
seq << ""
|
|
39
|
+
seq << inner
|
|
40
|
+
seq.add_segment(RemoteObject.new(rng.bytes(3)), size: 3, etag: "tail-v1")
|
|
41
|
+
|
|
42
|
+
expected = remote.bytes + "«redacted — ✂»\n".b + inner.each_in_range(0..(inner.size - 1)).map { |s, r| fetch(s, r) }.join.b
|
|
43
|
+
seq.each_in_range((seq.size - 3)..(seq.size - 1)) { |s, r| expected << fetch(s, r) }
|
|
44
|
+
[seq, expected]
|
|
45
|
+
end
|
|
46
|
+
|
|
47
|
+
def test_size_and_each_in_range_cover_every_byte
|
|
48
|
+
seq, expected = build_sequence_and_expected_bytes
|
|
49
|
+
assert_equal expected.bytesize, seq.size
|
|
50
|
+
|
|
51
|
+
rng = Random.new(Minitest.seed)
|
|
52
|
+
ranges = [0..0, 0..(seq.size - 1), 195..215, 199..200, (seq.size - 1)..(seq.size - 1)]
|
|
53
|
+
50.times do
|
|
54
|
+
a, b = [rng.rand(seq.size), rng.rand(seq.size)].sort
|
|
55
|
+
ranges << (a..b)
|
|
56
|
+
end
|
|
57
|
+
|
|
58
|
+
ranges.each do |range|
|
|
59
|
+
out = +"".b
|
|
60
|
+
seq.each_in_range(range) { |segment, range_in_segment| out << fetch(segment, range_in_segment) }
|
|
61
|
+
assert_same_bytes expected.byteslice(range), out, "Mismatch for #{range}"
|
|
62
|
+
end
|
|
63
|
+
end
|
|
64
|
+
|
|
65
|
+
def test_each_in_range_yields_leaf_segments_with_ranges_inside_them
|
|
66
|
+
seq = ServeByteRange::Sequence.new("abc", ServeByteRange::Sequence.new("de", "fgh"), "ij")
|
|
67
|
+
assert_equal [["abc", 2..2], ["de", 0..1], ["fgh", 0..0]], seq.each_in_range(2..5).to_a
|
|
68
|
+
assert_equal [["fgh", 2..2], ["ij", 0..1]], seq.each_in_range(7..9).to_a
|
|
69
|
+
assert_equal [], seq.each_in_range(10..12).to_a
|
|
70
|
+
assert_equal [], ServeByteRange::Sequence.new.each_in_range(0..1).to_a
|
|
71
|
+
end
|
|
72
|
+
|
|
73
|
+
def test_add_segment_skips_empty_segments_and_refuses_bad_sizes
|
|
74
|
+
seq = ServeByteRange::Sequence.new
|
|
75
|
+
seq.add_segment(:nothing, size: 0)
|
|
76
|
+
assert_equal 0, seq.size
|
|
77
|
+
assert_raises(ArgumentError) { seq.add_segment(:x, size: -1) }
|
|
78
|
+
assert_raises(ArgumentError) { seq.add_segment(:x, size: "1") }
|
|
79
|
+
end
|
|
80
|
+
|
|
81
|
+
def test_etag_changes_when_a_segment_does
|
|
82
|
+
a = ServeByteRange::Sequence.new("abc", "def")
|
|
83
|
+
b = ServeByteRange::Sequence.new("abc", "deF")
|
|
84
|
+
assert_match(/\A"[0-9a-f]{40}"\z/, a.etag)
|
|
85
|
+
assert_equal a.etag, ServeByteRange::Sequence.new("abc", "def").etag
|
|
86
|
+
refute_equal a.etag, b.etag
|
|
87
|
+
refute_equal ServeByteRange::Sequence.new("ab", "c").etag, ServeByteRange::Sequence.new("a", "bc").etag
|
|
88
|
+
|
|
89
|
+
nested_a = ServeByteRange::Sequence.new("x", a)
|
|
90
|
+
nested_b = ServeByteRange::Sequence.new("x", b)
|
|
91
|
+
refute_equal nested_a.etag, nested_b.etag
|
|
92
|
+
end
|
|
93
|
+
|
|
94
|
+
def test_serve_sequence_serves_whole_body_single_and_multiple_ranges
|
|
95
|
+
seq, expected = build_sequence_and_expected_bytes
|
|
96
|
+
serve = ->(env) { ServeByteRange.serve_sequence(env, seq, multipart_boundary: "azuleju") { |segment, r, io| io.write(fetch(segment, r)) } }
|
|
97
|
+
read = ->(body) { StringIO.new.binmode.tap { |out| body.each { |chunk| out.write(chunk) } }.string }
|
|
98
|
+
|
|
99
|
+
status, headers, body = serve.call({})
|
|
100
|
+
assert_equal 200, status
|
|
101
|
+
assert_equal seq.etag, headers["ETag"]
|
|
102
|
+
assert_equal expected.bytesize.to_s, headers["Content-Length"]
|
|
103
|
+
assert_same_bytes expected, read.call(body)
|
|
104
|
+
|
|
105
|
+
status, headers, body = serve.call("HTTP_RANGE" => "bytes=195-215")
|
|
106
|
+
assert_equal 206, status
|
|
107
|
+
assert_equal "bytes 195-215/#{seq.size}", headers["Content-Range"]
|
|
108
|
+
assert_same_bytes expected.byteslice(195..215), read.call(body)
|
|
109
|
+
|
|
110
|
+
status, headers, body = serve.call("HTTP_RANGE" => "bytes=0-3,201-204", "HTTP_IF_RANGE" => seq.etag)
|
|
111
|
+
assert_equal 206, status
|
|
112
|
+
output = read.call(body)
|
|
113
|
+
assert_equal headers["Content-Length"].to_i, output.bytesize
|
|
114
|
+
assert_includes output, expected.byteslice(0..3)
|
|
115
|
+
assert_includes output, expected.byteslice(201..204)
|
|
116
|
+
|
|
117
|
+
status, _, _ = serve.call("HTTP_IF_NONE_MATCH" => seq.etag)
|
|
118
|
+
assert_equal 304, status
|
|
119
|
+
end
|
|
120
|
+
|
|
121
|
+
def test_serve_sequence_complains_about_the_segment_which_wrote_the_wrong_amount
|
|
122
|
+
seq = ServeByteRange::Sequence.new("abc", "def")
|
|
123
|
+
_, _, body = ServeByteRange.serve_sequence({}, seq) { |segment, r, io| io.write(segment[r]) unless segment == "def" }
|
|
124
|
+
error = assert_raises(RuntimeError) { body.each {} }
|
|
125
|
+
assert_includes error.message, "segment (String, bytes 0-2 of it) requires 3 bytes"
|
|
126
|
+
|
|
127
|
+
_, _, body = ServeByteRange.serve_sequence({}, seq) { |segment, r, io| io.write(segment + "!") }
|
|
128
|
+
error = assert_raises(RuntimeError) { body.each {} }
|
|
129
|
+
assert_includes error.message, "the limit for this segment (String, bytes 0-2 of it) is 3"
|
|
130
|
+
end
|
|
131
|
+
|
|
132
|
+
def test_etag_is_weak_unless_every_segment_has_an_etag
|
|
133
|
+
assert ServeByteRange::Sequence.new("abc").strong_etag?
|
|
134
|
+
assert_match(/\A"[0-9a-f]{40}"\z/, ServeByteRange::Sequence.new("abc").etag)
|
|
135
|
+
|
|
136
|
+
seq = ServeByteRange::Sequence.new("abc").add_segment(:remote, size: 10, etag: "v1")
|
|
137
|
+
assert seq.strong_etag?
|
|
138
|
+
|
|
139
|
+
seq.add_segment(:other_remote, size: 10)
|
|
140
|
+
refute seq.strong_etag?
|
|
141
|
+
assert_match(/\AW\/"[0-9a-f]{40}"\z/, seq.etag)
|
|
142
|
+
|
|
143
|
+
refute ServeByteRange::Sequence.new("x", seq).strong_etag? # weakness carries over from nested sequences
|
|
144
|
+
end
|
|
145
|
+
|
|
146
|
+
def test_serves_range_regardless_of_if_range_when_etag_is_weak
|
|
147
|
+
seq = ServeByteRange::Sequence.new.add_segment("abcdef", size: 6)
|
|
148
|
+
env = {"HTTP_RANGE" => "bytes=0-1", "HTTP_IF_RANGE" => seq.etag}
|
|
149
|
+
status, headers, _ = ServeByteRange.serve_sequence(env, seq) { |segment, r, io| io.write(segment[r]) }
|
|
150
|
+
assert_equal 200, status # a weak validator can not be used for If-Range
|
|
151
|
+
assert_equal seq.etag, headers["ETag"]
|
|
152
|
+
|
|
153
|
+
status, _, _ = ServeByteRange.serve_sequence({"HTTP_IF_NONE_MATCH" => seq.etag}, seq) { |segment, r, io| io.write(segment[r]) }
|
|
154
|
+
assert_equal 304, status
|
|
155
|
+
end
|
|
156
|
+
|
|
157
|
+
def test_etag_includes_segment_sizes
|
|
158
|
+
a = ServeByteRange::Sequence.new.add_segment(:obj, size: 10, etag: "v1")
|
|
159
|
+
b = ServeByteRange::Sequence.new.add_segment(:obj, size: 20, etag: "v1")
|
|
160
|
+
refute_equal a.etag, b.etag
|
|
161
|
+
end
|
|
162
|
+
|
|
163
|
+
def test_etag_changes_when_segments_are_added_after_it_was_computed
|
|
164
|
+
seq = ServeByteRange::Sequence.new("abc")
|
|
165
|
+
etag_before = seq.etag
|
|
166
|
+
seq << "def"
|
|
167
|
+
refute_equal etag_before, seq.etag
|
|
168
|
+
assert_same seq.etag, seq.etag
|
|
169
|
+
end
|
|
170
|
+
|
|
171
|
+
def test_append_only_takes_objects_it_can_size_in_bytes
|
|
172
|
+
seq = ServeByteRange::Sequence.new
|
|
173
|
+
seq << StringIO.new("abcdef")
|
|
174
|
+
seq << Struct.new(:bytesize).new(4)
|
|
175
|
+
assert_equal 10, seq.size
|
|
176
|
+
|
|
177
|
+
[["aaa", "bbb"], {k: "v"}, 42, :sym].each do |unsizeable|
|
|
178
|
+
assert_raises(ArgumentError) { seq << unsizeable }
|
|
179
|
+
end
|
|
180
|
+
assert_equal 10, seq.size
|
|
181
|
+
end
|
|
182
|
+
|
|
183
|
+
def test_each_in_range_with_exclusive_empty_and_open_ranges
|
|
184
|
+
seq = ServeByteRange::Sequence.new("abc", "def")
|
|
185
|
+
assert_equal [["abc", 0..2]], seq.each_in_range(0...3).to_a
|
|
186
|
+
assert_equal [["abc", 2..2], ["def", 0..0]], seq.each_in_range(2...4).to_a
|
|
187
|
+
assert_equal [], seq.each_in_range(3...3).to_a
|
|
188
|
+
assert_raises(ArgumentError) { seq.each_in_range(5..3).to_a }
|
|
189
|
+
assert_raises(ArgumentError) { seq.each_in_range(Range.new(1, nil)).to_a }
|
|
190
|
+
assert_raises(ArgumentError) { seq.each_in_range(Range.new(nil, 1)).to_a }
|
|
191
|
+
end
|
|
192
|
+
|
|
193
|
+
def test_segments_can_not_change_after_being_added
|
|
194
|
+
str = +"hello"
|
|
195
|
+
seq = ServeByteRange::Sequence.new(str)
|
|
196
|
+
str << " world"
|
|
197
|
+
assert_equal 5, seq.size
|
|
198
|
+
assert_equal [["hello", 0..4]], seq.each_in_range(0..4).to_a
|
|
199
|
+
|
|
200
|
+
inner = ServeByteRange::Sequence.new("ab")
|
|
201
|
+
outer = ServeByteRange::Sequence.new(inner, "cd")
|
|
202
|
+
assert inner.frozen?
|
|
203
|
+
assert_raises(FrozenError) { inner << "XY" }
|
|
204
|
+
assert_equal 4, outer.size
|
|
205
|
+
assert_equal 2, inner.size
|
|
206
|
+
end
|
|
207
|
+
|
|
208
|
+
def test_frozen_sequence_keeps_its_etag
|
|
209
|
+
seq = ServeByteRange::Sequence.new("abc").freeze
|
|
210
|
+
assert_match(/\A"[0-9a-f]{40}"\z/, seq.etag)
|
|
211
|
+
assert_raises(FrozenError) { seq.add_segment(:x, size: 1, etag: "x") }
|
|
212
|
+
end
|
|
213
|
+
|
|
214
|
+
def test_segment_etags_are_compared_without_quotes
|
|
215
|
+
quoted = ServeByteRange::Sequence.new.add_segment(:obj, size: 3, etag: '"abc"')
|
|
216
|
+
bare = ServeByteRange::Sequence.new.add_segment(:obj, size: 3, etag: "abc")
|
|
217
|
+
assert_equal bare.etag, quoted.etag
|
|
218
|
+
assert quoted.strong_etag?
|
|
219
|
+
|
|
220
|
+
weak = ServeByteRange::Sequence.new.add_segment(:obj, size: 3, etag: 'W/"abc"')
|
|
221
|
+
refute weak.strong_etag?
|
|
222
|
+
assert_equal "W/#{bare.etag}", weak.etag
|
|
223
|
+
end
|
|
224
|
+
end
|
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
# Compares two strings byte for byte, and describes where they differ - showing the offset and
|
|
4
|
+
# what the bytes there should have been - instead of a diff of a binary blob
|
|
5
|
+
class ByteComparator
|
|
6
|
+
CONTEXT_BYTES = 8
|
|
7
|
+
BLOCK_SIZE = 4096
|
|
8
|
+
|
|
9
|
+
def initialize(expected, actual)
|
|
10
|
+
@expected = expected.b
|
|
11
|
+
@actual = actual.b
|
|
12
|
+
end
|
|
13
|
+
|
|
14
|
+
def same?
|
|
15
|
+
@expected == @actual
|
|
16
|
+
end
|
|
17
|
+
|
|
18
|
+
# @return [Integer,nil] the offset of the first differing byte, or nil if the strings are the same
|
|
19
|
+
def first_difference_offset
|
|
20
|
+
return if same?
|
|
21
|
+
common = [@expected.bytesize, @actual.bytesize].min
|
|
22
|
+
# Skip over equal blocks first, comparing byte by byte over 100KB+ strings is slow-ish
|
|
23
|
+
offset = 0
|
|
24
|
+
offset += BLOCK_SIZE while offset + BLOCK_SIZE <= common && @expected.byteslice(offset, BLOCK_SIZE) == @actual.byteslice(offset, BLOCK_SIZE)
|
|
25
|
+
offset += 1 while offset < common && @expected.getbyte(offset) == @actual.getbyte(offset)
|
|
26
|
+
offset
|
|
27
|
+
end
|
|
28
|
+
|
|
29
|
+
# @return [String,nil] the description of the difference, or nil if the strings are the same
|
|
30
|
+
def describe_difference
|
|
31
|
+
offset = first_difference_offset
|
|
32
|
+
return unless offset
|
|
33
|
+
[
|
|
34
|
+
(@expected.bytesize == @actual.bytesize) ? "Bytes differ" : "Bytes differ (expected #{@expected.bytesize} bytes, got #{@actual.bytesize})",
|
|
35
|
+
"diff at offset #{offset},",
|
|
36
|
+
"should have been #{format_bytes(@expected.byteslice(offset, CONTEXT_BYTES))}",
|
|
37
|
+
"but was #{format_bytes(@actual.byteslice(offset, CONTEXT_BYTES))}"
|
|
38
|
+
].join("\n")
|
|
39
|
+
end
|
|
40
|
+
|
|
41
|
+
private
|
|
42
|
+
|
|
43
|
+
def format_bytes(bytes)
|
|
44
|
+
return "[empty]" if bytes.nil? || bytes.empty?
|
|
45
|
+
"[" + bytes.unpack("C*").map { |b| "0x%02X" % b }.join(" ") + "]"
|
|
46
|
+
end
|
|
47
|
+
end
|
|
@@ -0,0 +1,10 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require_relative "byte_comparator"
|
|
4
|
+
|
|
5
|
+
module BytesAssertions
|
|
6
|
+
def assert_same_bytes(expected, actual, message = nil)
|
|
7
|
+
comparator = ByteComparator.new(expected, actual)
|
|
8
|
+
assert(comparator.same?, -> { [message, comparator.describe_difference].compact.join("\n") })
|
|
9
|
+
end
|
|
10
|
+
end
|
metadata
CHANGED
|
@@ -1,15 +1,14 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: serve_byte_range
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: 1.
|
|
4
|
+
version: 1.1.0
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- Julik Tarkhanov
|
|
8
8
|
- Sebastian van Hesteren
|
|
9
|
-
autorequire:
|
|
10
9
|
bindir: exe
|
|
11
10
|
cert_chain: []
|
|
12
|
-
date:
|
|
11
|
+
date: 1980-01-02 00:00:00.000000000 Z
|
|
13
12
|
dependencies:
|
|
14
13
|
- !ruby/object:Gem::Dependency
|
|
15
14
|
name: rack
|
|
@@ -17,22 +16,22 @@ dependencies:
|
|
|
17
16
|
requirements:
|
|
18
17
|
- - ">="
|
|
19
18
|
- !ruby/object:Gem::Version
|
|
20
|
-
version: '
|
|
19
|
+
version: '2.0'
|
|
21
20
|
type: :runtime
|
|
22
21
|
prerelease: false
|
|
23
22
|
version_requirements: !ruby/object:Gem::Requirement
|
|
24
23
|
requirements:
|
|
25
24
|
- - ">="
|
|
26
25
|
- !ruby/object:Gem::Version
|
|
27
|
-
version: '
|
|
26
|
+
version: '2.0'
|
|
28
27
|
- !ruby/object:Gem::Dependency
|
|
29
|
-
name:
|
|
28
|
+
name: base64
|
|
30
29
|
requirement: !ruby/object:Gem::Requirement
|
|
31
30
|
requirements:
|
|
32
31
|
- - ">="
|
|
33
32
|
- !ruby/object:Gem::Version
|
|
34
33
|
version: '0'
|
|
35
|
-
type: :
|
|
34
|
+
type: :runtime
|
|
36
35
|
prerelease: false
|
|
37
36
|
version_requirements: !ruby/object:Gem::Requirement
|
|
38
37
|
requirements:
|
|
@@ -40,7 +39,7 @@ dependencies:
|
|
|
40
39
|
- !ruby/object:Gem::Version
|
|
41
40
|
version: '0'
|
|
42
41
|
- !ruby/object:Gem::Dependency
|
|
43
|
-
name:
|
|
42
|
+
name: minitest
|
|
44
43
|
requirement: !ruby/object:Gem::Requirement
|
|
45
44
|
requirements:
|
|
46
45
|
- - ">="
|
|
@@ -54,35 +53,7 @@ dependencies:
|
|
|
54
53
|
- !ruby/object:Gem::Version
|
|
55
54
|
version: '0'
|
|
56
55
|
- !ruby/object:Gem::Dependency
|
|
57
|
-
name:
|
|
58
|
-
requirement: !ruby/object:Gem::Requirement
|
|
59
|
-
requirements:
|
|
60
|
-
- - '='
|
|
61
|
-
- !ruby/object:Gem::Version
|
|
62
|
-
version: 1.28.5
|
|
63
|
-
type: :development
|
|
64
|
-
prerelease: false
|
|
65
|
-
version_requirements: !ruby/object:Gem::Requirement
|
|
66
|
-
requirements:
|
|
67
|
-
- - '='
|
|
68
|
-
- !ruby/object:Gem::Version
|
|
69
|
-
version: 1.28.5
|
|
70
|
-
- !ruby/object:Gem::Dependency
|
|
71
|
-
name: yard
|
|
72
|
-
requirement: !ruby/object:Gem::Requirement
|
|
73
|
-
requirements:
|
|
74
|
-
- - "~>"
|
|
75
|
-
- !ruby/object:Gem::Version
|
|
76
|
-
version: '0.9'
|
|
77
|
-
type: :development
|
|
78
|
-
prerelease: false
|
|
79
|
-
version_requirements: !ruby/object:Gem::Requirement
|
|
80
|
-
requirements:
|
|
81
|
-
- - "~>"
|
|
82
|
-
- !ruby/object:Gem::Version
|
|
83
|
-
version: '0.9'
|
|
84
|
-
- !ruby/object:Gem::Dependency
|
|
85
|
-
name: sord
|
|
56
|
+
name: rake
|
|
86
57
|
requirement: !ruby/object:Gem::Requirement
|
|
87
58
|
requirements:
|
|
88
59
|
- - ">="
|
|
@@ -96,25 +67,26 @@ dependencies:
|
|
|
96
67
|
- !ruby/object:Gem::Version
|
|
97
68
|
version: '0'
|
|
98
69
|
- !ruby/object:Gem::Dependency
|
|
99
|
-
name:
|
|
70
|
+
name: standard
|
|
100
71
|
requirement: !ruby/object:Gem::Requirement
|
|
101
72
|
requirements:
|
|
102
|
-
- -
|
|
73
|
+
- - '='
|
|
103
74
|
- !ruby/object:Gem::Version
|
|
104
|
-
version:
|
|
75
|
+
version: 1.28.5
|
|
105
76
|
type: :development
|
|
106
77
|
prerelease: false
|
|
107
78
|
version_requirements: !ruby/object:Gem::Requirement
|
|
108
79
|
requirements:
|
|
109
|
-
- -
|
|
80
|
+
- - '='
|
|
110
81
|
- !ruby/object:Gem::Version
|
|
111
|
-
version:
|
|
82
|
+
version: 1.28.5
|
|
112
83
|
description: Serve byte range HTTP responses lazily
|
|
113
84
|
email:
|
|
114
85
|
- me@julik.nl
|
|
115
86
|
executables: []
|
|
116
87
|
extensions: []
|
|
117
|
-
extra_rdoc_files:
|
|
88
|
+
extra_rdoc_files:
|
|
89
|
+
- README.md
|
|
118
90
|
files:
|
|
119
91
|
- ".github/workflows/ci.yml"
|
|
120
92
|
- ".gitignore"
|
|
@@ -122,18 +94,35 @@ files:
|
|
|
122
94
|
- Gemfile
|
|
123
95
|
- README.md
|
|
124
96
|
- Rakefile
|
|
97
|
+
- Steepfile
|
|
98
|
+
- gemfiles/rack_2.gemfile
|
|
99
|
+
- gemfiles/rack_3.gemfile
|
|
100
|
+
- gemfiles/typecheck.gemfile
|
|
125
101
|
- lib/serve_byte_range.rb
|
|
102
|
+
- lib/serve_byte_range/sequence.rb
|
|
126
103
|
- lib/serve_byte_range/version.rb
|
|
127
|
-
- rbi/serve_byte_range.rbi
|
|
128
104
|
- serve_byte_range.gemspec
|
|
105
|
+
- sig/serve_byte_range.rbs
|
|
106
|
+
- sig/serve_byte_range/sequence.rbs
|
|
107
|
+
- sig/serve_byte_range/version.rbs
|
|
108
|
+
- sig_shims/rack.rbs
|
|
109
|
+
- test/byte_comparator_test.rb
|
|
129
110
|
- test/range_server_test.rb
|
|
111
|
+
- test/sequence_test.rb
|
|
112
|
+
- test/support/byte_comparator.rb
|
|
113
|
+
- test/support/bytes_assertions.rb
|
|
130
114
|
homepage: https://github.com/julik/serve_byte_range
|
|
131
115
|
licenses:
|
|
132
116
|
- MIT
|
|
133
117
|
metadata:
|
|
118
|
+
homepage_uri: https://github.com/julik/serve_byte_range
|
|
119
|
+
source_code_uri: https://github.com/julik/serve_byte_range
|
|
134
120
|
allowed_push_host: https://rubygems.org
|
|
135
|
-
|
|
136
|
-
|
|
121
|
+
rdoc_options:
|
|
122
|
+
- "--markup"
|
|
123
|
+
- markdown
|
|
124
|
+
- "--main"
|
|
125
|
+
- README.md
|
|
137
126
|
require_paths:
|
|
138
127
|
- lib
|
|
139
128
|
required_ruby_version: !ruby/object:Gem::Requirement
|
|
@@ -147,8 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
|
|
|
147
136
|
- !ruby/object:Gem::Version
|
|
148
137
|
version: '0'
|
|
149
138
|
requirements: []
|
|
150
|
-
rubygems_version: 3.
|
|
151
|
-
signing_key:
|
|
139
|
+
rubygems_version: 3.6.9
|
|
152
140
|
specification_version: 4
|
|
153
141
|
summary: Serve byte range HTTP responses lazily
|
|
154
142
|
test_files: []
|
data/rbi/serve_byte_range.rbi
DELETED
|
@@ -1,208 +0,0 @@
|
|
|
1
|
-
# typed: strong
|
|
2
|
-
module ServeByteRange
|
|
3
|
-
VERSION = T.let("1.0.0", T.untyped)
|
|
4
|
-
|
|
5
|
-
# sord omit - no YARD return type given, using untyped
|
|
6
|
-
# Strictly - the boundary is supposed to not appear in any of the parts of the multipart response, so _first_
|
|
7
|
-
# you need to scan the response, pick a byte sequence that does not occur in it, and then use that. In practice,
|
|
8
|
-
# nobody does that - and a well-behaved HTTP client should honor the Content-Range header when extracting
|
|
9
|
-
# the byte range from the response. See https://stackoverflow.com/questions/37413715
|
|
10
|
-
sig { returns(T.untyped) }
|
|
11
|
-
def self.generate_boundary; end
|
|
12
|
-
|
|
13
|
-
# The RFC specifically gives an example of non-canonical, but still
|
|
14
|
-
# valid request for overlapping ranges:
|
|
15
|
-
# > Several legal but not canonical specifications of the second 500
|
|
16
|
-
# > bytes (byte offsets 500-999, inclusive):
|
|
17
|
-
# > bytes=500-600,601-999
|
|
18
|
-
# > bytes=500-700,601-999
|
|
19
|
-
# In such cases, ranges need to be collapsed together. First, to avoid serving
|
|
20
|
-
# a tiny byte range over and over - causing excessive requests to upstream,
|
|
21
|
-
# second - to optimize for doing less requests in total.
|
|
22
|
-
#
|
|
23
|
-
# _@param_ `ranges` — an array of inclusive, limited ranges of integers
|
|
24
|
-
#
|
|
25
|
-
# _@return_ — ranges squashed together honoring their overlaps
|
|
26
|
-
sig { params(ranges: T::Array[T::Range[T.untyped]]).returns(T::Array[T.untyped]) }
|
|
27
|
-
def self.coalesce_ranges(ranges); end
|
|
28
|
-
|
|
29
|
-
# _@param_ `env` — the Rack env
|
|
30
|
-
#
|
|
31
|
-
# _@param_ `resource_size` — the size of the complete resource in bytes
|
|
32
|
-
#
|
|
33
|
-
# _@param_ `etag` — the current ETag of the resource, or nil if none
|
|
34
|
-
#
|
|
35
|
-
# _@param_ `resource_content_type` — the MIME type string of the resource
|
|
36
|
-
#
|
|
37
|
-
# _@param_ `multipart_boundary` — The string to use as multipart boundary. Default is an automatically generated pseudo-random string.
|
|
38
|
-
#
|
|
39
|
-
# _@return_ — the Rack response triplet of `[status, header_hash, enumerable_body]`
|
|
40
|
-
#
|
|
41
|
-
# ```ruby
|
|
42
|
-
# status, headers, body = serve_ranges(env, resource_size: file.size) do |range, io|
|
|
43
|
-
# file.seek(range.begin)
|
|
44
|
-
# IO.copy_stream(file, io, range.size)
|
|
45
|
-
# end
|
|
46
|
-
# [status, headers, body]
|
|
47
|
-
# ```
|
|
48
|
-
sig do
|
|
49
|
-
params(
|
|
50
|
-
env: T::Hash[T.untyped, T.untyped],
|
|
51
|
-
resource_size: Integer,
|
|
52
|
-
etag: T.nilable(String),
|
|
53
|
-
resource_content_type: String,
|
|
54
|
-
multipart_boundary: String,
|
|
55
|
-
range_serving_block: T.untyped
|
|
56
|
-
).returns(T::Array[T.untyped])
|
|
57
|
-
end
|
|
58
|
-
def self.serve_ranges(env, resource_size:, etag: nil, resource_content_type: "binary/octet-stream", multipart_boundary: generate_boundary, &range_serving_block); end
|
|
59
|
-
|
|
60
|
-
class BlockWritableWithLimit
|
|
61
|
-
# sord omit - no YARD type given for "limit", using untyped
|
|
62
|
-
sig { params(limit: T.untyped, block_that_accepts_writes: T.untyped).void }
|
|
63
|
-
def initialize(limit, &block_that_accepts_writes); end
|
|
64
|
-
|
|
65
|
-
# sord omit - no YARD type given for "string", using untyped
|
|
66
|
-
# sord omit - no YARD return type given, using untyped
|
|
67
|
-
sig { params(string: T.untyped).returns(T.untyped) }
|
|
68
|
-
def write(string); end
|
|
69
|
-
|
|
70
|
-
# sord omit - no YARD return type given, using untyped
|
|
71
|
-
sig { returns(T.untyped) }
|
|
72
|
-
def verify!; end
|
|
73
|
-
end
|
|
74
|
-
|
|
75
|
-
class ByteRangeBody
|
|
76
|
-
# sord omit - no YARD type given for "http_range:", using untyped
|
|
77
|
-
# sord omit - no YARD type given for "resource_size:", using untyped
|
|
78
|
-
# sord omit - no YARD type given for "resource_content_type:", using untyped
|
|
79
|
-
sig do
|
|
80
|
-
params(
|
|
81
|
-
http_range: T.untyped,
|
|
82
|
-
resource_size: T.untyped,
|
|
83
|
-
resource_content_type: T.untyped,
|
|
84
|
-
serving_block: T.untyped
|
|
85
|
-
).void
|
|
86
|
-
end
|
|
87
|
-
def initialize(http_range:, resource_size:, resource_content_type: "binary/octet-stream", &serving_block); end
|
|
88
|
-
|
|
89
|
-
# sord omit - no YARD return type given, using untyped
|
|
90
|
-
sig { returns(T.untyped) }
|
|
91
|
-
def status; end
|
|
92
|
-
|
|
93
|
-
# sord omit - no YARD return type given, using untyped
|
|
94
|
-
sig { params(blk: T.untyped).returns(T.untyped) }
|
|
95
|
-
def each(&blk); end
|
|
96
|
-
|
|
97
|
-
# sord omit - no YARD return type given, using untyped
|
|
98
|
-
sig { returns(T.untyped) }
|
|
99
|
-
def content_length; end
|
|
100
|
-
|
|
101
|
-
# sord omit - no YARD return type given, using untyped
|
|
102
|
-
sig { returns(T.untyped) }
|
|
103
|
-
def content_type; end
|
|
104
|
-
|
|
105
|
-
# sord omit - no YARD return type given, using untyped
|
|
106
|
-
sig { returns(T.untyped) }
|
|
107
|
-
def headers; end
|
|
108
|
-
end
|
|
109
|
-
|
|
110
|
-
class EmptyBody
|
|
111
|
-
# sord omit - no YARD return type given, using untyped
|
|
112
|
-
sig { returns(T.untyped) }
|
|
113
|
-
def status; end
|
|
114
|
-
|
|
115
|
-
# sord omit - no YARD return type given, using untyped
|
|
116
|
-
sig { returns(T.untyped) }
|
|
117
|
-
def content_length; end
|
|
118
|
-
|
|
119
|
-
# sord omit - no YARD return type given, using untyped
|
|
120
|
-
sig { params(blk: T.untyped).returns(T.untyped) }
|
|
121
|
-
def each(&blk); end
|
|
122
|
-
|
|
123
|
-
# sord omit - no YARD return type given, using untyped
|
|
124
|
-
sig { returns(T.untyped) }
|
|
125
|
-
def headers; end
|
|
126
|
-
end
|
|
127
|
-
|
|
128
|
-
class NotModifiedBody < ServeByteRange::EmptyBody
|
|
129
|
-
# sord omit - no YARD return type given, using untyped
|
|
130
|
-
sig { returns(T.untyped) }
|
|
131
|
-
def status; end
|
|
132
|
-
end
|
|
133
|
-
|
|
134
|
-
class WholeBody < ServeByteRange::ByteRangeBody
|
|
135
|
-
# sord omit - no YARD type given for "resource_size:", using untyped
|
|
136
|
-
# sord omit - no YARD type given for "**more", using untyped
|
|
137
|
-
sig { params(resource_size: T.untyped, more: T.untyped, serving_block: T.untyped).void }
|
|
138
|
-
def initialize(resource_size:, **more, &serving_block); end
|
|
139
|
-
|
|
140
|
-
# sord omit - no YARD return type given, using untyped
|
|
141
|
-
sig { returns(T.untyped) }
|
|
142
|
-
def status; end
|
|
143
|
-
|
|
144
|
-
# sord omit - no YARD return type given, using untyped
|
|
145
|
-
sig { returns(T.untyped) }
|
|
146
|
-
def headers; end
|
|
147
|
-
end
|
|
148
|
-
|
|
149
|
-
class Unsatisfiable < ServeByteRange::EmptyBody
|
|
150
|
-
# sord omit - no YARD type given for "resource_size:", using untyped
|
|
151
|
-
sig { params(resource_size: T.untyped).void }
|
|
152
|
-
def initialize(resource_size:); end
|
|
153
|
-
|
|
154
|
-
# sord omit - no YARD return type given, using untyped
|
|
155
|
-
sig { returns(T.untyped) }
|
|
156
|
-
def status; end
|
|
157
|
-
|
|
158
|
-
# sord omit - no YARD return type given, using untyped
|
|
159
|
-
sig { returns(T.untyped) }
|
|
160
|
-
def headers; end
|
|
161
|
-
end
|
|
162
|
-
|
|
163
|
-
# See https://www.ietf.org/archive/id/draft-ietf-httpbis-p5-range-09.html
|
|
164
|
-
class MultipartByteRangesBody < ServeByteRange::ByteRangeBody
|
|
165
|
-
# sord omit - no YARD type given for "boundary:", using untyped
|
|
166
|
-
# sord omit - no YARD type given for "**params_for_single_range", using untyped
|
|
167
|
-
# _@param_ `http_ranges`
|
|
168
|
-
sig do
|
|
169
|
-
params(
|
|
170
|
-
http_ranges: T::Array[T::Range[T.untyped]],
|
|
171
|
-
boundary: T.untyped,
|
|
172
|
-
params_for_single_range: T.untyped,
|
|
173
|
-
serving_block: T.untyped
|
|
174
|
-
).void
|
|
175
|
-
end
|
|
176
|
-
def initialize(http_ranges:, boundary:, **params_for_single_range, &serving_block); end
|
|
177
|
-
|
|
178
|
-
# sord omit - no YARD return type given, using untyped
|
|
179
|
-
sig { params(blk: T.untyped).returns(T.untyped) }
|
|
180
|
-
def each(&blk); end
|
|
181
|
-
|
|
182
|
-
# sord omit - no YARD return type given, using untyped
|
|
183
|
-
sig { returns(T.untyped) }
|
|
184
|
-
def content_length; end
|
|
185
|
-
|
|
186
|
-
# sord omit - no YARD return type given, using untyped
|
|
187
|
-
sig { returns(T.untyped) }
|
|
188
|
-
def content_type; end
|
|
189
|
-
|
|
190
|
-
# sord omit - no YARD return type given, using untyped
|
|
191
|
-
sig { returns(T.untyped) }
|
|
192
|
-
def headers; end
|
|
193
|
-
|
|
194
|
-
# sord omit - no YARD return type given, using untyped
|
|
195
|
-
sig { returns(T.untyped) }
|
|
196
|
-
def compute_envelope_size; end
|
|
197
|
-
|
|
198
|
-
# sord omit - no YARD return type given, using untyped
|
|
199
|
-
sig { returns(T.untyped) }
|
|
200
|
-
def trailer; end
|
|
201
|
-
|
|
202
|
-
# sord omit - no YARD type given for "http_range", using untyped
|
|
203
|
-
# sord omit - no YARD type given for "part_index", using untyped
|
|
204
|
-
# sord omit - no YARD return type given, using untyped
|
|
205
|
-
sig { params(http_range: T.untyped, part_index: T.untyped).returns(T.untyped) }
|
|
206
|
-
def part_header(http_range, part_index); end
|
|
207
|
-
end
|
|
208
|
-
end
|