omnibus-sonian 1.2.0.1

data/bin/omnibus

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+# Trap interrupts to quit cleanly. See
+# https://twitter.com/mitchellh/status/283014103189053442
+Signal.trap("INT") { exit 1 }
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'omnibus/cli'
+
+Omnibus::CLI::Application.start

data/lib/omnibus.rb

@@ -0,0 +1,304 @@
+#
+# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'ohai'
+o = Ohai::System.new
+o.require_plugin('os')
+o.require_plugin('platform')
+o.require_plugin('linux/cpu') if o.os == 'linux'
+o.require_plugin('kernel')
+OHAI = o
+
+require 'omnibus/library'
+require 'omnibus/reports'
+require 'omnibus/config'
+require 'omnibus/exceptions'
+require 'omnibus/software'
+require 'omnibus/project'
+require 'omnibus/fetchers'
+require 'omnibus/health_check'
+require 'omnibus/build_version'
+require 'omnibus/overrides'
+require 'omnibus/version'
+
+require 'pathname'
+
+module Omnibus
+
+  DEFAULT_CONFIG_FILENAME = 'omnibus.rb'.freeze
+
+  # Configure Omnibus.
+  #
+  # After this has been called, the {Omnibus::Config} object is
+  # available as `Omnibus.config`.
+  #
+  # @return [void]
+  #
+  # @deprecated Use {#load_configuration} if you need to process a
+  #   config file, followed by {#process_configuration} to act upon it.
+  def self.configure
+    load_configuration
+    process_configuration
+  end
+
+  # Convenience method for access to the Omnibus::Config object.
+  # Provided for backward compatibility.
+  #
+  # @ return [Omnibus::Config]
+  #
+  # @deprecated Just refer to {Omnibus::Config} directly.
+  def self.config
+    Config
+  end
+
+  # Load in an Omnibus configuration file.  Values will be merged with
+  # and override the defaults defined in {Omnibus::Config}.
+  #
+  # @param file [String] path to a configuration file to load
+  #
+  # @return [void]
+  def self.load_configuration(file=nil)
+    if file
+      Config.from_file(file)
+    end
+  end
+
+  # Processes the configuration to construct the dependency tree of
+  # projects and software.
+  #
+  # @return [void]
+  def self.process_configuration
+    Config.validate
+    process_dsl_files
+    generate_extra_rake_tasks
+  end
+
+  # All {Omnibus::Project} instances that have been created.
+  #
+  # @return [Array<Omnibus::Project>]
+  def self.projects
+    @projects ||= []
+  end
+
+  # Names of all the {Omnibus::Project} instances that have been created.
+  #
+  # @return [Array<String>]
+  def self.project_names
+    projects.map{|p| p.name}
+  end
+
+  # Load the {Omnibus::Project} instance with the given name.
+  #
+  # @param name [String]
+  # @return {Omnibus::Project}
+  def self.project(name)
+    projects.find{ |p| p.name == name}
+  end
+
+  # The absolute path to the Omnibus project/repository directory.
+  #
+  # @return [String]
+  #
+  # @deprecated Call {Omnibus::Config.project_root} instead.  We need
+  #   to be able to easily tweak this at runtime via the CLI tool.
+  def self.project_root
+    Config.project_root
+  end
+
+  # The source root is the path to the root directory of the `omnibus` gem.
+  #
+  # @return [Pathname]
+  def self.source_root
+    @source_root ||= Pathname.new(File.expand_path("../..", __FILE__))
+  end
+
+  # The source root is the path to the root directory of the `omnibus-software`
+  # gem.
+  #
+  # @return [Pathname]
+  def self.omnibus_software_root
+    @omnibus_software_root ||= begin
+      if spec = Gem::Specification.find_all_by_name('omnibus-software').first
+        Pathname.new(spec.gem_dir)
+      else
+        nil
+      end
+    end
+  end
+
+  # Return paths to all configured {Omnibus::Project} DSL files.
+  #
+  # @return [Array<String>]
+  def self.project_files
+    ruby_files(File.join(project_root, Config.project_dir))
+  end
+
+  # Return paths to all configured {Omnibus::Software} DSL files.
+  #
+  # @return [Array<String>]
+  def self.software_files
+    ruby_files(File.join(project_root, Config.software_dir))
+  end
+
+  # Backward compat alias
+  #
+  # @todo print a deprecation message
+  class << self
+    alias :root :project_root
+  end
+
+  private
+
+  # Generates {Omnibus::Project}s for each project DSL file in
+  # `project_specs`.  All projects are then accessible at
+  # {Omnibus#projects}
+  #
+  # @return [void]
+  #
+  # @see Omnibus::Project
+  def self.expand_projects
+    project_files.each do |spec|
+      Omnibus.projects << Omnibus::Project.load(spec)
+    end
+  end
+
+  # Generate {Omnibus::Software} objects for all software DSL files in
+  # `software_specs`.
+  #
+  # @param overrides [Hash] a hash of version override information.
+  # @param software_files [Array<String>]
+  # @return [void]
+  #
+  # @see Omnibus::Overrides#overrides
+  def self.expand_software(overrides, software_map)
+    unless overrides.is_a? Hash
+      raise ArgumentError, "Overrides argument must be a hash!  You passed #{overrides.inspect}."
+    end
+
+    Omnibus.projects.each do |project|
+      project.dependencies.each do |dependency|
+        recursively_load_dependency(dependency, project, overrides, software_map)
+      end
+    end
+  end
+
+  # Processes all configured {Omnibus::Project} and
+  # {Omnibus::Software} DSL files.
+  #
+  # @return [void]
+  def self.process_dsl_files
+    # Do projects first
+    expand_projects
+
+    # Then do software
+    final_software_map = prefer_local_software(omnibus_software_files,
+                                           software_files)
+
+    overrides = Config.override_file ? Omnibus::Overrides.overrides : {}
+
+    expand_software(overrides, final_software_map)
+  end
+
+  # Creates some additional Rake tasks beyond those generated in the
+  # process of reading in the DSL files.
+  #
+  # @return [void]
+  #
+  # @todo Not so sure I like how this is being done, but at least it
+  #   isolates the Rake stuff.
+  def self.generate_extra_rake_tasks
+    require 'omnibus/clean_tasks'
+  end
+
+  # Return a list of all the Ruby files (i.e., those with an "rb"
+  # extension) in the given directory
+  #
+  # @param dir [String]
+  # @return [Array<String>]
+  def self.ruby_files(dir)
+    Dir.glob("#{dir}/*.rb")
+  end
+
+  # Retrieve the fully-qualified paths to every software definition
+  # file bundled in the {https://github.com/opscode/omnibus-software omnibus-software} gem.
+  #
+  # @return [Array<String>] the list of paths. Will be empty if the
+  #   `omnibus-software` gem is not in the gem path.
+  def self.omnibus_software_files
+    if omnibus_software_root
+      Dir.glob(File.join(omnibus_software_root, 'config', 'software', '*.rb'))
+    else
+      []
+    end
+  end
+
+  # Given a list of software definitions from `omnibus-software` itself, and a
+  # list of software files local to the current project, create a
+  # single list of software definitions.  If the software was defined
+  # in both sets, the locally-defined one ends up in the final list.
+  #
+  # The base name of the software file determines what software it
+  # defines.
+  #
+  # @param omnibus_files [Array<String>]
+  # @param local_files [Array<String>]
+  # @return [Array<String>]
+  def self.prefer_local_software(omnibus_files, local_files)
+    base = software_map(omnibus_files)
+    local = software_map(local_files)
+    base.merge(local)
+  end
+
+  # Given a list of file paths, create a map of the basename (without
+  # extension) to the complete path.
+  #
+  # @param files [Array<String>]
+  # @return [Hash<String, String>]
+  def self.software_map(files)
+    files.each_with_object({}) do |file, collection|
+      software_name = File.basename(file, ".*")
+      collection[software_name] = file
+    end
+  end
+
+  # Loads a project's dependency recursively, ensuring all transitive dependencies
+  # are also loaded.
+  #
+  # @param dependency_name [String]
+  # @param project [Omnibus::Project]
+  # @param overrides [Hash] a hash of version override information.
+  # @param software_map [Hash<String, String>]
+  #
+  # @return [void]
+  def self.recursively_load_dependency(dependency_name, project, overrides, software_map)
+    dep_file = software_map[dependency_name]
+
+    unless dep_file
+      raise MissingProjectDependency.new(dependency_name,
+                                         [File.join(project_root, Config.software_dir),
+                                          File.join(omnibus_software_root, 'config', 'software')])
+    end
+
+    dep_software = Omnibus::Software.load(dep_file, project, overrides)
+    project.library.component_added(dep_software)
+
+    # load any transitive deps for the component into the library also
+    dep_software.dependencies.each do |dep|
+      recursively_load_dependency(dep, project, overrides, software_map)
+    end
+  end
+end

data/lib/omnibus/artifact.rb

@@ -0,0 +1,151 @@
+module Omnibus
+  class Artifact
+
+    attr_reader :path
+    attr_reader :platforms
+    attr_reader :config
+
+    # @param path [String] relative or absolute path to a package file.
+    # @param platforms [Array<Array<String, String, String>>] an Array of
+    #   distro, distro version, architecture tuples. By convention, the first
+    #   platform is the platform on which the artifact was built.
+    # @param config [#Hash<Symbol, Object>] configuration for the release.
+    #   Artifact only uses `:build_version => String`.
+    def initialize(path, platforms, config)
+      @path = path
+      @platforms = platforms
+      @config = config
+    end
+
+    # Adds this artifact to the `release_manifest`, which is mutated. Intended
+    # to be used in a visitor-pattern fashion over a collection of Artifacts to
+    # generate a final release manifest.
+    #
+    # @param release_manifest [Hash{ String => Hash }] a version 1 style release
+    #   manifest Hash (see example)
+    #
+    # @example Add the package to release_manifest:
+    #   add_to_release_manifest!( {} )
+    #     "el" => {
+    #       "5" => { "x86_64" => { "11.4.0-1" => "/el/5/x86_64/demoproject-11.4.0-1.el5.x86_64.rpm" } }
+    #     }
+    # @return [Hash{String=>Hash}] the updated release manifest.
+    def add_to_release_manifest!(release_manifest)
+      platforms.each do |distro, version, arch|
+        release_manifest[distro] ||= {}
+        release_manifest[distro][version] ||= {}
+        release_manifest[distro][version][arch] = { build_version => relpath }
+        # TODO: when adding checksums, the desired format is like this:
+        # build_support_json[platform][platform_version][machine_architecture][options[:version]]["relpath"] = build_location
+      end
+      release_manifest
+    end
+
+    # Adds this artifact to the `release_manifest`, which is mutated. Intended
+    # to be used in a visitor-pattern fashion over a collection of Artifacts to
+    # generate a final release manifest.
+    #
+    # @param release_manifest [Hash{ String => Hash }] a version 2 style release
+    #   manifest Hash (see example)
+    #
+    # @example Add the package to release_manifest:
+    #   add_to_release_manifest!( {} )
+    #     "el" => {
+    #       "5" => {
+    #         "x86_64" => {
+    #           "11.4.0-1" => {
+    #             "relpath" => "/el/5/x86_64/demoproject-11.4.0-1.el5.x86_64.rpm",
+    #             "md5" => "123f00d...",
+    #             "sha256" => 456beef..."
+    #           }
+    #         }
+    #       }
+    #     }
+    # @return [Hash{String=>Hash}] the updated release manifest.
+    def add_to_v2_release_manifest!(release_manifest)
+      platforms.each do |distro, version, arch|
+        pkg_info = {
+          "relpath" => relpath,
+          "md5" => md5,
+          "sha256" => sha256
+        }
+
+        release_manifest[distro] ||= {}
+        release_manifest[distro][version] ||= {}
+        release_manifest[distro][version][arch] = { build_version => pkg_info  }
+      end
+      release_manifest
+    end
+
+    # Metadata about the artifact as a flat Hash.
+    #
+    # @example For a RHEL/CentOS 6, 64-bit package of project version 11.4.0-1
+    #   flat_metadata
+    #     { "platform" => "el",
+    #       "platform_version" => "6",
+    #       "arch" => "x86_64",
+    #       "version" => "11.4.0-1",
+    #       "md5" => "d41d8cd98f00b204e9800998ecf8427e",
+    #       "sha256" => "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" }
+    #
+    # @return [Hash{String=>String}] the artifact metadata
+    def flat_metadata
+      distro, version, arch = build_platform
+      {
+        "platform" => distro,
+        "platform_version" => version,
+        "arch" => arch,
+        "version" => build_version,
+        "basename" => File.basename(path),
+        "md5" => md5,
+        "sha256" => sha256
+      }
+    end
+
+    # Platform on which the artifact was built. By convention, this is the
+    # first in the list of platforms passed to {#initialize}.
+    # @return [Array<String, String, String>] an Array of distro, distro
+    #   version, architecture.
+    def build_platform
+      platforms.first
+    end
+
+    # @return [String] build version of the project.
+    def build_version
+      config[:version]
+    end
+
+    # @return [String] relative path at which the artifact should be located
+    #   when uploaded to artifact repo.
+    # @example Chef 11.4.0-1 on 64 bit RHEL 6:
+    #   relpath
+    #     "/el/6/x86_64/chef-11.4.0-1.el5.x86_64.rpm"
+    def relpath
+      # upload build to build platform directory
+      "/#{build_platform.join('/')}/#{path.split('/').last}"
+    end
+
+    # @return [String] hex encoded MD5 of the package
+    def md5
+      @md5 ||= digest(Digest::MD5)
+    end
+
+    # @return [String] hex encoded SHA2-256 of the package
+    def sha256
+      @sha256 ||= digest(Digest::SHA256)
+    end
+
+    private
+
+    def digest(digest_class)
+      digest = digest_class.new
+      File.open(path) do |io|
+        while chunk = io.read(1024 * 8)
+          digest.update(chunk)
+        end
+      end
+      digest.hexdigest
+    end
+  end
+end
+