public override NativeResultCode CloseKey(RegistryRequest request)
{
// In the transparent registry keys are closed in one of the following two ways:
// - If hKey is an alias, the alias is removed.
// - If hKey is not an alias, hKey is removed from the internal dictionary by base.DeleteKey()
// BUT if hKey has aliases pointing to it, the removal needs to wait until all aliases are closed.
uint realKey;
if (IsAlias(request.Handle, out realKey))
{
RemoveAlias(request.Handle);
lock (_keysPendingClosureSyncRoot)
if (_keysPendingClosure.Contains(realKey)
&& !HasAliases(realKey))
{
base.DeleteKey(new RegistryRequest {Handle = realKey});
_keysPendingClosure.Remove(realKey);
}
return NativeResultCode.Success;
}
if (!HasAliases(request.Handle))
return base.DeleteKey(request);
lock (_keysPendingClosureSyncRoot)
if (!_keysPendingClosure.Contains(request.Handle))
_keysPendingClosure.Add(request.Handle);
return NativeResultCode.Success;
}
public static byte[] processModificationRequest(Command command)
{
RegistryRequest request = (RegistryRequest)Util.Serialization.deserialize(command.data);
bool success = false;
String errMessage = null;
if (RegistryIndex.data.ContainsKey((RegistryHive)request.hive))
{
RegistryKeyData entry = Util.Metadata.Find(RegistryIndex.data[(RegistryHive)request.hive], request.data);
if (entry != null)
{
try
{
entry.value.SetValue(request.newValue.name, request.newValue.value);
success = true;
}
catch (Exception e)
{
errMessage = e.Message;
}
}
else
{
errMessage = "Error with internal storage of registry client-side";
}
}
return(Util.Serialization.serialize(new RegistryResponse
{
error = (success) ? "Success!" : (errMessage == null) ? "Unknown error!" : errMessage,
keyData = null
}));
}
public override NativeResultCode CloseKey(RegistryRequest request)
{
// In the transparent registry keys are closed in one of the following two ways:
// - If hKey is an alias, the alias is removed.
// - If hKey is not an alias, hKey is removed from the internal dictionary by base.DeleteKey()
// BUT if hKey has aliases pointing to it, the removal needs to wait until all aliases are closed.
uint realKey;
if (IsAlias(request.Handle, out realKey))
{
RemoveAlias(request.Handle);
lock (_keysPendingClosureSyncRoot)
if (_keysPendingClosure.Contains(realKey) &&
!HasAliases(realKey))
{
base.DeleteKey(new RegistryRequest {
Handle = realKey
});
_keysPendingClosure.Remove(realKey);
}
return(NativeResultCode.Success);
}
if (!HasAliases(request.Handle))
{
return(base.DeleteKey(request));
}
lock (_keysPendingClosureSyncRoot)
if (!_keysPendingClosure.Contains(request.Handle))
{
_keysPendingClosure.Add(request.Handle);
}
return(NativeResultCode.Success);
}
public override NativeResultCode CreateKey(RegistryRequest request, out RegCreationDisposition creationDisposition)
{
var virtualKeyPath = RegistryTranslator.ToVirtualPath(request.KeyFullPath);
var virtReq = new RegistryRequest(request) {KeyFullPath = virtualKeyPath};
var result = base.CreateKey(virtReq, out creationDisposition);
request.Handle = virtReq.Handle;
return result;
}
/// <summary>
/// Closes the key handle specified in <paramref name="request"/>.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public virtual NativeResultCode CloseKey(RegistryRequest request)
{
if (!IsKnownKey(request))
{
return(NativeResultCode.InvalidHandle);
}
// Aliases should always be freed. Removing items from _keys is implemented by DeleteKey()
RemoveAlias(request.Handle);
return(NativeResultCode.Success);
}
public async Task <bool> RegistryExecutor()
{
var registryBody = new RegistryRequest
{
Key = _options.ExecutorAppName,
Host = _options.ExecutorUrl
};
return(await InnnerAdminHttpClient <string>(CreateRestRequest($"{_options.ApiUriSegments}/registry", registryBody), "注册执行器"));
}
public override NativeResultCode CreateKey(RegistryRequest request, out RegCreationDisposition creationDisposition)
{
var virtualKeyPath = RegistryTranslator.ToVirtualPath(request.KeyFullPath);
var virtReq = new RegistryRequest(request)
{
KeyFullPath = virtualKeyPath
};
var result = base.CreateKey(virtReq, out creationDisposition);
request.Handle = virtReq.Handle;
return(result);
}
public override NativeResultCode OpenKey(RegistryRequest request)
{
// Always create a new VirtualRegistryKey, no matter if if one already exists for keyName.
// Why? There is no counter for the number of users of each handle.
// => if one user closes the handle, other users won't be able to use it anymore.
if (HostRegistry.KeyExists(request.KeyFullPath))
{
request.Handle = BufferKey(request.KeyFullPath);
return(NativeResultCode.Success);
}
request.Handle = 0;
return(NativeResultCode.FileNotFound);
}
/// <summary>
/// Opens the key from the specified path.
/// The open handle is set to <paramref name="request.Handle"/>.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public virtual NativeResultCode OpenKey(RegistryRequest request)
{
VirtualRegistryKey key;
using (_keysSynchronizationLock.EnterDisposableReadLock())
key = _keys.Values.FirstOrDefault(k => k.Path.ToLowerInvariant() == request.KeyFullPath.ToLowerInvariant());
if (key == null)
{
return(NativeResultCode.FileNotFound);
}
request.Handle = key.Handle;
return(NativeResultCode.Success);
}
public override NativeResultCode OpenKey(RegistryRequest request)
{
// Always create a new VirtualRegistryKey, no matter if if one already exists for keyName.
// Why? There is no counter for the number of users of each handle.
// => if one user closes the handle, other users won't be able to use it anymore.
if (HostRegistry.KeyExists(request.KeyFullPath))
{
request.Handle = BufferKey(request.KeyFullPath);
return NativeResultCode.Success;
}
request.Handle = 0;
return NativeResultCode.FileNotFound;
}
public override NativeResultCode CreateKey(RegistryRequest request, out RegCreationDisposition creationDisposition)
{
// Create the key in the real registry.
var registryKey = HostRegistry.CreateKey(request.KeyFullPath, out creationDisposition);
if (registryKey != null)
{
registryKey.Close();
request.Handle = BufferKey(request.KeyFullPath);
return NativeResultCode.Success;
}
request.Handle = 0;
return NativeResultCode.AccessDenied;
}
public override NativeResultCode CreateKey(RegistryRequest request, out RegCreationDisposition creationDisposition)
{
// Create the key in the real registry.
var registryKey = HostRegistry.CreateKey(request.KeyFullPath, out creationDisposition);
if (registryKey != null)
{
registryKey.Close();
request.Handle = BufferKey(request.KeyFullPath);
return(NativeResultCode.Success);
}
request.Handle = 0;
return(NativeResultCode.AccessDenied);
}
/// <summary>
/// Deletes the key associated with the handle specified in <paramref name="request"/>.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public virtual NativeResultCode DeleteKey(RegistryRequest request)
{
using (_keysSynchronizationLock.EnterDisposableWriteLock())
{
request.Handle = EnsureHandleIsNoAlias(request.Handle);
if (!_keys.ContainsKey(request.Handle))
{
return(NativeResultCode.InvalidHandle);
}
RemoveAliasesFor(request.Handle);
_keys.Remove(request.Handle);
}
_indexGenerator.Release(request.Handle);
return(NativeResultCode.Success);
}
/// <summary>
/// Creates a key with the specified path.
/// The open handle is set to <paramref name="request.Handle"/>.
/// </summary>
/// <param name="request"></param>
/// <param name="creationDisposition">Whether the key is opened or created.</param>
/// <returns></returns>
public virtual NativeResultCode CreateKey(RegistryRequest request, out RegCreationDisposition creationDisposition)
{
if (OpenKey(request) == NativeResultCode.Success)
{
creationDisposition = RegCreationDisposition.OpenedExistingKey;
}
else
{
creationDisposition = RegCreationDisposition.CreatedNewKey;
var regKey = ConstructRegistryKey(request.KeyFullPath);
WriteKey(regKey);
request.Handle = regKey.Handle;
}
return(NativeResultCode.Success);
}
/// <summary>
/// Returns whether the database knows a key with the handle specified in <paramref name="request"/>.
/// The full path of the key is set to <paramref name="request.KeyFullPath"/> if the key is known.
/// </summary>
/// <param name="request">The index to search a key for.</param>
/// <returns></returns>
public bool IsKnownKey(RegistryRequest request)
{
using (_keysSynchronizationLock.EnterDisposableReadLock())
{
if (_keyAliases.ContainsKey(request.Handle))
{
request.Handle = _keyAliases[request.Handle];
}
if (_keys.Keys.Contains(request.Handle))
{
request.KeyFullPath = _keys[request.Handle].Path;
return(true);
}
}
return(false);
}
public override NativeResultCode OpenKey(RegistryRequest request)
{
var virtualKeyPath = RegistryTranslator.ToVirtualPath(request.KeyFullPath);
var virtReq = new RegistryRequest(request) { KeyFullPath = virtualKeyPath };
if (base.OpenKey(virtReq) == NativeResultCode.Success)
{
request.Handle = virtReq.Handle;
return NativeResultCode.Success;
}
if (request.VirtualizationType == VirtualizationType.Virtual
|| !HostRegistry.KeyExists(request.KeyFullPath))
return NativeResultCode.FileNotFound;
var virtualRegistryKey = ConstructRegistryKey(virtualKeyPath);
WriteKey(virtualRegistryKey, true);
request.Handle = virtualRegistryKey.Handle;
return NativeResultCode.Success;
}
private RegistryRequest Build_Test01()
{
var request = new RegistryRequest
{
Id = "urn:xdskit:com:c7ptmx37tfbcwy8ky7a",
Comment = "This is a comment",
Slots = new List <Slot>
{
new Slot
{
Name = "creationTime",
Type = "urn:xdskit:com:c7ptmx37tfbcwy8ky7b",
Values = new List <string> {
"2015-01-01"
}
},
new Slot
{
Name = "languageCode",
Type = "urn:xdskit:com:c7ptmx37tfbcwy8ky7c",
Values = new List <string> {
"en-US", "en-GB", "en-AU"
}
},
new Slot
{
Name = "serviceStartTime",
Values = new List <string> {
"2015-01-01T09:00:00"
}
},
new Slot
{
Name = "serviceStopTime",
Values = new List <string> {
"2015-01-01T21:00:00"
}
}
}
};
return(request);
}
public static byte[] getRegistrySubkeys(Command command)
{
RegistryRequest request = (RegistryRequest)Util.Serialization.deserialize(command.data);
byte[] data;
if (request.buildHive && request.hive != null)
{
RegistryIndex.index((RegistryHive)request.hive, RegistryView.Default);
data = Util.Serialization.serialize(new RegistryResponse
{
error = String.Empty,
isDictionary = false,
keyData = RegistryIndex.data[(RegistryHive)request.hive],
hive = (RegistryHive)request.hive
});
}
else if (request.hive == null)
{
data = Util.Serialization.serialize(new RegistryResponse
{
error = String.Empty,
isDictionary = true,
dictionary = RegistryIndex.data
});
}
else
{
data = Util.Serialization.serialize(new RegistryResponse
{
error = String.Empty,
isDictionary = false,
keyData = RegistryIndex.data[(RegistryHive)request.hive],
hive = (RegistryHive)request.hive
});
}
return(data);
}
public override NativeResultCode OpenKey(RegistryRequest request)
{
var virtualKeyPath = RegistryTranslator.ToVirtualPath(request.KeyFullPath);
var virtReq = new RegistryRequest(request)
{
KeyFullPath = virtualKeyPath
};
if (base.OpenKey(virtReq) == NativeResultCode.Success)
{
request.Handle = virtReq.Handle;
return(NativeResultCode.Success);
}
if (request.VirtualizationType == VirtualizationType.Virtual ||
!HostRegistry.KeyExists(request.KeyFullPath))
{
return(NativeResultCode.FileNotFound);
}
var virtualRegistryKey = ConstructRegistryKey(virtualKeyPath);
WriteKey(virtualRegistryKey, true);
request.Handle = virtualRegistryKey.Handle;
return(NativeResultCode.Success);
}
public override NativeResultCode DeleteKey(RegistryRequest request)
{
// Overriden, first delete the real key.
if (HiveHelper.IsHiveHandle(request.Handle))
{
return(NativeResultCode.AccessDenied);
}
if (!IsKnownKey(request))
{
return(NativeResultCode.InvalidHandle);
}
var index = request.KeyFullPath.LastIndexOf(@"\");
var subKeyName = request.KeyFullPath.Substring(index + 1);
var keyFullPath = request.KeyFullPath.Substring(0, index);
var registryKey = HostRegistry.OpenKey(keyFullPath, true);
try
{
if (registryKey != null)
{
registryKey.DeleteSubKeyTree(subKeyName);
}
}
catch (ArgumentException)
{
// Key is not found in real registry, call base to delete it from the buffer.
base.DeleteKey(request);
return(NativeResultCode.FileNotFound);
}
catch
{
return(NativeResultCode.AccessDenied);
}
// Real key is deleted, now delete the virtual one.
return(base.DeleteKey(request));
}
/// <summary>
/// Returns whether the database knows a key with the handle specified in <paramref name="request"/>.
/// The full path of the key is set to <paramref name="request.KeyFullPath"/> if the key is known.
/// </summary>
/// <param name="request">The index to search a key for.</param>
/// <returns></returns>
public bool IsKnownKey(RegistryRequest request)
{
using (_keysSynchronizationLock.EnterDisposableReadLock())
{
if (_keyAliases.ContainsKey(request.Handle))
request.Handle = _keyAliases[request.Handle];
if (_keys.Keys.Contains(request.Handle))
{
request.KeyFullPath = _keys[request.Handle].Path;
return true;
}
}
return false;
}
/// <summary>
/// Closes the key handle specified in <paramref name="request"/>.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public virtual NativeResultCode CloseKey(RegistryRequest request)
{
if (!IsKnownKey(request))
return NativeResultCode.InvalidHandle;
// Aliases should always be freed. Removing items from _keys is implemented by DeleteKey()
RemoveAlias(request.Handle);
return NativeResultCode.Success;
}
public RegistryValueRequest(RegistryRequest request)
: base(request)
{
Value = new VirtualRegistryValue(null, null, ValueType.INVALID);
}
/// <summary>
/// Deletes the key associated with the handle specified in <paramref name="request"/>.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public virtual NativeResultCode DeleteKey(RegistryRequest request)
{
using (_keysSynchronizationLock.EnterDisposableWriteLock())
{
request.Handle = EnsureHandleIsNoAlias(request.Handle);
if (!_keys.ContainsKey(request.Handle))
return NativeResultCode.InvalidHandle;
RemoveAliasesFor(request.Handle);
_keys.Remove(request.Handle);
}
_indexGenerator.Release(request.Handle);
return NativeResultCode.Success;
}
/// <summary>
/// Creates a key with the specified path.
/// The open handle is set to <paramref name="request.Handle"/>.
/// </summary>
/// <param name="request"></param>
/// <param name="creationDisposition">Whether the key is opened or created.</param>
/// <returns></returns>
public virtual NativeResultCode CreateKey(RegistryRequest request, out RegCreationDisposition creationDisposition)
{
if (OpenKey(request) == NativeResultCode.Success)
{
creationDisposition = RegCreationDisposition.OpenedExistingKey;
}
else
{
creationDisposition = RegCreationDisposition.CreatedNewKey;
var regKey = ConstructRegistryKey(request.KeyFullPath);
WriteKey(regKey);
request.Handle = regKey.Handle;
}
return NativeResultCode.Success;
}
public override NativeResultCode DeleteKey(RegistryRequest request)
{
// Overriden, first delete the real key.
if (HiveHelper.IsHiveHandle(request.Handle))
return NativeResultCode.AccessDenied;
if (!IsKnownKey(request))
return NativeResultCode.InvalidHandle;
var index = request.KeyFullPath.LastIndexOf(@"\");
var subKeyName = request.KeyFullPath.Substring(index + 1);
var keyFullPath = request.KeyFullPath.Substring(0, index);
var registryKey = HostRegistry.OpenKey(keyFullPath, true);
try
{
if (registryKey != null)
registryKey.DeleteSubKeyTree(subKeyName);
}
catch (ArgumentException)
{
// Key is not found in real registry, call base to delete it from the buffer.
base.DeleteKey(request);
return NativeResultCode.FileNotFound;
}
catch
{
return NativeResultCode.AccessDenied;
}
// Real key is deleted, now delete the virtual one.
return base.DeleteKey(request);
}
public RegistryValueRequest(RegistryRequest request)
: base(request)
{
Value = new VirtualRegistryValue(null, null, ValueType.INVALID);
}
/// <summary>
/// Opens the key from the specified path.
/// The open handle is set to <paramref name="request.Handle"/>.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public virtual NativeResultCode OpenKey(RegistryRequest request)
{
VirtualRegistryKey key;
using (_keysSynchronizationLock.EnterDisposableReadLock())
key = _keys.Values.FirstOrDefault(k => k.Path.ToLowerInvariant() == request.KeyFullPath.ToLowerInvariant());
if (key == null)
return NativeResultCode.FileNotFound;
request.Handle = key.Handle;
return NativeResultCode.Success;
}
