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

Returns a new instance of 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

#architecture ⇒ Object

Returns the value of attribute architecture.



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

def architecture
  @architecture
end

#run_context ⇒ Object

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 



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

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 



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

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

Returns:

  • (Boolean) 


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

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
  return false
end

#delete_key(key_path, recursive) ⇒ Object 



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

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 



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

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 



270
271
272
 
# File 'lib/chef/win32/registry.rb', line 270

def get_name_from_type(val_class)
  _name_type_map[val_class]
end

#get_subkeys(key_path) ⇒ Object 



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

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
  return subkeys
end

#get_type_from_name(val_type) ⇒ Object 



266
267
268
 
# File 'lib/chef/win32/registry.rb', line 266

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

Returns:

  • (Boolean) 


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

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
  return false
end

#hive_exists?(key_path) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#key_exists!(key_path) ⇒ Object 



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

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

Returns:

  • (Boolean) 


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

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

Returns:

  • (Boolean) 


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

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_architecture ⇒ Object

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



194
195
196
197
 
# File 'lib/chef/win32/registry.rb', line 194

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
 
# File 'lib/chef/win32/registry.rb', line 63

def set_value(key_path, value)
  Chef::Log.debug("Updating value #{value[:name]} in registry key #{key_path} with type #{value[:type]} and data #{value[: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]), value[: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]), value[:data])
    end
    Chef::Log.debug("Value #{value[:name]} in registry key #{key_path} created")
  end
  true
end

#type_matches!(key_path, value) ⇒ Object 



253
254
255
256
257
 
# File 'lib/chef/win32/registry.rb', line 253

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

Returns:

  • (Boolean) 


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

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
  return false
end

#value_exists!(key_path, value) ⇒ Object 



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

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

Returns:

  • (Boolean) 


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

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
  return false
end