Class: Chef::Provider::Package

Inherits:
Chef::Provider show all
Extended by:
Mixin::SubclassDirective
Includes:
Mixin::ShellOut
Defined in:
lib/chef/provider/package.rb,
lib/chef/provider/package/aix.rb,
lib/chef/provider/package/apt.rb,
lib/chef/provider/package/cab.rb,
lib/chef/provider/package/dnf.rb,
lib/chef/provider/package/ips.rb,
lib/chef/provider/package/msu.rb,
lib/chef/provider/package/rpm.rb,
lib/chef/provider/package/yum.rb,
lib/chef/provider/package/dpkg.rb,
lib/chef/provider/package/pacman.rb,
lib/chef/provider/package/zypper.rb,
lib/chef/provider/package/openbsd.rb,
lib/chef/provider/package/paludis.rb,
lib/chef/provider/package/portage.rb,
lib/chef/provider/package/smartos.rb,
lib/chef/provider/package/solaris.rb,
lib/chef/provider/package/windows.rb,
lib/chef/provider/package/homebrew.rb,
lib/chef/provider/package/macports.rb,
lib/chef/provider/package/rubygems.rb,
lib/chef/provider/package/chocolatey.rb,
lib/chef/provider/package/powershell.rb,
lib/chef/provider/package/dnf/version.rb,
lib/chef/provider/package/freebsd/pkg.rb,
lib/chef/provider/package/windows/exe.rb,
lib/chef/provider/package/windows/msi.rb,
lib/chef/provider/package/freebsd/base.rb,
lib/chef/provider/package/freebsd/port.rb,
lib/chef/provider/package/freebsd/pkgng.rb,
lib/chef/provider/package/yum/rpm_utils.rb,
lib/chef/provider/package/yum/yum_cache.rb,
lib/chef/provider/package/dnf/python_helper.rb,
lib/chef/provider/package/windows/registry_uninstall_entry.rb

Defined Under Namespace

Modules: Freebsd Classes: Aix, Apt, Cab, Chocolatey, Dnf, Dpkg, Homebrew, Ips, Macports, Msu, Openbsd, Pacman, Paludis, Portage, Powershell, Rpm, Rubygems, SmartOS, Solaris, Windows, Yum, Zypper

Instance Attribute Summary collapse

Attributes inherited from Chef::Provider

#action, #cookbook_name, #current_resource, #new_resource, #recipe_name, #run_context

Instance Method Summary collapse

Methods included from Mixin::SubclassDirective

subclass_directive

Methods included from Mixin::ShellOut

#a_to_s, #clean_array, #shell_out, #shell_out!, #shell_out_compact, #shell_out_compact!, #shell_out_compact_timeout, #shell_out_compact_timeout!, #shell_out_with_systems_locale, #shell_out_with_systems_locale!

Methods included from Mixin::PathSanity

#enforce_path_sanity, #sanitized_path

Methods inherited from Chef::Provider

action, #action_nothing, #cleanup_after_converge, #compile_and_converge_action, #converge_by, #converge_if_changed, #events, include_resource_dsl?, include_resource_dsl_module, #node, #process_resource_requirements, provides, provides?, #requirements, #resource_collection, #resource_updated?, #run_action, #set_updated_status, supports?, use_inline_resources, #whyrun_mode?, #whyrun_supported?

Methods included from Mixin::Provides

#provided_as, #provides, #provides?

Methods included from Mixin::DescendantsTracker

#descendants, descendants, direct_descendants, #direct_descendants, find_descendants_by_name, #find_descendants_by_name, #inherited, store_inherited

Methods included from Mixin::LazyModuleInclude

#descendants, #include, #included

Methods included from Mixin::NotifyingBlock

#notifying_block, #subcontext_block

Methods included from DSL::DeclareResource

#build_resource, #declare_resource, #delete_resource, #delete_resource!, #edit_resource, #edit_resource!, #find_resource, #find_resource!, #with_run_context

Methods included from Mixin::PowershellOut

#powershell_out, #powershell_out!

Methods included from Mixin::WindowsArchitectureHelper

#assert_valid_windows_architecture!, #disable_wow64_file_redirection, #forced_32bit_override_required?, #is_i386_process_on_x86_64_windows?, #node_supports_windows_architecture?, #node_windows_architecture, #restore_wow64_file_redirection, #valid_windows_architecture?, #with_os_architecture, #wow64_architecture_override_required?, #wow64_directory

Methods included from DSL::PlatformIntrospection

#docker?, #platform?, #platform_family?, #value_for_platform, #value_for_platform_family

Constructor Details

#initialize(new_resource, run_context) ⇒ Package

Returns a new instance of Package.



47
48
49
50
 
# File 'lib/chef/provider/package.rb', line 47

def initialize(new_resource, run_context)
  super
  @candidate_version = nil
end

Instance Attribute Details

#candidate_version ⇒ Array, String

Hook that subclasses use to populate the candidate_version(s)

Returns:

  • (Array, String) —

    candidate_version(s) may be a string or array



45
46
47
 
# File 'lib/chef/provider/package.rb', line 45

def candidate_version
  @candidate_version
end

Instance Method Details

#action_lock ⇒ Object 



222
223
224
225
226
227
228
229
230
231
232
233
234
 
# File 'lib/chef/provider/package.rb', line 222

def action_lock
  if package_locked(new_resource.name, new_resource.version) == false
    description = new_resource.version ? "version #{new_resource.version} of " : ""
    converge_by("lock #{description}package #{current_resource.package_name}") do
      multipackage_api_adapter(current_resource.package_name, new_resource.version) do |name, version|
        lock_package(name, version)
        Chef::Log.info("#{new_resource} locked")
      end
    end
  else
    Chef::Log.debug("#{new_resource} is already locked")
  end
end

#action_unlock ⇒ Object 



236
237
238
239
240
241
242
243
244
245
246
247
248
 
# File 'lib/chef/provider/package.rb', line 236

def action_unlock
  if package_locked(new_resource.name, new_resource.version) == true
    description = new_resource.version ? "version #{new_resource.version} of " : ""
    converge_by("unlock #{description}package #{current_resource.package_name}") do
      multipackage_api_adapter(current_resource.package_name, new_resource.version) do |name, version|
        unlock_package(name, version)
        Chef::Log.info("#{new_resource} unlocked")
      end
    end
  else
    Chef::Log.debug("#{new_resource} is already unlocked")
  end
end

#as_array(thing) ⇒ Object

helper method used by subclasses



382
383
384
 
# File 'lib/chef/provider/package.rb', line 382

def as_array(thing)
  [ thing ].flatten
end

#check_resource_semantics! ⇒ Object 



56
57
58
59
60
61
62
 
# File 'lib/chef/provider/package.rb', line 56

def check_resource_semantics!
  # FIXME: this is not universally true and subclasses are needing to override this and no-ops it.  It should be turned into
  # another "subclass_directive" and the apt and yum providers should declare that they need this behavior.
  if new_resource.package_name.is_a?(Array) && !new_resource.source.nil?
    raise Chef::Exceptions::InvalidResourceSpecification, "You may not specify both multipackage and source"
  end
end

#define_resource_requirements ⇒ Object 



66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/chef/provider/package.rb', line 66

def define_resource_requirements
  # XXX: upgrade with a specific version doesn't make a whole lot of sense, but why don't we throw this anyway if it happens?
  # if not, shouldn't we raise to tell the user to use install instead of upgrade if they want to pin a version?
  requirements.assert(:install) do |a|
    a.assertion { candidates_exist_for_all_forced_changes? }
    a.failure_message(Chef::Exceptions::Package, "No version specified, and no candidate version available for #{forced_packages_missing_candidates.join(', ')}")
    a.whyrun("Assuming a repository that offers #{forced_packages_missing_candidates.join(', ')} would have been configured")
  end

  # XXX: Does it make sense to pass in a source with :upgrade? Probably
  # not, but as with the above comment, we don't yet enforce such a thing,
  # so we'll just leave things as-is for now.
  requirements.assert(:upgrade, :install) do |a|
    a.assertion { candidates_exist_for_all_uninstalled? || new_resource.source }
    a.failure_message(Chef::Exceptions::Package, "No candidate version available for #{packages_missing_candidates.join(', ')}")
    a.whyrun("Assuming a repository that offers #{packages_missing_candidates.join(', ')} would have been configured")
  end
end

#expand_options(options) ⇒ Object

used by subclasses. deprecated. use #a_to_s instead.



297
298
299
300
301
 
# File 'lib/chef/provider/package.rb', line 297

def expand_options(options)
  # its deprecated but still work to do to deprecate it fully
  #Chef.deprecated(:package_misc, "expand_options is deprecated, use shell_out_compact or shell_out_compact_timeout instead")
  options ? " #{options}" : ""
end

#get_preseed_file(name, version) ⇒ Object

@todo: extract apt/dpkg specific preseeding to a helper class



341
342
343
344
345
346
347
348
349
350
351
 
# File 'lib/chef/provider/package.rb', line 341

def get_preseed_file(name, version)
  resource = preseed_resource(name, version)
  resource.run_action(:create)
  Chef::Log.debug("#{new_resource} fetched preseed file to #{resource.path}")

  if resource.updated_by_last_action?
    resource.path
  else
    false
  end
end

#have_any_matching_version? ⇒ Boolean

Returns:

  • (Boolean) 


164
165
166
167
168
169
170
 
# File 'lib/chef/provider/package.rb', line 164

def have_any_matching_version?
  f = []
  new_version_array.each_with_index do |item, index|
    f << (item == current_version_array[index])
  end
  f.any?
end

#install_package(name, version) ⇒ Object

Raises:



264
265
266
 
# File 'lib/chef/provider/package.rb', line 264

def install_package(name, version)
  raise Chef::Exceptions::UnsupportedAction, "#{self} does not support :install"
end

#load_current_resource ⇒ Object 



64
 
# File 'lib/chef/provider/package.rb', line 64

def load_current_resource; end

#lock_package(name, version) ⇒ Object

Raises:



288
289
290
 
# File 'lib/chef/provider/package.rb', line 288

def lock_package(name, version)
  raise( Chef::Exceptions::UnsupportedAction, "#{self} does not support :lock" )
end

#multipackage_api_adapter(name, version) ⇒ Object 



256
257
258
259
260
261
262
 
# File 'lib/chef/provider/package.rb', line 256

def multipackage_api_adapter(name, version)
  if use_multipackage_api?
    yield [name].flatten, [version].flatten
  else
    yield name, version
  end
end

#options ⇒ Object 



52
53
54
 
# File 'lib/chef/provider/package.rb', line 52

def options
  new_resource.options
end

#package_locked(name, version) ⇒ Object

Raises:



250
251
252
 
# File 'lib/chef/provider/package.rb', line 250

def package_locked(name, version)
  raise Chef::Exceptions::UnsupportedAction, "#{self} has no way to detect if package is locked"
end

#preseed_package(file) ⇒ Object

Raises:



280
281
282
 
# File 'lib/chef/provider/package.rb', line 280

def preseed_package(file)
  raise Chef::Exceptions::UnsupportedAction, "#{self} does not support pre-seeding package install/upgrade instructions"
end

#preseed_resource(name, version) ⇒ Object

@todo: extract apt/dpkg specific preseeding to a helper class



354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
 
# File 'lib/chef/provider/package.rb', line 354

def preseed_resource(name, version)
  # A directory in our cache to store this cookbook's preseed files in
  file_cache_dir = Chef::FileCache.create_cache_path("preseed/#{new_resource.cookbook_name}")
  # The full path where the preseed file will be stored
  cache_seed_to = "#{file_cache_dir}/#{name}-#{version}.seed"

  Chef::Log.debug("#{new_resource} fetching preseed file to #{cache_seed_to}")

  if template_available?(new_resource.response_file)
    Chef::Log.debug("#{new_resource} fetching preseed file via Template")
    remote_file = Chef::Resource::Template.new(cache_seed_to, run_context)
    remote_file.variables(new_resource.response_file_variables)
  elsif cookbook_file_available?(new_resource.response_file)
    Chef::Log.debug("#{new_resource} fetching preseed file via cookbook_file")
    remote_file = Chef::Resource::CookbookFile.new(cache_seed_to, run_context)
  else
    message = "No template or cookbook file found for response file #{new_resource.response_file}"
    raise Chef::Exceptions::FileNotFound, message
  end

  remote_file.cookbook_name = new_resource.cookbook_name
  remote_file.source(new_resource.response_file)
  remote_file.backup(false)
  remote_file
end

#purge_package(name, version) ⇒ Object

Raises:



276
277
278
 
# File 'lib/chef/provider/package.rb', line 276

def purge_package(name, version)
  raise Chef::Exceptions::UnsupportedAction, "#{self} does not support :purge"
end

#reconfig_package(name, version) ⇒ Object

Raises:



284
285
286
 
# File 'lib/chef/provider/package.rb', line 284

def reconfig_package(name, version)
  raise( Chef::Exceptions::UnsupportedAction, "#{self} does not support :reconfig" )
end

#remove_package(name, version) ⇒ Object

Raises:



272
273
274
 
# File 'lib/chef/provider/package.rb', line 272

def remove_package(name, version)
  raise Chef::Exceptions::UnsupportedAction, "#{self} does not support :remove"
end

#removing_package? ⇒ Boolean

Returns:

  • (Boolean) 


172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/chef/provider/package.rb', line 172

def removing_package?
  if !current_version_array.any?
    # ! any? means it's all nil's, which means nothing is installed
    false
  elsif !new_version_array.any?
    true # remove any version of all packages
  elsif have_any_matching_version?
    true # remove the version we have
  else
    false # we don't have the version we want to remove
  end
end

#target_version_already_installed?(current_version, target_version) ⇒ Boolean

Check the current_version against either the candidate_version or the new_version

For some reason the windows provider subclasses this (to implement passing Arrays to versions for some reason other than multipackage stuff, which is mildly terrifying).

This MUST have ‘equality’ semantics – the exact thing matches the exact thing.

The current_version should probably be dropped out of the method signature, it should always be the first argument.

The name is not just bad, but i find it completely misleading, consider:

target_version_already_installed?(current_version, new_version)
target_version_already_installed?(current_version, candidate_version)

which of those is the ‘target_version’? i’d say the new_version and i’m confused when i see it called with the candidate_version.

‘current_version_equals?(version)` would be a better name

Returns:

  • (Boolean) 


322
323
324
325
 
# File 'lib/chef/provider/package.rb', line 322

def target_version_already_installed?(current_version, target_version)
  return false unless current_version && target_version
  current_version == target_version
end

#unlock_package(name, version) ⇒ Object

Raises:



292
293
294
 
# File 'lib/chef/provider/package.rb', line 292

def unlock_package(name, version)
  raise( Chef::Exceptions::UnsupportedAction, "#{self} does not support :unlock" )
end

#upgrade_package(name, version) ⇒ Object

Raises:



268
269
270
 
# File 'lib/chef/provider/package.rb', line 268

def upgrade_package(name, version)
  raise Chef::Exceptions::UnsupportedAction, "#{self} does not support :upgrade"
end

#version_requirement_satisfied?(current_version, new_version) ⇒ Boolean

Check the current_version against the new_resource.version, possibly using fuzzy matching criteria.

Subclasses MAY override this to provide fuzzy matching on the resource (‘>=’ and ‘~>’ stuff)

This should only ever be offered the same arguments (so they should most likely be removed from the method signature).

‘new_version_satisfied?()` might be a better name

Returns:

  • (Boolean) 


336
337
338
 
# File 'lib/chef/provider/package.rb', line 336

def version_requirement_satisfied?(current_version, new_version)
  target_version_already_installed?(current_version, new_version)
end