pax_global_header 0000666 0000000 0000000 00000000064 12545554713 0014525 g ustar 00root root 0000000 0000000 52 comment=40dddfb368526948e769492a00a7937c5a044a4d
vagrant-cachier-1.2.1/ 0000775 0000000 0000000 00000000000 12545554713 0014564 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/.gitignore 0000664 0000000 0000000 00000000226 12545554713 0016554 0 ustar 00root root 0000000 0000000 *.gem
*.rbc
.bundle
.config
.yardoc
InstalledFiles
_yardoc
coverage
doc/
lib/bundler/man
pkg
rdoc
spec/reports
test/tmp
test/version_tmp
tmp
.vagrant
vagrant-cachier-1.2.1/CHANGELOG.md 0000664 0000000 0000000 00000017314 12545554713 0016403 0 ustar 00root root 0000000 0000000 ## [1.2.1](https://github.com/fgrehm/vagrant-cachier/compare/v1.2.0...v1.2.1) (July 3, 2015)
IMPROVEMENTS:
- Add chef\_zero support to chef bucket [[GH-153]]
[GH-153]: https://github.com/fgrehm/vagrant-cachier/issues/153
## [1.2.0](https://github.com/fgrehm/vagrant-cachier/compare/v1.1.0...v1.2.0) (Jan 14, 2015)
FEATURES:
- [Chef Gems bucket](http://fgrehm.viewdocs.io/vagrant-cachier/buckets/chef_rubygems) [[GH-129]]
[GH-129]: https://github.com/fgrehm/vagrant-cachier/pull/129
BUG FIXES:
- Fix provisioner resolution on Vagrant 1.7+ [[GH-133]] / [[GH-134]]
- Do not modify Vagrant core object, preventing unpredictable behavior [[GH-135]]
[GH-133]: https://github.com/fgrehm/vagrant-cachier/issues/133
[GH-134]: https://github.com/fgrehm/vagrant-cachier/pull/134
[GH-135]: https://github.com/fgrehm/vagrant-cachier/pull/135
## [1.1.0](https://github.com/fgrehm/vagrant-cachier/compare/v1.0.0...v1.1.0) (Oct 15, 2014)
FEATURES:
- [Bower bucket](http://fgrehm.viewdocs.io/vagrant-cachier/buckets/bower) [[GH-125]]
[GH-125]: https://github.com/fgrehm/vagrant-cachier/pull/125
IMPROVEMENTS:
- Resolve $HOME even if VM spits bogus new lines [[GH-122]] / [[GH-124]]
[GH-122]: https://github.com/fgrehm/vagrant-cachier/issues/122
[GH-124]: https://github.com/fgrehm/vagrant-cachier/pull/124
## [1.0.0](https://github.com/fgrehm/vagrant-cachier/compare/v0.9.0...v1.0.0) (Sep 22, 2014)
Public API is considered stable.
## [0.9.0](https://github.com/fgrehm/vagrant-cachier/compare/v0.8.0...v0.9.0) (Aug 9, 2014)
FEATURES:
- Suport for caching packages for Docker containers that doesn't have a base box specified [[GH-116]]
[GH-116]: https://github.com/fgrehm/vagrant-cachier/pull/116
## [0.8.0](https://github.com/fgrehm/vagrant-cachier/compare/v0.7.2...v0.8.0) (Jul 20, 2014)
BACKWARDS INCOMPATIBILITIES:
- Removed deprecated `config.enable_nfs` config.
- Changed composer cache bucket to use `$HOME/.composer/cache` [[GH-89]]
IMPROVEMENTS:
- Set composer cache bucket ownership to the configured SSH user.
BUG FIXES:
- Automatically disable apt-lists bucket when a Windows host is detected [[GH-106]]
- Skip `chmod 777` for `smb` mounted folders [[GH-107]]
- Do not error if base box has been removed and `:box` is configured as the cache scope [[GH-86]]
[GH-86]: https://github.com/fgrehm/vagrant-cachier/issues/86
[GH-89]: https://github.com/fgrehm/vagrant-cachier/issues/89
[GH-106]: https://github.com/fgrehm/vagrant-cachier/issues/106
[GH-107]: https://github.com/fgrehm/vagrant-cachier/issues/107
## [0.7.2](https://github.com/fgrehm/vagrant-cachier/compare/v0.7.1...v0.7.2) (May 08, 2014)
IMPROVEMENTS:
- Add `azure`, `brightbox`, `cloudstack`, `vcloud` and `vsphere` to the list
of known cloud providers [[GH-104]]
[GH-104]: https://github.com/fgrehm/vagrant-cachier/pull/104
## [0.7.1](https://github.com/fgrehm/vagrant-cachier/compare/v0.7.0...v0.7.1) (May 04, 2014)
BUG FIXES:
- Fix support for using multiple generic buckets [[GH-101]]
[GH-101]: https://github.com/fgrehm/vagrant-cachier/pull/101
## [0.7.0](https://github.com/fgrehm/vagrant-cachier/compare/v0.6.0...v0.7.0) (Apr 06, 2014)
FEATURES:
- ["Generic" cache bucket](http://fgrehm.viewdocs.io/vagrant-cachier/buckets/generic) [[GH-94]] / [[GH-4]].
BUG FIXES:
- Fix apt-cacher bucket undefined method error [[GH-96]]
[GH-94]: https://github.com/fgrehm/vagrant-cachier/pull/94
[GH-4]: https://github.com/fgrehm/vagrant-cachier/issues/4
[GH-96]: https://github.com/fgrehm/vagrant-cachier/issues/96
## [0.6.0](https://github.com/fgrehm/vagrant-cachier/compare/v0.5.1...v0.6.0) (Feb 26, 2014)
BACKWARDS INCOMPATIBILITIES:
- Plugin activation is now triggered by the `cache.scope` config and that config
is now required. Previous versions of the plugin had it set to `:box` but
there is no consensus whether `:box` and `:machine` is better. This is to
highlight that you need to think about the caching strategy you are going
to use. For more information and to discuss this move please check [GH-17](https://github.com/fgrehm/vagrant-cachier/issues/17).
- Because `cache.scope` is now a requirement and in order to reduce the amount of
configuration required by the plugin, we enabled automatic bucket detection by
default. To revert to the old behavior you can disable it globally from your
`~/.vagrant.d/Vagrantfile`.
- Support for Vagrant < 1.4 is gone, please use a previous plugin version if
you are running Vagrant 1.2 / 1.3
- Automatic handling of multiple machine scoped cache dirs from versions
prior to 0.3.0 of this plugin was removed.
- Support for `enable_nfs` has been deprecated and will be removed on 0.7.0,
please use `cache.synced_folder_opts = {type: :nfs}` instead.
FEATURES:
- Warm up cache buckets with files available on guest in case bucket is empty
- Support for offline provisioning of apt-packages by caching `/var/lib/apt/lists` [GH-84]
- Support for specifying custom cache bucket synced folder opts
- Support to force disabe the plugin [GH-72]
- Automatically disable the plugin for cloud providers [GH-45]
- Skip configuration of buckets that have been configured already [GH-85]
BUG FIXES:
- Properly fix NFS support for Vagrant 1.4+ [GH-76]
## [0.5.1](https://github.com/fgrehm/vagrant-cachier/compare/v0.5.0...v0.5.1) (Dec 20, 2013)
BUG FIXES:
- Fix NFS support for Vagrant 1.4+ [GH-67]
## [0.5.0](https://github.com/fgrehm/vagrant-cachier/compare/v0.4.1...v0.5.0) (Nov 8, 2013)
FEATURES:
- Support for [zypper] [GH-54]
## [0.4.1](https://github.com/fgrehm/vagrant-cachier/compare/v0.4.0...v0.4.1) (Oct 27, 2013)
BUG FIXES:
- Do not attempt to configure apt-cacher-ng bucket if it is not installed on guest
machine.
## [0.4.0](https://github.com/fgrehm/vagrant-cachier/compare/v0.3.3...v0.4.0) (Oct 23, 2013)
FEATURES:
- Support for [npm](https://npmjs.org/) [GH-51]
- Support for [Composer](http://getcomposer.org/) [GH-48]
- Support for `apt-cacher-ng` [GH-30]
BUG FIXES:
- Allow halting nonresponsive machine when plugin is installed [GH-8]
## [0.3.3](https://github.com/fgrehm/vagrant-cachier/compare/v0.3.2...v0.3.3) (Sep 11, 2013)
BUG FIXES:
- Automatically create `partial` dir under apt cache bucket dir to allow usage
on Ubuntu 10.04 guests [GH-40]
## [0.3.2](https://github.com/fgrehm/vagrant-cachier/compare/v0.3.1...v0.3.2) (Aug 14, 2013)
BUG FIXES:
- Prevent errors when caching is disabled and a provisioner is enabled [GH-41]
## [0.3.1](https://github.com/fgrehm/vagrant-cachier/compare/v0.3.0...v0.3.1) (Aug 13, 2013)
BUG FIXES:
- Prevent errors when caching is disabled
## [0.3.0](https://github.com/fgrehm/vagrant-cachier/compare/v0.2.0...v0.3.0) (Aug 5, 2013)
BACKWARDS INCOMPATIBILITIES:
- Machine scoped cache dirs are now kept on `.vagrant/machines/MACHINE/cache`
to allow downloaded packages to be reused between providers. If a single cache
directory exists, the plugin will automatically move it to the right place,
if multiple directories are found, it will halt execution and will error out,
letting the user know what has to be done in order to fix things.
FEATURES:
- Add `file_cache_path` support for Chef. [GH-14]
- Reconfigure buckets before each provisioner. [GH-26] / [GH-32]
IMPROVEMENTS:
- Don't error out if a bucket is configured for a non-capable guest. [GH-27]
## [0.2.0](https://github.com/fgrehm/vagrant-cachier/compare/v0.1.0...v0.2.0) (July 10, 2013)
FEATURES:
- Support enabling NFS for root cache folder. [GH-7]
- Support RVM bucket
## [0.1.0](https://github.com/fgrehm/vagrant-cachier/compare/v0.0.6...v0.1.0) (June 9, 2013)
IMPROVEMENTS:
- Moves from `Vagrant` to recommended `VagrantPlugins` top-level
module namespace. [GH-9]
## 0.0.6 (May 22, 2013)
- Initial public release.
vagrant-cachier-1.2.1/Gemfile 0000664 0000000 0000000 00000000456 12545554713 0016064 0 ustar 00root root 0000000 0000000 source 'https://rubygems.org'
group :development do
gem 'vagrant', github: 'mitchellh/vagrant', tag: 'v1.7.2'
gem 'rake'
end
group :plugins do
gemspec
gem 'vagrant-lxc', github: 'fgrehm/vagrant-lxc'
gem 'vagrant-pristine', github: 'fgrehm/vagrant-pristine'
gem 'vagrant-omnibus'
end
vagrant-cachier-1.2.1/Gemfile.lock 0000664 0000000 0000000 00000005333 12545554713 0017012 0 ustar 00root root 0000000 0000000 GIT
remote: git://github.com/fgrehm/vagrant-lxc.git
revision: c9cd671a32f730fff4b6e4fdd3687a531af0663c
specs:
vagrant-lxc (1.1.0)
GIT
remote: git://github.com/fgrehm/vagrant-pristine.git
revision: 503dbc47848c81d0fbfa6840491856f518d244a1
specs:
vagrant-pristine (0.3.0)
GIT
remote: git://github.com/mitchellh/vagrant.git
revision: 1cd667b243f4a263cd5322b6455165cc676b6f7f
tag: v1.7.2
specs:
vagrant (1.7.2)
bundler (>= 1.5.2, < 1.8.0)
childprocess (~> 0.5.0)
erubis (~> 2.7.0)
hashicorp-checkpoint (~> 0.1.1)
i18n (~> 0.6.0)
listen (~> 2.8.0)
log4r (~> 1.1.9, < 1.1.11)
net-scp (~> 1.1.0)
net-sftp (~> 2.1)
net-ssh (>= 2.6.6, < 2.10.0)
nokogiri (= 1.6.3.1)
rb-kqueue (~> 0.2.0)
rest-client (>= 1.6.0, < 2.0)
wdm (~> 0.1.0)
winrm (~> 1.1.3)
PATH
remote: .
specs:
GEM
remote: https://rubygems.org/
specs:
akami (1.2.2)
gyoku (>= 0.4.0)
nokogiri
builder (3.2.2)
celluloid (0.16.0)
timers (~> 4.0.0)
childprocess (0.5.5)
ffi (~> 1.0, >= 1.0.11)
erubis (2.7.0)
ffi (1.9.6)
gssapi (1.0.3)
ffi (>= 1.0.1)
gyoku (1.2.2)
builder (>= 2.1.2)
hashicorp-checkpoint (0.1.4)
hitimes (1.2.2)
httpclient (2.6.0.1)
httpi (0.9.7)
rack
i18n (0.6.11)
listen (2.8.5)
celluloid (>= 0.15.2)
rb-fsevent (>= 0.9.3)
rb-inotify (>= 0.9)
little-plugger (1.1.3)
log4r (1.1.10)
logging (1.8.2)
little-plugger (>= 1.1.3)
multi_json (>= 1.8.4)
mime-types (2.4.3)
mini_portile (0.6.0)
multi_json (1.10.1)
net-scp (1.1.2)
net-ssh (>= 2.6.5)
net-sftp (2.1.2)
net-ssh (>= 2.6.5)
net-ssh (2.9.2)
netrc (0.10.2)
nokogiri (1.6.3.1)
mini_portile (= 0.6.0)
nori (1.1.5)
rack (1.6.0)
rake (10.4.2)
rb-fsevent (0.9.4)
rb-inotify (0.9.5)
ffi (>= 0.5.0)
rb-kqueue (0.2.3)
ffi (>= 0.5.0)
rest-client (1.7.2)
mime-types (>= 1.16, < 3.0)
netrc (~> 0.7)
rubyntlm (0.1.1)
savon (0.9.5)
akami (~> 1.0)
builder (>= 2.1.2)
gyoku (>= 0.4.0)
httpi (~> 0.9)
nokogiri (>= 1.4.0)
nori (~> 1.0)
wasabi (~> 1.0)
timers (4.0.1)
hitimes
uuidtools (2.1.5)
vagrant-omnibus (1.4.1)
wasabi (1.0.0)
nokogiri (>= 1.4.0)
wdm (0.1.0)
winrm (1.1.3)
gssapi (~> 1.0.0)
httpclient (~> 2.2, >= 2.2.0.2)
logging (~> 1.6, >= 1.6.1)
nokogiri (~> 1.5)
rubyntlm (~> 0.1.1)
savon (= 0.9.5)
uuidtools (~> 2.1.2)
PLATFORMS
ruby
DEPENDENCIES
rake
vagrant!
vagrant-cachier!
vagrant-lxc!
vagrant-omnibus
vagrant-pristine!
BUNDLED WITH
1.10.4
vagrant-cachier-1.2.1/LICENSE.txt 0000664 0000000 0000000 00000002060 12545554713 0016405 0 ustar 00root root 0000000 0000000 Copyright (c) 2013-2014 Fabio Rehm
MIT License
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.
vagrant-cachier-1.2.1/README.md 0000664 0000000 0000000 00000005710 12545554713 0016046 0 ustar 00root root 0000000 0000000 # vagrant-cachier
[](http://badge.fury.io/rb/vagrant-cachier) [](https://gitter.im/fgrehm/vagrant-cachier)
A [Vagrant](http://www.vagrantup.com/) plugin that helps you reduce the amount of
coffee you drink while waiting for boxes to be provisioned by sharing a common
package cache among similar VM instances. Kinda like [vagrant-apt_cache](https://github.com/avit/vagrant-apt_cache)
or [this magical snippet](http://gist.github.com/juanje/3797297) but targeting
multiple package managers and Linux distros.
## Help Needed!
This project is looking for maintainers, please see [GH-143](https://github.com/fgrehm/vagrant-cachier/issues/143) for more.
## Installation
Make sure you have Vagrant 1.4+ and run:
```
vagrant plugin install vagrant-cachier
```
## Quick start
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'your-box'
if Vagrant.has_plugin?("vagrant-cachier")
# Configure cached packages to be shared between instances of the same base box.
# More info on http://fgrehm.viewdocs.io/vagrant-cachier/usage
config.cache.scope = :box
# OPTIONAL: If you are using VirtualBox, you might want to use that to enable
# NFS for shared folders. This is also very useful for vagrant-libvirt if you
# want bi-directional sync
config.cache.synced_folder_opts = {
type: :nfs,
# The nolock option can be useful for an NFSv3 client that wants to avoid the
# NLM sideband protocol. Without this option, apt-get might hang if it tries
# to lock files needed for /var/cache/* operations. All of this can be avoided
# by using NFSv4 everywhere. Please note that the tcp option is not the default.
mount_options: ['rw', 'vers=3', 'tcp', 'nolock']
}
# For more information please check http://docs.vagrantup.com/v2/synced-folders/basic_usage.html
end
end
```
For more information please read the documentation available at
http://fgrehm.viewdocs.io/vagrant-cachier.
## Providers that are known to work
* Vagrant's built in VirtualBox and Docker providers
* [vagrant-lxc](https://github.com/fgrehm/vagrant-lxc)
* [VMware providers](http://www.vagrantup.com/vmware) with NFS enabled (See
[GH-24](https://github.com/fgrehm/vagrant-cachier/issues/24) for more info)
* [vagrant-libvirt](https://github.com/pradels/vagrant-libvirt)
* [vagrant-kvm](https://github.com/adrahon/vagrant-kvm)
* _[Let us know if it is compatible with other providers!](https://github.com/fgrehm/vagrant-cachier/issues/new)_
_Please note that as of v0.6.0 the plugin will automatically disable any
previously defined configs for [cloud providers](lib/vagrant-cachier/plugin.rb#L19-22)_
## Contributing
1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request
vagrant-cachier-1.2.1/Rakefile 0000664 0000000 0000000 00000000145 12545554713 0016231 0 ustar 00root root 0000000 0000000 Dir['./tasks/**/*.rake'].each { |f| load f }
require 'bundler/gem_tasks'
task :ci => ['spec:unit']
vagrant-cachier-1.2.1/development/ 0000775 0000000 0000000 00000000000 12545554713 0017106 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/development/Cheffile 0000664 0000000 0000000 00000000144 12545554713 0020535 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby
#^syntax detection
site 'http://community.opscode.com/api/v1'
cookbook 'java'
vagrant-cachier-1.2.1/development/Cheffile.lock 0000664 0000000 0000000 00000000153 12545554713 0021464 0 ustar 00root root 0000000 0000000 SITE
remote: http://community.opscode.com/api/v1
specs:
java (1.19.2)
DEPENDENCIES
java (>= 0)
vagrant-cachier-1.2.1/development/Vagrantfile 0000664 0000000 0000000 00000010052 12545554713 0021271 0 ustar 00root root 0000000 0000000 # -*- mode: ruby -*-
# vi: set ft=ruby :
Vagrant.configure("2") do |config|
config.vm.synced_folder "../", "/vagrant", id: 'vagrant-root'
config.cache.scope = :machine
config.cache.auto_detect = true
config.cache.synced_folder_opts = { type: :nfs }
config.vm.provider :virtualbox do |vb|
vb.customize [ "modifyvm", :id, "--memory", 256, "--cpus", "1" ]
end
config.vm.provider :lxc do |lxc|
lxc.customize 'aa_profile', 'unconfined'
end
configure_private_network = lambda do |node, suffix|
node.vm.network :private_network, ip: "192.168.50.#{suffix}"
end
initial_debian_setup = lambda do |debian, git_pkg = 'git'|
debian.vm.provision :shell, inline: "apt-get update && apt-get install -y #{git_pkg} php5-cli curl wget htop"
end
install_nvm_and_rvm = lambda do |node|
# Installs RVM
node.vm.provision :shell, inline: '
if ! [ -d /home/vagrant/.rvm ]; then
HOME=/home/vagrant su -p vagrant -l -c "curl -L https://get.rvm.io | bash -s stable"
fi
'
# Here we have the RVM cache bucket configured, so we install 2.0.0
node.vm.provision :shell, inline: '
if ! [ -d /home/vagrant/.rvm/rubies/ruby-2.0.0* ]; then
HOME=/home/vagrant su -p vagrant -l -c "rvm install 2.0.0 && rvm use 2.0.0 --default"
fi
'
node.vm.provision :shell, inline: '
if ! [ -d /home/vagrant/.nvm ]; then
apt-get install git -y
HOME=/home/vagrant su -p vagrant -l -c "
curl https://raw.github.com/creationix/nvm/master/install.sh | sh
"
fi
'
node.vm.provision :shell, inline: '
if ! [ -d /home/vagrant/.nvm/v0.10* ]; then
HOME=/home/vagrant su -p vagrant -l -c "
nvm install 0.10
nvm alias default 0.10
"
fi
'
end
config.vm.define :ubuntu do |ubuntu|
ubuntu.vm.box = "raring64"
ubuntu.vm.provider :lxc do |_, override|
override.vm.box = 'fgrehm/raring64-lxc'
end
configure_private_network.call ubuntu, 10
initial_debian_setup.call(ubuntu)
install_nvm_and_rvm.call(ubuntu)
ubuntu.omnibus.chef_version = :latest
ubuntu.vm.provision :chef_solo do |chef|
chef.add_recipe "cachier::default"
end
end
config.vm.define :lucid do |lucid|
lucid.vm.box = "lucid64"
# Disable NFS
lucid.cache.synced_folder_opts = { }
configure_private_network.call lucid, 11
initial_debian_setup.call(lucid, 'git-core')
install_nvm_and_rvm.call(lucid)
end
config.vm.define :debian do |debian|
debian.vm.box = "squeeze64"
debian.vm.box_url = 'http://f.willianfernandes.com.br/vagrant-boxes/DebianSqueeze64.box'
configure_private_network.call debian, 12
initial_debian_setup.call(debian)
install_nvm_and_rvm.call(debian)
end
config.vm.define :centos do |centos|
centos.vm.box = 'centos6_64'
centos.vm.box_url = 'http://developer.nrel.gov/downloads/vagrant-boxes/CentOS-6.4-x86_64-v20130309.box'
configure_private_network.call centos, 13
centos.vm.provision :shell, inline: '
(
mkdir -p /tmp/epel
cd /tmp/epel
wget http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
wget http://rpms.famillecollet.com/enterprise/remi-release-6.rpm
sudo rpm -Uvh remi-release-6*.rpm epel-release-6*.rpm
)
yum install -y libffi-devel ruby-devel git
'
centos.vm.provision :shell, inline: 'gem install bundler'
end
config.vm.define :arch do |arch|
arch.vm.box = 'arch64'
arch.vm.box_url = 'https://dl.dropboxusercontent.com/u/6750592/Arch_Linux_2013.11_x64.box'
# Disable NFS
arch.cache.synced_folder_opts = { }
arch.vm.provision :shell, inline: 'pacman -Syu --noconfirm libffi git ruby && gem install bundler'
end
config.vm.define :opensuse do |suse|
suse.vm.box = 'opensuse-12'
suse.vm.box_url = 'http://sourceforge.net/projects/opensusevagrant/files/12.3/opensuse-12.3-64.box/download'
# Disable NFS
suse.cache.synced_folder_opts = { }
suse.vm.provision :shell, inline: 'time zypper install -y git'
end
end
vagrant-cachier-1.2.1/development/cookbooks/ 0000775 0000000 0000000 00000000000 12545554713 0021077 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/development/cookbooks/cachier/ 0000775 0000000 0000000 00000000000 12545554713 0022475 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/development/cookbooks/cachier/recipes/ 0000775 0000000 0000000 00000000000 12545554713 0024127 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/development/cookbooks/cachier/recipes/default.rb 0000664 0000000 0000000 00000000312 12545554713 0026074 0 ustar 00root root 0000000 0000000 zip_filepath = "#{Chef::Config['file_cache_path']}/vagrant-cachier.tar.gz"
zip_url = "https://github.com/fgrehm/vagrant-cachier/archive/v0.6.0.tar.gz"
remote_file(zip_filepath) { source zip_url }
vagrant-cachier-1.2.1/docs/ 0000775 0000000 0000000 00000000000 12545554713 0015514 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/docs/benchmarks.md 0000664 0000000 0000000 00000005360 12545554713 0020157 0 ustar 00root root 0000000 0000000 # Benchmarks
During the early days of this plugin, [@fgrehm](https://github.com/fgrehm) wrote
a [blog post](http://fabiorehm.com/blog/2013/05/24/stop-wasting-bandwidth-with-vagrant-cachier#show_me_the_numbers)
with some benchmarks on the time that was cut down by using the plugin. If you
are interested on the numbers only, the VMs tested were one of vagrant-lxc's
Ubuntu [dev boxes](https://github.com/fgrehm/vagrant-lxc/wiki/Development#using-virtualbox-for-development),
[rails-dev-box](https://github.com/rails/rails-dev-box), his own [rails-base-box](https://github.com/fgrehm/rails-base-box)
and Discourse's [dev box](https://github.com/discourse/discourse/blob/master/Vagrantfile)
| | First provision | Second provision | Diff. | APT cache |
| --- | :---: | :---: | :---: | :---: |
| rails-dev-box | 4m45s | 3m20s | ~29% | 66mb |
| rails-base-box | 11m56s | 7m54s | ~34% | 77mb |
| vagrant-lxc | 10m16s | 5m9s | ~50% | 124mb |
| discourse | 1m41s | 49s | ~51% | 62mb |
_Please note that the tests were made on May 24th 2013 and nowadays they might
be a bit different_
Some people have shared their numbers on Twitter and had experienced even better
results:
Holy cow... If you dig Vagrant, and like time - you need Vagrant Cachier. 60% speed increase for me. https://t.co/225jRH7bDa@vagrantup
vagrant-cachier took my vagrant spin up from 30 to 5 minutes and reduced my caffeine intake by 3 cups http://t.co/V0uYpr3U0y
— Russell Cardullo (@russellcardullo) June 7, 2013
vagrant-cachier-1.2.1/docs/buckets/ 0000775 0000000 0000000 00000000000 12545554713 0017154 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/docs/buckets/apt-cacher.md 0000664 0000000 0000000 00000002041 12545554713 0021502 0 ustar 00root root 0000000 0000000 # APT-CACHER
Used by Debian-like Linux distros, will get configured under guest's `/var/cache/apt-cacher-ng`
and only works with NFS-shared folders since `vboxsf` is enforcing `vagrant`-user and `apt-cacher`
is running under `apt-cacher-ng` user.
To manually enable it:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'some-debian-box'
config.cache.enable :apt_cacher
end
```
One use case for this bucket is if you are using containers inside your VMs, e.g
VirtualBox -> LXC. This would allow you to reuse packages without sharing folder
inside VirtualBox:
# install apt-cacher on (Host)-VM
$ sudo apt-get install apt-cacher-ng
# get the IP for eth0 interface
$ ifconfig eth0 |grep "inet addr"|awk '{print $2}' |cut -c6-20
# configure mirror on for your docker/LXC instances:
$ echo 'Acquire::http { Proxy "http://X.X.X.X:3142"; };' > /etc/apt/apt.conf.d/10mirror
# check, if working by tailing log on (Host)-VM, while installing packages on (Guest)-VMs
$ tail -f /var/log/apt-cacher-ng/apt-cacher.log
vagrant-cachier-1.2.1/docs/buckets/apt-lists.md 0000664 0000000 0000000 00000001772 12545554713 0021425 0 ustar 00root root 0000000 0000000 # APT lists
Used by Debian-like Linux distros, will get configured under guest's `/var/lib/apt/lists`.
As explained on [Wikipedia](http://en.wikipedia.org/wiki/Advanced_Packaging_Tool#Files),
`/var/lib/apt/lists` is the "storage area for state information for each package
resource specified in sources.list". By enabling this bucket, `apt` will be able
to install cached packages without hitting the remote repositories for the main
package lists, [being particularly useful when developing offline](https://github.com/fgrehm/vagrant-cachier/pull/84#issue-27311414).
To manually enable it:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'some-debian-box'
config.cache.enable :apt_lists
end
```
## Heads up!
This bucket is automatically disabled for Windows hosts, please have a look at
the following issues for more information:
* https://github.com/fgrehm/vagrant-cachier/issues/106
* https://github.com/fgrehm/vagrant-cachier/issues/109
* https://github.com/fgrehm/vagrant-cachier/issues/113
vagrant-cachier-1.2.1/docs/buckets/apt.md 0000664 0000000 0000000 00000000760 12545554713 0020265 0 ustar 00root root 0000000 0000000 # APT
Used by Debian-like Linux distros, will get configured under guest's `/var/cache/apt/archives`.
To manually enable it:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'some-debian-box'
config.cache.enable :apt
end
```
_Please note that to avoid re-downloading packages, you should avoid `apt-get clean`
as much as possible in order to make a better use of the cache, even if you are
packaging a box since the downloaded packages are actually stored on the host
machine._
vagrant-cachier-1.2.1/docs/buckets/bower.md 0000664 0000000 0000000 00000000457 12545554713 0020622 0 ustar 00root root 0000000 0000000 # [Bower](http://bower.io/)
Compatible with probably any type of linux guest distro, will cache guests'
`$HOME/.cache/bower` if bower is detected.
To manually enable it:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'some-box-with-bower-installed'
config.cache.enable :bower
end
```
vagrant-cachier-1.2.1/docs/buckets/chef.md 0000664 0000000 0000000 00000000461 12545554713 0020404 0 ustar 00root root 0000000 0000000 # Chef
When a Chef provisioner is detected, this bucket caches the default
`file_cache_path` directory, `/var/chef/cache`. Requires Vagrant 1.2.4+.
To manually enable it:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'some-box-using-chef-provisioner'
config.cache.enable :chef
end
```
vagrant-cachier-1.2.1/docs/buckets/chef_rubygems.md 0000664 0000000 0000000 00000001036 12545554713 0022320 0 ustar 00root root 0000000 0000000 # Chef RubyGems
When a Chef installation is detected, this bucket caches its embedded gems.
Most of these gems are part of the Chef omnibus package but sometimes cookbooks
need to install extra gems to run within the context of a Chef recipe using the
`chef_gem` resource.
The embedded Chef gem location is returned by running the
`/opt/chef/embedded/bin/gem env gemdir` command.
To manually enable it:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'some-box-using-chef-provisioner'
config.cache.enable :chef_gem
end
```
vagrant-cachier-1.2.1/docs/buckets/composer.md 0000664 0000000 0000000 00000000473 12545554713 0021331 0 ustar 00root root 0000000 0000000 # [Composer](http://getcomposer.org/)
Compatible with probably any type of linux guest distro, will cache guests'
`$HOME/.composer/cache` if PHP is detected.
To manually enable it:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'some-box-with-php-installed'
config.cache.enable :composer
end
```
vagrant-cachier-1.2.1/docs/buckets/generic.md 0000664 0000000 0000000 00000002157 12545554713 0021117 0 ustar 00root root 0000000 0000000 # Generic
This bucket is never enabled by default. You have to enable it explicitly like
this:
```ruby
Vagrant.configure("2") do |config|
config.cache.enable :generic, { :cache_dir => "/var/cache/some" }
end
```
The `:cache_dir` parameter is required. It specifies the directory on the guest
that will be cached under the "/tmp/vagrant-cache/generic" bucket.
You may enable more than one generic bucket by giving them different names,
like this:
```ruby
Vagrant.configure("2") do |config|
config.cache.enable :generic, {
"one" => { cache_dir: "/var/cache/one" },
"two" => { cache_dir: "/var/cache/two" },
}
end
```
In this case you get two buckets called "one" and "two" under the guest's
`/tmp/vagrant-cache` directory.
The Generic bucket is useful if you want to implement a caching mechanism by
hand. For instance, if you want to cache your wget downloads under
`/var/cache/wget` you can do this:
```ruby
Vagrant.configure("2") do |config|
config.cache.enable :generic, {
"wget" => { cache_dir: "/var/cache/wget" },
}
end
```
Then, you invoke wget like this:
```sh
wget -N -P /var/cache/wget URL
```
vagrant-cachier-1.2.1/docs/buckets/npm.md 0000664 0000000 0000000 00000001142 12545554713 0020266 0 ustar 00root root 0000000 0000000 # [npm](https://npmjs.org/)
Compatible with probably any type of linux guest distro, will hook into npm's
cache directory under the result of running `npm config get cache` as
the default SSH user (usually `vagrant`) on your guest.
To manually enable it:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'some-box-with-nodejs-installed'
config.cache.enable :npm
end
```
If you use [nvm](https://github.com/creationix/nvm) / [n](https://github.com/visionmedia/n)
on the guest machine, make sure it is already installed before enabling
the bucket, otherwise you won't benefit from this plugin.
vagrant-cachier-1.2.1/docs/buckets/pacman.md 0000664 0000000 0000000 00000000353 12545554713 0020736 0 ustar 00root root 0000000 0000000 # Pacman
Used by Arch Linux, will get configured under guest's `/var/cache/pacman/pkg`.
To manually enable it:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'some-arch-linux-box'
config.cache.enable :pacman
end
```
vagrant-cachier-1.2.1/docs/buckets/rubygems.md 0000664 0000000 0000000 00000001506 12545554713 0021335 0 ustar 00root root 0000000 0000000 # RubyGems
Compatible with probably with any type of guest distro, will hook into the `cache`
folder under the result of running `gem env gemdir` as the default SSH user (usualy
`vagrant`) on your guest. If you use rbenv / rvm on the guest machine, make sure
it is already installed before enabling the bucket, otherwise you won't benefit
from this plugin.
To manually enable it:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'some-box-with-ruby-installed'
config.cache.enable :gem
end
```
## Heads up about `bundle install --deployment`
Please note that when the `--deployment` flag is passed on to `bundle install`
your gems **will not be cached** since bundler ends up skipping the default gem
cache dir. For more information about this, please check [GH-62](https://github.com/fgrehm/vagrant-cachier/issues/62).
vagrant-cachier-1.2.1/docs/buckets/rvm.md 0000664 0000000 0000000 00000003345 12545554713 0020307 0 ustar 00root root 0000000 0000000 # [rvm](https://rvm.io/)
Compatible with probably with any type of linux guest distro, will hook into the
`cache` folder under the result of running rvm info as the default SSH user (usualy
`vagrant`) on your guest. If you use rvm on the guest machine, make sure it is
already installed before enabling the bucket, otherwise you won't benefit from
this plugin.
To manually enable it:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'some-box-with-rvm-installed'
config.cache.enable :gem
end
```
## Heads up!
If you are installing rvm, rubies and gems on a single provisioning step, **you
will not benefit from this bucket**. There is absolutely no way we can "magically"
hook into your provisioning scripts to configure things for leveraging the cache.
For instance, the following shell provisioner **will result in no package cached at
all**:
```ruby
config.vm.provision :shell, privileged: false, inline: %[
curl -L https://get.rvm.io | bash -s stable
rvm install 1.9.3
rvm use 1.9.3 --default
cd /path/to/project
bundle install
]
```
To work around that you can either configure things by hand on your provisioning
scripts or you can enable automatic bucket detection and split your scripts into
multiple stages:
```ruby
# Install RVM so that Ruby tarballs are cached
config.vm.provision :shell, privileged: false, inline: %[
curl -L https://get.rvm.io | bash -s stable
]
# Install Ruby 1.9.3 making use of the RVM cache and configure the RubyGems
# cache afterwards
config.vm.provision :shell, privileged: false, inline: %[
rvm install 1.9.3
rvm use 1.9.3 --default
]
# Install gems making use of the RubyGems cache
config.vm.provision :shell, privileged: false, inline: %[
cd /path/to/project
bundle install
]
```
vagrant-cachier-1.2.1/docs/buckets/yum.md 0000664 0000000 0000000 00000001223 12545554713 0020306 0 ustar 00root root 0000000 0000000 # Yum
Used by CentOS guests, will get configured under guest's `/var/cache/yum`. It will
also [make sure](lib/vagrant-cachier/bucket/yum.rb#L20) that `keepcache` is set to
`1` on guest's `/etc/yum.conf`.
To manually enable it:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'some-centos-box'
config.cache.enable :yum
end
```
### :warning: Notice about Windows hosts :warning:
In case this bucket is enabled and a Windows host is in use, you might see an
ugly stacktrace as described on [this comment](https://github.com/fgrehm/vagrant-cachier/issues/117#issuecomment-50548393)
if some Yum repository is not available during provisioning.
vagrant-cachier-1.2.1/docs/buckets/zypper.md 0000664 0000000 0000000 00000000542 12545554713 0021030 0 ustar 00root root 0000000 0000000 # Zypper
Used by SuSE guests, will get configured under guest's `/var/cache/zypp/packages`. It will
also [make sure](lib/vagrant-cachier/bucket/zypper.rb#L20) that `keep-packages` is enabled
for all repositories.
To manually enable it:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'some-suse-box'
config.cache.enable :zypper
end
```
vagrant-cachier-1.2.1/docs/development.md 0000664 0000000 0000000 00000005136 12545554713 0020365 0 ustar 00root root 0000000 0000000 # Development
## Installing from sources
If you want to install the plugin from sources:
```bash
git clone https://github.com/fgrehm/vagrant-cachier.git
cd vagrant-cachier
bundle install
bundle exec rake build
vagrant plugin install pkg/vagrant-cachier-VERSION.gem
```
## Sanity checks
While we don't get to implement some proper unit testing, there are some basic [Bats](https://github.com/sstephenson/bats)
tests that basically acts as a [sanity check](https://github.com/fgrehm/vagrant-cachier/blob/master/spec/acceptance/sanity_check.bats)
that you can run with `bats spec/acceptance` in case you are planning to submit a
Pull Request. Just keep in mind that it might take a while to run if you are
using the default VirtualBox provider.
## How to create a new bucket?
The concept of a cache _bucket_ is pretty easy to understand, we basically
symlink a folder under the guest's `/tmp/vagrant-cache` into the folder where
other tools keep downloaded packages. For example, in the case of the
[apt bucket](buckets/apt), we symlink `/var/cache/apt/archives` to
`/tmp/vagrant-cache/apt` so that `.deb` packages downloaded with `apt-get install`
can be reused when bringing machines up from scratch.
If you want to see some other package manager supported, you'll first need to
know if it has some sort of caching in place, where does it get stored and if
it needs some extra configuration. For some managers that path will be fixed
(like the canonical apt bucket), for others you might need to read some
configuration by [running a command](https://github.com/fgrehm/vagrant-cachier/blob/master/lib/vagrant-cachier/cap/linux/rvm_path.rb#L10)
on the guest VM (like [rvm](buckets/rvm)) and you might even need to [tweak some configs](https://github.com/fgrehm/vagrant-cachier/blob/master/lib/vagrant-cachier/bucket/yum.rb#L20)
on the guest (like the [yum](buckets/yum) bucket).
There's currently a lot of duplication around the "installation" of cache buckets
so there's plenty of source code for you to read in order to understand how
things work under the hood but if you don't feel comfortable reading / writing
Ruby code you can provide a high level overview of how to do things using plain
old bash.
For example, if you were to explain how to set up the rvm bucket, the script
below should give vagrant-cachier maintainers an overview of how to set things
up:
```bash
# Check is rvm is installed
if ! $(rvm info > /dev/null); then
exit 0
fi
# If it is installed, read the cache dir
RVM_CACHE="${rvm_path}/archives"
# "Install" the bucket!
mkdir -p /tmp/vagrant-cache/rvm/archives
ln -s /tmp/vagrant-cache/rvm/archives $RVM_CACHE
```
vagrant-cachier-1.2.1/docs/how-does-it-work.md 0000664 0000000 0000000 00000003674 12545554713 0021167 0 ustar 00root root 0000000 0000000 ## How does it work?
On vagrant-cachier's _"jargon"_, cached packages are kept in _cache buckets_.
Those _buckets_ are basically directories that are shared between the host machine
and VMs that are kept around between `vagrant destroy`s. Each _bucket_ (or synced
folder if you prefer) is meant to cache specific types of packages, like [apt](buckets/apt)'s
`.deb`s or [RubyGems](buckets/rubygems) `.gem`s. Please have a look at the
"Available Buckets" menu above for more information on each bucket.
Regarding configurations, right now the plugin does not make any assumptions for
you and you have to configure things properly from your `Vagrantfile`. In other
words, _the plugin is disabled by default_.
Cache buckets will always be available from `/tmp/vagrant-cache` on your guest and
the appropriate folders will get symlinked to the right path _after_ the machine is
up but _right before_ it gets provisioned. We _could_ potentially do it on one go
and share bucket's folders directly to the right path if we were only using VirtualBox
because it shares folders _after_ booting the machine but the LXC provider does that
_as part of_ the boot process (synced folders are actually `lxc-start` parameters)
and as of now we are not able to get some information that this plugin requires
about the guest machine / container before it is actually up and running.
Under the hood, the plugin will hook into Vagrant in order to set things up for each
configured cache bucket _before and after_ running each defined provisioner. Before
halting the machine, it will also revert the changes required to set things up by
hooking into calls to `Vagrant::Builtin::GracefulHalt` so that you can repackage
the machine for others to use without requiring users to install the plugin as well.
Please keep in mind that this plugin won't do magic, if you are compiling things
during provisioning or manually downloading packages outside of a bucket you
won't see that much of improvement.
vagrant-cachier-1.2.1/docs/index.md 0000664 0000000 0000000 00000004671 12545554713 0017155 0 ustar 00root root 0000000 0000000 # vagrant-cachier
A [Vagrant](http://www.vagrantup.com/) plugin that helps you reduce the amount of
coffee you drink while waiting for boxes to be provisioned by sharing a common
package cache among similiar VM instances. Kinda like [vagrant-apt_cache](https://github.com/avit/vagrant-apt_cache)
or [this magical snippet](http://gist.github.com/juanje/3797297) but targetting
multiple package managers and Linux distros.
## Installation
Make sure you have Vagrant 1.4+ and run:
```
vagrant plugin install vagrant-cachier
```
## Quick start
The easiest way to set things up is just to enable [cache buckets auto detection](usage)
from within your `Vagrantfile`:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'your-box'
if Vagrant.has_plugin?("vagrant-cachier")
# Configure cached packages to be shared between instances of the same base box.
# More info on the "Usage" link above
config.cache.scope = :box
# OPTIONAL: If you are using VirtualBox, you might want to use that to enable
# NFS for shared folders. This is also very useful for vagrant-libvirt if you
# want bi-directional sync
config.cache.synced_folder_opts = {
type: :nfs,
# The nolock option can be useful for an NFSv3 client that wants to avoid the
# NLM sideband protocol. Without this option, apt-get might hang if it tries
# to lock files needed for /var/cache/* operations. All of this can be avoided
# by using NFSv4 everywhere. Please note that the tcp option is not the default.
mount_options: ['rw', 'vers=3', 'tcp', 'nolock']
}
end
end
```
For more information please check out the links on the menu above.
## Providers that are known to work
* Vagrant's built in VirtualBox provider
* [vagrant-lxc](https://github.com/fgrehm/vagrant-lxc)
* [VMware providers](http://www.vagrantup.com/vmware) with NFS enabled (See
[GH-24](https://github.com/fgrehm/vagrant-cachier/issues/24) for more info)
* [vagrant-libvirt](https://github.com/pradels/vagrant-libvirt)
* [vagrant-kvm](https://github.com/adrahon/vagrant-kvm)
_Please note that as of v0.6.0 the plugin will automatically disable any
previously defined configs for [cloud providers](lib/vagrant-cachier/plugin.rb#L19-22)_
## Contributing
1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request
vagrant-cachier-1.2.1/docs/template.html 0000664 0000000 0000000 00000013177 12545554713 0020226 0 ustar 00root root 0000000 0000000
{{NAME}} :: viewdocs.io
vagrant-cachier-1.2.1/docs/usage.md 0000664 0000000 0000000 00000011413 12545554713 0017142 0 ustar 00root root 0000000 0000000 # Usage
## Being nice to others
It is a good practice to wrap plugin specific configuration with `has_plugin?` checks
so the user's Vagrantfiles do not break if `vagrant-cachier` is uninstalled or
the Vagrantfile is shared with people that don't have the plugin installed:
```ruby
Vagrant.configure("2") do |config|
# ...
if Vagrant.has_plugin?("vagrant-cachier")
# ... vagrant-cachier configs ...
end
end
```
## Cache scope
This is the only required configuration for the plugin to work and should be present
on your project's specific `Vagrantfile` or on your `~/.vagrant.d/Vagrantfile` in
order to enable it.
### `:box` scope
By setting `cache.scope` to `:box`, downloaded packages will get stored on a folder
scoped to base boxes under your `~/.vagrant.d/cache`. The idea is to leverage the
cache by allowing downloaded packages to be reused across projects. So, if your
`Vagrantfile` has something like:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'some-box'
if Vagrant.has_plugin?("vagrant-cachier")
config.cache.scope = :box
end
end
```
The cached files will be stored under `$HOME/.vagrant.d/cache/some-box`.
### `:machine` scope
If you are on a [multi VM environment](http://docs.vagrantup.com/v2/multi-machine/index.html),
there is a huge chance that you'll end up having issues by sharing the same bucket
across different machines. For example, if you `apt-get install` from two machines
at "almost the same time" you are probably going to hit a _"SystemError: Failed to
lock /var/cache/apt/archives/lock"_. To work around that, you can set the scope
to be based on machines:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'some-box'
if Vagrant.has_plugin?("vagrant-cachier")
config.cache.scope = :machine
end
end
```
This will tell vagrant-cachier to download packages to `.vagrant/machines//cache`
on your current project directory.
## Cache buckets automatic detection
This is the easiest way to get started with plugin and is enabled by default.
Under the hood, `vagrant-cachier` does its best to find out what is supported on the
guest machine and will set buckets accordingly.
If you want that behavior to be disabled, you can set `cache.auto_detect` to `false`
from your Vagrantfile:
```ruby
Vagrant.configure("2") do |config|
config.vm.box = 'some-box'
if Vagrant.has_plugin?("vagrant-cachier")
config.cache.scope = :machine # or :box
config.cache.auto_detect = false
end
end
```
## Enable buckets as needed
If for whatever reason you need to have a fined grained control over what buckets
are configured, you can do so by "cherry picking" them on your `Vagrantfile`:
```ruby
Vagrant.configure("2") do |config|
config.cache.auto_detect = false
config.cache.enable :apt
config.cache.enable :gem
end
```
_Please refer to the "Available Buckets" menu above to find out which buckets
are supported._
## Custom cache buckets synced folders options
For fine grained control over the cache bucket synced folder options you can use
the `synced_folder_opts` config. That's useful if, for example, you are using
VirtualBox and want to enable NFS for improved performance:
```ruby
Vagrant.configure("2") do |config|
config.cache.synced_folder_opts = {
type: :nfs,
# The nolock option can be useful for an NFSv3 client that wants to avoid the
# NLM sideband protocol. Without this option, apt-get might hang if it tries
# to lock files needed for /var/cache/* operations. All of this can be avoided
# by using NFSv4 everywhere. Please note that the tcp option is not the default.
mount_options: ['rw', 'vers=3', 'tcp', 'nolock']
}
end
```
Please referer to http://docs.vagrantup.com/v2/synced-folders/basic_usage.html for
more information about the supported parameters.
## Finding out disk space used by buckets
At some point we might implement a `vagrant cache stats` command that will give you that
information, but while that does not get implemented you can run the code below
if you are on a Linux machine:
```
# scope = :box (default)
$ du -h -d0 $HOME/.vagrant.d/cache
405M /home/user/.vagrant.d/cache/precise64
1.1G /home/user/.vagrant.d/cache/raring64
448M /home/user/.vagrant.d/cache/quantal64
# scope = :machine
$ du -h -d0 .vagrant/machines/*/cache
16K .vagrant/machines/precise/cache
90M .vagrant/machines/quantal/cache
210M .vagrant/machines/raring/cache
```
## Cleaning up cache buckets
At some point we might implement a `vagrant cache clean [bucket-name]` command that will
take care of things for you, but while that does not get implemented you can run
the code below if you are on a Linux machine:
```
# scope = :box (default)
$ rm -rf $HOME/.vagrant.d/cache//
# scope = :machine
$ rm -rf .vagrant/machines//cache/
```
vagrant-cachier-1.2.1/lib/ 0000775 0000000 0000000 00000000000 12545554713 0015332 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/lib/vagrant-cachier.rb 0000664 0000000 0000000 00000000126 12545554713 0020714 0 ustar 00root root 0000000 0000000 require 'vagrant'
require "vagrant-cachier/version"
require "vagrant-cachier/plugin"
vagrant-cachier-1.2.1/lib/vagrant-cachier/ 0000775 0000000 0000000 00000000000 12545554713 0020370 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/lib/vagrant-cachier/action/ 0000775 0000000 0000000 00000000000 12545554713 0021645 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/lib/vagrant-cachier/action/clean.rb 0000664 0000000 0000000 00000003661 12545554713 0023262 0 ustar 00root root 0000000 0000000 require 'timeout'
module VagrantPlugins
module Cachier
class Action
class Clean
def initialize(app, env)
@app = app
@logger = Log4r::Logger.new("vagrant::cachier::action::clean")
end
def call(env)
@env = env
@machine = env[:machine]
if symlinks.any?
env[:ui].info I18n.t('vagrant_cachier.cleanup')
if sshable?
symlinks.each do |symlink|
remove_symlink symlink
end
end
File.delete @machine.data_dir.join('cache_dirs').to_s
end
@app.call env
end
def sshable?
return if @machine.state.id != :running
# By default Vagrant will keep trying [1] to ssh connect to the VM for
# a long and we've got to prevent that from happening, so we just wait
# a few seconds and assume that the VM is halted / unresponsive and we
# carry on if it times out.
# [1] - https://github.com/mitchellh/vagrant/blob/57e95323b6600b146167f0f14f83b22dd31dd03f/plugins/communicators/ssh/communicator.rb#L185-L200
begin
Timeout.timeout(35) do
while true
return true if @machine.communicate.ready?
sleep 0.5
end
end
rescue Timeout::Error
@env[:ui].warn(I18n.t('vagrant_cachier.unable_to_ssh'))
end
return false
end
def symlinks
# TODO: Check if file exists instead of a blank rescue
@symlinks ||= @machine.data_dir.join('cache_dirs').read.split rescue []
end
def remove_symlink(symlink)
if @machine.communicate.test("test -L #{symlink}")
@logger.info "Removing symlink for '#{symlink}'"
@machine.communicate.sudo("unlink #{symlink}")
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/action/configure_bucket_root.rb 0000664 0000000 0000000 00000004010 12545554713 0026546 0 ustar 00root root 0000000 0000000 require 'timeout'
module VagrantPlugins
module Cachier
class Action
class ConfigureBucketRoot
def initialize(app, env)
@app = app
@logger = Log4r::Logger.new("vagrant::cachier::action::clean")
end
def call(env)
@env = env
if !env[:cache_buckets_folder_configured] && env[:machine].config.cache.enabled?
setup_buckets_folder
env[:cache_buckets_folder_configured] = true
end
@app.call env
end
def setup_buckets_folder
FileUtils.mkdir_p(cache_root.to_s) unless cache_root.exist?
synced_folder_opts = {id: "vagrant-cache"}
synced_folder_opts.merge!(@env[:machine].config.cache.synced_folder_opts || {})
@env[:machine].config.vm.synced_folder cache_root, '/tmp/vagrant-cache', synced_folder_opts
@env[:cache_dirs] = []
end
def cache_root
@cache_root ||= case @env[:machine].config.cache.scope.to_sym
when :box
@box_name = box_name
# Box is optional with docker provider
if @box_name.nil? && @env[:machine].provider_name.to_sym == :docker
@image_name = image_name
# Use the image name if it's set
if @image_name
bucket_name = @image_name.gsub(':', '-')
else
raise "Cachier plugin only supported with docker provider when image is used"
end
else
bucket_name = @box_name
end
@env[:home_path].join('cache', bucket_name)
when :machine
@env[:machine].data_dir.parent.join('cache')
else
raise "Unknown cache scope: '#{@env[:machine].config.cache.scope}'"
end
end
def box_name
@env[:machine].config.vm.box
end
def image_name
@env[:machine].provider_config.image
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/action/install_buckets.rb 0000664 0000000 0000000 00000004161 12545554713 0025362 0 ustar 00root root 0000000 0000000 require_relative '../bucket'
module VagrantPlugins
module Cachier
class Action
class InstallBuckets
def initialize(app, env, opts = {})
@app = app
@logger = Log4r::Logger.new("vagrant::cachier::action::clean")
@opts = opts
end
def call(env)
@app.call(env)
return unless env[:machine].config.cache.enabled?
chmod_bucket_root(env[:machine]) if @opts[:chmod]
configure_cache_buckets(env)
end
def chmod_bucket_root(machine)
machine.communicate.sudo 'mkdir -p /tmp/vagrant-cache'
# https://github.com/fgrehm/vagrant-cachier/issues/107
if ! smb_synced_folder_enabled?(machine)
@logger.info "'chmod'ing bucket root dir to 777..."
machine.communicate.sudo 'chmod 777 /tmp/vagrant-cache'
end
end
def configure_cache_buckets(env)
if env[:machine].config.cache.auto_detect
Bucket.auto_detect(env)
end
return unless env[:machine].config.cache.buckets.any?
env[:ui].info 'Configuring cache buckets...'
cache_config = env[:machine].config.cache
cache_config.buckets.each do |bucket_name, configs|
@logger.info "Installing #{bucket_name} with configs #{configs.inspect}"
Bucket.install(bucket_name, env, configs)
end
data_file = env[:machine].data_dir.join('cache_dirs')
data_file.open('w') { |f| f.print env[:cache_dirs].uniq.join("\n") }
end
def smb_synced_folder_enabled?(machine)
synced_folder_opts = machine.config.cache.synced_folder_opts
synced_folder_opts ||= {}
# If smb was explicitly enabled
if synced_folder_opts[:type] && synced_folder_opts[:type].to_s == 'smb'
return true
elsif machine.provider_name.to_sym == :hyperv
# If the provider in use is hyperv, the default synced folder is 'smb'
# unless specified
return synced_folder_opts[:type] == nil
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/bucket.rb 0000664 0000000 0000000 00000005754 12545554713 0022205 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Bucket
def self.inherited(base)
@buckets ||= []
@buckets << base
end
def self.auto_detect(env)
@buckets.each do |bucket|
if bucket.respond_to?(:capability) && env[:machine].guest.capability?(bucket.capability)
env[:machine].config.cache.enable bucket.bucket_name
end
end
end
def self.bucket_name
class_name = self.name.split('::').last
class_name.scan(/[A-Z][a-z]*/).map{|x| x.downcase}.join("_")
end
def self.install(name, env, configs)
bucket = const_get(name.to_s.split("_").map{|x| x.capitalize}.join(""))
bucket.new(name, env, configs).install
end
def initialize(name, env, configs)
@name = name
@env = env
@configs = configs
end
def machine
@env[:machine]
end
def guest
machine.guest
end
def comm
machine.communicate
end
# TODO: "merge" symlink and user_symlink methods
def symlink(guest_path, bucket_path = "/tmp/vagrant-cache/#{@name}")
return if @env[:cache_dirs].include?(guest_path)
@env[:cache_dirs] << guest_path
comm.execute("mkdir -p #{bucket_path}")
unless symlink?(guest_path)
comm.sudo("mkdir -p `dirname #{guest_path}`")
if empty_dir?(bucket_path) && !empty_dir?(guest_path)
# Warm up cache with guest machine data
comm.sudo("shopt -s dotglob && mv #{guest_path}/* #{bucket_path}")
end
comm.sudo("rm -rf #{guest_path}")
comm.sudo("ln -s #{bucket_path} #{guest_path}")
end
end
def user_symlink(guest_path)
return if @env[:cache_dirs].include?(guest_path)
@env[:cache_dirs] << guest_path
bucket_path = "/tmp/vagrant-cache/#{@name}"
comm.execute("mkdir -p #{bucket_path}")
unless symlink?(guest_path)
comm.execute("mkdir -p `dirname #{guest_path}`")
if empty_dir?(bucket_path) && !empty_dir?(guest_path)
# Warm up cache with guest machine data
comm.execute("shopt -s dotglob && mv #{guest_path}/* #{bucket_path}")
end
comm.execute("rm -rf #{guest_path}")
comm.execute("ln -s #{bucket_path} #{guest_path}")
end
end
def empty_dir?(path)
not comm.test("test \"$(ls -A #{path} 2>/dev/null)\"")
end
def symlink?(path)
comm.test("test -L #{path}")
end
end
end
end
require_relative "bucket/apt"
require_relative "bucket/chef"
require_relative "bucket/gem"
require_relative "bucket/chef_gem"
require_relative "bucket/pacman"
require_relative "bucket/yum"
require_relative "bucket/rvm"
require_relative "bucket/apt_cacher"
require_relative "bucket/apt_lists"
require_relative "bucket/composer"
require_relative "bucket/bower"
require_relative "bucket/npm"
require_relative "bucket/zypper"
require_relative "bucket/generic"
vagrant-cachier-1.2.1/lib/vagrant-cachier/bucket/ 0000775 0000000 0000000 00000000000 12545554713 0021645 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/lib/vagrant-cachier/bucket/apt.rb 0000664 0000000 0000000 00000001121 12545554713 0022751 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Bucket
class Apt < Bucket
def self.capability
:apt_cache_dir
end
def install
if guest.capability?(:apt_cache_dir)
guest_path = guest.capability(:apt_cache_dir)
return if @env[:cache_dirs].include?(guest_path)
symlink(guest_path)
comm.execute("mkdir -p /tmp/vagrant-cache/#{@name}/partial")
else
@env[:ui].info I18n.t('vagrant_cachier.skipping_bucket', bucket: 'APT')
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/bucket/apt_cacher.rb 0000664 0000000 0000000 00000001672 12545554713 0024271 0 ustar 00root root 0000000 0000000 # Apt-Cacher NG is a caching proxy for software packages which are downloaded by
# Unix/Linux system distribution mechanisms from mirror servers accessible via HTTP.
module VagrantPlugins
module Cachier
class Bucket
class AptCacher < Bucket
def self.capability
:apt_cacher_dir
end
def install
if guest.capability?(:apt_cacher_dir)
if guest_path = guest.capability(:apt_cacher_dir)
synced_folder_type = (machine.config.cache.synced_folder_opts || {})[:type]
if synced_folder_type && synced_folder_type.to_sym == :nfs
symlink(guest_path)
else
@env[:ui].warn I18n.t('vagrant_cachier.nfs_required', bucket: 'apt-cacher')
end
end
else
@env[:ui].info I18n.t('vagrant_cachier.skipping_bucket', bucket: 'apt-cacher')
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/bucket/apt_lists.rb 0000664 0000000 0000000 00000001421 12545554713 0024172 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Bucket
class AptLists < Bucket
def self.capability
:apt_lists_dir
end
def install
# Apt lists bucket can't be used on windows hosts
# https://github.com/fgrehm/vagrant-cachier/issues/106
return if Vagrant::Util::Platform.windows?
if guest.capability?(:apt_lists_dir)
guest_path = guest.capability(:apt_lists_dir)
return if @env[:cache_dirs].include?(guest_path)
symlink(guest_path)
comm.execute("mkdir -p /tmp/vagrant-cache/#{@name}/partial")
else
@env[:ui].info I18n.t('vagrant_cachier.skipping_bucket', bucket: 'apt-lists')
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/bucket/bower.rb 0000664 0000000 0000000 00000000736 12545554713 0023316 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Bucket
class Bower < Bucket
def self.capability
:bower_path
end
def install
if guest.capability?(:bower_path)
if bower_path = guest.capability(:bower_path)
user_symlink(bower_path)
end
else
@env[:ui].info I18n.t('vagrant_cachier.skipping_bucket', bucket: 'Bower')
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/bucket/chef.rb 0000664 0000000 0000000 00000000756 12545554713 0023107 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Bucket
class Chef < Bucket
def self.capability
:chef_file_cache_path
end
def install
if guest.capability?(:chef_file_cache_path)
guest_path = guest.capability(:chef_file_cache_path)
symlink(guest_path) if guest_path
else
@env[:ui].info I18n.t('vagrant_cachier.skipping_bucket', bucket: 'Chef')
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/bucket/chef_gem.rb 0000664 0000000 0000000 00000001260 12545554713 0023726 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Bucket
class ChefGem < Bucket
def self.capability
:chef_gemdir
end
def install
if guest.capability?(:chef_gemdir)
if gemdir_path = guest.capability(:chef_gemdir)
prefix = gemdir_path.split('/').last
bucket_path = "/tmp/vagrant-cache/#{@name}/#{prefix}"
gem_cache_path = "#{gemdir_path}/cache"
symlink(gem_cache_path, bucket_path)
end
else
@env[:ui].info I18n.t('vagrant_cachier.skipping_bucket', bucket: 'ChefRubyGems')
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/bucket/composer.rb 0000664 0000000 0000000 00000000763 12545554713 0024027 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Bucket
class Composer < Bucket
def self.capability
:composer_path
end
def install
if guest.capability?(:composer_path)
if composer_path = guest.capability(:composer_path)
user_symlink(composer_path)
end
else
@env[:ui].info I18n.t('vagrant_cachier.skipping_bucket', bucket: 'Composer')
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/bucket/gem.rb 0000664 0000000 0000000 00000001231 12545554713 0022737 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Bucket
class Gem < Bucket
def self.capability
:gemdir
end
def install
if guest.capability?(:gemdir)
if gemdir_path = guest.capability(:gemdir)
prefix = gemdir_path.split('/').last
bucket_path = "/tmp/vagrant-cache/#{@name}/#{prefix}"
gem_cache_path = "#{gemdir_path}/cache"
symlink(gem_cache_path, bucket_path)
end
else
@env[:ui].info I18n.t('vagrant_cachier.skipping_bucket', bucket: 'RubyGems')
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/bucket/generic.rb 0000664 0000000 0000000 00000001312 12545554713 0023603 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Bucket
class Generic < Bucket
def install
# First we normalize the @configs hash as a hash of hashes
if @configs.has_key?(:cache_dir)
@configs = { @name => @configs }
end
# Now we iterate through all generic buckets's configurations and
# set them up.
@configs.each do |key, conf|
if conf.has_key?(:cache_dir)
symlink(conf[:cache_dir], "/tmp/vagrant-cache/#{key}")
else
@env[:ui].info I18n.t('vagrant_cachier.skipping_bucket', bucket: "Generic[#{key}]")
end
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/bucket/npm.rb 0000664 0000000 0000000 00000000734 12545554713 0022770 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Bucket
class Npm < Bucket
def self.capability
:npm_cache_dir
end
def install
if guest.capability?(:npm_cache_dir)
guest_path = guest.capability(:npm_cache_dir)
user_symlink(guest_path) if guest_path
else
@env[:ui].info I18n.t('vagrant_cachier.skipping_bucket', bucket: 'npm')
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/bucket/pacman.rb 0000664 0000000 0000000 00000000730 12545554713 0023431 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Bucket
class Pacman < Bucket
def self.capability
:pacman_cache_dir
end
def install
if guest.capability?(:pacman_cache_dir)
guest_path = guest.capability(:pacman_cache_dir)
symlink(guest_path)
else
@env[:ui].info I18n.t('vagrant_cachier.skipping_bucket', bucket: 'Pacman')
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/bucket/rvm.rb 0000664 0000000 0000000 00000001224 12545554713 0022775 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Bucket
class Rvm < Bucket
def self.capability
:rvm_path
end
def install
if guest.capability?(:rvm_path)
if rvm_path = guest.capability(:rvm_path)
prefix = rvm_path.split('/').last
bucket_path = "/tmp/vagrant-cache/#{@name}/#{prefix}"
rvm_cache_path = "#{rvm_path}/archives"
symlink(rvm_cache_path, bucket_path)
end
else
@env[:ui].info I18n.t('vagrant_cachier.skipping_bucket', bucket: 'RVM')
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/bucket/yum.rb 0000664 0000000 0000000 00000001174 12545554713 0023007 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Bucket
class Yum < Bucket
def self.capability
:yum_cache_dir
end
def install
if guest.capability?(:yum_cache_dir)
guest_path = guest.capability(:yum_cache_dir)
return if @env[:cache_dirs].include?(guest_path)
# Ensure caching is enabled
comm.sudo("sed -i 's/keepcache=0/keepcache=1/g' /etc/yum.conf")
symlink(guest_path)
else
@env[:ui].info I18n.t('vagrant_cachier.skipping_bucket', bucket: 'Yum')
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/bucket/zypper.rb 0000664 0000000 0000000 00000001200 12545554713 0023514 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Bucket
class Zypper < Bucket
def self.capability
:zypper_cache_dir
end
def install
if guest.capability?(:zypper_cache_dir)
guest_path = guest.capability(:zypper_cache_dir)
return if @env[:cache_dirs].include?(guest_path)
# Ensure caching is enabled
comm.sudo("zypper modifyrepo --keep-packages --all")
symlink(guest_path)
else
@env[:ui].info I18n.t('vagrant_cachier.skipping_bucket', bucket: 'Zypper')
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/ 0000775 0000000 0000000 00000000000 12545554713 0021133 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/arch/ 0000775 0000000 0000000 00000000000 12545554713 0022050 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/arch/pacman_cache_dir.rb 0000664 0000000 0000000 00000000355 12545554713 0025620 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
module Cap
module Arch
module PacmanCacheDir
def self.pacman_cache_dir(machine)
'/var/cache/pacman/pkg'
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/debian/ 0000775 0000000 0000000 00000000000 12545554713 0022355 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/debian/apt_cache_dir.rb 0000664 0000000 0000000 00000000353 12545554713 0025450 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
module Cap
module Debian
module AptCacheDir
def self.apt_cache_dir(machine)
'/var/cache/apt/archives'
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/debian/apt_cacher_dir.rb 0000664 0000000 0000000 00000001253 12545554713 0025632 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
module Cap
module Debian
module AptCacherDir
CACHER_CONF = '/etc/apt-cacher-ng/acng.conf'
CACHER_CACHE_DIR = "$(cat #{CACHER_CONF} | grep CacheDir | cut -d' ' -f 2)"
def self.apt_cacher_dir(machine)
cache_dir = nil
machine.communicate.tap do |comm|
return unless comm.test("test -f #{CACHER_CONF}")
comm.execute "echo #{CACHER_CACHE_DIR}" do |buffer, output|
cache_dir = output.chomp if buffer == :stdout
end
end
return cache_dir
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/debian/apt_lists_dir.rb 0000664 0000000 0000000 00000000346 12545554713 0025545 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
module Cap
module Debian
module AptListsDir
def self.apt_lists_dir(machine)
'/var/lib/apt/lists'
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/linux/ 0000775 0000000 0000000 00000000000 12545554713 0022272 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/linux/bower_path.rb 0000664 0000000 0000000 00000001014 12545554713 0024745 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
module Cap
module Linux
module BowerPath
def self.bower_path(machine)
bower_path = nil
machine.communicate.tap do |comm|
return unless comm.test('which bower')
comm.execute 'echo $HOME' do |buffer, output|
bower_path = output.chomp if buffer == :stdout
end
end
return "#{bower_path}/.cache/bower"
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/linux/chef_file_cache_path.rb 0000664 0000000 0000000 00000001622 12545554713 0026663 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
module Cap
module Linux
module ChefFileCachePath
def self.chef_provisioner?(machine)
provisioners = machine.config.vm.provisioners
chef_provisioners = [:chef_solo, :chef_client, :chef_zero]
compat_provisioners = provisioners.select { |p| chef_provisioners.include? p.name || p.type }
if compat_provisioners.size > 1
raise "One machine is using multiple chef provisioners, which is unsupported."
end
using_chef = compat_provisioners.empty? ? false : true
using_chef
end
def self.chef_file_cache_path(machine)
chef_file_cache_path = nil
chef_file_cache_path = '/var/chef/cache' if chef_provisioner?(machine)
return chef_file_cache_path
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/linux/chef_gemdir.rb 0000664 0000000 0000000 00000001042 12545554713 0025050 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
module Cap
module Linux
module ChefGemdir
def self.chef_gemdir(machine)
gemdir = nil
machine.communicate.tap do |comm|
return unless comm.test('test -f /opt/chef/embedded/bin/gem')
comm.execute '/opt/chef/embedded/bin/gem env gemdir' do |buffer, output|
gemdir = output.chomp if buffer == :stdout
end
end
return gemdir
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/linux/composer_path.rb 0000664 0000000 0000000 00000001267 12545554713 0025470 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
module Cap
module Linux
module ComposerPath
def self.composer_path(machine)
composer_path = nil
machine.communicate.tap do |comm|
return unless comm.test('which php')
# on some VMs an extra new line seems to come out, so we loop over
# the output just in case
composer_path = ''
comm.execute 'echo $HOME' do |buffer, output|
composer_path += output.chomp if buffer == :stdout
end
end
return "#{composer_path}/.composer/cache"
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/linux/gemdir.rb 0000664 0000000 0000000 00000000751 12545554713 0024071 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
module Cap
module Linux
module Gemdir
def self.gemdir(machine)
gemdir = nil
machine.communicate.tap do |comm|
return unless comm.test('which gem')
comm.execute 'gem env gemdir' do |buffer, output|
gemdir = output.chomp if buffer == :stdout
end
end
return gemdir
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/linux/npm_cache_dir.rb 0000664 0000000 0000000 00000001020 12545554713 0025363 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
module Cap
module Linux
module NpmCacheDir
def self.npm_cache_dir(machine)
npm_cache_dir = nil
machine.communicate.tap do |comm|
return unless comm.test('which npm')
comm.execute 'npm config get cache' do |buffer, output|
npm_cache_dir = output.chomp if buffer == :stdout
end
end
return npm_cache_dir
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/linux/rvm_path.rb 0000664 0000000 0000000 00000000762 12545554713 0024444 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
module Cap
module Linux
module RvmPath
def self.rvm_path(machine)
rvm_path = nil
machine.communicate.tap do |comm|
return unless comm.test('rvm info')
comm.execute 'echo $rvm_path' do |buffer, output|
rvm_path = output.chomp if buffer == :stdout
end
end
return rvm_path
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/redhat/ 0000775 0000000 0000000 00000000000 12545554713 0022402 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/redhat/yum_cache_dir.rb 0000664 0000000 0000000 00000000342 12545554713 0025521 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
module Cap
module RedHat
module YumCacheDir
def self.yum_cache_dir(machine)
'/var/cache/yum'
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/suse/ 0000775 0000000 0000000 00000000000 12545554713 0022112 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/lib/vagrant-cachier/cap/suse/zypper_cache_dir.rb 0000664 0000000 0000000 00000000360 12545554713 0025750 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
module Cap
module SuSE
module ZypperCacheDir
def self.zypper_cache_dir(machine)
'/var/cache/zypp/packages'
end
end
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/capabilities.rb 0000664 0000000 0000000 00000004040 12545554713 0023344 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Plugin < Vagrant.plugin('2')
guest_capability 'linux', 'gemdir' do
require_relative 'cap/linux/gemdir'
Cap::Linux::Gemdir
end
guest_capability 'linux', 'chef_gemdir' do
require_relative 'cap/linux/chef_gemdir'
Cap::Linux::ChefGemdir
end
guest_capability 'linux', 'rvm_path' do
require_relative 'cap/linux/rvm_path'
Cap::Linux::RvmPath
end
guest_capability 'linux', 'composer_path' do
require_relative 'cap/linux/composer_path'
Cap::Linux::ComposerPath
end
guest_capability 'linux', 'bower_path' do
require_relative 'cap/linux/bower_path'
Cap::Linux::BowerPath
end
guest_capability 'linux', 'chef_file_cache_path' do
require_relative 'cap/linux/chef_file_cache_path'
Cap::Linux::ChefFileCachePath
end
guest_capability 'linux', 'npm_cache_dir' do
require_relative 'cap/linux/npm_cache_dir'
Cap::Linux::NpmCacheDir
end
guest_capability 'debian', 'apt_cache_dir' do
require_relative 'cap/debian/apt_cache_dir'
Cap::Debian::AptCacheDir
end
guest_capability 'debian', 'apt_cacher_dir' do
require_relative 'cap/debian/apt_cacher_dir'
Cap::Debian::AptCacherDir
end
guest_capability 'debian', 'apt_lists_dir' do
require_relative 'cap/debian/apt_lists_dir'
Cap::Debian::AptListsDir
end
guest_capability 'redhat', 'yum_cache_dir' do
require_relative 'cap/redhat/yum_cache_dir'
Cap::RedHat::YumCacheDir
end
guest_capability 'suse', 'yum_cache_dir' do
# Disable Yum on suse guests
end
guest_capability 'arch', 'pacman_cache_dir' do
require_relative 'cap/arch/pacman_cache_dir'
Cap::Arch::PacmanCacheDir
end
guest_capability 'suse', 'zypper_cache_dir' do
require_relative 'cap/suse/zypper_cache_dir'
Cap::SuSE::ZypperCacheDir
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/config.rb 0000664 0000000 0000000 00000003162 12545554713 0022164 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Config < Vagrant.plugin(2, :config)
attr_accessor :scope, :auto_detect, :synced_folder_opts
attr_reader :buckets
ALLOWED_SCOPES = %w( box machine )
def initialize
@scope = UNSET_VALUE
@auto_detect = UNSET_VALUE
@synced_folder_opts = UNSET_VALUE
@ui = Vagrant::UI::Colored.new
end
def enable(bucket, opts = {})
(@buckets ||= {})[bucket] = opts
end
def validate(machine)
errors = _detected_errors
if enabled? && backed_by_cloud_provider?(machine)
machine.ui.warn(I18n.t('vagrant_cachier.backed_by_cloud_provider',
provider: machine.provider_name))
disable!
end
if enabled? && ! ALLOWED_SCOPES.include?(@scope.to_s)
errors << I18n.t('vagrant_cachier.unknown_cache_scope',
allowed: ALLOWED_SCOPES.inspect,
cache_scope: @scope)
end
{ "vagrant cachier" => errors }
end
def enabled?
return @enabled unless @enabled.nil?
@enabled = @scope != UNSET_VALUE
end
def disable!
@enabled = false
end
def finalize!
return unless enabled?
@auto_detect = true if @auto_detect == UNSET_VALUE
@synced_folder_opts = nil if @synced_folder_opts == UNSET_VALUE
@buckets = @buckets ? @buckets.dup : {}
end
private
def backed_by_cloud_provider?(machine)
CLOUD_PROVIDERS.include?(machine.provider_name.to_s)
end
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/hooks.rb 0000664 0000000 0000000 00000002136 12545554713 0022042 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
class Plugin < Vagrant.plugin('2')
action_hook VagrantPlugins::Cachier::Plugin::ALL_ACTIONS do |hook|
require_relative 'action/configure_bucket_root'
require_relative 'action/install_buckets'
hook.before Vagrant::Action::Builtin::Provision, Action::ConfigureBucketRoot
# This will do the initial buckets installation
hook.after Vagrant::Action::Builtin::Provision, Action::InstallBuckets, chmod: true
end
# This ensure buckets are reconfigured after provisioners runs
action_hook :provisioner_run do |hook|
require_relative 'action/install_buckets'
hook.after :run_provisioner, Action::InstallBuckets
end
clean_action_hook = lambda do |hook|
require_relative 'action/clean'
hook.before Vagrant::Action::Builtin::GracefulHalt, Action::Clean
end
action_hook 'remove-guest-symlinks-on-halt', :machine_action_halt, &clean_action_hook
action_hook 'remove-guest-symlinks-on-package', :machine_action_package, &clean_action_hook
end
end
end
vagrant-cachier-1.2.1/lib/vagrant-cachier/plugin.rb 0000664 0000000 0000000 00000001556 12545554713 0022222 0 ustar 00root root 0000000 0000000 unless Gem::Requirement.new('>= 1.4.0').satisfied_by?(Gem::Version.new(Vagrant::VERSION))
raise 'vagrant-cachier requires Vagrant >= 1.4.0 in order to work!'
end
# Add our custom translations to the load path
I18n.load_path << File.expand_path("../../../locales/en.yml", __FILE__)
module VagrantPlugins
module Cachier
class Plugin < Vagrant.plugin('2')
name 'vagrant-cachier'
config 'cache' do
require_relative "config"
Config
end
end
# Keep an eye on https://github.com/mitchellh/vagrant/wiki/Available-Vagrant-Plugins#wiki-providers
# for more.
CLOUD_PROVIDERS = %w( aws cloudstack digitalocean hp joyent openstack rackspace
softlayer proxmox managed azure brightbox cloudstack vcloud
vsphere )
end
end
require_relative "hooks"
require_relative "capabilities"
vagrant-cachier-1.2.1/lib/vagrant-cachier/version.rb 0000664 0000000 0000000 00000000107 12545554713 0022400 0 ustar 00root root 0000000 0000000 module VagrantPlugins
module Cachier
VERSION = "1.2.1"
end
end
vagrant-cachier-1.2.1/locales/ 0000775 0000000 0000000 00000000000 12545554713 0016206 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/locales/en.yml 0000664 0000000 0000000 00000001244 12545554713 0017334 0 ustar 00root root 0000000 0000000 en:
vagrant_cachier:
cleanup: |-
Removing cache buckets symlinks...
skipping_bucket: |-
Skipping %{bucket} cache bucket as the guest machine does not support it
unknown_cache_scope: |-
Unknown cache scope '%{cache_scope}' (allowed scopes: %{allowed})
nfs_required: |-
The '%{bucket}' cache bucket requires NFS to be enabled, please add
`config.cache.synced_folder_opts = {type: :nfs}` to your Vagrantfile.
unable_to_ssh: |-
vagrant-cachier was unable to SSH into the VM to remove symlinks!
backed_by_cloud_provider: |-
The machine is backed by a cloud provider (%{provider}), caching
will be disabled.
vagrant-cachier-1.2.1/spec/ 0000775 0000000 0000000 00000000000 12545554713 0015516 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/spec/acceptance/ 0000775 0000000 0000000 00000000000 12545554713 0017604 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/spec/acceptance/fixtures/ 0000775 0000000 0000000 00000000000 12545554713 0021455 5 ustar 00root root 0000000 0000000 vagrant-cachier-1.2.1/spec/acceptance/fixtures/auto-detect-with-provisioning.rb 0000664 0000000 0000000 00000000574 12545554713 0027723 0 ustar 00root root 0000000 0000000 Vagrant.configure("2") do |config|
config.vm.provider :virtualbox do |_, override|
override.vm.box = "chef/ubuntu-14.04"
end
config.vm.provider :lxc do |_, override|
override.vm.box = "fgrehm/trusty64-lxc"
end
config.cache.auto_detect = true
config.cache.scope = :machine
config.vm.provision :shell, inline: 'apt-get update && apt-get install -y git'
end
vagrant-cachier-1.2.1/spec/acceptance/fixtures/auto-detect.rb 0000664 0000000 0000000 00000000476 12545554713 0024227 0 ustar 00root root 0000000 0000000 Vagrant.configure("2") do |config|
config.vm.provider :virtualbox do |_, override|
override.vm.box = "chef/ubuntu-14.04"
end
config.vm.provider :lxc do |_, override|
override.vm.box = "fgrehm/trusty64-lxc"
end
config.cache.auto_detect = true
config.vm.provision :shell, inline: 'echo Hello!'
end
vagrant-cachier-1.2.1/spec/acceptance/fixtures/no-cachier-simple.rb 0000664 0000000 0000000 00000000346 12545554713 0025304 0 ustar 00root root 0000000 0000000 Vagrant.configure("2") do |config|
config.vm.provider :virtualbox do |_, override|
override.vm.box = "chef/ubuntu-14.04"
end
config.vm.provider :lxc do |_, override|
override.vm.box = "fgrehm/trusty64-lxc"
end
end
vagrant-cachier-1.2.1/spec/acceptance/fixtures/no-cachier-with-provisioning.rb 0000664 0000000 0000000 00000000433 12545554713 0027507 0 ustar 00root root 0000000 0000000 Vagrant.configure("2") do |config|
config.vm.provider :virtualbox do |_, override|
override.vm.box = "chef/ubuntu-14.04"
end
config.vm.provider :lxc do |_, override|
override.vm.box = "fgrehm/trusty64-lxc"
end
config.vm.provision :shell, inline: 'echo Hello!'
end
vagrant-cachier-1.2.1/spec/acceptance/sanity_check.bats 0000664 0000000 0000000 00000002177 12545554713 0023132 0 ustar 00root root 0000000 0000000 #!/usr/bin/env bats
load test_helper
@test "Vagrantfile without cachier statement does not blow up when bringing the VM up" {
configure_env "no-cachier-simple.rb"
vagrant_up
[ "$status" -eq 0 ]
vagrant_destroy
configure_env "no-cachier-with-provisioning.rb"
vagrant_up
[ "$status" -eq 0 ]
vagrant_destroy
}
@test "Vagrantfile with cachier auto_detect statement does not blow up when bringing the VM up" {
configure_env "auto-detect.rb"
vagrant_up
[ "$status" -eq 0 ]
vagrant_destroy
}
@test "APT cache bucket configures the cache dir properly and keeps cache dir around" {
configure_env "auto-detect-with-provisioning.rb"
# Make sure cache dir does not exist
test ! -d tmp/.vagrant/machines/default/cache/apt
vagrant_up
[ "$status" -eq 0 ]
# Make sure packages are being cached
test -d tmp/.vagrant/machines/default/cache/apt
FILES=(`ls tmp/.vagrant/machines/default/cache/apt/git*.deb`)
[ ${#FILES[@]} -gt 0 ]
vagrant_destroy
# Make sure packages are not removed between machine rebuilds
FILES=(`ls tmp/.vagrant/machines/default/cache/apt/git*.deb`)
[ ${#FILES[@]} -gt 0 ]
empty_cache
}
vagrant-cachier-1.2.1/spec/acceptance/test_helper.bash 0000664 0000000 0000000 00000000617 12545554713 0022765 0 ustar 00root root 0000000 0000000 vagrant_up() {
pushd tmp
run bundle exec vagrant up > /tmp/vagrant-cachier-tests.log
popd
}
vagrant_destroy() {
pushd tmp
run bundle exec vagrant destroy -f
popd
}
configure_env() {
fixture=$1
mkdir -p tmp/
cp spec/acceptance/fixtures/${fixture} tmp/Vagrantfile
vagrant_destroy
[ "$status" -eq 0 ]
rm -rf tmp/.vagrant
}
empty_cache() {
rm -rf tmp/.vagrant/cache
}
vagrant-cachier-1.2.1/vagrant-cachier.gemspec 0000664 0000000 0000000 00000001400 12545554713 0021162 0 ustar 00root root 0000000 0000000 # coding: utf-8
lib = File.expand_path('../lib', __FILE__)
$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
require 'vagrant-cachier/version'
Gem::Specification.new do |spec|
spec.name = "vagrant-cachier"
spec.version = VagrantPlugins::Cachier::VERSION
spec.authors = ["Fabio Rehm"]
spec.email = ["fgrehm@gmail.com"]
spec.description = %q{Caffeine reducer}
spec.summary = spec.description
spec.homepage = "https://github.com/fgrehm/vagrant-cachier"
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"]
end