vanagon 0.13.1 → 0.14.1

data/lib/vanagon/optparse.rb

@@ -2,40 +2,86 @@ require 'optparse'
 
 class Vanagon
   class OptParse
-    FLAGS = {
-        :workdir => ['-w DIR', '--workdir DIR', "Working directory where build source should be put (defaults to a tmpdir)"],
-        :"remote-workdir" => ['-r DIR', '--remote-workdir DIR', "Working directory where build source should be put on the remote host (defaults to a tmpdir)"],
-        :configdir => ['-c', '--configdir DIR', 'Configs dir (defaults to $pwd/configs)'],
-        :target => ['-t HOST', '--target HOST', 'Configure a target machine for build and packaging (defaults to grabbing one from the pooler)'],
-        :engine => ['-e ENGINE', '--engine ENGINE', "A custom engine to use (defaults to the pooler) [base, local, docker, pooler currently supported]"],
-        :skipcheck => ['--skipcheck', 'Skip the `check` stage when building components'],
-        :preserve => ['-p', '--preserve', 'Whether to tear down the VM on success or not (defaults to false)'],
-        :verbose => ['-v', '--verbose', 'Verbose output (does nothing)'],
-        :only_build => ["--only-build COMPONENT,COMPONENT,...", Array, 'Only build this array of components']
-      }.freeze
-
-    def initialize(banner, options = [])
-      @options = Hash[options.map { |v| [v, nil] }]
-      @optparse = OptionParser.new do |opts|
+    def initialize(banner, symbols = []) # rubocop:disable Metrics/AbcSize
+      ## symbols array kept for backward compatibility but ignored
+
+      @options = Hash.new
+      @options[:preserve] = :'on-failure'
+
+      @option_parser = OptionParser.new do |opts| # rubocop:disable Metrics/BlockLength
         opts.banner = banner
+        opts.separator ""
+        opts.separator "Options:"
+
+        opts.on("-h",
+                "--help",
+                "Display help") do
+          $stdout.puts opts
+          exit 1
+        end
+
+        opts.on("-v",
+                "--verbose",
+                "Verbose output (does nothing)") do |verbose|
+          @options[:verbose] = verbose
+        end
+
+        opts.on("-w DIRECTORY",
+                "--workdir DIRECTORY",
+                "Working directory on the local host (defaults to calling mktemp)") do |workdir|
+          @options[:workdir] = workdir
+        end
+
+        opts.on("-r DIRECTORY",
+                "--remote-workdir DIRECTORY",
+                "Working directory on the remote host (defaults to calling mktemp)") do |remote|
+          @options[:"remote-workdir"] = remote
+        end
+
+        opts.on("-c DIRECTORY",
+                "--configdir DIRECTORY",
+                "Configuration directory (defaults to $CWD/configs)") do |configuration_directory|
+          @options[:configdir] = configuration_directory
+        end
 
-        FLAGS.each_pair do |name, args|
-          if @options.include?(name)
-            opts.on(*args) do |value|
-              @options[name] = value
-            end
+        opts.on("-t HOST",
+                "--target HOST",
+                "Name of target machine for build and packaging (defaults to requesting from the pooler)") do |target|
+          @options[:target] = target
+        end
+
+        opts.on("-e ENGINE",
+                "--engine ENGINE",
+                "Custom engine to use [base, local, docker, pooler] (defaults to \"pooler\")") do |engine|
+          @options[:engine] = engine
+        end
+
+        opts.on("--skipcheck",
+                "Skip the \"check\" stage when building components") do |skipcheck|
+          @options[:skipcheck] = skipcheck
+        end
+
+        opts.on("-p [RULE]",
+                "--preserve [RULE]",
+                ["never", "on-failure", "always"],
+                "Rule for VM preservation. [never, on-failure, always]") do |rule|
+          if rule.nil?
+            @options[:preserve] = :always
+          else
+            @options[:preserve] = rule.to_sym
           end
         end
 
-        opts.on('-h', '--help', 'Display help') do
-          $stdout.puts opts
-          exit 1
+        opts.on("--only-build COMPONENT,COMPONENT,...",
+                Array,
+                "Only build listed COMPONENTs") do |components|
+          @options[:only_build] = components
         end
       end
     end
 
     def parse!(args)
-      @optparse.parse!(args)
+      @option_parser.parse!(args)
       @options
     end
 

data/lib/vanagon/platform.rb

@@ -37,6 +37,7 @@ class Vanagon
     attr_accessor :rpmbuild # This is RedHat/EL/Fedora/SLES specific
     attr_accessor :sort
     attr_accessor :tar
+    attr_accessor :shasum
 
     # Hold a string containing the values that a given platform
     # should use when a Makefile is run - resolves to the CFLAGS
@@ -215,6 +216,7 @@ class Vanagon
       @find ||= "find"
       @sort ||= "sort"
       @copy ||= "cp"
+      @shasum ||= "sha1sum"
 
       # Our first attempt at defining metadata about a platform
       @cross_compiled ||= false
@@ -435,6 +437,34 @@ class Vanagon
       end
     end
 
+    # Save the generic compiled archive and relevant metadata as packaging
+    # output. This will include a json file with all of the components/versions
+    # that were built and a bill of materials when relevant. The archive will be
+    # a gzipped tarball.
+    #
+    # @param project The Vanagon::Project to run this on
+    # @return array of commands to be run
+    def generate_compiled_archive(project)
+      name_and_version = "#{project.name}-#{project.version}"
+      name_and_version_and_platform = "#{name_and_version}.#{name}"
+      final_archive = "output/#{name_and_version_and_platform}.tar.gz"
+      archive_directory = "#{project.name}-archive"
+      metadata = project.build_manifest_json(true)
+      metadata.gsub!(/\n/, '\n')
+      [
+        "mkdir output",
+        "mkdir #{archive_directory}",
+        "gunzip -c #{name_and_version}.tar.gz | '#{tar}' -C #{archive_directory} -xf -",
+        "rm #{name_and_version}.tar.gz",
+        "cd #{archive_directory}/#{name_and_version}; rm -f bill-of-materials; #{tar} cf ../../#{name_and_version_and_platform}.tar *",
+        "gzip -9c #{name_and_version_and_platform}.tar > #{name_and_version_and_platform}.tar.gz",
+        "echo -e \"#{metadata}\" > output/#{name_and_version_and_platform}.json",
+        "cp bill-of-materials output/#{name_and_version_and_platform}-bill-of-materials ||:",
+        "cp #{name_and_version_and_platform}.tar.gz output",
+        "#{shasum} #{final_archive} > #{final_archive}.sha1"
+      ]
+    end
+
     # Set the command to turn the target machine into a builder for vanagon
     #
     # @param command [String] Command to enable the target machine to build packages for the platform

data/lib/vanagon/platform/deb.rb

@@ -29,10 +29,15 @@ class Vanagon
       # @param workdir [String] working directory to stage the evaluated templates in
       # @param name [String] name of the project
       # @param binding [Binding] binding to use in evaluating the packaging templates
-      def generate_packaging_artifacts(workdir, name, binding)
+      # @param project [Vanagon::Project] Vanagon::Project we are building for
+      def generate_packaging_artifacts(workdir, name, binding, project) # rubocop:disable Metrics/AbcSize
         deb_dir = File.join(workdir, "debian")
         FileUtils.mkdir_p(deb_dir)
 
+        unless project.get_interest_triggers("install").empty? && project.get_interest_triggers("upgrade").empty? && project.get_activate_triggers.empty?
+          erb_file(File.join(VANAGON_ROOT, "resources/deb/triggers.erb"), File.join(deb_dir, "#{name}.triggers"), false, { :binding => binding })
+        end
+
         # Lots of templates here
         ["changelog", "conffiles", "control", "docs", "dirs", "install", "preinst", "postinst", "postrm", "prerm", "rules"].each do |deb_file|
           erb_file(File.join(VANAGON_ROOT, "resources/deb/#{deb_file}.erb"), File.join(deb_dir, deb_file), false, { :binding => binding })

data/lib/vanagon/platform/dsl.rb

@@ -111,6 +111,10 @@ class Vanagon
         @platform.tar = tar_cmd
       end
 
+      def shasum(sha1sum_command)
+        @platform.shasum = sha1sum_command
+      end
+
       # Set the type of package we are going to build for this platform
       #
       # @param pkg_type [String] The type of package we are going to build for this platform

data/lib/vanagon/platform/osx.rb

@@ -64,7 +64,8 @@ class Vanagon
       # @param workdir [String] working directory to stage the evaluated templates in
       # @param name [String] name of the project
       # @param binding [Binding] binding to use in evaluating the packaging templates
-      def generate_packaging_artifacts(workdir, name, binding) # rubocop:disable Metrics/AbcSize
+      # @param project [Vanagon::Project] Vanagon::Project we are building for
+      def generate_packaging_artifacts(workdir, name, binding, project) # rubocop:disable Metrics/AbcSize
         resources_dir = File.join(workdir, "resources", "osx")
         FileUtils.mkdir_p(resources_dir)
         script_dir = File.join(workdir, "scripts")
@@ -100,6 +101,7 @@ class Vanagon
         @name = name
         @make = "/usr/bin/make"
         @tar = "tar"
+        @shasum = "/usr/bin/shasum"
         @pkgbuild = "/usr/bin/pkgbuild"
         @productbuild = "/usr/bin/productbuild"
         @hdiutil = "/usr/bin/hdiutil"

data/lib/vanagon/platform/rpm.rb

@@ -33,7 +33,8 @@ class Vanagon
       # @param workdir [String] working directory to stage the evaluated templates in
       # @param name [String] name of the project
       # @param binding [Binding] binding to use in evaluating the packaging templates
-      def generate_packaging_artifacts(workdir, name, binding)
+      # @param project [Vanagon::Project] Vanagon::Project we are building for
+      def generate_packaging_artifacts(workdir, name, binding, project)
         erb_file(File.join(VANAGON_ROOT, "resources/rpm/project.spec.erb"), File.join(workdir, "#{name}.spec"), false, { :binding => binding })
       end
 

data/lib/vanagon/platform/rpm/aix.rb

@@ -17,6 +17,7 @@ class Vanagon
           @make = "/usr/bin/gmake"
           @tar = "/opt/freeware/bin/tar"
           @patch = "/opt/freeware/bin/patch"
+          @shasum = "/opt/freeware/bin/sha1sum"
           @num_cores = "lsdev -Cc processor |wc -l"
           @install = "/opt/freeware/bin/install"
           @rpmbuild = "/usr/bin/rpm"

data/lib/vanagon/platform/solaris_10.rb

@@ -48,7 +48,6 @@ class Vanagon
 
           bom_install,
 
-          "rm #{name_and_version}.tar.gz",
           "cp -r packaging $(tempdir)/",
 
           # Here we are tweaking file/dir ownership and perms in the following ways
@@ -81,7 +80,8 @@ class Vanagon
       # @param workdir [String] working directory to stage the evaluated templates in
       # @param name [String] name of the project
       # @param binding [Binding] binding to use in evaluating the packaging templates
-      def generate_packaging_artifacts(workdir, name, binding)
+      # @param project [Vanagon::Project] Vanagon::Project we are building for
+      def generate_packaging_artifacts(workdir, name, binding, project)
         ["pkginfo", "depend", "preinstall", "preremove", "postinstall", "proto"].each do |template|
           target_dir = File.join(workdir, 'packaging')
           FileUtils.mkdir_p(target_dir)
@@ -185,6 +185,7 @@ class Vanagon
         @make = "/opt/csw/bin/gmake"
         @tar = "/usr/sfw/bin/gtar"
         @patch = "/usr/bin/gpatch"
+        @shasum = "/opt/csw/bin/shasum"
         # solaris 10
         @num_cores = "/usr/bin/kstat cpu_info | awk '{print $$1}' | grep '^core_id$$' | wc -l"
         super(name)

data/lib/vanagon/platform/solaris_11.rb

@@ -40,7 +40,8 @@ class Vanagon
       # @param workdir [String] working directory to stage the evaluated templates in
       # @param name [String] name of the project
       # @param binding [Binding] binding to use in evaluating the packaging templates
-      def generate_packaging_artifacts(workdir, name, binding)
+      # @param project [Vanagon::Project] Vanagon::Project we are building for
+      def generate_packaging_artifacts(workdir, name, binding, project)
         target_dir = File.join(workdir, 'packaging')
         FileUtils.mkdir_p(target_dir)
         erb_file(File.join(VANAGON_ROOT, "resources/solaris/11/p5m.erb"), File.join(target_dir, "#{name}.p5m"), false, { :binding => binding })

data/lib/vanagon/platform/windows.rb

@@ -11,6 +11,10 @@ class Vanagon
           return generate_msi_package(project)
         when "nuget"
           return generate_nuget_package(project)
+        when "archive"
+          # We don't need to generate the package for archives, return an
+          # empty array
+          return []
         else
           raise Vanagon::Error, "I don't know how to build package type '#{project.platform.package_type}' for Windows. Teach me?"
         end
@@ -26,6 +30,8 @@ class Vanagon
           return msi_package_name(project)
         when "nuget"
           return nuget_package_name(project)
+        when "archive"
+          return "#{project.name}-#{project.version}-archive"
         else
           raise Vanagon::Error, "I don't know how to name package type '#{project.platform.package_type}' for Windows. Teach me?"
         end
@@ -36,12 +42,16 @@ class Vanagon
       # @param workdir [String] working directory to stage the evaluated templates in
       # @param name [String] name of the project
       # @param binding [Binding] binding to use in evaluating the packaging templates
-      def generate_packaging_artifacts(workdir, name, binding)
+      # @param project [Vanagon::Project] Vanagon::Project we are building for
+      def generate_packaging_artifacts(workdir, name, binding, project)
         case @package_type
         when "msi"
           return generate_msi_packaging_artifacts(workdir, name, binding)
         when "nuget"
           return generate_nuget_packaging_artifacts(workdir, name, binding)
+        when "archive"
+          # We don't need to generate packaging artifacts if this is an archive
+          return
         else
           raise Vanagon::Error, "I don't know how create packaging artifacts for package type '#{project.platform.package_type}' for Windows. Teach me?"
         end

data/lib/vanagon/project.rb

@@ -83,6 +83,13 @@ class Vanagon
     # Should we include source packages?
     attr_accessor :source_artifacts
 
+    # Should we include platform-specific archives as final outputs
+    # probably gzipped tarball for *nix, and probably 7z for win
+    attr_accessor :compiled_archive
+
+    # Should we generate platform-specific packages (rpm, deb, dmg, msi, etc)
+    attr_accessor :generate_packages
+
     # Loads a given project from the configdir
     #
     # @param name [String] the name of the project
@@ -109,7 +116,7 @@ class Vanagon
     # @param name [String] name of the project
     # @param platform [Vanagon::Platform] platform for the project to be built for
     # @return [Vanagon::Project] the project with the given name and platform
-    def initialize(name, platform)
+    def initialize(name, platform) # rubocop:disable Metrics/AbcSize
       @name = name
       @components = []
       @requires = []
@@ -125,6 +132,8 @@ class Vanagon
       @conflicts = []
       @package_overrides = []
       @source_artifacts = false
+      @compiled_archive = false
+      @generate_packages = true
     end
 
     # Magic getter to retrieve settings in the project
@@ -168,7 +177,7 @@ class Vanagon
     def get_files
       files = []
       files.push @version_file if @version_file
-      files.push @components.map(&:files).flatten
+      files.push components.flat_map(&:files)
       files.flatten.uniq
     end
 
@@ -210,7 +219,7 @@ class Vanagon
     # @return [Array] array of runtime requirements for the project
     def get_requires
       req = []
-      req << @components.map(&:requires).flatten
+      req << components.flat_map(&:requires)
       req << @requires
       req.flatten.uniq
     end
@@ -221,7 +230,7 @@ class Vanagon
     def get_replaces
       replaces = []
       replaces.push @replaces.flatten
-      replaces.push @components.map(&:replaces).flatten
+      replaces.push components.flat_map(&:replaces)
       replaces.flatten.uniq
     end
 
@@ -231,7 +240,7 @@ class Vanagon
 
     # Collects all of the conflicts for the project and its components
     def get_conflicts
-      conflicts = @components.flat_map(&:conflicts) + @conflicts
+      conflicts = components.flat_map(&:conflicts) + @conflicts
       # Mash the whole thing down into a flat Array
       conflicts.flatten.uniq
     end
@@ -248,7 +257,7 @@ class Vanagon
     # @param [string] name of service to grab
     # @return [@component.service obj] specific service
     def get_service(name)
-      @components.each do |component|
+      components.each do |component|
         if component.name == name
           return component.service
         end
@@ -262,7 +271,7 @@ class Vanagon
     def get_provides
       provides = []
       provides.push @provides.flatten
-      provides.push @components.map(&:provides).flatten
+      provides.push components.flat_map(&:provides)
       provides.flatten.uniq
     end
 
@@ -270,15 +279,26 @@ class Vanagon
       !get_provides.empty?
     end
 
-    # Collects the preinstall packaging actions for the project and it's components
-    # for the specified packaging state
+    # Checks that the string pkg_state is valid (install OR upgrade).
+    # Return vanagon error if invalid
+    #
+    # @param pkg_state [String] package state input
+    def check_pkg_state_string(pkg_state)
+      unless ["install", "upgrade"].include? pkg_state
+        raise Vanagon::Error, "#{pkg_state} should be a string containing one of 'install' or 'upgrade'"
+      end
+    end
+
+    # Collects the preinstall packaging actions for the project and its components
+    #  for the specified packaging state
     #
     # @param pkg_state [String] the package state we want to run the given scripts for.
-    #   Can be one or more of 'install' or 'upgrade'
+    #   Can be one of 'install' or 'upgrade'
     # @return [String] string of Bourne shell compatible scriptlets to execute during the preinstall
     #   phase of packaging during the state of the system defined by pkg_state (either install or upgrade)
     def get_preinstall_actions(pkg_state)
-      scripts = @components.map(&:preinstall_actions).flatten.compact.select { |s| s.pkg_state.include? pkg_state }.map(&:scripts)
+      check_pkg_state_string(pkg_state)
+      scripts = components.flat_map(&:preinstall_actions).compact.select { |s| s.pkg_state.include? pkg_state }.map(&:scripts)
       if scripts.empty?
         return ': no preinstall scripts provided'
       else
@@ -286,16 +306,81 @@ class Vanagon
       end
     end
 
+    # Collects the install trigger scripts for the project for the specified packing state
+    #
+    # @param pkg_state [String] the package state we want to run the given scripts for.
+    #   Can be one of the 'install' or 'upgrade'
+    # @return [Hash] of scriptlets to execute during the pkg_state (install or upgrade)
+    #   there can be more than one script for each package (key)
+    def get_trigger_scripts(pkg_state)
+      triggers = Hash.new { |hsh, key| hsh[key] = [] }
+      check_pkg_state_string(pkg_state)
+      pkgs = components.flat_map(&:install_triggers).compact.select { |s| s.pkg_state.include? pkg_state }
+      pkgs.each do |package|
+        triggers[package.pkg].push package.scripts
+      end
+      triggers
+    end
+
+    # Grabs the install trigger scripts for the specified pkg
+    #
+    # @param pkg [String] the pkg we watch for being installed
+    def get_install_trigger_scripts(pkg)
+      scripts = get_trigger_scripts("install")
+      return scripts[pkg].join("\n")
+    end
+
+    # Grabs the upgrade trigger scripts for the specified pkg
+    #
+    # @param pkg [String] the pkg we watch for being upgraded
+    def get_upgrade_trigger_scripts(pkg)
+      scripts = get_trigger_scripts("upgrade")
+      return scripts[pkg].join("\n")
+    end
+
+    # Grabs all pkgs that have trigger scripts for 'install' and 'upgrade'
+    #
+    # @return [Array] a list of all the pkgs that have trigger scripts
+    def get_all_trigger_pkgs()
+      install_triggers = get_trigger_scripts("install")
+      upgrade_triggers = get_trigger_scripts("upgrade")
+      packages = (install_triggers.keys + upgrade_triggers.keys).uniq
+      return packages
+    end
+
+    # Collects the interest triggers for the project and its scripts for the
+    #  specified packaging state
+    #
+    # @param pkg_state [String] the package state we want to run the given scripts for.
+    #   Can be one of 'install' or 'upgrade'
+    # @return [Array] of OpenStructs of all interest triggers for the pkg_state
+    #   Use array of openstructs because we need both interest_name and the scripts
+    def get_interest_triggers(pkg_state)
+      interest_triggers = []
+      check_pkg_state_string(pkg_state)
+      interests = components.flat_map(&:interest_triggers).compact.select { |s| s.pkg_state.include? pkg_state }
+      interests.each do |interest|
+        interest_triggers.push(interest)
+      end
+      interest_triggers.flatten.compact
+    end
+
+    # Collects activate triggers for the project and its components
+    #
+    # @return [Array] of activate triggers
+    def get_activate_triggers()
+      components.flat_map(&:activate_triggers).compact.map(&:activate_name)
+    end
 
     # Collects the postinstall packaging actions for the project and it's components
-    # for the specified packaging state
+    #  for the specified packaging state
     #
     # @param pkg_state [String] the package state we want to run the given scripts for.
-    #   Can be one or more of 'install' or 'upgrade'
+    #   Can be one of 'install' or 'upgrade'
     # @return [String] string of Bourne shell compatible scriptlets to execute during the postinstall
     #   phase of packaging during the state of the system defined by pkg_state (either install or upgrade)
     def get_postinstall_actions(pkg_state)
-      scripts = @components.map(&:postinstall_actions).flatten.compact.select { |s| s.pkg_state.include? pkg_state }.map(&:scripts)
+      scripts = components.flat_map(&:postinstall_actions).compact.select { |s| s.pkg_state.include? pkg_state }.map(&:scripts)
       if scripts.empty?
         return ': no postinstall scripts provided'
       else
@@ -311,7 +396,7 @@ class Vanagon
     # @return [String] string of Bourne shell compatible scriptlets to execute during the preremove
     #   phase of packaging during the state of the system defined by pkg_state (either removal or upgrade)
     def get_preremove_actions(pkg_state)
-      scripts = @components.map(&:preremove_actions).flatten.compact.select { |s| s.pkg_state.include? pkg_state }.map(&:scripts)
+      scripts = components.flat_map(&:preremove_actions).compact.select { |s| s.pkg_state.include? pkg_state }.map(&:scripts)
       if scripts.empty?
         return ': no preremove scripts provided'
       else
@@ -327,7 +412,7 @@ class Vanagon
     # @return [String] string of Bourne shell compatible scriptlets to execute during the postremove
     #   phase of packaging during the state of the system defined by pkg_state (either removal or upgrade)
     def get_postremove_actions(pkg_state)
-      scripts = @components.map(&:postremove_actions).flatten.compact.select { |s| s.pkg_state.include? pkg_state }.map(&:scripts)
+      scripts = components.flat_map(&:postremove_actions).compact.select { |s| s.pkg_state.include? pkg_state }.map(&:scripts)
       if scripts.empty?
         return ': no postremove scripts provided'
       else
@@ -339,7 +424,7 @@ class Vanagon
     #
     # @return [Array] array of configfiles installed by components of the project
     def get_configfiles
-      @components.map(&:configfiles).flatten.uniq
+      components.flat_map(&:configfiles).uniq
     end
 
     def has_configfiles?
@@ -352,7 +437,7 @@ class Vanagon
     def get_directories
       dirs = []
       dirs.push @directories
-      dirs.push @components.map(&:directories).flatten
+      dirs.push components.flat_map(&:directories)
       dirs.flatten.uniq
     end
 
@@ -384,7 +469,7 @@ class Vanagon
     #
     # @return [Array] the services provided by components in the project
     def get_services
-      @components.map(&:service).flatten.compact
+      components.flat_map(&:service).compact
     end
 
     # Simple utility for determining if the components in the project declare
@@ -415,7 +500,7 @@ class Vanagon
     #
     # @return [Array] a listing of component names and versions
     def generate_bill_of_materials
-      @components.map { |comp| "#{comp.name} #{comp.version}" }.sort
+      components.map { |comp| "#{comp.name} #{comp.version}" }.sort
     end
 
     # Method to generate the command to create a tarball of the project
@@ -451,7 +536,7 @@ class Vanagon
     # @param component [Vanagon::Component] component to check for already satisfied build dependencies
     # @return [Array] a list of the build dependencies for the given component that are satisfied by other components in the project
     def list_component_dependencies(component)
-      component.build_requires.select { |dep| @components.map(&:name).include?(dep) }
+      component.build_requires.select { |dep| components.map(&:name).include?(dep) }
     end
 
     # Get the package name for the project on the current platform
@@ -465,7 +550,14 @@ class Vanagon
     #
     # @return [String, Array] commands to build a package for the current project as defined by the platform
     def generate_package
-      @platform.generate_package(self)
+      cmds = []
+      if generate_packages
+        cmds << @platform.generate_package(self)
+      end
+      if compiled_archive
+        cmds << @platform.generate_compiled_archive(self)
+      end
+      cmds.flatten
     end
 
     # Generate any required files to build a package for this project on the
@@ -473,7 +565,7 @@ class Vanagon
     #
     # @param workdir [String] workdir to put the packaging files into
     def generate_packaging_artifacts(workdir)
-      @platform.generate_packaging_artifacts(workdir, @name, binding)
+      @platform.generate_packaging_artifacts(workdir, @name, binding, self)
     end
 
     # Generate a json hash which lists all of the dependant components of the
@@ -482,7 +574,7 @@ class Vanagon
     # @return [Hash] where the top level keys are components and their values
     #   are hashes with additional information on the component.
     def generate_dependencies_info
-      @components.each_with_object({}) do |component, hsh|
+      components.each_with_object({}) do |component, hsh|
         hsh.merge!(component.get_dependency_hash)
       end
     end
@@ -493,7 +585,7 @@ class Vanagon
     #
     # @return [Hash] of information which is useful to know about how a package
     #   was built and what went into the package.
-    def build_manifest_json
+    def build_manifest_json(pretty = false)
       manifest = {
         "packaging_type" => {
           "vanagon" => VANAGON_VERSION,
@@ -502,6 +594,11 @@ class Vanagon
         "components" => generate_dependencies_info,
         "build_time" => BUILD_TIME,
       }
+      if pretty
+        JSON.pretty_generate(manifest)
+      else
+        manifest
+      end
     end
 
     # Writes a json file at `ext/build_metadata.json` containing information
@@ -509,9 +606,37 @@ class Vanagon
     #
     # @return [Hash] of build information
     def save_manifest_json
-      manifest = build_manifest_json
+      manifest = build_manifest_json(true)
       File.open(File.join('ext', 'build_metadata.json'), 'w') do |f|
-        f.write(JSON.pretty_generate(manifest))
+        f.write(manifest)
+      end
+    end
+
+    # Load the settings hash from an upstream vanagon project.
+    # This will clone a git repo at a specified branch and load the specified
+    # vanagon project (with no components). The settings hash of the upstream
+    # project will be merged with the existing settings hash, overriding any
+    # duplicates at the time of calling with the value from upstream. To
+    # override settings from upstream, you need to set the `proj.setting` after
+    # `proj.inherit_settings`.
+    #
+    # As the settings are not lazy-loaded, if you need to override a setting
+    # from upstream that is used in later settings, you'll need to override all
+    # of the settings based on the one you're overriding.
+    #
+    # @param upstream_project_name [String] The name of the vanagon project to load
+    # @param upstream_git_url [URI] The URL to clone this vanagon project from
+    # @param upstream_git_branch [String] The branch of the vanagon project to clone from
+    def load_upstream_settings(upstream_project_name, upstream_git_url, upstream_git_branch)
+      Dir.mktmpdir do |working_directory|
+        upstream_source = Vanagon::Component::Source::Git.new(upstream_git_url, workdir: working_directory, ref: upstream_git_branch)
+        upstream_source.fetch
+        # We don't want to load any of the upstream components, so we're going to
+        # pass an array with an empty string as the component list for load_project
+        no_components = ['']
+        upstream_project = Vanagon::Project.load_project(upstream_project_name, File.join(working_directory, upstream_source.dirname, "configs", "projects"), platform, no_components)
+        @settings.merge!(upstream_project.settings)
+        upstream_project.cleanup
       end
     end
   end