Ejemplo n.º 1
0
        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 {0} stream.", SystemStreams.ScavengesStream);
                            return;
                        }
                    }

                    Log.Debug("Setting max age for the {0} stream to {1}.", 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 {0} days metadata for the {1} stream. Reason: {2}", _scavengeHistoryMaxAge.TotalDays, SystemStreams.ScavengesStream, m.Result);
                        }
                    });
                }
            });
        }
 public Task<StreamMetadataResult> GetStreamMetadataAsync(string stream, UserCredentials userCredentials = null)
 {
     return GetStreamMetadataAsRawBytesAsync(stream, userCredentials).ContinueWith(t =>
     {
         if (t.Exception != null)
             throw t.Exception.InnerException;
         var res = t.Result;
         if (res.StreamMetadata == null || res.StreamMetadata.Length == 0)
             return new StreamMetadataResult(res.Stream, res.IsStreamDeleted, res.MetastreamVersion, StreamMetadata.Create());
         var metadata = StreamMetadata.FromJsonBytes(res.StreamMetadata);
         return new StreamMetadataResult(res.Stream, res.IsStreamDeleted, res.MetastreamVersion, metadata);
     });
 }
Ejemplo n.º 3
0
        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);
                        }
                    });
                }
            });
        }
        GetStreamMetadataAsync(string stream, UserCredentials userCredentials = null)
        {
            return(GetStreamMetadataAsRawBytesAsync(stream, userCredentials).ContinueWith(t => {
                ThrowIfNotNull(t.Exception);

                var res = t.Result;
                if (res.StreamMetadata == null || res.StreamMetadata.Length == 0)
                {
                    return new StreamMetadataResult(res.Stream, res.IsStreamDeleted, res.MetastreamVersion,
                                                    StreamMetadata.Create(), res.MetaEventCreated);
                }
                var metadata = StreamMetadata.FromJsonBytes(res.StreamMetadata);
                return new StreamMetadataResult(res.Stream, res.IsStreamDeleted, res.MetastreamVersion, metadata, res.MetaEventCreated);
            }));
        }