Class: Omnibus::Publisher

Inherits:
Object
  • Object
show all
Includes:
Digestable, Logging
Defined in:
lib/omnibus/publisher.rb

Direct Known Subclasses

ArtifactoryPublisher, NullPublisher, S3Publisher

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Logging

included

Methods included from Digestable

#digest, #digest_directory, included

Constructor Details

#initialize(pattern, options = {}) ⇒ Publisher

Create a new publisher from the given pattern.

Examples:

{
  'ubuntu-10.04-x86_64' => [
    'ubuntu-10.04-x86_64',
    'ubuntu-12.04-x86_64',
    'ubuntu-14.04-x86_64',
  ],
}

Parameters:

  • pattern (String) —

    the path/pattern of the release artifact(s)

  • options (Hash) (defaults to: {}) —

    the list of options passed to the publisher

Options Hash (options):

  • :platform_mappings (Hash) —

    A simple mapping of build to publish platform(s)


54
55
56
57
58
59
60
61
62
63
 
# 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

Class Method Details

.publish(pattern, options = {}, &block) ⇒ Object

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

Parameters:

  • pattern (String) —

    the path/pattern of the release artifact(s)

  • options (Hash) (defaults to: {}) —

    the list of options passed to the publisher


28
29
30
 
# File 'lib/omnibus/publisher.rb', line 28

def publish(pattern, options = {}, &block)
  new(pattern, options).publish(&block)
end

Instance Method Details

#packages ⇒ Array<String>

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

Returns:

  • (Array<String>) 

70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# 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) ⇒ Array<String>

This method is abstract.

Returns the list of uploaded packages.

Parameters:

  • _block (Proc) —

    if given, the block will yield the currently uploading “thing”

Returns:

  • (Array<String>) —

    the list of uploaded packages

Raises:

  • (NotImplementedError) 

136
137
138
 
# File 'lib/omnibus/publisher.rb', line 136

def publish(&_block)
  raise NotImplementedError
end