Defog wraps the fog gem (specifically, Fog::Storage), providing access to files stored in the cloud via proxy files on the local file system. A proxy file can be
- Read-only: A local cached copy of a cloud file.
- Write-only: A local file that will be uploaded to the cloud.
- Read-Write: A local file that mirrors a cloud file, propogating changes back to the cloud.
Defog thus lets you use ordinary programmatic tools to access and manipulate your cloud data. Thanks to the magic of fog it works across cloud providers, and it also works with the local file system as a "provider" so that you can, e.g. use the local file system for development and the cloud for production.
Defog also provides a few simple remote-file management methods to minimize the need to dig down into the Fog layer; but full access to the underlying fog objects is available should it be needed.
Full Rdoc is available at [https://rubydoc.info/gems/defog](Full Rdoc is available at https://rubydoc.info/gems/defog)
Connect to the remote storage by creating a Defog::Proxy
object, which
proxies files in a specific remote location, e.g.:
defog = Defog::Proxy.new(:provider => :AWS,
:aws_access_key_id => "yourid",
:aws_secret_access_key => "yoursecret",
:region => "optional-s3-region",
:bucket => "s3-bucket-name")
defog = Defog::Proxy.new(:provider => :Local,
:local_root => "/path/to/directory")
For complete options, see Defog::Proxy.new RDOC
Open a proxy to a remote file by creating a Defog::File
object:
file = defog.file("key/of/file", mode)
# ... access file ...
file.close
defog.file("key/of/file", mode) do |file|
# ... access file ...
end
mode
can be "r", "r+", "w", "w+", "a", or "a+" with the usual semantics, and
can be suffixed with "b" or with ":" and encoding as usual.
When opened in a readable mode ("r", "r+", "w+", "a+"), Defog first caches the cloud file in the local proxy. When opened in a writeable mode ("r+", "w", "w+", "a", "a+"), Defog arranges to upload the changes back to the cloud file at close time.
The Defog::File
class inherits from ::File
. So you can use it directly
for I/O operations, such as
defog.file("key", "r") do |file|
file.readlines
end
You can also access the proxy file via its path, allowing things such as
defog.file("image100x100.jpg", "w") do |file|
system("convert souce.png -scale 100x100 #{file.path}")
end
(Note that the proxy file path has the same file extension as the cloud key string.)
Closing the file object (explicitly or implicitly at the end of the block) synchronizes the local proxy with the remote storage if needed, and then (by default) deletes the local proxy file.
To suppress deleting the local proxy file, use :persist => true
(see
Persistence below). To suppress updating the remote storage, delete the local
proxy file before closing (e.g. via File.unlink(file.path)
) or pass
:synchronize => false
to the #close
method.
Calling Defog::Proxy#file without a mode returns a Defog::Handle object that supports cloud file query and manipulation:
handle = defog.file("key")
handle.exist? # => true if the cloud file exists
handle.delete # deletes the cloud file
handle.size # => size of the cloud file
handle.last_modified # => modification date of the cloud file
handle.md5_hash # => MD5 hash digest of the cloud file
In fact, defog.file("key", mode, options, &block)
is really just shorthand
for
defog.file("key").open(mode, options, &block)
In addition, the handle allows you to look up the path where the local proxy file will be if/when you open the proxy (but without actually doing the proxying).
defog.file("key").proxy_path # => Pathname where proxy file is, was, or will be
You can also iterate through handles of all cloud files, e.g.:
defog.each { |handle| puts handle.key }
defog.each.select { |handle| handle.last_modified < 12.hours.ago }
By default, Defog will delete the local proxy when closing a file. However, it is possible to keep the local proxy file so that it if the remote is accessed again the data will not need to be transferred again. (This is true even between executions of the program: a Defog::Proxy instance can start with proxy files already in place, and it will use them.)
Persistence can be enabled by default for the Defog::Proxy instance via:
defog = Defog::Proxy.new(:provider => ..., :persist => true)
And/or persistence can be overridden on a per-file basis at proxy open time:
file = defog.file("key/of/file", mode, :persist => true)
or at proxy close time:
file.close(:persist => true)
When opening a file whose local proxy has been persisted, Defog checks to see if the local proxy is out of date and if so replaces it (via MD5 digests).
For basic usage, you don't need to worry about the cache, the default settings work fine. But if you will be persisting proxy files you may want to manage the cache more carefully.
The cache for a given Defog::Proxy is rooted at a directory on the local file system. You can set and query the root via
defog = Defog::Proxy.new(:provider => ..., :proxy_root => "/my/chosen/root")
defog.proxy_root # => returns a Pathname
If you don't specify a root, Defog uses one of two defaults:
{Rails.root}/tmp/defog/{provider}-{location} # if Rails is defined
{Dir.tmpdir}/defog/{provider}-{location} # if Rails is not defined
In these, location
disambiguates between Defog::Proxy instances. For :AWS
it's the bucket name and for :local it's the local_root
directory path with
slashes replaced with dashes.
[Why cache local files, you ask? Why not bypass this whole cache thing if using :local? Well, the motivation for supporting :local is to use it in development and use :AWS in production. So, to more faithfully mimic production behavior, :local mode goes through the same code path and same caching mechanism.]
Within the cache, indvidiual proxy files are located by treating the key as a path relative to the proxy root (with slashes in the key indicating subdirectories in the path).
Defog can perform simple size management of the local proxy file cache. This is of course useful mostly when persisting files.
You can specify a maximum cache size via:
defog = Defog::Proxy.new(:provider => ..., :max_cache_size => size-in-bytes)
If a maximum size is set, then before downloading data to create a proxy, Defog will check the space available and delete persisted proxy files as needed in LRU order. Does not delete files for proxies that are currently open. If this would not free up enough space (because of open proxies or just because the remote is larger than the cache), raises Defog::Error::CacheFull and doesn't actually delete anything.
For writeable proxes, of course Defog doesn't know in advance the size of the data you will write into proxy file. As a crude estimate, if the remote file already exists, Defog will reserve the same amount of space. Instead, you can tell Defog the expected size via:
defog.file("key", "w", :size_hint => size-in-bytes)
You can also manage the cache manually, by explicitly deleting an individual persisted proxy files, such as via:
defog.file("key").proxy_path.unlink
And it's fair game to delete proxy files outside of Defog, such as via a cron job. Of course in these cases it's up to you to make sure not to unintentionally delete a proxy file that's currently open.
Sometimes you may want to have multiple Defog proxies, each scoped to a different "subdirectory" of a cloud storage location -- but all of them sharing a single cache in order to limit the max cache size across them all).
That works OK out of the box (as of v0.8.0): the default proxy_root
is created without regard for the prefix
-- but the proxy_path
for files within the cache does include the prefix. So it's safe to create multiple defog proxies that differ only in prefix
, and they will share the cache without colliding with each other.
Notes:
-
Each defog proxy will manage the entire cache based on its own
max_cache_size
setting. So presumably you would pass the samemax_cache_size
to each. -
Best to avoid multithreading though, as there's no locking around the cache management. So in principle one thread could delete a proxy that another thread is using.
You can access the underlying fog objects as needed:
defog = Defog::Proxy.new(:provider => ...)
defog.fog_connection # => the Fog::Storage object
defog.fog_directory # => the fog directory that contains the files being proxied
defog.file("key").fog_model # => the fog model for the cloud file
Gemfile:
gem 'defog'
Defog is tested on:
- Ruby: MRI 2.1.3, MRI 2.3.0
- Fog Storage: :local, :AWS
The above storage providers are what the author uses. Please fork and add others! (There's just a very small amount of provider-specific code in one file, plus appropriate rspec examples.)
Release Notes:
- 0.9.5 - Add mime-type dependency which fog-storage requires
- 0.9.4 - Bug fix: don't fail when checking atime if file gets deleted by another process (more robust)
- 0.9.3 - Bug fix: don't fail when measuring cache if file gets deleted by another process (more robust)
- 0.9.2 - Bug fix: don't fail when measuring cache if file gets deleted by another process (more robust)
- 0.9.1 - Bug fix: don't fail when measuring cache if file gets deleted by another process
- 0.9.0 - Expose Handle#md5_hash
- 0.8.0 - Include prefix in proxy_path (thus allowing cache sharing)
- 0.7.2 - Bug fix: don't fail when clearing cache if another process clears it first
- 0.7.1 - Add key info to message if there's an exception when getting file
- 0.7.0 - Add :query option to Handle#url
- 0.6.1 - Bug fix (caching)
- 0.6.0 - Add logging
Released under the MIT License. See LICENSE for details.