Feature #1410 » buffered_io.patch
| test/unit/lib/buffered_io_test.rb (revision 0) | ||
|---|---|---|
| 1 |
# This program is free software; you can redistribute it and/or |
|
| 2 |
# modify it under the terms of the GNU General Public License |
|
| 3 |
# as published by the Free Software Foundation; either version 2 |
|
| 4 |
# of the License, or (at your option) any later version. |
|
| 5 |
# |
|
| 6 |
# This program is distributed in the hope that it will be useful, |
|
| 7 |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
| 8 |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
| 9 |
# GNU General Public License for more details. |
|
| 10 |
# |
|
| 11 |
# You should have received a copy of the GNU General Public License |
|
| 12 |
# along with this program; if not, write to the Free Software |
|
| 13 |
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
|
| 14 | ||
| 15 |
require File.dirname(__FILE__) + '/../../test_helper' |
|
| 16 | ||
| 17 |
class BufferedIOTest < Test::Unit::TestCase |
|
| 18 | ||
| 19 |
CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" |
|
| 20 |
def self.rand_string(length=8) |
|
| 21 |
s='' |
|
| 22 |
length.times{ s << CHARS[rand(CHARS.length)] }
|
|
| 23 |
s |
|
| 24 |
end |
|
| 25 | ||
| 26 |
TEST_STRING=rand_string(1000) |
|
| 27 |
|
|
| 28 |
def test_stop_caching |
|
| 29 |
io = BufferedIO.new(StringIO.new(TEST_STRING)) |
|
| 30 |
io.cache = true |
|
| 31 |
t = io.read(5) |
|
| 32 |
assert_equal 5, io.internal_buffer.size |
|
| 33 |
io.cache = false |
|
| 34 |
t += io.read |
|
| 35 |
assert_equal TEST_STRING, t |
|
| 36 |
assert_equal 5, io.internal_buffer.size |
|
| 37 |
end |
|
| 38 | ||
| 39 |
def test_is_binary_data |
|
| 40 |
io = BufferedIO.new(StringIO.new(TEST_STRING)) |
|
| 41 |
io2 = BufferedIO.new(StringIO.new(TEST_STRING)) |
|
| 42 |
io2.cache = true |
|
| 43 |
[io, io2].each do |io| |
|
| 44 |
assert_equal false, io.is_binary_data? |
|
| 45 |
t = io.read |
|
| 46 |
assert_equal TEST_STRING, t |
|
| 47 |
end |
|
| 48 |
end |
|
| 49 | ||
| 50 |
end |
|
| app/models/repository.rb (working copy) | ||
|---|---|---|
| 67 | 67 |
scm.properties(path, identifier) |
| 68 | 68 |
end |
| 69 | 69 |
|
| 70 |
def cat(path, identifier=nil) |
|
| 71 |
scm.cat(path, identifier) |
|
| 70 |
def cat(path, identifier=nil, &block)
|
|
| 71 |
scm.cat(path, identifier, &block)
|
|
| 72 | 72 |
end |
| 73 | 73 |
|
| 74 | 74 |
def diff(path, rev, rev_to) |
| app/controllers/repositories_controller.rb (working copy) | ||
|---|---|---|
| 110 | 110 |
def entry |
| 111 | 111 |
@entry = @repository.entry(@path, @rev) |
| 112 | 112 |
show_error_not_found and return unless @entry |
| 113 |
|
|
| 113 | ||
| 114 | 114 |
# If the entry is a dir, show the browser |
| 115 | 115 |
browse and return if @entry.is_dir? |
| 116 |
|
|
| 117 |
@content = @repository.cat(@path, @rev) |
|
| 118 |
show_error_not_found and return unless @content |
|
| 119 |
if 'raw' == params[:format] || @content.is_binary_data? |
|
| 120 |
# Force the download if it's a binary file |
|
| 121 |
send_data @content, :filename => @path.split('/').last
|
|
| 122 |
else |
|
| 123 |
# Prevent empty lines when displaying a file with Windows style eol |
|
| 124 |
@content.gsub!("\r\n", "\n")
|
|
| 125 |
end |
|
| 116 | ||
| 117 |
@repository.cat(@path, @rev) do |content| |
|
| 118 |
show_error_not_found and return unless content |
|
| 119 |
if 'raw' == params[:format] || content.is_binary_data? |
|
| 120 |
# Force the download if it's a binary file |
|
| 121 |
content.size = @entry.size |
|
| 122 |
send_data content, :filename => @path.split('/').last
|
|
| 123 |
else |
|
| 124 |
# Prevent empty lines when displaying a file with Windows style eol |
|
| 125 |
@content = content.read.gsub("\r\n", "\n")
|
|
| 126 |
end |
|
| 127 |
end |
|
| 126 | 128 |
end |
| 127 | 129 |
|
| 128 | 130 |
def annotate |
| lib/redmine/scm/adapters/subversion_adapter.rb (working copy) | ||
|---|---|---|
| 190 | 190 |
diff |
| 191 | 191 |
end |
| 192 | 192 |
|
| 193 |
def cat(path, identifier=nil) |
|
| 193 |
def cat(path, identifier=nil, &block)
|
|
| 194 | 194 |
identifier = (identifier and identifier.to_i > 0) ? identifier.to_i : "HEAD" |
| 195 | 195 |
cmd = "#{SVN_BIN} cat #{target(URI.escape(path))}@#{identifier}"
|
| 196 | 196 |
cmd << credentials_string |
| 197 | 197 |
cat = nil |
| 198 |
shellout(cmd) do |io| |
|
| 198 |
if block_given? |
|
| 199 |
shellout(cmd) do |io| |
|
| 200 |
io.binmode |
|
| 201 |
yield BufferedIO.new(io) |
|
| 202 |
end |
|
| 203 |
else |
|
| 204 |
io = shellout(cmd) |
|
| 199 | 205 |
io.binmode |
| 200 |
cat = io.read
|
|
| 206 |
return BufferedIO.new(io)
|
|
| 201 | 207 |
end |
| 202 |
return nil if $? && $?.exitstatus != 0 |
|
| 203 |
cat |
|
| 204 | 208 |
end |
| 205 | 209 |
|
| 206 | 210 |
def annotate(path, identifier=nil) |
| lib/redmine/scm/adapters/bazaar_adapter.rb (working copy) | ||
|---|---|---|
| 151 | 151 |
diff |
| 152 | 152 |
end |
| 153 | 153 |
|
| 154 |
def cat(path, identifier=nil) |
|
| 154 |
def cat(path, identifier=nil, &block)
|
|
| 155 | 155 |
cmd = "#{BZR_BIN} cat"
|
| 156 | 156 |
cmd << " -r#{identifier.to_i}" if identifier && identifier.to_i > 0
|
| 157 | 157 |
cmd << " #{target(path)}"
|
| 158 | 158 |
cat = nil |
| 159 |
shellout(cmd) do |io| |
|
| 159 |
if block_given? |
|
| 160 |
shellout(cmd) do |io| |
|
| 161 |
io.binmode |
|
| 162 |
yield BufferedIO.new(io) |
|
| 163 |
end |
|
| 164 |
else |
|
| 165 |
io = shellout(cmd) |
|
| 160 | 166 |
io.binmode |
| 161 |
cat = io.read
|
|
| 167 |
return BufferedIO.new(io)
|
|
| 162 | 168 |
end |
| 163 |
return nil if $? && $?.exitstatus != 0 |
|
| 164 |
cat |
|
| 165 | 169 |
end |
| 166 | 170 |
|
| 167 | 171 |
def annotate(path, identifier=nil) |
| lib/redmine/scm/adapters/abstract_adapter.rb (working copy) | ||
|---|---|---|
| 113 | 113 |
return nil |
| 114 | 114 |
end |
| 115 | 115 |
|
| 116 |
def cat(path, identifier=nil) |
|
| 116 |
def cat(path, identifier=nil, &block)
|
|
| 117 | 117 |
return nil |
| 118 | 118 |
end |
| 119 | 119 |
|
| ... | ... | |
| 172 | 172 |
def self.shellout(cmd, &block) |
| 173 | 173 |
logger.debug "Shelling out: #{cmd}" if logger && logger.debug?
|
| 174 | 174 |
begin |
| 175 |
IO.popen(cmd, "r+") do |io| |
|
| 175 |
if block_given? |
|
| 176 |
IO.popen(cmd, "r+") do |io| |
|
| 177 |
io.close_write |
|
| 178 |
block.call(io) |
|
| 179 |
end |
|
| 180 |
else |
|
| 181 |
io = IO.popen(cmd, "r+") |
|
| 176 | 182 |
io.close_write |
| 177 |
block.call(io) if block_given?
|
|
| 183 |
return io
|
|
| 178 | 184 |
end |
| 179 | 185 |
rescue Errno::ENOENT => e |
| 180 | 186 |
msg = strip_credential(e.message) |
| lib/redmine/scm/adapters/git_adapter.rb (working copy) | ||
|---|---|---|
| 249 | 249 |
blame |
| 250 | 250 |
end |
| 251 | 251 |
|
| 252 |
def cat(path, identifier=nil) |
|
| 252 |
def cat(path, identifier=nil, &block)
|
|
| 253 | 253 |
if identifier.nil? |
| 254 | 254 |
identifier = 'HEAD' |
| 255 | 255 |
end |
| 256 | 256 |
cmd = "#{GIT_BIN} --git-dir #{target('')} show #{shell_quote(identifier + ':' + path)}"
|
| 257 | 257 |
cat = nil |
| 258 |
shellout(cmd) do |io| |
|
| 258 |
if block_given? |
|
| 259 |
shellout(cmd) do |io| |
|
| 260 |
io.binmode |
|
| 261 |
yield BufferedIO.new(io) |
|
| 262 |
end |
|
| 263 |
else |
|
| 264 |
io = shellout(cmd) |
|
| 259 | 265 |
io.binmode |
| 260 |
cat = io.read
|
|
| 266 |
return BufferedIO.new(io)
|
|
| 261 | 267 |
end |
| 262 |
return nil if $? && $?.exitstatus != 0 |
|
| 263 |
cat |
|
| 264 | 268 |
end |
| 265 | 269 |
end |
| 266 | 270 |
end |
| lib/redmine/scm/adapters/mercurial_adapter.rb (working copy) | ||
|---|---|---|
| 169 | 169 |
diff |
| 170 | 170 |
end |
| 171 | 171 |
|
| 172 |
def cat(path, identifier=nil) |
|
| 172 |
def cat(path, identifier=nil, &block)
|
|
| 173 | 173 |
cmd = "#{HG_BIN} -R #{target('')} cat"
|
| 174 | 174 |
cmd << " -r " + (identifier ? identifier.to_s : "tip") |
| 175 | 175 |
cmd << " #{target(path)}"
|
| 176 | 176 |
cat = nil |
| 177 |
shellout(cmd) do |io| |
|
| 177 |
if block_given? |
|
| 178 |
shellout(cmd) do |io| |
|
| 179 |
io.binmode |
|
| 180 |
yield BufferedIO.new(io) |
|
| 181 |
end |
|
| 182 |
else |
|
| 183 |
io = shellout(cmd) |
|
| 178 | 184 |
io.binmode |
| 179 |
cat = io.read
|
|
| 185 |
return BufferedIO.new(io)
|
|
| 180 | 186 |
end |
| 181 |
return nil if $? && $?.exitstatus != 0 |
|
| 182 |
cat |
|
| 183 | 187 |
end |
| 184 | 188 |
|
| 185 | 189 |
def annotate(path, identifier=nil) |
| lib/redmine/scm/adapters/filesystem_adapter.rb (working copy) | ||
|---|---|---|
| 71 | 71 |
entries.sort_by_name |
| 72 | 72 |
end |
| 73 | 73 |
|
| 74 |
def cat(path, identifier=nil) |
|
| 75 |
File.new(target(path), "rb").read |
|
| 74 |
def cat(path, identifier=nil, &block) |
|
| 75 |
if block_given? |
|
| 76 |
File.open(target(path), "rb") do |io| |
|
| 77 |
io.binmode |
|
| 78 |
yield BufferedIO.new(io) |
|
| 79 |
end |
|
| 80 |
else |
|
| 81 |
io = File.new(target(path), "rb") |
|
| 82 |
io.binmode |
|
| 83 |
return BufferedIO.new(io) |
|
| 84 |
end |
|
| 76 | 85 |
end |
| 77 | 86 | |
| 78 | 87 |
private |
| lib/redmine/scm/adapters/cvs_adapter.rb (working copy) | ||
|---|---|---|
| 241 | 241 |
diff |
| 242 | 242 |
end |
| 243 | 243 |
|
| 244 |
def cat(path, identifier=nil) |
|
| 244 |
def cat(path, identifier=nil, &block)
|
|
| 245 | 245 |
identifier = (identifier) ? identifier : "HEAD" |
| 246 | 246 |
logger.debug "<cvs> cat path:'#{path}',identifier #{identifier}"
|
| 247 | 247 |
path_with_project="#{url}#{with_leading_slash(path)}"
|
| ... | ... | |
| 249 | 249 |
cmd << " -D \"#{time_to_cvstime(identifier)}\"" if identifier
|
| 250 | 250 |
cmd << " -p #{shell_quote path_with_project}"
|
| 251 | 251 |
cat = nil |
| 252 |
shellout(cmd) do |io| |
|
| 253 |
cat = io.read |
|
| 252 |
if block_given? |
|
| 253 |
shellout(cmd) do |io| |
|
| 254 |
io.binmode |
|
| 255 |
yield BufferedIO.new(io) |
|
| 256 |
end |
|
| 257 |
else |
|
| 258 |
io = shellout(cmd) |
|
| 259 |
io.binmode |
|
| 260 |
return BufferedIO.new(io) |
|
| 254 | 261 |
end |
| 255 |
return nil if $? && $?.exitstatus != 0 |
|
| 256 |
cat |
|
| 257 | 262 |
end |
| 258 | 263 | |
| 259 | 264 |
def annotate(path, identifier=nil) |
| lib/redmine/scm/adapters/darcs_adapter.rb (working copy) | ||
|---|---|---|
| 134 | 134 |
diff |
| 135 | 135 |
end |
| 136 | 136 |
|
| 137 |
def cat(path, identifier=nil) |
|
| 137 |
def cat(path, identifier=nil, &block)
|
|
| 138 | 138 |
cmd = "#{DARCS_BIN} show content --repodir #{@url}"
|
| 139 | 139 |
cmd << " --match \"hash #{identifier}\"" if identifier
|
| 140 | 140 |
cmd << " #{shell_quote path}"
|
| 141 | 141 |
cat = nil |
| 142 |
shellout(cmd) do |io| |
|
| 142 |
if block_given? |
|
| 143 |
shellout(cmd) do |io| |
|
| 144 |
io.binmode |
|
| 145 |
yield BufferedIO.new(io) |
|
| 146 |
end |
|
| 147 |
else |
|
| 148 |
io = shellout(cmd) |
|
| 143 | 149 |
io.binmode |
| 144 |
cat = io.read
|
|
| 150 |
return BufferedIO.new(io)
|
|
| 145 | 151 |
end |
| 146 |
return nil if $? && $?.exitstatus != 0 |
|
| 147 |
cat |
|
| 148 | 152 |
end |
| 149 | 153 | |
| 150 | 154 |
private |
| lib/buffered_io.rb (revision 0) | ||
|---|---|---|
| 1 |
# This program is free software; you can redistribute it and/or |
|
| 2 |
# modify it under the terms of the GNU General Public License |
|
| 3 |
# as published by the Free Software Foundation; either version 2 |
|
| 4 |
# of the License, or (at your option) any later version. |
|
| 5 |
# |
|
| 6 |
# This program is distributed in the hope that it will be useful, |
|
| 7 |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
| 8 |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
| 9 |
# GNU General Public License for more details. |
|
| 10 |
# |
|
| 11 |
# You should have received a copy of the GNU General Public License |
|
| 12 |
# along with this program; if not, write to the Free Software |
|
| 13 |
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
|
| 14 |
class BufferedIO |
|
| 15 | ||
| 16 |
attr_accessor :cache, :size |
|
| 17 | ||
| 18 |
def initialize(io) |
|
| 19 |
@source = io |
|
| 20 |
@cache = false |
|
| 21 |
@synced = true |
|
| 22 |
end |
|
| 23 | ||
| 24 |
def cache=(b) |
|
| 25 |
if b and synced? |
|
| 26 |
@cache = true |
|
| 27 |
else |
|
| 28 |
@cache = false |
|
| 29 |
end |
|
| 30 |
end |
|
| 31 | ||
| 32 |
def internal_buffer |
|
| 33 |
@internal_buffer || @internal_buffer = StringIO.new |
|
| 34 |
end |
|
| 35 | ||
| 36 |
def is_binary_data? |
|
| 37 |
if synced? |
|
| 38 |
position = internal_buffer.pos |
|
| 39 |
internal_buffer.rewind |
|
| 40 |
s = read_and_cache(4096) |
|
| 41 |
internal_buffer.pos = position |
|
| 42 |
s.is_binary_data? |
|
| 43 |
else |
|
| 44 |
raise Exception.new("Cannot do this test on an uncached buffer")
|
|
| 45 |
end |
|
| 46 |
end |
|
| 47 | ||
| 48 |
def synced? |
|
| 49 |
@synced |
|
| 50 |
end |
|
| 51 | ||
| 52 |
def read(x=nil) |
|
| 53 |
if cache |
|
| 54 |
read_and_cache(x) |
|
| 55 |
else |
|
| 56 |
read_and_dont_cache(x) |
|
| 57 |
end |
|
| 58 |
end |
|
| 59 | ||
| 60 |
def pos=(x) |
|
| 61 |
if x > internal_buffer.size |
|
| 62 |
if sinced? and cache |
|
| 63 |
_append @source.read(x - internal_buffer.pos) |
|
| 64 |
internal_buffer.pos = x |
|
| 65 |
else |
|
| 66 |
@source.pos = x |
|
| 67 |
end |
|
| 68 |
else |
|
| 69 |
internal_buffer.pos = x |
|
| 70 |
end |
|
| 71 |
end |
|
| 72 | ||
| 73 |
["pos", "rewind", "tell"].each do |m| |
|
| 74 |
define_method(m) do |
|
| 75 |
if synced? |
|
| 76 |
internal_buffer.send(m) |
|
| 77 |
else |
|
| 78 |
@source.send(m) |
|
| 79 |
end |
|
| 80 |
end |
|
| 81 |
end |
|
| 82 |
|
|
| 83 |
private |
|
| 84 |
|
|
| 85 |
def _append(s) |
|
| 86 |
unless s.nil? |
|
| 87 |
internal_buffer << s |
|
| 88 |
internal_buffer.pos -= s.size |
|
| 89 |
end |
|
| 90 |
end |
|
| 91 | ||
| 92 |
def read_source(x) |
|
| 93 |
@synced = false |
|
| 94 |
@source.read(x) |
|
| 95 |
end |
|
| 96 | ||
| 97 |
# Read the buffer by filling readed data in the cache. |
|
| 98 |
def read_and_cache(x=nil) |
|
| 99 |
if synced? |
|
| 100 |
to_read = x ? to_read = x + internal_buffer.pos - internal_buffer.size : nil |
|
| 101 |
_append(@source.read(to_read)) if to_read.nil? or to_read > 0 |
|
| 102 |
internal_buffer.read(x) |
|
| 103 |
else |
|
| 104 |
# Data is missing |
|
| 105 |
raise "Cannot cache a partially cached stream" |
|
| 106 |
end |
|
| 107 |
end |
|
| 108 | ||
| 109 |
# Read without filling the cache and ram by the way. |
|
| 110 |
# Not cached data will not be readable anymore if the |
|
| 111 |
# buffer cannot rewind. |
|
| 112 |
def read_and_dont_cache(x=nil) |
|
| 113 |
if synced? |
|
| 114 |
# Source and cache buffer are synced |
|
| 115 |
if internal_buffer.pos == internal_buffer.size |
|
| 116 |
# There is nothing to read in the cache |
|
| 117 |
read_source(x) |
|
| 118 |
else # internal_buffer.pos < @source.pos |
|
| 119 |
if x.nil? or (internal_buffer.pos + x) > internal_buffer.size |
|
| 120 |
# There is a first part to read in the cache |
|
| 121 |
# and another in the source |
|
| 122 |
internal_buffer.read + read_source(x) |
|
| 123 |
else |
|
| 124 |
# All is in the cache |
|
| 125 |
internal_buffer.read(x) |
|
| 126 |
end |
|
| 127 |
end |
|
| 128 |
else |
|
| 129 |
@internal_buffer = nil |
|
| 130 |
read_source(x) |
|
| 131 |
end |
|
| 132 |
end |
|
| 133 |
end |
|