Class: Better::Tempfile

Inherits:
File
  • Object
show all
Defined in:
lib/better/tempfile.rb

Overview

A utility class for managing temporary files. When you create a Tempfile object, it will create a temporary file with a unique filename. A Tempfile objects behaves just like a File object, and you can perform all the usual file operations on it: reading data, writing data, changing its permissions, etc. So although this class does not explicitly document all instance methods supported by File, you can in fact call any File instance method on a Tempfile object.

Comparison to Ruby’s bundled version

  • Much better documentation.

  • Is unit tested.

  • Ruby 1.8’s version can generate “weird” path names that can confuse certain command line tools such as Curl. Better::Tempfile is based on Ruby 1.9’s version and generates saner filenames.

  • Ruby 1.8’s version has a bug which makes unlink-before-close (as described below) unusable: it raises an an exception when #close is called if the tempfile was unlinked before.

  • Ruby 1.9.1’s version closes the file when #unlink is called. This makes unlink-before-close unusable.

  • Ruby’s bundled version deletes the temporary file in its finalizer, even when #unlink was called before. As a result it may potentially delete other Ruby processes’ temp files when it’s not supposed to.

Better::Tempfile is based on Ruby 1.9.2’s version (SVN 24594).

Synopsis

require 'better/tempfile'

file = Better::Tempfile.new('foo')
file.path      # => A unique filename in the OS's temp directory,
               #    e.g.: "/tmp/foo.24722.0"
               #    This filename contains 'foo' in its basename.
file.write("hello world")
file.rewind
file.read      # => "hello world"
file.close
file.unlink    # deletes the temp file

Good practices

Explicit close

When a Tempfile object is garbage collected, or when the Ruby interpreter exits, its associated temporary file is automatically deleted. This means that’s it’s unnecessary to explicitly delete a Tempfile after use, though it’s good practice to do so: not explicitly deleting unused Tempfiles can potentially leave behind large amounts of tempfiles on the filesystem until they’re garbage collected. The existance of these temp files can make it harder to determine a new Tempfile filename.

Therefore, one should always call #unlink or close in an ensure block, like this:

file = Better::Tempfile.new('foo)
begin
   ...do something with file...
ensure
   file.close
   file.unlink   # deletes the temp file
end

Unlink after creation

On POSIX systems, it’s possible to unlink a file right after creating it, and before closing it. This removes the filesystem entry without closing the file handle, so it ensures that only the processes that already had the file handle open can access the file’s contents. It’s strongly recommended that you do this if you do not want any other processes to be able to read from or write to the Tempfile, and you do not need to know the Tempfile’s filename either.

For example, a practical use case for unlink-after-creation would be this: you need a large byte buffer that’s too large to comfortably fit in RAM, e.g. when you’re writing a web server and you want to buffer the client’s file upload data.

Please refer to #unlink for more information and a code example.

Minor notes

Tempfile’s filename picking method is both thread-safe and inter-process-safe: it guarantees that no other threads or processes will pick the same filename.

Tempfile itself however may not be entirely thread-safe. If you access the same Tempfile object from multiple threads then you should protect it with a mutex.

Defined Under Namespace

Classes: CreationError

Constant Summary collapse

MAX_TRIES =

:nodoc:

10
@@live_tempfiles = 
[]
@@lock = 
Mutex.new

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(basename, *rest) ⇒ Tempfile

call-seq:

new(basename, [tmpdir = Dir.tmpdir], [options])

Creates a temporary file with permissions 0600 (= only readable and writable by the owner) and opens it with mode “w+”.

The basename parameter is used to determine the name of the temporary file. You can either pass a String or an Array with 2 String elements. In the former form, the temporary file’s base name will begin with the given string. In the latter form, the temporary file’s base name will begin with the array’s first element, and end with the second element. For example:

file = Better::Tempfile.new('hello')
file.path  # => something like: "/tmp/foo2843-8392-92849382--0"

# Use the Array form to enforce an extension in the filename:
file = Better::Tempfile.new(['hello', '.jpg'])
file.path  # => something like: "/tmp/foo2843-8392-92849382--0.jpg"

The temporary file will be placed in the directory as specified by the tmpdir parameter. By default, this is Dir.tmpdir (see ‘tmpdir.rb’ in the Ruby standard library.) When $SAFE > 0 and the given tmpdir is tainted, it uses ‘/tmp’ as the temporary directory. Please note that ENV values are tainted by default, and Dir.tmpdir‘s return value might come from environment variables (e.g. $TMPDIR).

file = Better::Tempfile.new('hello', '/home/aisaka')
file.path  # => something like: "/home/aisaka/foo2843-8392-92849382--0"

You can also pass an options hash. Under the hood, Better::Tempfile creates the temporary file using File.open. These options will be passed to File.open. This is mostly useful on Ruby 1.9 for specifying encoding options, e.g.:

Better::Tempfile.new('hello', '/home/aisaka', :encoding => 'ascii-8bit')

# You can also omit the 'tmpdir' parameter:
Better::Tempfile.new('hello', :encoding => 'ascii-8bit')

Exceptions

Under rare circumstances, this constructor can raise an instance of Better::Tempfile::CreationError. This could happen if a large number of threads or processes are simultaneously trying to create temp files and stepping on each others’ toes. If Better::Tempfile.new cannot find a unique filename within a limited number of tries, then it will raise this exception.



214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
 
# File 'lib/better/tempfile.rb', line 214

def initialize(basename, *rest)
  # I wish keyword argument settled soon.
  if rest.last.respond_to?(:to_hash)
    opts = rest.last.to_hash
    rest.pop
  else
    opts = nil
  end
  tmpdir = rest[0] || Dir::tmpdir
  if $SAFE > 0 && tmpdir.tainted?
    tmpdir = '/tmp'
  end

  lock = tmpname = nil
  n = failure = 0
  @@lock.synchronize do
    begin
      begin
        tmpname = File.join(tmpdir, make_tmpname(basename, n))
        lock = tmpname + '.lock'
        n += 1
      end while @@live_tempfiles.include?(tmpname) ||
                File.exist?(lock) ||
                File.exist?(tmpname)
      self.class.make_directory(lock)
    rescue SystemCallError
      failure += 1
      retry if failure < MAX_TRIES
      raise CreationError, ("cannot generate tempfile `%s'" % tmpname)
    end
  end

  @finalizer_info = [tmpname]
  @finalizer_callback = self.class.create_finalizer_callback(@finalizer_info)
  ObjectSpace.define_finalizer(self, @finalizer_callback)

  if opts.nil?
    opts = []
  else
    opts = [opts]
  end
  @tmpfile = File.open(tmpname, File::RDWR | File::CREAT | File::EXCL, 0600, *opts)
  @tmpname = tmpname
  @@live_tempfiles << tmpname
  @finalizer_info[1] = @tmpfile
  @finalizer_info[2] = @@live_tempfiles

  super(@tmpfile)

  # Now we have all the File/IO methods defined, you must not
  # carelessly put bare puts(), etc. after this.

  Dir.rmdir(lock)
end

Class Method Details

.create_finalizer_callback(info) ⇒ Object

:nodoc:



146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/better/tempfile.rb', line 146

def create_finalizer_callback(info) # :nodoc:
  original_pid = $$
  Proc.new do
    # If we forked, then don't cleanup the temp files created by
    # the parent process.
    if original_pid == $$
      path, tmpfile, live_tempfiles = *info
      tmpfile.close if tmpfile
      File.unlink(path) if path && File.exist?(path)
      live_tempfiles.delete(path) if live_tempfiles
    end
  end
end

.make_directory(dir) ⇒ Object

:nodoc:



160
161
162
 
# File 'lib/better/tempfile.rb', line 160

def make_directory(dir) # :nodoc:
  Dir.mkdir(dir)
end

.open(*args) ⇒ Object

Creates a new Tempfile.

If no block is given, this is a synonym for Tempfile.new.

If a block is given, then a Tempfile object will be constructed, and the block is run with said object as argument. The Tempfile oject will be automatically closed after the block terminates. The call returns the value of the block.

In any case, all arguments (+*args+) will be passed to Tempfile.new.

Better::Tempfile.open('foo', '/home/temp') do |f|
   ... do something with f ...
end

# Equivalent:
f = Better::Tempfile.open('foo', '/home/temp')
begin
   ... do something with f ...
ensure
   f.close
end



132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/better/tempfile.rb', line 132

def open(*args)
  tempfile = new(*args)

  if block_given?
    begin
      yield(tempfile)
    ensure
      tempfile.close
    end
  else
    tempfile
  end
end

Instance Method Details

#close(unlink_now = false) ⇒ Object

Closes the file. If unlink_now is true, then the file will be unlinked (deleted) after closing. Of course, you can choose to later call #unlink if you do not unlink it now.



280
281
282
283
284
285
286
 
# File 'lib/better/tempfile.rb', line 280

def close(unlink_now = false)
  if unlink_now
    close!
  else
    _close
  end
end

#close! ⇒ Object

Closes and unlinks (deletes) the file. Has the same effect as called close(true).



290
291
292
293
 
# File 'lib/better/tempfile.rb', line 290

def close!
  _close
  unlink if !unlinked?
end

#open ⇒ Object

Opens or reopens the file with mode “r+”.



270
271
272
273
274
275
 
# File 'lib/better/tempfile.rb', line 270

def open
  @tmpfile.close if @tmpfile
  @tmpfile = File.open(@tmpname, 'r+')
  @finalizer_info[1] = @tmpfile
  __setobj__(@tmpfile)
end

#path ⇒ Object

Returns the full path name of the temporary file. This will be nil if #unlink has been called.



350
351
352
 
# File 'lib/better/tempfile.rb', line 350

def path
  @tmpname
end

#size ⇒ Object Also known as: length

Returns the size of the temporary file. As a side effect, the IO buffer is flushed before determining the size.



356
357
358
359
360
361
362
363
 
# File 'lib/better/tempfile.rb', line 356

def size
  if @tmpfile
    @tmpfile.flush
    @tmpfile.stat.size
  else
    0
  end
end

#unlink ⇒ Object Also known as: delete

Unlinks (deletes) the file from the filesystem. One should always unlink the file after using it, as is explained in the “Explicit close” good practice section in the Tempfile overview:

file = Better::Tempfile.new('foo)
begin
   ...do something with file...
ensure
   file.close
   file.unlink   # deletes the temp file
end

On POSIX systems it’s possible to unlink a file before closing it. This practice is explained in detail in the Tempfile overview (section “Unlink after creation”); please refer there for more information.

However, unlink-before-close may not be supported on non-POSIX operating systems. Microsoft Windows is the most notable case: unlinking a non-closed file will result in an error, which this method will silently ignore. If you want to practice unlink-before-close whenever possible, then you should write code like this:

file = Better::Tempfile.new('foo')
file.unlink   # On Windows this silently fails.
begin
   ... do something with file ...
ensure
   file.close!   # Closes the file handle. If the file wasn't unlinked
                 # because #unlink failed, then this method will attempt
                 # to do so again.
end



328
329
330
331
332
333
334
335
336
337
338
339
 
# File 'lib/better/tempfile.rb', line 328

def unlink
  begin
    if File.exist?(@tmpname) # keep this order for thread safeness
      unlink_file(@tmpname)
    end
    @@live_tempfiles.delete(@tmpname)
    @finalizer_info = @tmpname = nil
    ObjectSpace.undefine_finalizer(self)
  rescue Errno::EACCES
    # may not be able to unlink on Windows; just ignore
  end
end

#unlinked? ⇒ Boolean

Returns whether #unlink has been called on this Tempfile, and whether it succeeded.

Returns:

  • (Boolean) 


344
345
346
 
# File 'lib/better/tempfile.rb', line 344

def unlinked?
  @tmpname.nil?
end