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_versionArray, 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_lockObject


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_unlockObject


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


386
387
388
# File 'lib/chef/provider/package.rb', line 386

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_requirementsObject


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
302
303
304
305
# 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")
  if options
    " #{options.is_a?(Array) ? Shellwords.join(options) : options}"
  else
    ""
  end
end

#get_preseed_file(name, version) ⇒ Object

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


345
346
347
348
349
350
351
352
353
354
355
# File 'lib/chef/provider/package.rb', line 345

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


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_resourceObject


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

def load_current_resource; end

#lock_package(name, version) ⇒ Object


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

#optionsObject


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

def options
  new_resource.options
end

#package_locked(name, version) ⇒ Object


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


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


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

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


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


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


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)

326
327
328
329
# File 'lib/chef/provider/package.rb', line 326

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


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


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)

340
341
342
# File 'lib/chef/provider/package.rb', line 340

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