bundle2rpm 1.0.1

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2011 Matt Savona
+
+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.

data/README.md

@@ -0,0 +1,22 @@
+# bundle2rpm: a gem to package bundles
+
+bundle2rpm is a tool designed to facilitate the packaging and deployment of Gem bundles on RedHat-like Linux systems. Leveraging the lovely [Bundler](http://gembundler.com) tool, bundle2rpm strives to produce self-contained RPMs that can be easily installed on other systems.
+
+### Why?
+
+Let's talk enterprise (*gasp*). In extremely large development environments (hundreds of developers or more) it is not always possible for system administrators to accommodate requests to test, install and manage multiple versions of Ruby Gems. When development or production systems are shared between teams or projects, each with their own Gem requirements. To centrally maintain Gems across many systems that will satisfy the requirements of these many teams and projects is nearly impossible. Ideally, each project defines their own Gemfile and Bundler takes care of all the really hard work. bundle2rpm provides an elegant way to construct RPMs that can be built on development systems where compilers and header files are available, and then the binary RPM can be installed and leveraged on any other system in the organization.
+
+### How?
+
+Install Bundler and bundle2rpm:
+`gem install bundler bundle2rpm`
+
+Build your RPM (options are available, see `bundle2rpm -h`):
+`bundle2rpm /path/to/your/Gemfile /where/to/install`
+
+Install the RPM produced by bundle2rpm on any RedHat system:
+`rpm -ivh yourbundled.rpm`
+
+### Issues
+
+bundle2rpm is still being tweaked. Documentation is still being pieced together as well. Still, please do let me know if you encounter any problems and I will be happy to take a look into them.

data/bin/bundle2rpm

@@ -0,0 +1,375 @@
+#!/bin/env ruby
+
+# bundle2rpm
+# Matt Savona - 2011
+# 
+# Leverage the lovely Gem Bundler tool to produce nicely packaged RPMs.
+
+require "fileutils"
+require "optparse"
+require "time"
+require "pp"
+
+TMP_DIR = "/tmp"
+
+@variable_map = {
+  :package_name    => { :default => "rubygem-custom_bundle", :comment => "Name of your package (mybundle)." },
+  :package_version => { :default => "1.0.0", :comment => "Version number of your package (ex. 1.0.0)." },
+  :package_release => { :default => "1", :comment => "Release number of your package (ex. 1)." },
+  :author          => { :default => "bundle2rpm", :comment => "Your name (ex. John Smith)." },
+  :email           => { :default => "bundle2rpm@localhost", :comment => "Your email (ex. john@example.com)." },
+  :url             => { :default => "http://localhost/", :comment => "Your URL (ex. http://loopforever.com)." },
+  :license         => { :default => "GPL", :comment => "License for your package (ex. GPL)." },
+  :user            => { :default => "root", :comment => "Username that owns the files in this RPM (ex. jsmith)." },
+  :group           => { :default => "root", :comment => "Groupname that owns the files in this RPM (ex. developers)." },
+  :changelog       => { :immutable => true, :deferred_default => { :stage => 0, :invoke => :changelog } }
+}
+
+@options = {}
+
+@gemfile, @prefix, @verbose, @no_cleanup, @package_full_name = nil
+@tmp_dir, @working_dir, @save_rpm_to, @rpm_spec_file = nil
+
+module Exceptions
+  class ArgumentError < StandardError; end
+  class BuildError < StandardError; end
+  class CommandError < StandardError; end
+end
+
+def main
+  deferred_variables = [ [],[],[] ]
+
+  OptionParser.new do |o|
+    o.banner = "Usage: #{$0} [options] /path/to/Gemfile /path/to/install/into"
+
+    o.separator ""
+    o.separator "RPM spec file options:"
+
+    @variable_map.each do |k,v|
+      next if v[:immutable]
+
+      o.on("--#{k.to_s.gsub(/_/, "-")} VALUE", v[:comment]) do |ov|
+        @options[k] = ov
+      end
+    end
+
+    o.separator ""
+    o.separator "General options:"
+    o.on("--bundler VERSION", "Pull in and package this version of bundler (from Rubyforge/Gemcutter only). Defaults to the same version of bundler that is used to construct your RPM (first in your PATH).") do |ov|
+      @options[:bundler_version] = ov
+    end
+    o.on("--save-rpm-to DIR", "If specified, the RPM built for you will be written to this directory. Defaults to your working directory.") do |ov|
+      @options[:save_rpm_to] = ov
+    end
+    o.on("--no-cleanup", "Do not cleanup working directory. Useful only for debugging purposes, normally you want your transient build files cleaned up.") do |ov|
+      @no_cleanup = true
+    end
+    o.on("--tmp-dir DIR", "Temporary directory to use for transient `bundle install` and RPM build files.") do |ov|
+      @options[:tmp_dir] = ov
+    end
+    o.on("-v", "--verbose", "Print additional output.") do |ov|
+      @verbose = true
+    end
+    o.on_tail("-h", "--help", "Show this message.") do
+      puts o
+      exit
+    end
+  end.parse!
+
+  @gemfile = normalize_path(ARGV[0])
+  @prefix  = normalize_path(ARGV[1])
+  @tmp_dir = normalize_path(@options[:tmp_dir] || TMP_DIR)
+  @save_rpm_to = normalize_path(@options[:save_rpm_to] || FileUtils.pwd)
+
+  raise Exceptions::ArgumentError, "You must specify the path to an existing Gemfile." if !@gemfile || !File.exists?(@gemfile)
+  raise Exceptions::ArgumentError, "You must specify the path where you want your RPM to install into." if !@prefix
+
+  puts "---"
+  puts "Gemfile:        #{@gemfile}"
+  puts "Install Prefix: #{@prefix}"
+  puts "---"
+
+  # Define a value for all entries in the @variable_map, either user supplied or default:
+  @variable_map.each do |k,v|
+    if v[:deferred_default]
+      deferred_variables[v[:deferred_default][:stage]] << { :key => k, :invoke => v[:deferred_default][:invoke] }
+    end
+      
+    @variable_map[k][:value] = @options[k] || v[:default]
+  end
+
+  # Some variables are deferred, meaning their value cannot be known until other variable's have values assigned
+  # to them. These can be deferred into (upto) three stages:
+  deferred_variables.each do |stage|
+    stage.each do |deferred_variable|
+      @variable_map[deferred_variable[:key]][:value] = self.send(deferred_variable[:invoke])
+    end
+  end
+
+  @package_full_name = []
+  @package_full_name << @variable_map[:package_name][:value]
+  @package_full_name << @variable_map[:package_version][:value]
+  @package_full_name << @variable_map[:package_release][:value]
+  @package_full_name = @package_full_name.join("-")
+  @working_dir = setup_working_dir
+  @rpm_spec_file = write_rpm_spec("#{@working_dir}/rpmbuild/SPECS/#{@package_full_name}.spec")
+  prepare_bundle
+  build_rpm
+end
+
+def write_rpm_spec(to_file)
+  puts "Generating RPM spec file."
+  
+  spec_file = DATA.read
+
+  # Replace all |xxx| variables in our template with the mapped
+  # values via @variable_map:
+  @variable_map.each do |k,v|
+    spec_file.gsub!(/\|#{k.to_s}\|/, v[:value])
+  end
+
+  File.open(to_file, "w") do |f|
+    f.puts spec_file
+  end
+
+  return to_file
+end
+
+def prepare_bundle
+  puts "Bundling your gems."
+
+  # Don't let people's custom gem environments get in the way:
+  ENV["GEM_HOME"] = ENV["GEM_PATH"] = nil
+
+  bundler_version = @options[:bundler_version] || get_bundler_version
+  bundle_into = "#{@working_dir}/rpmbuild/SOURCES/#{@package_full_name}"
+  bundle_config_file = "#{bundle_into}/.bundle/config"
+
+  # Make ourselves a /bin directory to store our artificial ruby binaries:
+  FileUtils.mkdir("#{bundle_into}/bin")
+
+  # Copy over Gemfile and Gemfile.lock into our source directory:
+  [@gemfile, "#{@gemfile}.lock"].each do |gf|
+    FileUtils.cp(gf, bundle_into) if File.exists?(gf)
+  end
+
+  # No .lock file exists yet, so we need to bundle install first:
+  if !File.exists?("#{bundle_into}/Gemfile.lock")
+    exec_command("bundle install --gemfile #{bundle_into}/Gemfile --path #{bundle_into} --binstubs #{bundle_into}/bundle_bin")
+  end
+
+  # Install in "deployment" mode:
+  exec_command("bundle install --deployment --gemfile #{bundle_into}/Gemfile --path #{bundle_into} --binstubs #{bundle_into}/bundle_bin")
+
+  # We don't make any assumptions about the ruby version, so glob in order
+  # to find the paths we're looking for:
+  source_gem_path = source_bin_path = nil
+  Dir["#{bundle_into}/ruby/*/*"].each do |d|
+    case File.basename(d)
+      when "gems"
+        source_gem_path = d.gsub(/\/gems$/, "")
+    end
+  end 
+
+  # It is permissible for a bundle to not include a bin_path, but it must contain a gem path:
+  raise Exceptions::BuildError, "Unable to determine appropriate Gem path value for your bundle. Unable to proceed." unless source_gem_path
+
+  source_bin_path = "#{source_gem_path}/bin"
+
+  # At this point we want all Rubygem interaction within our source directory:
+  ENV["GEM_HOME"] = ENV["GEM_PATH"] = source_gem_path
+
+  # Pull in bundler for packaging inside the RPM itself:
+  exec_command("gem install bundler -v #{bundler_version} --no-rdoc --no-ri")
+
+  # Move our Bundler binstubs to a more sensible location (adjacent to the bin directory Rubygems would create):
+  source_bundle_bin_path = File.expand_path("#{source_bin_path}/../bundle_bin")
+  FileUtils.mv("#{bundle_into}/bundle_bin", source_bundle_bin_path)
+
+  # Chop off our build prefix, so we can insert some magic (REPLACE_WITH_BUNDLE_DIR)
+  # that will be interpolated at RPM post-install time:
+  built_gem_path = source_gem_path.gsub(/^#{bundle_into}\//, "")
+  built_bin_path = source_bin_path.gsub(/^#{bundle_into}\//, "")
+  built_bundle_bin_path = source_bundle_bin_path.gsub(/^#{bundle_into}\//, "")
+
+  # Rewrite the bundler config file to normalize paths:
+  bundle_config = File.read(bundle_config_file)
+  bundle_config = bundle_config.gsub(/#{bundle_into}/, "REPLACE_WITH_BUNDLE_DIR")
+  bundle_config = bundle_config.gsub(/\/bundle_bin/, "/#{built_bundle_bin_path}")
+  File.open(bundle_config_file, "w") { |f| f.puts bundle_config }
+
+  # REPLACE_WITH_BUNDLE_DIR is interpolated at post-install time, as that is
+  # the only time when the value is known since this is built as a relocatable
+  # RPM:
+  File.open("#{bundle_into}/bin/env.bash", "w") do |f|
+    f.puts <<-EOS
+#!/bin/bash
+export B2R_BUNDLE_DIR="REPLACE_WITH_BUNDLE_DIR"
+export GEM_HOME="${B2R_BUNDLE_DIR}/#{built_gem_path}"
+export GEM_PATH="${B2R_BUNDLE_DIR}/#{built_gem_path}"
+export BUNDLE_GEMFILE="${B2R_BUNDLE_DIR}/Gemfile"
+export PATH="${B2R_BUNDLE_DIR}/#{built_bundle_bin_path}:${B2R_BUNDLE_DIR}/#{built_bin_path}:$PATH"
+    EOS
+  end
+
+  ["ruby", "irb"].each do |bin|
+    File.open("#{bundle_into}/bin/#{bin}", "w") do |f|
+      f.puts <<-EOS
+#!/bin/bash
+. "REPLACE_WITH_BUNDLE_DIR/bin/env.bash"
+
+/bin/env #{bin} $@
+      EOS
+    end
+
+    File.chmod(0755, "#{bundle_into}/bin/#{bin}")
+  end
+end
+
+def get_bundler_version
+  bundler_version = `bundle -v 2>&1`
+
+  if $? == 0
+    # Bundler version 1.0.15
+    if bundler_version =~ /^Bundler version (.*)$/
+      return $1.strip
+    end
+  end
+
+  raise Exceptions::BuildError, "Unable to determine existing bundler version. You can explicitly set this with the --bundler option or try running `bundle -v` yourself and confirming a version number is returned."
+end
+
+def build_rpm
+  puts "Building RPM."
+
+  exec_command("rpmbuild --define '_topdir #{@working_dir}/rpmbuild' --define '_prefix #{@prefix}' -ba #{@rpm_spec_file}")
+
+  # Move any RPMs we built into @save_rpm_to:
+  Dir["#{@working_dir}/rpmbuild/RPMS/*/*.rpm"].each do |src_path|
+    filename = File.basename(src_path)
+    dest_path = "#{@save_rpm_to}/#{filename}"
+    FileUtils.mv(src_path, dest_path, :force => true)
+
+    puts "Wrote RPM: #{dest_path}"
+  end
+end
+
+def changelog(comment = "bundle2rpm managed build")
+  date = Time.now.strftime("%a %b %e %Y")
+
+  entries = [] 
+  entries << "* #{date} #{@variable_map[:author][:value]} <#{@variable_map[:email][:value]}> #{@variable_map[:package_version][:value]}-#{@variable_map[:package_release][:value]}"
+  entries << "- #{comment[0..79]}\n"
+
+  return entries.join("\n")
+end
+
+def normalize_path(path)
+  return nil if path.nil? || path.empty?
+  return File.expand_path(path).gsub(/\/$/, "")
+end
+
+def exec_command(command, fatal = true)
+  output_buffer = []
+  puts "+ #{command}" if @verbose
+
+  IO.popen("#{command} 2>&1") do |output|
+    while line = output.gets do
+      if @verbose
+        puts "> #{line}"
+      else
+        output_buffer << "> #{line}"
+      end
+    end
+  end
+
+  if $? != 0
+    puts "+ #{command}" if !@verbose
+    puts output_buffer
+    raise Exceptions::CommandError, "Failure of previous command was fatal, stopping." if fatal
+  end
+end
+
+def setup_working_dir
+  working_dir = "#{@tmp_dir}/bundle2rpm-#{@variable_map[:package_name][:value]}-#{Time.now.to_i.to_s}"
+
+  # This is the root working directory:
+  FileUtils.mkdir(working_dir)
+
+  # This is the rpmbuild directory structure:
+  %w{ BUILD RPMS SOURCES SPECS SRPMS }.each do |d|
+    FileUtils.mkdir_p("#{working_dir}/rpmbuild/#{d}")
+  end
+
+  # This is where we'll deploy via `bundle install`:
+  FileUtils.mkdir("#{working_dir}/rpmbuild/SOURCES/#{@package_full_name}")  
+
+  # This is our transient GEM_HOME:
+  FileUtils.mkdir("#{working_dir}/.gems")
+
+  return working_dir
+end
+
+def cleanup_working_dir
+  return if !@working_dir || !File.exists?(@working_dir)
+  FileUtils.rm_rf(@working_dir)
+end
+
+begin
+  main
+rescue SystemExit, Interrupt
+  puts "Cancelling bundle2rpm operations at your request."
+rescue Exceptions::ArgumentError => e
+  puts "#{e.class}: #{e.message}"
+rescue Exceptions::BuildError => e
+  puts "#{e.class}: #{e.message}"
+rescue Exceptions::CommandError => e
+  puts "#{e.class}: #{e.message}"
+ensure
+  cleanup_working_dir unless @no_cleanup
+end
+
+__END__
+Summary: bundle2rpm Package
+Name: |package_name|
+Version: |package_version|
+Release: |package_release|
+License: |license|
+Group: Applications/RubyGems
+URL: |url|
+BuildRoot: %{_tmppath}/%{name}-root
+Prefix: %(echo %{_prefix})
+AutoProv: no
+
+%description
+This package was generated by bundle2rpm. It contains a deployed Gem bundle which
+may contain one or more individual Ruby Gems.
+
+%install
+[ -d ${RPM_BUILD_ROOT} ] && rm -rf ${RPM_BUILD_ROOT}
+install -d ${RPM_BUILD_ROOT}%{_prefix}
+cp -R ${RPM_SOURCE_DIR}/* ${RPM_BUILD_ROOT}%{_prefix}
+
+find ${RPM_BUILD_ROOT}%{_prefix} \( \( -type f -o -type l \) -printf '"%%p"\n' \) \
+        -o \( -type d -a -printf '%%%%dir "%%p"\n' \) \
+        | sed "s@${RPM_BUILD_ROOT}@@g" \
+        > bundle.lst
+
+# Remove the first line, it's the prefix-dir which we do not
+# want under rpm control:
+sed -i 1d bundle.lst
+
+%post
+#!/bin/bash
+bundle_dir="%{_prefix}/%{name}-%{version}-%{release}"
+sed -i "s@REPLACE_WITH_BUNDLE_DIR@${bundle_dir}@g" ${bundle_dir}/.bundle/*
+sed -i "s@REPLACE_WITH_BUNDLE_DIR@${bundle_dir}@g" ${bundle_dir}/bin/*
+
+%clean
+[ -d ${RPM_BUILD_ROOT} ] && rm -rf ${RPM_BUILD_ROOT}
+
+%files -f bundle.lst
+%defattr(-,|user|,|group|,-)
+
+%changelog
+|changelog|

data/bundle2rpm.gemspec

@@ -0,0 +1,24 @@
+spec = Gem::Specification.new do |s|
+  s.name = "bundle2rpm"
+  s.version = "1.0.1"
+  s.platform = Gem::Platform::RUBY
+  s.date = "2011-07-12"
+  s.rubyforge_project = "bundle2rpm"
+  s.summary = "Convert Bundler gem bundles into RPMs."
+  s.description = "Turns your gem bundles into RPMs!"
+
+  s.homepage = "http://loopforever.com" 
+  s.authors = ["Matt Savona"]
+  s.email = "matt.savona@gmail.com"
+
+  s.has_rdoc = false
+
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.bindir = "bin"
+  s.require_paths = ["lib"]
+  s.executables << "bundle2rpm"
+  s.files = `git ls-files`.split("\n") 
+
+  s.add_dependency("bundler", "~> 1.0.10")
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: bundle2rpm
+version: !ruby/object:Gem::Version 
+  hash: 21
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 1
+  version: 1.0.1
+platform: ruby
+authors: 
+- Matt Savona
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-12 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 0
+        - 10
+        version: 1.0.10
+  type: :runtime
+  version_requirements: *id001
+description: Turns your gem bundles into RPMs!
+email: matt.savona@gmail.com
+executables: 
+- bundle2rpm
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- LICENSE
+- README.md
+- bin/bundle2rpm
+- bundle2rpm.gemspec
+- lib/.gitstub
+has_rdoc: true
+homepage: http://loopforever.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: bundle2rpm
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Convert Bundler gem bundles into RPMs.
+test_files: []
+