Bundler

Ruby dependency manager. Uses Gemfiles. gem install bundler. Example of Gemfile:

source 'https://rubygems.org
gem 'nokogiri'
gem 'rack', '~>1.1'
gem 'rspec', :require => 'spec'

Then inside app, require 'rubygems' and require 'bundler/setup'

• bundle exec runs an executable that comes with a gem in your bundle
• bundler stores gems (in development) in the default location of the machine
• in --deployment, it installs unique to the app (defaults to vender/cache)
  • bundle show <gemname>

Gemfile + Gemfile.lock -- source

source 'https://rubygems.org' defines which upstream to pull gems from.

• Gemfile.lock makes your application a single package of both your own and third-party code
  • snapshot of last time everything worked, important to commit to repos for consistency across multiple machines

bundle install -- source

Installs gems specified in the Gemfile.

• if Gemfile.lock does not exist, Bundler will fetch all remotes sources and resolve dependencies, installing needed gems
• if it does exist, and Gemfile is unchanged, Bundler fetches all remote sources and uses dependencies specified in Gemfile.lock
• If Gemfile.lock exists, and Gemfile is changed, Gemfile.lock is used for all unchanged gems, and will re-resolve the dependencies of gems that you did update
• never sudo bundle install, several steps are user dependent

Conservative Updating

As safety, bundler will not automatically update a gem whose dependency versions conflict with the Gemfile.lock. This means if gem A and B depend of C, when A is updated, requiring a new version of C, B will never break from this, at worst failing loudly.

• first bundle install, which guarantees unchanged gems will remain untouched by the system
• then bundle update <gemname> if bundle install cannot update it

Tracing a bundle install

1. executable bundle
2. requires bundler
3. requires cli, passed to install command
   • sets options, then calls #install
4. Installer.install
   • inherits environment
   • resolve_if_need decides what dependencies are needed, all calculated locally
   • calls install
   • install in parallel
5. ParallelInstaller.call
   • creates a new ParallelInstaller object
   • call on object
   • enqueue specs selects all gems that don't have dependencies, enqueues each spec
   • batch installs with process_specs, by dequeuing from worker_pool
6. Builds a pool of Workers
   • defines threads as workers, constantly proccessing the request queue
   • requests are processed by lambda func, to be exact, this lambda func defined earlier. We pass it a spec object and worker ID
   • this calls install_from_spec
7. Gem installer is called
   • calls install or install_with_settings
   • calls post install on the gem

Gemstash

a cache for remote servers (including rubygems.org) and a private gem source. By default, it is a local cache.

• if bundler is being run across multiple servers, could it could improve speed
• especially if same set of gems are used across multiple machines

# Tell Bundler that you want Gemstash to find gems:
bundle config mirror.https://rubygems.org http://localhost:9292

# set Bundler to fallback to rubygems.org
bundle config mirror.https://rubygems.org.fallback_timeout true
bundle config mirror.https://rubygems.org.fallback_timeout 3

Gemstash lives is ~/.gemstash, stores cached & private gems

• by default, uses SQLite to store details

Gem in a box

Another gem caching solution, older than gemstash, more of a gem server than a cache. Uses gemirro, as a dependency for creating a RubyGems mirror.