Class: Omnibus::Software

Inherits:
Object
  • Object
show all
Includes:
Cleanroom, Digestable, Logging, NullArgumentable, Sugarable, Util
Defined in:
lib/omnibus/software.rb

Constant Summary

Constants included from Util

Util::SHELLOUT_OPTIONS

Constants included from NullArgumentable

NullArgumentable::NULL

Instance Attribute Summary collapse

DSL methods collapse

Public API collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Util

#compiler_safe_path, #copy_file, #create_directory, #create_file, #create_link, included, #path_key, #remove_directory, #remove_file, #retry_block, #shellout, #shellout!, #windows_safe_path

Methods included from Sugarable

extended, included, #node

Methods included from NullArgumentable

included, #null?

Methods included from Logging

included

Methods included from Digestable

#digest, #digest_directory, included

Constructor Details

#initialize(project, filepath = nil, manifest = nil) ⇒ Software

Create a new software object.

Parameters:

  • project (Project) —

    the Omnibus project that instantiated this software definition

  • filepath (String) (defaults to: nil) —

    the path to where this software definition lives on disk

  • manifest (String) (defaults to: nil) —

    the user-supplied software manifest


95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/omnibus/software.rb', line 95

def initialize(project, filepath = nil, manifest = nil)
  unless project.is_a?(Project)
    raise ArgumentError,
      "`project' must be a kind of `Omnibus::Project', but was `#{project.class.inspect}'!"
  end

  # Magical methods
  @filepath = filepath
  @project  = project
  @manifest = manifest

  # Overrides
  @overrides = NULL
end

Instance Attribute Details

#manifest ⇒ Object (readonly)

Returns the value of attribute manifest.


81
82
83
 
# File 'lib/omnibus/software.rb', line 81

def manifest
  @manifest
end

Class Method Details

.load(project, name, manifest) ⇒ Software

Parameters:

  • project (Project) —

    the project that loaded this software definition

  • name (String) —

    the path to the software definition to load from disk

Returns:


32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/omnibus/software.rb', line 32

def load(project, name, manifest)
  loaded_softwares["#{project.name}:#{name}"] ||= begin
    filepath = Omnibus.software_path(name)

    if filepath.nil?
      raise MissingSoftware.new(name)
    else
      log.internal(log_key) do
        "Loading software `#{name}' from `#{filepath}' using overrides from #{project.name}."
      end
    end

    instance = new(project, filepath, manifest)
    instance.evaluate_file(filepath)
    instance.load_dependencies

    # Add the loaded component to the library
    project.library.component_added(instance)

    instance
  end
end

.reset! ⇒ Object

Reset cached software information.


58
59
60
 
# File 'lib/omnibus/software.rb', line 58

def reset!
  @loaded_softwares = nil
end

Instance Method Details

#<=>(other) ⇒ 1, ...

Compare two software projects (by name).

Returns:

  • (1, 0, -1) 

125
126
127
 
# File 'lib/omnibus/software.rb', line 125

def <=>(other)
  name <=> other.name
end

#==(other) ⇒ true, false Also known as: eql?

Determine if two softwares are identical.

Parameters:

Returns:

  • (true, false) 

1137
1138
1139
 
# File 'lib/omnibus/software.rb', line 1137

def ==(other)
  hash == other.hash
end

#bin_dirs(val = NULL) ⇒ Array<String>

Sets the bin_dirs where this software installs bins.

Examples:

bin_dirs ['/opt/chef-workstation/bin']

Parameters:

  • val (Array<String>) (defaults to: NULL) —

    the bin_dirs of the software

Returns:

  • (Array<String>) 

219
220
221
222
223
224
225
 
# File 'lib/omnibus/software.rb', line 219

def bin_dirs(val = NULL)
  if null?(val)
    @bin_dirs || [windows_safe_path("#{install_dir}/bin"), windows_safe_path("#{install_dir}/embedded/bin")]
  else
    @bin_dirs = val
  end
end

#build(&block) ⇒ Proc

Define a series of Builder DSL commands that are executed to build the software.

Parameters:

  • block (Proc) —

    a block of build commands

Returns:

  • (Proc) —

    the build block

See Also:


644
645
646
 
# File 'lib/omnibus/software.rb', line 644

def build(&block)
  builder.evaluate(&block)
end

#build_dir ⇒ String

The path where the software will be built.

Returns:

  • (String) 

614
615
616
 
# File 'lib/omnibus/software.rb', line 614

def build_dir
  File.expand_path("#{Config.build_dir}/#{project.name}")
end

#build_me(build_wrappers = []) ⇒ true

Build the software package. If git caching is turned on (see Config#use_git_caching), the build is restored according to the documented restoration procedure in the git cache. If the build cannot be restored (if the tag does not exist), the actual build steps are executed.

Parameters:

  • build_wrappers (Array<#execute_pre_build, #execute_post_build>) (defaults to: []) —

    Build wrappers inject behavior before or after the software is built. They can be any object that implements `#execute_pre_build` and `#execute_post_build`, taking this Software as an argument. Note that these callbacks are only triggered when the software actually gets built; if the build is skipped by the git cache, the callbacks DO NOT run.

Returns:

  • (true) 

1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
 
# File 'lib/omnibus/software.rb', line 1090

def build_me(build_wrappers = [])
  if Config.use_git_caching
    if !real_version
      log.info(log_key) do
        "Forcing a build because resolved version is nil"
      end
      execute_build(build_wrappers)
      project.dirty!(self) unless project.dirty? # omnibus can only be mildly dirty
    elsif project.dirty?
      log.info(log_key) do
        "Building because `#{project.culprit.name}' dirtied the cache"
      end
      execute_build(build_wrappers)
    elsif git_cache.restore
      log.info(log_key) { "Restored from cache" }
    else
      log.info(log_key) { "Could not restore from cache" }
      execute_build(build_wrappers)
      project.dirty!(self)
    end
  else
    log.debug(log_key) { "Forcing build because git caching is off" }
    execute_build(build_wrappers)
  end

  project.build_version_dsl.resolve(self)
  true
end

#builder ⇒ Builder

The builder object for this software definition.

Returns:


879
880
881
 
# File 'lib/omnibus/software.rb', line 879

def builder
  @builder ||= Builder.new(self)
end

#default_version(val = NULL) ⇒ String

Set or retrieve the #default_version of the software to build.

Examples:

default_version '1.2.3'

Parameters:

  • val (String) (defaults to: NULL) —

    the default version to set for the software. For a git source, the default version may be a git ref (e.g. tag, branch name, or sha).

Returns:

  • (String) 

375
376
377
378
379
380
381
 
# File 'lib/omnibus/software.rb', line 375

def default_version(val = NULL)
  if null?(val)
    @version
  else
    @version = val
  end
end

#dependencies ⇒ Array<String>

The list of software dependencies for this software. These is the software that comprises your software, and is distinct from runtime dependencies.

Parameters:

  • (Array<String>)

Returns:

  • (Array<String>)

See Also:


920
921
922
 
# File 'lib/omnibus/software.rb', line 920

def dependencies
  @dependencies ||= []
end

#dependency(val) ⇒ Array<String>

Add a software dependency to this software.

Examples:

dependency 'libxml2'
dependency 'libpng'

Parameters:

  • val (String) —

    the name of a software dependency

Returns:

  • (Array<String>) —

    the list of current dependencies


261
262
263
264
 
# File 'lib/omnibus/software.rb', line 261

def dependency(val)
  dependencies << val
  dependencies.dup
end

#dependency_licenses(val = NULL) ⇒ Array<Hash>

Set or retrieve licensing information of the dependencies. The information set is not validated or inspected. It is directly

passed to LicenseScout.

dependency_licenses [

{
  dependency_name: "logstash-output-websocket",
  dependency_manager: "logstash_plugin",
  license: "Apache-2.0",
  license_file: [
    "relative/path/to/license/file",
    "https://download.elastic.co/logstash/LICENSE"
  ]
},
...

]

Parameters:

  • val (Hash) (defaults to: NULL)
  • val (Array<Hash>) (defaults to: NULL) —

    dependency license information.

Returns:

  • (Array<Hash>) 

468
469
470
471
472
473
474
 
# File 'lib/omnibus/software.rb', line 468

def dependency_licenses(val = NULL)
  if null?(val)
    @dependency_licenses || nil
  else
    @dependency_licenses = Array(val)
  end
end

#description(val = NULL) ⇒ String

Sets the description of the software.

Examples:

description 'Installs libxslt'

Parameters:

  • val (String) (defaults to: NULL) —

    the description of the software

Returns:

  • (String) 

178
179
180
181
182
183
184
 
# File 'lib/omnibus/software.rb', line 178

def description(val = NULL)
  if null?(val)
    @description
  else
    @description = val
  end
end

#embedded_bin(bin) ⇒ String

Returns the platform safe full path under embedded/bin directory to the given binary

Parameters:

  • bin (String) —

    Name of the binary under embedded/bin

Returns:

  • (String) 

814
815
816
 
# File 'lib/omnibus/software.rb', line 814

def embedded_bin(bin)
  windows_safe_path("#{install_dir}/embedded/bin/#{bin}")
end

#fetch ⇒ true, false

Fetch the software definition using the appropriate fetcher. This may fetch the software from a local path location, git location, or download the software from a remote URL (HTTP(s)/FTP)

Returns:

  • (true, false) —

    true if the software was fetched, false if it was cached


901
902
903
904
905
906
907
908
 
# File 'lib/omnibus/software.rb', line 901

def fetch
  if fetcher.fetch_required?
    fetcher.fetch
    true
  else
    false
  end
end

#fetch_dir(val = NULL) ⇒ String

Path to where any source is extracted to.

Files in a source directory are staged underneath here. Files from a url are fetched and extracted here. Look outside this directory at your own peril.

Returns:

  • (String) —

    the full absolute path to the software root fetch directory.


995
996
997
998
999
1000
1001
 
# File 'lib/omnibus/software.rb', line 995

def fetch_dir(val = NULL)
  if null?(val)
    @fetch_dir || File.expand_path("#{Config.source_dir}/#{name}")
  else
    @fetch_dir = val
  end
end

#fetcher ⇒ Fetcher

The fetcher for this software

This is where we handle all the crazy back-compat on relative_path. All fetchers in omnibus 4 use relative_path incorrectly. net_fetcher was the only one to use to sensibly, and even then only if fetch_dir was Config.source_dir and the source was an archive. Therefore, to not break everyone ever, we will still pass project_dir for all other fetchers. There is still one issue where other omnibus software (such as the appbundler dsl) currently assume that fetch_dir the same as source_dir. Therefore, we make one extra concession - when relative_path is set in a software definition to be the same as name (a very common scenario), we land the source into the fetch directory instead of project_dir. This is to avoid fiddling with the appbundler dsl until it gets sorted out.

Returns:


1043
1044
1045
1046
1047
1048
1049
1050
 
# File 'lib/omnibus/software.rb', line 1043

def fetcher
  @fetcher ||=
    if source_type == :url && File.basename(source[:url], "?*").end_with?(*NetFetcher::ALL_EXTENSIONS)
      Fetcher.fetcher_class_for_source(source).new(manifest_entry, fetch_dir, build_dir)
    else
      Fetcher.fetcher_class_for_source(source).new(manifest_entry, project_dir, build_dir)
    end
end

#filepath ⇒ String?

The path (on disk) where this software came from. Warning: this can be nil if a software was dynamically created!

Returns:

  • (String, nil) 

950
951
952
 
# File 'lib/omnibus/software.rb', line 950

def filepath
  @filepath
end

#hash ⇒ Fixnum

The unique “hash” for this software.

Returns:

  • (Fixnum)

See Also:

  • Omnibus::Software.((#shasum)

1126
1127
1128
 
# File 'lib/omnibus/software.rb', line 1126

def hash
  shasum.hash
end

#install_dir ⇒ String

The directory where this software is installed on disk.

Examples:

{ 'PATH' => "#{install_dir}/embedded/bin:#{ENV["PATH"]}", }

Returns:

  • (String) 

627
628
629
 
# File 'lib/omnibus/software.rb', line 627

def install_dir
  @project.install_dir
end

#lib_dirs(val = NULL) ⇒ Array<String>

Sets the lib_dirs where this software installs libs.

Examples:

lib_dirs ['/opt/chef-workstation/bin']

Parameters:

  • val (Array<String>) (defaults to: NULL) —

    the lib_dirs of the software

Returns:

  • (Array<String>) 

239
240
241
242
243
244
245
 
# File 'lib/omnibus/software.rb', line 239

def lib_dirs(val = NULL)
  if null?(val)
    @lib_dirs || [windows_safe_path("#{install_dir}/embedded/lib")]
  else
    @lib_dirs = val
  end
end

#license(val = NULL) ⇒ String

Set or retrieve the #license of the software to build.

Examples:

license 'Apache 2.0'

Parameters:

  • val (String) (defaults to: NULL) —

    the license to set for the software.

Returns:

  • (String) 

395
396
397
398
399
400
401
 
# File 'lib/omnibus/software.rb', line 395

def license(val = NULL)
  if null?(val)
    @license || "Unspecified"
  else
    @license = val
  end
end

#license_file(file) ⇒ String

Set or retrieve the location of a #license_file of the software. It can either be a relative path inside the source package or a URL.

Examples:

license_file 'LICENSES/artistic.txt'

Parameters:

  • val (String) —

    the location of the license file for the software.

Returns:

  • (String) 

418
419
420
421
 
# File 'lib/omnibus/software.rb', line 418

def license_file(file)
  license_files << file
  license_files.dup
end

#license_files ⇒ Array<String>

The list of license files for this software

Returns:

  • (Array<String>)

See Also:


940
941
942
 
# File 'lib/omnibus/software.rb', line 940

def license_files
  @license_files ||= []
end

#load_dependencies ⇒ true

Recursively load all the dependencies for this software.

Returns:

  • (true) 

866
867
868
869
870
871
872
 
# File 'lib/omnibus/software.rb', line 866

def load_dependencies
  dependencies.each do |dependency|
    Software.load(project, dependency, manifest)
  end

  true
end

#maintainer(val = NULL) ⇒ String

Sets the maintainer of the software. Currently this is for human consumption only and the tool doesn't do anything with it.

Examples:

maintainer "Joe Bob <[email protected]>"

Parameters:

  • val (String) (defaults to: NULL) —

    the maintainer of this sofware def

Returns:

  • (String) 

199
200
201
202
203
204
205
 
# File 'lib/omnibus/software.rb', line 199

def maintainer(val = NULL)
  if null?(val)
    @maintainer
  else
    @description = val
  end
end

#manifest_entry ⇒ Object 


110
111
112
113
114
115
116
117
118
 
# File 'lib/omnibus/software.rb', line 110

def manifest_entry
  @manifest_entry ||= if manifest
                        log.info(log_key) { "Using user-supplied manifest entry for #{name}" }
                        manifest.entry_for(name)
                      else
                        log.info(log_key) { "Resolving manifest entry for #{name}" }
                        to_manifest_entry
                      end
end

#name(val = NULL) ⇒ String

[Required] Sets or retreives the name of the software.

Examples:

name 'libxslt'

Parameters:

  • val (String) (defaults to: NULL) —

    name of the Software

Returns:

  • (String)

Raises:


158
159
160
161
162
163
164
 
# File 'lib/omnibus/software.rb', line 158

def name(val = NULL)
  if null?(val)
    @name || raise(MissingRequiredAttribute.new(self, :name, "libxslt"))
  else
    @name = val
  end
end

#ohai ⇒ Ohai

A proxy method to the underlying Ohai system.

Examples:

ohai['platform_family']

Returns:


845
846
847
 
# File 'lib/omnibus/software.rb', line 845

def ohai
  Ohai
end

#overridden? ⇒ true, false

Determine if this software version overridden externally, relative to the version declared within the software DSL file?

Returns:

  • (true, false) 

976
977
978
979
 
# File 'lib/omnibus/software.rb', line 976

def overridden?
  # NOTE: using instance variables to bypass accessors that enforce overrides
  @overrides.key?(:version) && (@overrides[:version] != @version)
end

#overrides ⇒ Hash

The repo-level and project-level overrides for the software.

Returns:

  • (Hash) 

959
960
961
962
963
964
965
966
967
 
# File 'lib/omnibus/software.rb', line 959

def overrides
  if null?(@overrides)
    # lazily initialized because we need the 'name' to be parsed first
    @overrides = {}
    @overrides = project.overrides[name.to_sym].dup if project.overrides[name.to_sym]
  end

  @overrides
end

#prepend_path(*paths) ⇒ String

A PATH variable format string representing the current PATH with the given path prepended. The correct path separator for the platform is used to join the paths.

Parameters:

  • paths (Array<String>)

Returns:

  • (String) 

828
829
830
831
832
833
834
 
# File 'lib/omnibus/software.rb', line 828

def prepend_path(*paths)
  path_values = Array(paths)
  path_values << ENV[path_key]

  separator = File::PATH_SEPARATOR || ":"
  path_values.join(separator)
end

#project ⇒ Project

The project that created this software.

Returns:


140
141
142
 
# File 'lib/omnibus/software.rb', line 140

def project
  @project
end

#project_dir ⇒ String

The path where the extracted software lives. All build commands associated with this software definition are run for under this path.

Why is it called project_dir when this is a software definition, I hear you cry. Because history and reasons. This really is a location underneath the global omnibus source directory that you have focused into using relative_path above.

These are not the only files your project fetches. They are merely the files that your project cares about. A source tarball may contain more directories that are not under your project_dir.

Returns:

  • (String) 

604
605
606
 
# File 'lib/omnibus/software.rb', line 604

def project_dir
  File.expand_path("#{fetch_dir}/#{relative_path}")
end

#project_file ⇒ Object

Deprecated.

There is no replacement for this DSL method

The path to the downloaded file from a NetFetcher.


654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
 
# File 'lib/omnibus/software.rb', line 654

def project_file
  if fetcher && fetcher.is_a?(NetFetcher)
    log.deprecated(log_key) do
      "project_file (DSL). This is a property of the NetFetcher and will " \
      "not be publically exposed in the next major release. In general, " \
      "you should not be using this method in your software definitions " \
      "as it is an internal implementation detail of the NetFetcher. If " \
      "you disagree with this statement, you should open an issue on the " \
      "Omnibus repository on GitHub an explain your use case. For now, " \
      "I will return the path to the downloaded file on disk, but please " \
      "rethink the problem you are trying to solve :)."
    end

    fetcher.downloaded_file
  else
    log.warn(log_key) do
      "Cannot retrieve a `project_file' for software `#{name}'. This " \
      "attribute is actually an internal representation that is unique " \
      "to the NetFetcher class and requires the use of a `source' " \
      "attribute that is declared using a `:url' key. For backwards-" \
      "compatability, I will return `nil', but this is most likely not " \
      "your desired behavior."
    end

    nil
  end
end

#real_version ⇒ Object

This is the real version if one exists (nil if there's no real version)


1009
1010
1011
 
# File 'lib/omnibus/software.rb', line 1009

def real_version
  @real_version ||= fetcher.version_for_cache || version
end

#relative_path(val = NULL) ⇒ String

The path relative to fetch_dir where relevant project files are stored. This applies to all sources.

Any command executed in the build step are run after cwd-ing into this path. The default is to stay at the top level of fetch_dir where the source tar-ball/git repo/file/directory has been staged.

Due to back-compat reasons, relative_path works completely differently for anything other than tar-balls/archives. In those situations, the source is checked out rooted at relative_path instead 'cause reasons. TODO: Fix this in omnibus 6.

Examples:

relative_path 'example-1.2.3'

Parameters:

  • val (String) (defaults to: NULL) —

    the relative path inside the source directory. default: '.'

Returns:

  • (String) 

580
581
582
583
584
585
586
 
# File 'lib/omnibus/software.rb', line 580

def relative_path(val = NULL)
  if null?(val)
    @relative_path || "."
  else
    @relative_path = val
  end
end

#shasum ⇒ String

The unique SHA256 for this sofware definition.

A software is defined by its parent project's shasum, its own name, its version_for_cache, and any overrides (as JSON). Additionally, if provided, the actual file contents are included in the SHA to ensure uniqueness.

Returns:

  • (String) 

1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
 
# File 'lib/omnibus/software.rb', line 1151

def shasum
  @shasum ||= begin
    digest = Digest::SHA256.new

    update_with_string(digest, project.shasum)
    update_with_string(digest, builder.shasum)
    update_with_string(digest, name)
    update_with_string(digest, version_for_cache)
    update_with_string(digest, FFI_Yajl::Encoder.encode(overrides))

    if filepath && File.exist?(filepath)
      update_with_file_contents(digest, filepath)
    else
      update_with_string(digest, "<DYNAMIC>")
    end

    digest.hexdigest
  end
end

#skip_transitive_dependency_licensing(val = NULL) ⇒ Boolean

Skip collecting licenses of transitive dependencies for this software

Examples:

skip_transitive_dependency_licensing true

Parameters:

  • val (Boolean) (defaults to: NULL) —

    set or reset transitive dependency license collection

Returns:

  • (Boolean) 

435
436
437
438
439
440
441
 
# File 'lib/omnibus/software.rb', line 435

def skip_transitive_dependency_licensing(val = NULL)
  if null?(val)
    @skip_transitive_dependency_licensing || false
  else
    @skip_transitive_dependency_licensing = val
  end
end

#source(val = NULL) ⇒ Hash

Set or retrieve the source for the software.

Only used in net_fetcher:

Only used in path_fetcher:

Only used in git_fetcher:

If multiple checksum types are provided, only the strongest will be used.

Examples:

source url: 'http://ftp.gnu.org/gnu/autoconf/autoconf-2.68.tar.gz',
       md5: 'c3b5247592ce694f7097873aa07d66fe'

Parameters:

  • val (Hash<Symbol, String>) (defaults to: NULL) —

    a single key/pair that defines the kind of source and a path specifier

Options Hash (val):

  • :git (String) — default: nil —

    a git URL

  • :github (String) — default: nil —

    a github ORG/REPO pair (e.g. chef/chef) that will be transformed to github.com/ORG/REPO.git

  • :url (String) — default: nil —

    general URL

  • :path (String) — default: nil —

    a fully-qualified local file system path

  • :md5 (String) — default: nil —

    the MD5 checksum of the downloaded artifact

  • :sha1 (String) — default: nil —

    the SHA1 checksum of the downloaded artifact

  • :sha256 (String) — default: nil —

    the SHA256 checksum of the downloaded artifact

  • :sha512 (String) — default: nil —

    the SHA512 checksum of the downloaded artifact

  • :cookie (String) — default: nil —

    a cookie to set

  • :authorization (String) — default: nil —

    an authorization header to set

  • :warning (String) — default: nil —

    a warning message to print when downloading

  • :extract (Symbol) — default: nil —

    either :tar, :lax_tar :seven_zip

  • :options (Hash) — default: nil —

    flags/options that are passed through to file_syncer in path_fetcher

  • :submodules (Boolean) — default: false —

    clone git submodules

Returns:

  • (Hash)

Raises:

  • (InvalidValue) —

    if the parameter is not a Hash

  • (InvalidValue) —

    if the hash includes extraneous keys

  • (InvalidValue) —

    if the hash declares keys that cannot work together (like :git and :path)


327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
 
# File 'lib/omnibus/software.rb', line 327

def source(val = NULL)
  unless null?(val)
    unless val.is_a?(Hash)
      raise InvalidValue.new(:source,
        "be a kind of `Hash', but was `#{val.class.inspect}'")
    end

    val = canonicalize_source(val)

    extra_keys = val.keys - [
      :git, :file, :path, :url, # fetcher types
      :md5, :sha1, :sha256, :sha512, # hash type - common to all fetchers
      :cookie, :warning, :unsafe, :extract, :cached_name, :authorization, # used by net_fetcher
      :options, # used by path_fetcher
      :submodules # used by git_fetcher
    ]
    unless extra_keys.empty?
      raise InvalidValue.new(:source,
        "only include valid keys. Invalid keys: #{extra_keys.inspect}")
    end

    duplicate_keys = val.keys & %i{git file path url}
    unless duplicate_keys.size < 2
      raise InvalidValue.new(:source,
        "not include duplicate keys. Duplicate keys: #{duplicate_keys.inspect}")
    end

    @source ||= {}
    @source.merge!(val)
  end

  override = canonicalize_source(overrides[:source])
  apply_overrides(:source, override)
end

#source_type ⇒ Symbol

The type of source specified for this software defintion.

Returns:

  • (Symbol) 

1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
 
# File 'lib/omnibus/software.rb', line 1057

def source_type
  if source
    if source[:url]
      :url
    elsif source[:git]
      :git
    elsif source[:file]
      :file
    elsif source[:path]
      :path
    end
  else
    :project_local
  end
end

#to_manifest_entry ⇒ Object 


883
884
885
886
887
888
889
890
891
 
# File 'lib/omnibus/software.rb', line 883

def to_manifest_entry
  Omnibus::ManifestEntry.new(name, {
                               source_type: source_type,
                               described_version: version,
                               locked_version: Fetcher.resolve_version(version, source),
                               locked_source: source,
                               license: license,
  })
end

#version(val = NULL, &block) ⇒ String, Proc

Evaluate a block only if the version matches.

Examples:

version '1.2.3' do
  source path: '/local/path/to/software-1.2.3'
end

Parameters:

  • val (String) (defaults to: NULL) —

    the version of the software

  • block (Proc) —

    the block to run if the version we are building matches the argument

Returns:

  • (String, Proc) 

492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
 
# File 'lib/omnibus/software.rb', line 492

def version(val = NULL, &block)
  final_version = apply_overrides(:version)

  if block_given?
    if val.equal?(NULL)
      raise InvalidValue.new(:version,
        "pass a block when given a version argument")
    else
      if val == final_version
        #
        # Unfortunately we need to make a specific logic here for license files.
        # We support multiple calls `license_file` and we support overriding the
        # license files inside a version block. We can not differentiate whether
        # `license_file` is being called from a version block or not. So we need
        # to check if the license files are being overridden during the call to
        # block.
        #
        # If so we use the new set, otherwise we restore the old license files.
        #
        current_license_files = @license_files
        @license_files = []

        yield

        new_license_files = @license_files

        if new_license_files.empty?
          @license_files = current_license_files
        end
      end
    end
  end

  return if final_version.nil?

  begin
    ChefUtils::VersionString.new(final_version)
  rescue ArgumentError
    log.warn(log_key) do
      "Version #{final_version} for software #{name} was not parseable. " \
      "Comparison methods such as #satisfies? will not be available for this version."
    end
    final_version
  end
end

#version_for_cache ⇒ Object

Returns the version to be used in cache.


1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
 
# File 'lib/omnibus/software.rb', line 1014

def version_for_cache
  @version_for_cache ||= if real_version
                           real_version
                         else
                           log.warn(log_key) do
                             "No version given! Git caching disabled." \
                           end

                           "0.0.0"
                         end
end

#version_guid ⇒ Object

TODO:

see comments on Fetcher#without_caching_for


1004
1005
1006
 
# File 'lib/omnibus/software.rb', line 1004

def version_guid
  fetcher.version_guid
end

#whitelist_file(file) ⇒ Array<String>

Add a file to the healthcheck whitelist.

Examples:

whitelist_file '/path/to/file'

Parameters:

  • file (String, Regexp) —

    the name of a file to ignore in the healthcheck

Returns:

  • (Array<String>) —

    the list of currently whitelisted files


551
552
553
554
555
 
# File 'lib/omnibus/software.rb', line 551

def whitelist_file(file)
  file = Regexp.new(file) unless file.is_a?(Regexp)
  whitelist_files << file
  whitelist_files.dup
end

#whitelist_files ⇒ Array<String>

The list of files to ignore in the healthcheck.

Returns:

  • (Array<String>) 

929
930
931
 
# File 'lib/omnibus/software.rb', line 929

def whitelist_files
  @whitelist_files ||= []
end

#with_embedded_path(env = {}) ⇒ Hash

A PATH variable format string representing the current PATH with the project's embedded/bin directory prepended. The correct path separator for the platform is used to join the paths.

Parameters:

  • env (Hash) (defaults to: {})

Returns:

  • (Hash) 

798
799
800
801
802
 
# File 'lib/omnibus/software.rb', line 798

def with_embedded_path(env = {})
  paths = ["#{install_dir}/bin", "#{install_dir}/embedded/bin"]
  path_value = prepend_path(paths)
  env.merge(path_key => path_value)
end

#with_standard_compiler_flags(env = {}, opts = {}) ⇒ Hash

Add standard compiler flags to the environment hash to produce omnibus binaries (correct RPATH, etc).

Supported options:

:aix => :use_gcc    force using gcc/g++ compilers on aix

Parameters:

  • env (Hash) (defaults to: {})
  • opts (Hash) (defaults to: {})

Returns:

  • (Hash) 

695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
 
# File 'lib/omnibus/software.rb', line 695

def with_standard_compiler_flags(env = {}, opts = {})
  env ||= {}
  opts ||= {}
  compiler_flags =
    case Ohai["platform"]
    when "aix"
      {
        "CC" => "xlc_r -q64",
        "CXX" => "xlC_r -q64",
        "CFLAGS" => "-q64 -I#{install_dir}/embedded/include -D_LARGE_FILES -O",
        "LDFLAGS" => "-q64 -L#{install_dir}/embedded/lib -Wl,-blibpath:#{install_dir}/embedded/lib:/usr/lib:/lib",
        "LD" => "ld -b64",
        "OBJECT_MODE" => "64",
        "ARFLAGS" => "-X64 cru",
      }
    when "solaris2"
      {
        "CC" => "gcc -m64 -static-libgcc",
        "LDFLAGS" => "-Wl,-rpath,#{install_dir}/embedded/lib -L#{install_dir}/embedded/lib -static-libgcc",
        "CFLAGS" => "-I#{install_dir}/embedded/include -O2",
      }
    when "freebsd"
      {
        "CC" => "clang",
        "CXX" => "clang++",
        "LDFLAGS" => "-L#{install_dir}/embedded/lib -Wl,-rpath,#{install_dir}/embedded/lib",
        "CFLAGS" => "-I#{install_dir}/embedded/include -O3 -D_FORTIFY_SOURCE=2 -fstack-protector",
      }
    when "windows"
      arch_flag = windows_arch_i386? ? "-m32" : "-m64"
      opt_flag = windows_arch_i386? ? "-march=i686" : "-march=x86-64"
      {
        "LDFLAGS" => "-L#{install_dir}/embedded/lib #{arch_flag} -fno-lto",
        # We do not wish to enable SSE even though we target i686 because
        # of a stack alignment issue with some libraries. We have not
        # exactly ascertained the cause but some compiled library/binary
        # violates gcc's assumption that the stack is going to be 16-byte
        # aligned which is just fine as long as one is pushing 32-bit
        # values from general purpose registers but stuff hits the fan as
        # soon as gcc emits aligned SSE xmm register spills which generate
        # GPEs and terminate the application very rudely with very little
        # to debug with.
        "CFLAGS" => "-I#{install_dir}/embedded/include #{arch_flag} -O3 #{opt_flag}",
      }
    else
      {
        "LDFLAGS" => "-Wl,-rpath,#{install_dir}/embedded/lib -L#{install_dir}/embedded/lib",
        "CFLAGS" => "-I#{install_dir}/embedded/include -O3 -D_FORTIFY_SOURCE=2 -fstack-protector",
      }
    end

  # merge LD_RUN_PATH into the environment.  most unix distros will fall
  # back to this if there is no LDFLAGS passed to the linker that sets
  # the rpath.  the LDFLAGS -R or -Wl,-rpath will override this, but in
  # some cases software may drop our LDFLAGS or think it knows better
  # and edit them, and we *really* want the rpath setting and do know
  # better.  in that case LD_RUN_PATH will probably survive whatever
  # edits the configure script does
  extra_linker_flags = {
    "LD_RUN_PATH" => "#{install_dir}/embedded/lib",
  }

  if solaris2?
    ld_options = "-R#{install_dir}/embedded/lib"

    if platform_version.satisfies?("<= 5.10")
      # in order to provide compatibility for earlier versions of libc on solaris 10,
      # we need to specify a mapfile that restricts the version of system libraries
      # used. See http://docs.oracle.com/cd/E23824_01/html/819-0690/chapter5-1.html
      # for more information
      # use the mapfile if it exists, otherwise ignore it
      mapfile_path = File.expand_path(Config.solaris_linker_mapfile, Config.project_root)
      ld_options << " -M #{mapfile_path}" if File.exist?(mapfile_path)
    end

    # solaris linker can also use LD_OPTIONS, so we throw the kitchen sink against
    # the linker, to find every way to make it use our rpath. This is also required
    # to use the aforementioned mapfile.
    extra_linker_flags["LD_OPTIONS"] = ld_options
  end

  env.merge(compiler_flags)
    .merge(extra_linker_flags).
    # always want to favor pkg-config from embedded location to not hose
    # configure scripts which try to be too clever and ignore our explicit
    # CFLAGS and LDFLAGS in favor of pkg-config info
    merge({ "PKG_CONFIG_PATH" => "#{install_dir}/embedded/lib/pkgconfig" }).
    # Set default values for CXXFLAGS and CPPFLAGS.
    merge("CXXFLAGS" => compiler_flags["CFLAGS"])
    .merge("CPPFLAGS" => compiler_flags["CFLAGS"])
    .merge("OMNIBUS_INSTALL_DIR" => install_dir)
end