private void WriteScavengeIndexInitializedEvent()
{
var metadataEventId = Guid.NewGuid();
var metaStreamId = SystemStreams.MetastreamOf(SystemStreams.ScavengesStream);
var metadata = new StreamMetadata(maxAge: TimeSpan.FromDays(_scavengeHistoryMaxAge));
var metaStreamEvent = new Event(metadataEventId, SystemEventTypes.StreamMetadata, isJson: true,
data: metadata.ToJsonBytes(), metadata: null);
_ioDispatcher.WriteEvent(metaStreamId, ExpectedVersion.Any, metaStreamEvent, SystemAccount.Principal, m => {
if (m.Result != OperationResult.Success)
{
Log.Error("Failed to write the $maxAge of {0} days metadata for the {1} stream. Reason: {2}", _scavengeHistoryMaxAge, SystemStreams.ScavengesStream, m.Result);
}
});
var indexInitializedEvent = new Event(Guid.NewGuid(), SystemEventTypes.ScavengeIndexInitialized,
true, new Dictionary <string, object> {
}.ToJsonBytes(), null);
_ioDispatcher.WriteEvent(SystemStreams.ScavengesStream, ExpectedVersion.NoStream, indexInitializedEvent, SystemAccount.Principal, m => {
if (m.Result != OperationResult.Success)
{
Log.Error("Failed to write the {0} event to the {1} stream. Reason: {2}", SystemEventTypes.ScavengeIndexInitialized, SystemStreams.ScavengesStream, m.Result);
}
});
}
public void ScavengeStarted()
{
var metadataEventId = Guid.NewGuid();
var metaStreamId = SystemStreams.MetastreamOf(_streamName);
var metadata = new StreamMetadata(maxAge: _scavengeHistoryMaxAge);
var metaStreamEvent = new Event(metadataEventId, SystemEventTypes.StreamMetadata, isJson: true,
data: metadata.ToJsonBytes(), metadata: null);
_ioDispatcher.WriteEvent(metaStreamId, ExpectedVersion.Any, metaStreamEvent, SystemAccount.Principal, m => {
if (m.Result != OperationResult.Success)
{
Log.Error(
"Failed to write the $maxAge of {days} days metadata for the {stream} stream. Reason: {reason}",
_scavengeHistoryMaxAge.TotalDays, _streamName, m.Result);
}
});
var scavengeStartedEvent = new Event(Guid.NewGuid(), SystemEventTypes.ScavengeStarted, true,
new Dictionary <string, object> {
{ "scavengeId", _scavengeId },
{ "nodeEndpoint", _nodeId },
}.ToJsonBytes(), null);
WriteScavengeDetailEvent(_streamName, scavengeStartedEvent, _retryAttempts);
}
private static void UpdateStreamAclWithRetry(
this IODispatcher ioDispatcher,
CancellationScope cancellationScope,
string streamId,
long expectedVersion,
ClaimsPrincipal principal,
StreamMetadata metadata,
Action <ClientMessage.WriteEventsCompleted> handler,
IEnumerator <Step> steps)
{
PerformWithRetry(
ioDispatcher,
handler,
steps,
expectedVersion == ExpectedVersion.Any,
TimeSpan.FromMilliseconds(100),
action =>
cancellationScope.Register(
ioDispatcher.WriteEvents(
SystemStreams.MetastreamOf(streamId),
expectedVersion,
new[] {
new Event(Guid.NewGuid(), SystemEventTypes.StreamMetadata, true, metadata.ToJsonBytes(),
null)
},
principal,
response => {
if (cancellationScope.Cancelled(response.CorrelationId))
{
return;
}
action(response, response.Result);
})));
}
private Event CreateStreamMetadataEvent()
{
var eventId = Guid.NewGuid();
var acl = new StreamAcl(
readRole: SystemRoles.Admins, writeRole: SystemRoles.Admins,
deleteRole: SystemRoles.Admins, metaReadRole: SystemRoles.All,
metaWriteRole: SystemRoles.Admins);
var metadata = new StreamMetadata(maxCount: 2, maxAge: null, cacheControl: null, acl: acl);
var dataBytes = metadata.ToJsonBytes();
return(new Event(eventId, SystemEventTypes.StreamMetadata, isJson: true, data: dataBytes, metadata: null));
}
private Event CreateStreamMetadataEvent(long?tb)
{
var eventId = Guid.NewGuid();
var acl = new StreamAcl(
readRole: SystemRoles.Admins, writeRole: SystemRoles.Admins,
deleteRole: SystemRoles.Admins, metaReadRole: SystemRoles.Admins,
metaWriteRole: SystemRoles.Admins);
var metadata = new StreamMetadata(cacheControl: null,
truncateBefore: tb,
acl: acl);
var dataBytes = metadata.ToJsonBytes();
return(new Event(eventId, SystemEventTypes.StreamMetadata, isJson: true, data: dataBytes, metadata: null));
}
private void SetScavengeStreamMetadata()
{
var metaStreamId = SystemStreams.MetastreamOf(SystemStreams.ScavengesStream);
_ioDispatcher.ReadBackward(metaStreamId, -1, 1, false, SystemAccount.Principal, readResult => {
if (readResult.Result == ReadStreamResult.Success || readResult.Result == ReadStreamResult.NoStream)
{
if (readResult.Events.Length == 1)
{
var currentMetadata = StreamMetadata.FromJsonBytes(readResult.Events[0].Event.Data);
var hasProperACL = currentMetadata.Acl != null &&
currentMetadata.Acl.ReadRoles != null &&
currentMetadata.Acl.ReadRoles.Contains(x => x.Equals("$ops"));
if (currentMetadata.MaxAge == _scavengeHistoryMaxAge && hasProperACL)
{
Log.Debug("Max age and $ops read permission already set for the {stream} stream.", SystemStreams.ScavengesStream);
return;
}
}
Log.Debug("Setting max age for the {stream} stream to {maxAge}.", SystemStreams.ScavengesStream,
_scavengeHistoryMaxAge);
Log.Debug("Setting $ops read permission for the {stream} stream", SystemStreams.ScavengesStream);
var acl = new StreamAcl(
new string[] { "$ops" },
new string[] {},
new string[] {},
new string[] {},
new string[] {}
);
var metadata = new StreamMetadata(maxAge: _scavengeHistoryMaxAge, acl: acl);
var metaStreamEvent = new Event(Guid.NewGuid(), SystemEventTypes.StreamMetadata, isJson: true,
data: metadata.ToJsonBytes(), metadata: null);
_ioDispatcher.WriteEvent(metaStreamId, ExpectedVersion.Any, metaStreamEvent,
SystemAccount.Principal, m => {
if (m.Result != OperationResult.Success)
{
Log.Error(
"Failed to write the $maxAge of {days} days and set $ops permission for the {stream} stream. Reason: {reason}",
_scavengeHistoryMaxAge.TotalDays, SystemStreams.ScavengesStream, m.Result);
}
});
}
});
}
private void SetOpsPermissions(IList <string> recentScavengeIds)
{
//sets $ops permissions on last 30 $scavenges-<scavenge id> stream
//added for backward compatibility to make UI scavenge history work properly with $ops users
var last30ScavengeIds = new HashSet <string>();
foreach (var scavengeId in recentScavengeIds)
{
if (last30ScavengeIds.Count >= 30)
{
break;
}
last30ScavengeIds.Add(scavengeId);
}
if (last30ScavengeIds.Count > 0)
{
Log.Debug("Setting $ops read permission on last {count} $scavenges-<scavenge id> streams.", last30ScavengeIds.Count);
}
foreach (var scavengeId in last30ScavengeIds)
{
var acl = new StreamAcl(
new string[] { "$ops" },
new string[] {},
new string[] {},
new string[] {},
new string[] {}
);
var scavengeIdStream = SystemStreams.ScavengesStream + "-" + scavengeId;
var metaStreamId = SystemStreams.MetastreamOf(scavengeIdStream);
var metadata = new StreamMetadata(maxAge: _scavengeHistoryMaxAge, acl: acl);
var metaStreamEvent = new Event(Guid.NewGuid(), SystemEventTypes.StreamMetadata, isJson: true,
data: metadata.ToJsonBytes(), metadata: null);
_ioDispatcher.WriteEvent(metaStreamId, ExpectedVersion.Any, metaStreamEvent,
SystemAccount.Principal, m => {
if (m.Result != OperationResult.Success)
{
Log.Error(
"Failed to set $ops read permission for the {stream} stream. Reason: {reason}",
_scavengeHistoryMaxAge.TotalDays, scavengeIdStream, m.Result);
}
});
}
}
private void WriteScavengeStartedEvent(string streamName, Guid scavengeId)
{
var metadataEventId = Guid.NewGuid();
var metaStreamId = SystemStreams.MetastreamOf(streamName);
var metadata = new StreamMetadata(maxAge: TimeSpan.FromDays(_scavengeHistoryMaxAge));
var metaStreamEvent = new Event(metadataEventId, SystemEventTypes.StreamMetadata, isJson: true,
data: metadata.ToJsonBytes(), metadata: null);
_ioDispatcher.WriteEvent(metaStreamId, ExpectedVersion.Any, metaStreamEvent, SystemAccount.Principal, m => { });
var scavengeStartedEvent = new Event(Guid.NewGuid(), SystemEventTypes.ScavengeStarted, true, new Dictionary <string, object> {
{ "scavengeId", scavengeId },
{ "nodeEndpoint", _nodeEndpoint },
}.ToJsonBytes(), null);
_ioDispatcher.WriteEvent(streamName, ExpectedVersion.Any, scavengeStartedEvent, SystemAccount.Principal, x => WriteScavengeEventCompleted(x, streamName));
}
private void SubmitWriteMetadata()
{
if (_awaitingWriteCompleted || _awaitingMetadataWriteCompleted || _awaitingListEventsCompleted)
{
throw new Exception();
}
var streamAcl = _streamId.StartsWith("$")
? new StreamAcl(SystemRoles.All, null, null, SystemRoles.All, null)
: new StreamAcl((string)null, null, null, null, null);
var streamMetadata = new StreamMetadata(
_writerConfiguration.MaxCount, _writerConfiguration.MaxAge, acl: streamAcl,
truncateBefore: _retrievedNextEventNumber == 0 ? (int?)null : _retrievedNextEventNumber);
_submittedWriteMetaStreamEvent = new Event(
Guid.NewGuid(), SystemEventTypes.StreamMetadata, true, streamMetadata.ToJsonBytes(), null);
_awaitingMetadataWriteCompleted = true;
PublishWriteMetaStream();
}
private void WriteScavengeStartedEvent(string streamName, Guid scavengeId)
{
var metadataEventId = Guid.NewGuid();
var metaStreamId = SystemStreams.MetastreamOf(streamName);
var metadata = new StreamMetadata(maxAge: TimeSpan.FromDays(_scavengeHistoryMaxAge));
var metaStreamEvent = new Event(metadataEventId, SystemEventTypes.StreamMetadata, isJson: true,
data: metadata.ToJsonBytes(), metadata: null);
_ioDispatcher.WriteEvent(metaStreamId, ExpectedVersion.Any, metaStreamEvent, SystemAccount.Principal, m => {
if (m.Result != OperationResult.Success)
{
Log.Error("Failed to write the $maxAge of {0} days metadata for the {1} stream. Reason: {2}", _scavengeHistoryMaxAge, streamName, m.Result);
}
});
var scavengeStartedEvent = new Event(Guid.NewGuid(), SystemEventTypes.ScavengeStarted, true, new Dictionary <string, object> {
{ "scavengeId", scavengeId },
{ "nodeEndpoint", _nodeEndpoint },
}.ToJsonBytes(), null);
WriteScavengeDetailEvent(streamName, scavengeStartedEvent, MaxRetryCount);
}
private void SetMaxAge()
{
var metaStreamId = SystemStreams.MetastreamOf(SystemStreams.ScavengesStream);
_ioDispatcher.ReadBackward(metaStreamId, -1, 1, false, SystemAccount.Principal, readResult => {
if (readResult.Result == ReadStreamResult.Success || readResult.Result == ReadStreamResult.NoStream)
{
if (readResult.Events.Length == 1)
{
var currentMetadata = StreamMetadata.FromJsonBytes(readResult.Events[0].Event.Data);
if (currentMetadata.MaxAge == _scavengeHistoryMaxAge)
{
Log.Debug("Max age already set for the {stream} stream.", SystemStreams.ScavengesStream);
return;
}
}
Log.Debug("Setting max age for the {stream} stream to {maxAge}.", SystemStreams.ScavengesStream,
_scavengeHistoryMaxAge);
var metadata = new StreamMetadata(maxAge: _scavengeHistoryMaxAge);
var metaStreamEvent = new Event(Guid.NewGuid(), SystemEventTypes.StreamMetadata, isJson: true,
data: metadata.ToJsonBytes(), metadata: null);
_ioDispatcher.WriteEvent(metaStreamId, ExpectedVersion.Any, metaStreamEvent,
SystemAccount.Principal, m => {
if (m.Result != OperationResult.Success)
{
Log.Error(
"Failed to write the $maxAge of {days} days metadata for the {stream} stream. Reason: {reason}",
_scavengeHistoryMaxAge.TotalDays, SystemStreams.ScavengesStream, m.Result);
}
});
}
});
}
public void ScavengeStarted(bool alwaysKeepScavenged, bool mergeChunks, int startFromChunk, int threads)
{
var metadataEventId = Guid.NewGuid();
var metaStreamId = SystemStreams.MetastreamOf(_streamName);
var acl = new StreamAcl(
new string[] { "$ops" },
new string[] { },
new string[] { },
new string[] { },
new string[] { }
);
var metadata = new StreamMetadata(maxAge: _scavengeHistoryMaxAge, acl: acl);
var metaStreamEvent = new Event(metadataEventId, SystemEventTypes.StreamMetadata, isJson: true,
data: metadata.ToJsonBytes(), metadata: null);
_ioDispatcher.WriteEvent(metaStreamId, ExpectedVersion.Any, metaStreamEvent, SystemAccounts.System, m => {
if (m.Result != OperationResult.Success)
{
Log.Error(
"Failed to write the $maxAge of {days} days metadata for the {stream} stream. Reason: {reason}",
_scavengeHistoryMaxAge.TotalDays, _streamName, m.Result);
}
});
var scavengeStartedEvent = new Event(Guid.NewGuid(), SystemEventTypes.ScavengeStarted, true,
new Dictionary <string, object> {
{ "scavengeId", _scavengeId },
{ "nodeEndpoint", _nodeId },
{ "alwaysKeepScavenged", alwaysKeepScavenged },
{ "mergeChunks", mergeChunks },
{ "startFromChunk", startFromChunk },
{ "threads", threads },
}.ToJsonBytes(), null);
WriteScavengeDetailEvent(_streamName, scavengeStartedEvent, _retryAttempts);
}
public void UpdateStreamAcl(
string streamId,
long expectedVersion,
IPrincipal principal,
StreamMetadata metadata,
Action <ClientMessage.WriteEventsCompleted> completed)
{
WriteEvents(
SystemStreams.MetastreamOf(streamId),
expectedVersion,
new[] { new Event(Guid.NewGuid(), SystemEventTypes.StreamMetadata, true, metadata.ToJsonBytes(), null) },
principal,
completed);
}
