private ApplyResourceChangeResult <RegistryKeyResource> DoCreate(
ApplyResourceChangeInput <RegistryKeyResource> input)
{
var newRes = input.PlannedState;
var pState = StateHelper.Deserialize <PrivateState>(input.PlannedPrivate)
?? new PrivateState();
_log.LogInformation($"Creating registry key at [{newRes.Root}][{newRes.Path}]");
RegistryKey root = RegUtil.ParseRootKey(newRes.Root);
RegistryKey newKey = root.OpenSubKey(newRes.Path, true);
if (newKey == null)
{
_log.LogInformation("Existing key does not exist, creating");
newKey = root.CreateSubKey(newRes.Path, true);
pState.RegistryKeyCreated = true;
}
using (var regKey = newKey)
{
ApplyValueDiffs(regKey, toAdd: newRes.Entries);
}
return(new ApplyResourceChangeResult <RegistryKeyResource>
{
NewState = input.PlannedState,
Private = StateHelper.Serialize(pState),
});
}
public ReadDataSourceResult <RegistryKeyDataSource> Read(
ReadDataSourceInput <RegistryKeyDataSource> input)
{
var result = new ReadDataSourceResult <RegistryKeyDataSource>();
var root = RegUtil.ParseRootKey(input.Config.Root);
if (root == null)
{
result.Error("invalid root, must be one of: "
+ string.Join(" | ", RegUtil.AllRootAliases));
}
else
{
using (var regKey = root.OpenSubKey(input.Config.Path))
{
result.State = new RegistryKeyDataSource
{
Root = input.Config.Root,
Path = input.Config.Path,
KeyNames = regKey.GetSubKeyNames(),
ValueNames = regKey.GetValueNames(),
Entries = new Dictionary <string, Registry.ComputedRegValue>(),
};
foreach (var n in result.State.ValueNames)
{
var val = regKey.GetValue(n);
var typ = regKey.GetValueKind(n);
var regVal = new ComputedRegValue {
Type = RegUtil.ToString(typ)
};
switch (typ)
{
case RegistryValueKind.MultiString:
regVal.Values = (string[])regKey.GetValue(n);
break;
case RegistryValueKind.Binary:
regVal.ValueBase64 = Convert.ToBase64String((byte[])regKey.GetValue(n)
?? new byte[0]);
break;
default:
regVal.Value = regKey.GetValue(n)?.ToString();
break;
}
result.State.Entries.Add(n, regVal);
}
}
}
return(result);
}
private ApplyResourceChangeResult <RegistryKeyResource> DoDelete(
ApplyResourceChangeInput <RegistryKeyResource> input)
{
var oldRes = input.PriorState;
var pState = StateHelper.Deserialize <PrivateState>(input.PlannedPrivate);
_log.LogInformation($"Deleting registry key at [{oldRes.Root}][{oldRes.Path}]");
RegistryKey root = RegUtil.ParseRootKey(oldRes.Root);
RegistryKey oldKey = root.OpenSubKey(oldRes.Path, true);
if (oldKey != null)
{
string delKey = null;
using (var regKey = oldKey)
{
ApplyValueDiffs(regKey, toDel: oldRes.Entries);
var subKeysLen = oldKey.GetSubKeyNames()?.Length ?? 0;
var valuesLen = oldKey.GetValueNames()?.Length ?? 0;
var forceDel = oldRes.ForceOnDelete ?? false;
if (!(pState?.RegistryKeyCreated ?? false))
{
_log.LogWarning("registry key was not created by us");
}
if (subKeysLen > 0)
{
_log.LogWarning($"registry key still has [{subKeysLen}] subkey(s)");
}
if (valuesLen > 0)
{
_log.LogWarning($"registry key still has [{valuesLen}] value(s)");
}
if (!(pState?.RegistryKeyCreated ?? false) || subKeysLen > 0 || valuesLen > 0)
{
if (forceDel)
{
_log.LogWarning("forced delete specified");
delKey = oldKey.Name;
}
else
{
_log.LogWarning("reg key was not created by us or is not empty, SKIPPING delete");
}
}
else
{
delKey = oldKey.Name;
}
}
if (delKey != null)
{
var openParent = RegUtil.OpenParentWithName(delKey, true);
if (openParent == null)
{
_log.LogWarning($"Cannot delete Registry Key [{delKey}], malformed path");
}
else
{
var(delRoot, parent, name) = openParent.Value;
_log.LogInformation($"Deleting Registry Key [{name}] under [{(parent??delRoot).Name}] ({delRoot.Name})");
using (var regKey = parent)
{
regKey.DeleteSubKeyTree(name, false);
}
}
}
}
else
{
_log.LogInformation("Could not open existing, prior reg key, skipping");
}
return(new ApplyResourceChangeResult <RegistryKeyResource>
{
NewState = input.PlannedState,
Private = null,
});
}
