class Omnibus::Publisher

Public Class Methods

new(pattern, options = {}) click to toggle source

Create a new publisher from the given pattern.

@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-x86_64' => [
    'ubuntu-10.04-x86_64',
    'ubuntu-12.04-x86_64',
    'ubuntu-14.04-x86_64',
  ],
}
# File lib/omnibus/publisher.rb, line 54
def initialize(pattern, options = {})
  @pattern = pattern
  @options = options.dup

  if @options[:platform_mappings]
    log.info(log_key) do
      "Publishing will be performed using provided platform mappings."
    end
  end
end
publish(pattern, options = {}, &block) click to toggle source

Shortcut class method for creating a new instance of this class and executing the publishing sequence.

@param (see Publisher#initialize)

# File lib/omnibus/publisher.rb, line 28
def publish(pattern, options = {}, &block)
  new(pattern, options).publish(&block)
end

Public Instance Methods

packages() click to toggle source

The list of packages that match the pattern in the initializer.

@return [Array<String>]

# File lib/omnibus/publisher.rb, line 70
def packages
  @packages ||= begin
    publish_packages = []
    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-x86_64` into `ubuntu`, `12.04` and `x86_64`
        build_platform, build_platform_version, build_architecture = build_platform.split("-")

        # 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 &&
            p.metadata[:arch] == build_architecture
        end

        if packages.empty?
          log.warn(log_key) do
            "Could not locate a package for build platform #{build_platform}-#{build_platform_version}-#{build_architecture}. " \
            "Publishing will be skipped for: #{publish_platforms.join(", ")}"
          end
        end

        publish_platforms.each do |publish_platform|
          publish_platform, publish_platform_version, publish_architecture = publish_platform.split("-")

          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, platform version and architecture in the metadata
            publish_metadata[:platform]         = publish_platform
            publish_metadata[:platform_version] = publish_platform_version
            publish_metadata[:arch]             = publish_architecture

            # 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

    if publish_packages.empty?
      log.info(log_key) { "No packages found, skipping publish" }
    end

    publish_packages
  end
end
publish(&_block) click to toggle source

@abstract

@param [Proc] _block

if given, the block will yield the currently uploading "thing"

@return [Array<String>]

the list of uploaded packages
# File lib/omnibus/publisher.rb, line 136
def publish(&_block)
  raise NotImplementedError
end

Private Instance Methods

safe_require(name) click to toggle source
# File lib/omnibus/publisher.rb, line 142
def safe_require(name)
  require name
rescue LoadError
  raise GemNotInstalled.new(name)
end