Class: Chef::Win32::Registry

Inherits:
Object
  • Object
show all
Extended by:
Mixin::WideString, ReservedNames::Win32::API::Registry
Includes:
Mixin::WideString, ReservedNames::Win32::API::Registry
Defined in:
lib/chef/win32/registry.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Mixin::WideString

utf8_to_wide, wide_to_utf8, wstring

Constructor Details

#initialize(run_context = nil, user_architecture = :machine) ⇒ Registry


45
46
47
48
# File 'lib/chef/win32/registry.rb', line 45

def initialize(run_context = nil, user_architecture = :machine)
  @run_context = run_context
  self.architecture = user_architecture
end

Instance Attribute Details

#architectureObject

Returns the value of attribute architecture


43
44
45
# File 'lib/chef/win32/registry.rb', line 43

def architecture
  @architecture
end

#run_contextObject

Returns the value of attribute run_context


42
43
44
# File 'lib/chef/win32/registry.rb', line 42

def run_context
  @run_context
end

Instance Method Details

#create_key(key_path, recursive) ⇒ Object


106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
# File 'lib/chef/win32/registry.rb', line 106

def create_key(key_path, recursive)
  Chef::Log.debug("Creating registry key #{key_path}")
  if keys_missing?(key_path)
    if recursive == true
      Chef::Log.debug("Registry key #{key_path} has missing subkeys, and recursive specified, creating them....")
      create_missing(key_path)
    else
      raise Chef::Exceptions::Win32RegNoRecursive, "Registry key #{key_path} has missing subkeys, and recursive not specified"
    end
  end
  if key_exists?(key_path)
    Chef::Log.debug("Registry key #{key_path} already exists, doing nothing")
  else
    hive, key = get_hive_and_key(key_path)
    hive.create(key, ::Win32::Registry::KEY_WRITE | registry_system_architecture)
    Chef::Log.debug("Registry key #{key_path} created")
  end
  true
end

#data_exists!(key_path, value) ⇒ Object


232
233
234
235
236
237
# File 'lib/chef/win32/registry.rb', line 232

def data_exists!(key_path, value)
  unless data_exists?(key_path, value)
    raise Chef::Exceptions::Win32RegDataMissing, "Registry key #{key_path} has no value named #{value[:name]}, containing type #{value[:type]} and data #{value[:data]}"
  end
  true
end

#data_exists?(key_path, value) ⇒ Boolean


210
211
212
213
214
215
216
217
218
219
220
221
222
223
# File 'lib/chef/win32/registry.rb', line 210

def data_exists?(key_path, value)
  key_exists!(key_path)
  hive, key = get_hive_and_key(key_path)
  hive.open(key, ::Win32::Registry::KEY_READ | registry_system_architecture) do |reg|
    reg.each do |val_name, val_type, val_data|
      if safely_downcase(val_name) == safely_downcase(value[:name]) &&
          val_type == get_type_from_name(value[:type]) &&
          val_data == value[:data]
        return true
      end
    end
  end
  false
end

#delete_key(key_path, recursive) ⇒ Object


126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
# File 'lib/chef/win32/registry.rb', line 126

def delete_key(key_path, recursive)
  Chef::Log.debug("Deleting registry key #{key_path}")
  unless key_exists?(key_path)
    Chef::Log.debug("Registry key #{key_path}, does not exist, not deleting")
    return true
  end
  if has_subkeys?(key_path) && !recursive
    raise Chef::Exceptions::Win32RegNoRecursive, "Registry key #{key_path} has subkeys, and recursive not specified"
  end
  hive, key_including_parent = get_hive_and_key(key_path)
  # key_including_parent: Software\\Root\\Branch\\Fruit
  # key => Fruit
  # key_parent => Software\\Root\\Branch
  key_parts = key_including_parent.split("\\")
  key = key_parts.pop
  key_parent = key_parts.join("\\")
  hive.open(key_parent, ::Win32::Registry::KEY_WRITE | registry_system_architecture) do |reg|
    reg.delete_key(key, recursive)
  end
  Chef::Log.debug("Registry key #{key_path} deleted")
  true
end

#delete_value(key_path, value) ⇒ Object


88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
# File 'lib/chef/win32/registry.rb', line 88

def delete_value(key_path, value)
  Chef::Log.debug("Deleting value #{value[:name]} from registry key #{key_path}")
  if value_exists?(key_path, value)
    begin
      hive, key = get_hive_and_key(key_path)
    rescue Chef::Exceptions::Win32RegKeyMissing
      return true
    end
    hive.open(key, ::Win32::Registry::KEY_SET_VALUE | registry_system_architecture) do |reg|
      reg.delete_value(value[:name])
      Chef::Log.debug("Deleted value #{value[:name]} from registry key #{key_path}")
    end
  else
    Chef::Log.debug("Value #{value[:name]} in registry key #{key_path} does not exist, not updated")
  end
  true
end

#get_name_from_type(val_class) ⇒ Object


272
273
274
# File 'lib/chef/win32/registry.rb', line 272

def get_name_from_type(val_class)
  _name_type_map[val_class]
end

#get_subkeys(key_path) ⇒ Object


185
186
187
188
189
190
191
192
193
# File 'lib/chef/win32/registry.rb', line 185

def get_subkeys(key_path)
  subkeys = []
  key_exists!(key_path)
  hive, key = get_hive_and_key(key_path)
  hive.open(key, ::Win32::Registry::KEY_READ | registry_system_architecture) do |reg|
    reg.each_key { |current_key| subkeys << current_key }
  end
  subkeys
end

#get_type_from_name(val_type) ⇒ Object


268
269
270
# File 'lib/chef/win32/registry.rb', line 268

def get_type_from_name(val_type)
  _type_name_map[val_type]
end

#get_values(key_path) ⇒ Object


55
56
57
58
59
60
61
# File 'lib/chef/win32/registry.rb', line 55

def get_values(key_path)
  hive, key = get_hive_and_key(key_path)
  key_exists!(key_path)
  values = hive.open(key, ::Win32::Registry::KEY_READ | registry_system_architecture) do |reg|
    reg.map { |name, type, data| { :name => name, :type => get_name_from_type(type), :data => data } }
  end
end

#has_subkeys?(key_path) ⇒ Boolean


176
177
178
179
180
181
182
183
# File 'lib/chef/win32/registry.rb', line 176

def has_subkeys?(key_path)
  key_exists!(key_path)
  hive, key = get_hive_and_key(key_path)
  hive.open(key, ::Win32::Registry::KEY_READ | registry_system_architecture) do |reg|
    reg.each_key { |key| return true }
  end
  false
end

#hive_exists?(key_path) ⇒ Boolean


167
168
169
170
171
172
173
174
# File 'lib/chef/win32/registry.rb', line 167

def hive_exists?(key_path)
  begin
    hive, key = get_hive_and_key(key_path)
  rescue Chef::Exceptions::Win32RegHiveMissing => e
    return false
  end
  true
end

#key_exists!(key_path) ⇒ Object


160
161
162
163
164
165
# File 'lib/chef/win32/registry.rb', line 160

def key_exists!(key_path)
  unless key_exists?(key_path)
    raise Chef::Exceptions::Win32RegKeyMissing, "Registry key #{key_path} does not exist"
  end
  true
end

#key_exists?(key_path) ⇒ Boolean


149
150
151
152
153
154
155
156
157
158
# File 'lib/chef/win32/registry.rb', line 149

def key_exists?(key_path)
  hive, key = get_hive_and_key(key_path)
  begin
    hive.open(key, ::Win32::Registry::KEY_READ | registry_system_architecture) do |current_key|
      return true
    end
  rescue ::Win32::Registry::Error => e
    return false
  end
end

#keys_missing?(key_path) ⇒ Boolean


261
262
263
264
265
266
# File 'lib/chef/win32/registry.rb', line 261

def keys_missing?(key_path)
  missing_key_arr = key_path.split("\\")
  missing_key_arr.pop
  key = missing_key_arr.join("\\")
  !key_exists?(key)
end

#registry_system_architectureObject

32-bit chef clients running on 64-bit machines will default to reading the 64-bit registry


196
197
198
199
# File 'lib/chef/win32/registry.rb', line 196

def registry_system_architecture
  applied_arch = ( architecture == :machine ) ? machine_architecture : architecture
  ( applied_arch == :x86_64 ) ? 0x0100 : 0x0200
end

#set_value(key_path, value) ⇒ Object


63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
# File 'lib/chef/win32/registry.rb', line 63

def set_value(key_path, value)
  data = value[:data]
  data = data.to_s if value[:type] == :string
  Chef::Log.debug("Updating value #{value[:name]} in registry key #{key_path} with type #{value[:type]} and data #{data}")
  key_exists!(key_path)
  hive, key = get_hive_and_key(key_path)
  if value_exists?(key_path, value)
    if data_exists?(key_path, value)
      Chef::Log.debug("Value #{value[:name]} in registry key #{key_path} already had those values, not updated")
      return false
    else
      hive.open(key, ::Win32::Registry::KEY_SET_VALUE | ::Win32::Registry::KEY_QUERY_VALUE | registry_system_architecture) do |reg|
        reg.write(value[:name], get_type_from_name(value[:type]), data)
      end
      Chef::Log.debug("Value #{value[:name]} in registry key #{key_path} updated")
    end
  else
    hive.open(key, ::Win32::Registry::KEY_SET_VALUE | ::Win32::Registry::KEY_QUERY_VALUE | registry_system_architecture) do |reg|
      reg.write(value[:name], get_type_from_name(value[:type]), data)
    end
    Chef::Log.debug("Value #{value[:name]} in registry key #{key_path} created")
  end
  true
end

#type_matches!(key_path, value) ⇒ Object


255
256
257
258
259
# File 'lib/chef/win32/registry.rb', line 255

def type_matches!(key_path, value)
  unless type_matches?(key_path, value)
    raise Chef::Exceptions::Win32RegTypesMismatch, "Registry key #{key_path} has a value #{value[:name]} with a type that is not #{value[:type]}"
  end
end

#type_matches?(key_path, value) ⇒ Boolean


239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
# File 'lib/chef/win32/registry.rb', line 239

def type_matches?(key_path, value)
  value_exists!(key_path, value)
  hive, key = get_hive_and_key(key_path)
  hive.open(key, ::Win32::Registry::KEY_READ | registry_system_architecture) do |reg|
    reg.each do |val_name, val_type|
      if val_name == value[:name]
        type_new = get_type_from_name(value[:type])
        if val_type == type_new
          return true
        end
      end
    end
  end
  false
end

#value_exists!(key_path, value) ⇒ Object


225
226
227
228
229
230
# File 'lib/chef/win32/registry.rb', line 225

def value_exists!(key_path, value)
  unless value_exists?(key_path, value)
    raise Chef::Exceptions::Win32RegValueMissing, "Registry key #{key_path} has no value named #{value[:name]}"
  end
  true
end

#value_exists?(key_path, value) ⇒ Boolean


201
202
203
204
205
206
207
208
# File 'lib/chef/win32/registry.rb', line 201

def value_exists?(key_path, value)
  key_exists!(key_path)
  hive, key = get_hive_and_key(key_path)
  hive.open(key, ::Win32::Registry::KEY_READ | registry_system_architecture) do |reg|
    return true if reg.any? { |val| safely_downcase(val) == safely_downcase(value[:name]) }
  end
  false
end