omnibus 4.0.0 → 4.1.0

data/lib/omnibus/packagers/solaris.rb

@@ -18,28 +18,20 @@ module Omnibus
   class Packager::Solaris < Packager::Base
     id :solaris
 
-    setup do
-      remove_directory('/tmp/pkgmk')
-      create_directory('/tmp/pkgmk')
-    end
-
     build do
-      Dir.chdir(staging_dir) do
-        shellout! "cd #{install_dirname} && find #{install_basename} -print > /tmp/pkgmk/files"
-      end
+      shellout! "cd #{install_dirname} && find #{install_basename} -print > #{staging_dir_path('files')}"
+      
 
       write_prototype_content
 
       write_pkginfo_content
 
-      copy_file("#{project.package_scripts_path}/postinst", '/tmp/pkgmk/postinstall')
-      copy_file("#{project.package_scripts_path}/postrm", '/tmp/pkgmk/postremove')
+      copy_file("#{project.package_scripts_path}/postinst", staging_dir_path('postinstall'))
+      copy_file("#{project.package_scripts_path}/postrm", staging_dir_path('postremove'))
 
-      Dir.chdir(staging_dir) do
-        shellout! "pkgmk -o -r #{install_dirname} -d /tmp/pkgmk -f /tmp/pkgmk/Prototype"
-        shellout! "pkgchk -vd /tmp/pkgmk #{project.package_name}"
-        shellout! "pkgtrans /tmp/pkgmk /var/cache/omnibus/pkg/#{package_name} #{project.package_name}"
-      end
+      shellout! "pkgmk -o -r #{install_dirname} -d #{staging_dir} -f #{staging_dir_path('Prototype')}"
+      shellout! "pkgchk -vd #{staging_dir} #{project.package_name}"
+      shellout! "pkgtrans #{staging_dir} #{package_path} #{project.package_name}"
     end
 
     # @see Base#package_name
@@ -58,6 +50,10 @@ module Omnibus
     def install_basename
       File.basename(project.install_dir)
     end
+    
+    def staging_dir_path(file_name)
+      File.join(staging_dir, file_name)
+    end
 
     #
     # Generate a Prototype file for solaris build
@@ -70,17 +66,15 @@ module Omnibus
       EOF
 
       # generate list of control files
-      File.open '/tmp/pkgmk/Prototype', 'w+' do |f|
+      File.open staging_dir_path('Prototype'), 'w+' do |f|
         f.write prototype_content
       end
 
-      Dir.chdir(staging_dir) do
-        # generate the prototype's file list
-        shellout! "cd #{install_dirname} && pkgproto < /tmp/pkgmk/files > /tmp/pkgmk/Prototype.files"
+      # generate the prototype's file list
+      shellout! "cd #{install_dirname} && pkgproto < #{staging_dir_path('files')} > #{staging_dir_path('Prototype.files')}"
 
-        # fix up the user and group in the file list to root
-        shellout! "awk '{ $5 = \"root\"; $6 = \"root\"; print }' < /tmp/pkgmk/Prototype.files >> /tmp/pkgmk/Prototype"
-      end
+      # fix up the user and group in the file list to root
+      shellout! "awk '{ $5 = \"root\"; $6 = \"root\"; print }' < #{staging_dir_path('Prototype.files')} >> #{staging_dir_path('Prototype')}"
     end
 
     #
@@ -102,7 +96,7 @@ module Omnibus
         EMAIL=#{project.maintainer}
         PSTAMP=#{`hostname`.chomp + Time.now.utc.iso8601}
       EOF
-      File.open '/tmp/pkgmk/pkginfo', 'w+' do |f|
+      File.open staging_dir_path('pkginfo'), 'w+' do |f|
         f.write pkginfo_content
       end
     end

data/lib/omnibus/project.rb

@@ -17,6 +17,9 @@
 
 require 'time'
 require 'json'
+require 'omnibus/manifest'
+require 'omnibus/manifest_entry'
+require 'omnibus/reports'
 
 module Omnibus
   class Project
@@ -27,7 +30,7 @@ module Omnibus
       #
       # @return [Project]
       #
-      def load(name)
+      def load(name, manifest=nil)
         loaded_projects[name] ||= begin
           filepath = Omnibus.project_path(name)
 
@@ -39,7 +42,7 @@ module Omnibus
             end
           end
 
-          instance = new(filepath)
+          instance = new(filepath, manifest)
           instance.evaluate_file(filepath)
           instance.load_dependencies
           instance
@@ -58,6 +61,8 @@ module Omnibus
       end
     end
 
+    attr_reader :manifest
+
     include Cleanroom
     include Digestable
     include Logging
@@ -65,8 +70,9 @@ module Omnibus
     include Sugarable
     include Util
 
-    def initialize(filepath = nil)
+    def initialize(filepath = nil, manifest=nil)
       @filepath = filepath
+      @manifest = manifest
     end
 
     #
@@ -370,6 +376,24 @@ module Omnibus
     end
     expose :build_version
 
+
+    #
+    # Set or retrieve the git revision of the omnibus
+    # project being built.
+    #
+    # If not set by the user, and the current workding directory is a
+    # git directory, it will return the revision of the current
+    # working directory.
+    #
+    def build_git_revision(val = NULL)
+      if null?(val)
+        @build_git_revision ||= get_local_revision
+      else
+        @build_git_revision = val
+      end
+    end
+    expose :build_git_revision
+
     #
     # Set or retrieve the build iteration of the project. Defaults to +1+ if not
     # otherwise set.
@@ -667,6 +691,46 @@ module Omnibus
     end
     expose :ohai
 
+    #
+    # Location of json-formated version manifest, written at at the
+    # end of the build. If no path is specified
+    # +install_dir+/version-manifest.json is used.
+    #
+    # @example
+    #   json_manifest_path
+    #
+    # @return [String]
+    #
+    def json_manifest_path(path = NULL)
+      if null?(path)
+        @json_manifest_path || File.join(install_dir, "version-manifest.json")
+      else
+        @json_manifest_path=path
+      end
+    end
+    expose :json_manifest_path
+
+    #
+    # Location of text-formatted manifest.
+    # (+install_dir+/version-manifest.txt if none is provided)
+    #
+    # This manifest uses the same format used by the
+    # 'version-manifest' software definition in omnibus-software.
+    #
+    # @example
+    #   text_manifest_path
+    #
+    # @return [String]
+    #
+    def text_manifest_path(path = NULL)
+      if null?(path)
+        @test_manifest_path || File.join(install_dir, "version-manifest.txt")
+      else
+        @text_manifest_path = path
+      end
+    end
+    expose :text_manifest_path
+
     #
     # @!endgroup
     # --------------------------------------------------
@@ -685,7 +749,7 @@ module Omnibus
     #
     def load_dependencies
       dependencies.each do |dependency|
-        Software.load(self, dependency)
+        Software.load(self, dependency, manifest)
       end
 
       true
@@ -904,37 +968,80 @@ module Omnibus
     end
 
     #
+    # Cache the build order so we don't re-compute
     #
+    # @return [Array<Omnibus::Software>]
     #
-    def build_me
-      FileUtils.rm_rf(install_dir)
-      FileUtils.mkdir_p(install_dir)
+    def softwares
+      @softwares ||= library.build_order
+    end
 
-      # Cache the build order so we don't re-compute
-      softwares = library.build_order
+    #
+    # Generate a version manifest of the loaded software sources.
+    #
+    # @returns [Omnibus::Manifest]
+    #
+    def built_manifest
+      log.info(log_key) { "Building version manifest" }
+      m = Omnibus::Manifest.new(build_version, build_git_revision)
+      softwares.each do |software|
+        m.add(software.name, software.manifest_entry)
+      end
+      m
+    end
 
-      # Download all softwares in parallel
+    def download
       ThreadPool.new(Config.workers) do |pool|
         softwares.each do |software|
           pool.schedule { software.fetch }
         end
       end
+    end
+
+    def build
+      FileUtils.rm_rf(install_dir)
+      FileUtils.mkdir_p(install_dir)
 
-      # Now build each software
       softwares.each do |software|
         software.build_me
       end
 
-      # Health check
+      write_json_manifest
+      write_text_manifest
       HealthCheck.run!(self)
-
-      # Package
       package_me
-
-      # Compress
       compress_me
     end
 
+    def write_json_manifest
+      File.open(json_manifest_path, 'w') do |f|
+        f.write(JSON.pretty_generate(built_manifest.to_hash))
+      end
+    end
+
+    #
+    # Writes a text manifest to the text_manifest_path.  This uses the
+    # same method as the "version-manifest" software definition in
+    # omnibus-software.
+    #
+    def write_text_manifest
+      File.open(text_manifest_path, 'w') do |f|
+        f.puts "#{name} #{build_version}"
+        f.puts ""
+        f.puts Omnibus::Reports.pretty_version_map(self)
+      end
+    end
+
+    #
+    # Download and build the project. Preserved for backwards
+    # compatibility.
+    #
+    def build_me
+      # Download all softwares in parallel
+      download
+      build
+    end
+
     #
     #
     #
@@ -1045,6 +1152,12 @@ module Omnibus
 
     private
 
+    def get_local_revision
+      GitRepository.new("./").revision
+    rescue StandardError
+      "unknown"
+    end
+
     #
     # The log key for this project, overriden to include the name of the
     # project for build output.

data/lib/omnibus/publisher.rb

@@ -35,22 +35,27 @@ module Omnibus
     #
     # @param [String] pattern
     #   the path/pattern of the release artifact(s)
+    #
     # @param [Hash] options
     #   the list of options passed to the publisher
+    # @option options [Hash] :platform_mappings A simple
+    #   mapping of build to publish platform(s)
+    # @example
+    #   {
+    #     'ubuntu-10.04' => [
+    #       'ubuntu-10.04',
+    #       'ubuntu-12.04',
+    #       'ubuntu-14.04',
+    #     ],
+    #   }
     #
     def initialize(pattern, options = {})
       @pattern = pattern
       @options = options.dup
 
-      if @options[:platform]
-        log.warn(log_key) do
-          "Publishing platform has been overriden to '#{@options[:platform]}'"
-        end
-      end
-
-      if @options[:platform_version]
-        log.warn(log_key) do
-          "Publishing platform version has been overriden to '#{@options[:platform_version]}'"
+      if @options[:platform_mappings]
+        log.info(log_key) do
+          "Publishing will be performed using provided platform mappings."
         end
       end
     end
@@ -61,7 +66,54 @@ module Omnibus
     # @return [Array<String>]
     #
     def packages
-      @packages ||= FileSyncer.glob(@pattern).map { |path| Package.new(path) }
+      @packages ||= begin
+        publish_packages = Array.new
+        build_packages   = FileSyncer.glob(@pattern).map { |path| Package.new(path) }
+
+        if @options[:platform_mappings]
+          # the platform map is a simple hash with publish to build platform mappings
+          @options[:platform_mappings].each_pair do |build_platform, publish_platforms|
+            # Splits `ubuntu-12.04` into `ubuntu` and `12.04`
+            build_platform, build_platform_version = build_platform.rpartition('-') - %w( - )
+
+            # locate the package for the build platform
+            packages = build_packages.select do |p|
+              p.metadata[:platform] == build_platform &&
+                p.metadata[:platform_version] == build_platform_version
+            end
+
+            if packages.empty?
+              log.warn(log_key) do
+                "Could not locate a package for build platform #{build_platform}-#{build_platform_version}. " \
+                "Publishing will be skipped for: #{publish_platforms.join(', ')}"
+              end
+            end
+
+            publish_platforms.each do |publish_platform|
+              publish_platform, publish_platform_version = publish_platform.rpartition('-') - %w( - )
+
+              packages.each do |p|
+                # create a copy of our package before mucking with its metadata
+                publish_package  = p.dup
+                publish_metadata = p.metadata.dup.to_hash
+
+                # override the platform and platform version in the metadata
+                publish_metadata[:platform]         = publish_platform
+                publish_metadata[:platform_version] = publish_platform_version
+
+                # Set the updated metadata on the package object
+                publish_package.metadata = Metadata.new(publish_package, publish_metadata)
+
+                publish_packages << publish_package
+              end
+            end
+          end
+        else
+          publish_packages.concat(build_packages)
+        end
+
+        publish_packages
+      end
     end
 
     #
@@ -79,45 +131,6 @@ module Omnibus
 
     private
 
-    #
-    # The platform to publish a package for. A publisher can be optionally
-    # initialized with a platform which should be used in all publishing
-    # logic. This allows a package built on one platform to be published
-    # for another platform. For example, one might build on Ubuntu and
-    # test/publish on Ubuntu and Debian.
-    #
-    # @note Even if a glob pattern matches multiple packages (potentially
-    #   across multiple platforms) all packages will be published for the
-    #   same platform.
-    #
-    # @param [Package] package
-    #
-    # @return [String]
-    #
-    def publish_platform(package)
-      @options[:platform] || package.metadata[:platform]
-    end
-
-    #
-    # The platform version to publish a package for. A publisher can be
-    # optionally initialized with a platform version which should be used
-    # in all publishing logic. This allows a package built on one
-    # platform to be published for another platform version. For example,
-    # one might build on Ubuntu 10.04 and test/publish on Ubuntu 10.04
-    # and 12.04.
-    #
-    # @note Even if a glob pattern matches multiple packages (potentially
-    #   across multiple platforms) all packages will be published for the
-    #   same platform version.
-    #
-    # @param [Package] package
-    #
-    # @return [String]
-    #
-    def publish_platform_version(package)
-      @options[:platform_version] || package.metadata[:platform_version]
-    end
-
     def safe_require(name)
       require name
     rescue LoadError

data/lib/omnibus/publishers/artifactory_publisher.rb

@@ -38,7 +38,10 @@ module Omnibus
             artifact_for(package).upload(
               repository,
               remote_path_for(package),
-              metadata_for(package),
+              metadata_for(package).merge(
+                'build.name'   => package.metadata[:name],
+                'build.number' => package.metadata[:version],
+              ),
             )
           end
         rescue Artifactory::Error::HTTPError => e
@@ -56,6 +59,14 @@ module Omnibus
         # If a block was given, "yield" the package to the caller
         block.call(package) if block
       end
+
+      if build_record?
+        if packages.empty?
+          log.warn(log_key) { "No packages were uploaded, build record will not be created." }
+        else
+          build_for(packages).save
+        end
+      end
     end
 
     private
@@ -79,6 +90,77 @@ module Omnibus
       )
     end
 
+    #
+    # The build object that corresponds to this package.
+    #
+    # @param [Array<Package>] packages
+    #   the packages to create the build from
+    #
+    # @return [Artifactory::Resource::Build]
+    #
+    def build_for(packages)
+      name = packages.first.metadata[:name]
+      # Attempt to load the version-manifest.json file which represents
+      # the build.
+      manifest = if File.exist?(version_manifest)
+                   Manifest.from_file(version_manifest)
+                 else
+                   Manifest.new(packages.first.metadata[:version])
+                 end
+
+      # Upload the actual package
+      log.info(log_key) { "Saving build info for #{name}, Build ##{manifest.build_version}" }
+
+      Artifactory::Resource::Build.new(
+        client: client,
+        name:   name,
+        number: manifest.build_version,
+        vcs_revision: manifest.build_git_revision,
+        build_agent: {
+          name: 'omnibus',
+          version: Omnibus::VERSION,
+        },
+        properties: {
+          'omnibus.project' => name,
+          'omnibus.version' => manifest.build_version,
+          'omnibus.version_manifest' => manifest.to_json,
+        },
+        modules: [
+          {
+            # com.getchef:chef-server:12.0.0
+            id: [
+              Config.artifactory_base_path.gsub('/', '.'),
+              name,
+              manifest.build_version,
+            ].join(':'),
+            artifacts: packages.map do |package|
+              {
+                type: File.extname(package.path).split('.').last,
+                sha1: package.metadata[:sha1],
+                md5:  package.metadata[:md5],
+                name: package.metadata[:basename],
+              }
+            end
+          }
+        ]
+      )
+    end
+
+    #
+    # Indicates if an Artifactory build record should be created for the
+    # published set of packages.
+    #
+    # @return [Boolean]
+    #
+    def build_record?
+      # We want to create a build record by default
+      if @options[:build_record].nil?
+        true
+      else
+        @options[:build_record]
+      end
+    end
+
     #
     # The Artifactory client object to communicate with the Artifactory API.
     #
@@ -109,8 +191,8 @@ module Omnibus
     def metadata_for(package)
       {
         'omnibus.project'          => package.metadata[:name],
-        'omnibus.platform'         => publish_platform(package),
-        'omnibus.platform_version' => publish_platform_version(package),
+        'omnibus.platform'         => package.metadata[:platform],
+        'omnibus.platform_version' => package.metadata[:platform_version],
         'omnibus.architecture'     => package.metadata[:arch],
         'omnibus.version'          => package.metadata[:version],
         'omnibus.iteration'        => package.metadata[:iteration],
@@ -130,6 +212,15 @@ module Omnibus
       @options[:repository]
     end
 
+    #
+    # The path to the builds version-manfest.json file (as supplied as an option).
+    #
+    # @return [String]
+    #
+    def version_manifest
+      @options[:version_manifest] || ''
+    end
+
     #
     # The path where the package will live inside of the Artifactory repository.
     # This is dynamically computed from the values in the project definition
@@ -148,8 +239,8 @@ module Omnibus
         Config.artifactory_base_path,
         package.metadata[:name],
         package.metadata[:version],
-        publish_platform(package),
-        publish_platform_version(package),
+        package.metadata[:platform],
+        package.metadata[:platform_version],
         package.metadata[:basename],
       )
     end