Class: Chef::Platform

Inherits:
Object
  • Object
show all
Extended by:
Mixin::ConvertToClassName, Mixin::ParamsValidate
Defined in:
lib/chef/platform.rb,
lib/chef/platform/rebooter.rb,
lib/chef/platform/priority_map.rb,
lib/chef/platform/query_helpers.rb,
lib/chef/platform/service_helpers.rb,
lib/chef/platform/provider_mapping.rb,
lib/chef/platform/provider_handler_map.rb,
lib/chef/platform/resource_handler_map.rb,
lib/chef/platform/provider_priority_map.rb,
lib/chef/platform/resource_priority_map.rb

Defined Under Namespace

Modules: Rebooter Classes: PriorityMap, ProviderHandlerMap, ProviderPriorityMap, ResourceHandlerMap, ResourcePriorityMap, ServiceHelpers

Class Attribute Summary collapse

Class Method Summary collapse

Methods included from Mixin::ConvertToClassName

constantize, convert_to_class_name, convert_to_snake_case, filename_to_qualified_string, normalize_snake_case_name, snake_case_basename

Methods included from Mixin::ParamsValidate

lazy, set_or_return, validate

Class Attribute Details

.platforms ⇒ Object 



31
32
33
 
# File 'lib/chef/platform/provider_mapping.rb', line 31

def platforms
  @platforms ||= { default: {} }
end

Class Method Details

.dsc_refresh_mode_disabled?(node) ⇒ Boolean

Returns:

  • (Boolean) 


96
97
98
99
100
101
 
# File 'lib/chef/platform/query_helpers.rb', line 96

def dsc_refresh_mode_disabled?(node)
  require "chef/util/powershell/cmdlet"
  cmdlet = Chef::Util::Powershell::Cmdlet.new(node, "Get-DscLocalConfigurationManager", :object)
  metadata = cmdlet.run!.return_value
  metadata["RefreshMode"] == "Disabled"
end

.find(name, version) ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/chef/platform/provider_mapping.rb', line 37

def find(name, version)
  Chef.deprecated(:chef_platform_methods, "#{self.class.name}.find is deprecated")
  provider_map = platforms[:default].clone

  name_sym = name
  if name.kind_of?(String)
    name = name.downcase
    name.gsub!(/\s/, "_")
    name_sym = name.to_sym
  end

  if platforms.has_key?(name_sym)
    platform_versions = platforms[name_sym].select { |k, v| k != :default }
    if platforms[name_sym].has_key?(:default)
      provider_map.merge!(platforms[name_sym][:default])
    end
    platform_versions.each do |platform_version, provider|
      begin
        version_constraint = Chef::VersionConstraint::Platform.new(platform_version)
        if version_constraint.include?(version)
          Chef::Log.debug("Platform #{name} version #{version} found")
          provider_map.merge!(provider)
        end
      rescue Chef::Exceptions::InvalidPlatformVersion
        Chef::Log.debug("Chef::Version::Comparable does not know how to parse the platform version: #{version}")
      end
    end
  end
  provider_map
end

.find_platform_and_version(node) ⇒ Object

Raises:

  • (ArgumentError) 


68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/chef/platform/provider_mapping.rb', line 68

def find_platform_and_version(node)
  platform = nil
  version = nil

  if node[:platform]
    platform = node[:platform]
  elsif node.attribute?("os")
    platform = node[:os]
  end

  raise ArgumentError, "Cannot find a platform for #{node}" unless platform

  if node[:platform_version]
    version = node[:platform_version]
  elsif node[:os_version]
    version = node[:os_version]
  elsif node[:os_release]
    version = node[:os_release]
  end

  raise ArgumentError, "Cannot find a version for #{node}" unless version

  return platform, version
end

.find_provider(platform, version, resource_type) ⇒ Object

Raises:



178
179
180
181
182
183
184
185
186
187
 
# File 'lib/chef/platform/provider_mapping.rb', line 178

def find_provider(platform, version, resource_type)
  Chef.deprecated(:chef_platform_methods, "#{self.class.name}.find_provider is deprecated")
  provider_klass = explicit_provider(platform, version, resource_type) ||
    platform_provider(platform, version, resource_type) ||
    resource_matching_provider(platform, version, resource_type)

  raise Chef::Exceptions::ProviderNotFound, "Cannot find a provider for #{resource_type} on #{platform} version #{version}" if provider_klass.nil?

  provider_klass
end

.find_provider_for_node(node, resource_type) ⇒ Object 



106
107
108
109
110
 
# File 'lib/chef/platform/provider_mapping.rb', line 106

def find_provider_for_node(node, resource_type)
  Chef.deprecated(:chef_platform_methods, "#{self.class.name}.find_provider_for_node is deprecated")
  platform, version = find_platform_and_version(node)
  find_provider(platform, version, resource_type)
end

.provider_for_node(node, resource_type) ⇒ Object

Raises:

  • (NotImplementedError) 


102
103
104
 
# File 'lib/chef/platform/provider_mapping.rb', line 102

def provider_for_node(node, resource_type)
  raise NotImplementedError, "#{self.class.name} no longer supports #provider_for_node"
end

.provider_for_resource(resource, action = :nothing) ⇒ Object

Raises:

  • (ArgumentError) 


93
94
95
96
97
98
99
100
 
# File 'lib/chef/platform/provider_mapping.rb', line 93

def provider_for_resource(resource, action = :nothing)
  Chef.deprecated(:chef_platform_methods, "#{self.class.name}.provider_for_resource is deprecated")
  node = resource.run_context && resource.run_context.node
  raise ArgumentError, "Cannot find the provider for a resource with no run context set" unless node
  provider = find_provider_for_node(node, resource).new(resource, resource.run_context)
  provider.action = action
  provider
end

.set(args) ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/chef/platform/provider_mapping.rb', line 112

def set(args)
  Chef.deprecated(:chef_platform_methods, "#{self.class.name}.set is deprecated")
  validate(
    args,
    {
      :platform => {
        :kind_of => Symbol,
        :required => false,
      },
      :version => {
        :kind_of => String,
        :required => false,
      },
      :resource => {
        :kind_of => Symbol,
      },
      :provider => {
        :kind_of => [ String, Symbol, Class ],
      },
    }
  )
  if args.has_key?(:platform)
    if args.has_key?(:version)
      if platforms.has_key?(args[:platform])
        if platforms[args[:platform]].has_key?(args[:version])
          platforms[args[:platform]][args[:version]][args[:resource].to_sym] = args[:provider]
        else
          platforms[args[:platform]][args[:version]] = {
            args[:resource].to_sym => args[:provider],
          }
        end
      else
        platforms[args[:platform]] = {
          args[:version] => {
            args[:resource].to_sym => args[:provider],
          },
        }
      end
    else
      if platforms.has_key?(args[:platform])
        if platforms[args[:platform]].has_key?(:default)
          platforms[args[:platform]][:default][args[:resource].to_sym] = args[:provider]
        elsif args[:platform] == :default
          platforms[:default][args[:resource].to_sym] = args[:provider]
        else
          platforms[args[:platform]] = { :default => { args[:resource].to_sym => args[:provider] } }
        end
      else
        platforms[args[:platform]] = {
          :default => {
            args[:resource].to_sym => args[:provider],
          },
        }
      end
    end
  else
    if platforms.has_key?(:default)
      platforms[:default][args[:resource].to_sym] = args[:provider]
    else
      platforms[:default] = {
        args[:resource].to_sym => args[:provider],
      }
    end
  end
end

.supported_powershell_version?(node, version_string) ⇒ Boolean

Returns:

  • (Boolean) 


103
104
105
106
107
108
 
# File 'lib/chef/platform/query_helpers.rb', line 103

def supported_powershell_version?(node, version_string)
  return false unless node[:languages] && node[:languages][:powershell]
  require "rubygems"
  Gem::Version.new(node[:languages][:powershell][:version]) >=
    Gem::Version.new(version_string)
end

.supports_dsc?(node) ⇒ Boolean

Returns:

  • (Boolean) 


82
83
84
85
 
# File 'lib/chef/platform/query_helpers.rb', line 82

def supports_dsc?(node)
  node[:languages] && node[:languages][:powershell] &&
    node[:languages][:powershell][:version].to_i >= 4
end

.supports_dsc_invoke_resource?(node) ⇒ Boolean

Returns:

  • (Boolean) 


87
88
89
90
 
# File 'lib/chef/platform/query_helpers.rb', line 87

def supports_dsc_invoke_resource?(node)
  supports_dsc?(node) &&
    supported_powershell_version?(node, "5.0.10018.0")
end

.supports_msi? ⇒ Boolean

Returns:

  • (Boolean) 


61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/chef/platform/query_helpers.rb', line 61

def supports_msi?
  return false unless windows?
  require "win32/registry"

  key = "System\\CurrentControlSet\\Services\\msiserver"
  access = ::Win32::Registry::KEY_QUERY_VALUE

  begin
    ::Win32::Registry::HKEY_LOCAL_MACHINE.open(key, access) do |reg|
      true
    end
  rescue ::Win32::Registry::Error
    false
  end
end

.supports_powershell_execution_bypass?(node) ⇒ Boolean

Returns:

  • (Boolean) 


77
78
79
80
 
# File 'lib/chef/platform/query_helpers.rb', line 77

def supports_powershell_execution_bypass?(node)
  node[:languages] && node[:languages][:powershell] &&
    node[:languages][:powershell][:version].to_i >= 3
end

.supports_refresh_mode_enabled?(node) ⇒ Boolean

Returns:

  • (Boolean) 


92
93
94
 
# File 'lib/chef/platform/query_helpers.rb', line 92

def supports_refresh_mode_enabled?(node)
  supported_powershell_version?(node, "5.0.10586.0")
end

.windows? ⇒ Boolean

Returns:

  • (Boolean) 


23
24
25
 
# File 'lib/chef/platform/query_helpers.rb', line 23

def windows?
  ChefConfig.windows?
end

.windows_nano_server? ⇒ Boolean

Returns:

  • (Boolean) 


39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/chef/platform/query_helpers.rb', line 39

def windows_nano_server?
  return false unless windows?
  require "win32/registry"

  # This method may be called before ohai runs (e.g., it may be used to
  # determine settings in config.rb). Chef::Win32::Registry.new uses
  # node attributes to verify the machine architecture which aren't
  # accessible before ohai runs.
  nano = nil
  key = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Server\\ServerLevels"
  access = ::Win32::Registry::KEY_QUERY_VALUE | 0x0100 # nano is 64-bit only
  begin
    ::Win32::Registry::HKEY_LOCAL_MACHINE.open(key, access) do |reg|
      nano = reg["NanoServer"]
    end
  rescue ::Win32::Registry::Error
    # If accessing the registry key failed, then we're probably not on
    # nano. Fail through.
  end
  return nano == 1
end

.windows_server_2003? ⇒ Boolean

Returns:

  • (Boolean) 


27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/chef/platform/query_helpers.rb', line 27

def windows_server_2003?
  # WMI startup shouldn't be performed unless we're on Windows.
  return false unless windows?
  require "wmi-lite/wmi"

  wmi = WmiLite::Wmi.new
  host = wmi.first_of("Win32_OperatingSystem")
  is_server_2003 = (host["version"] && host["version"].start_with?("5.2"))

  is_server_2003
end