DotNext.Net.Cluster by .NET Foundation and Contributors

<PackageReference Include="DotNext.Net.Cluster" Version="4.1.3" />

---

API Diff between 4.1.3 and 1.2.6

363 Additions 70 Removals

DotNext

• public class BinaryTransferObject : IDataTransferObject
• public static class DataTransferObject
• public interface IDataTransferObject
• public class StreamTransferObject : Disposable, IDataTransferObject

DotNext.Net

• public static class EndPointFormatter
  • public static MemoryOwner<byte> GetBytes(this EndPoint endPoint, MemoryAllocator<byte> allocator = null)
  • public static EndPoint ReadEndPoint(this ref SequenceReader reader)
  • public static void WriteEndPoint(this ref BufferWriterSlim writer, EndPoint endPoint)
• public interface IPeer
  • EndPoint EndPoint { get; }
• public interface IPeerMesh
  • IReadOnlySet<EndPoint> Peers { get; }
  • event Action<IPeerMesh, PeerEventArgs> PeerDiscovered
  • event Action<IPeerMesh, PeerEventArgs> PeerGone
• public interface IPeerMesh<TPeer> : IPeerMesh where TPeer : IPeer
  • TPeer TryGetPeer(EndPoint peer)
• public abstract class PeerEventArgs : EventArgs
  • public abstract EndPoint PeerAddress { get; }
  • protected PeerEventArgs()
  • public static PeerEventArgs Create(EndPoint peer)

DotNext.Net.Cluster

• public sealed delegate ClusterChangedEventHandler : MulticastDelegate
• public sealed delegate ClusterLeaderChangedEventHandler : MulticastDelegate
• public class ClusterMemberEventArgs : PeerEventArgs
  • public IClusterMember Member { get; }
  • public ClusterMemberEventArgs(IClusterMember member)
• public struct ClusterMemberId : IEquatable<ClusterMemberId>, IBinaryFormattable<ClusterMemberId>
  • public static int Size { get; }
  • public ClusterMemberId(ReadOnlySpan<byte> bytes)
  • public ClusterMemberId(Random random)
  • public ClusterMemberId(ref SpanReader reader)
  • public static ClusterMemberId FromEndPoint(EndPoint ep)
  • public static bool op_Equality(ref ClusterMemberId x, ref ClusterMemberId y)
  • public static bool op_Inequality(ref ClusterMemberId x, ref ClusterMemberId y)
  • public static bool TryParse(ReadOnlySpan<char> identifier, out ClusterMemberId value)
  • public static bool TryParse(string identifier, out ClusterMemberId value)
  • public bool Equals(ClusterMemberId other)
  • public void Format(ref SpanWriter writer)
• public sealed delegate ClusterMemberStatusChanged : MulticastDelegate
• public class ClusterMemberStatusChangedEventArgs : ClusterMemberEventArgs
  • public ClusterMemberStatus NewStatus { get; }
  • public ClusterMemberStatus PreviousStatus { get; }
  • public ClusterMemberStatusChangedEventArgs(IClusterMember member, ClusterMemberStatus previousStatus, ClusterMemberStatus newStatus)
• public class ClusterMemberStatusChangedEventArgs<TMember> : ClusterMemberStatusChangedEventArgs where TMember : IClusterMember
  • public TMember Member { get; }
  • public ClusterMemberStatusChangedEventArgs(TMember member, ClusterMemberStatus previousStatus, ClusterMemberStatus newStatus)
• public interface ICluster : IPeerMesh<IClusterMember>, IPeerMesh
  • IReadOnlyCollection<IClusterMember> Members { get; }
  • event ClusterLeaderChangedEventHandler LeaderChanged
  • event Action<ICluster, IClusterMember> LeaderChanged
• public interface IClusterMember : IPeer
  • IPEndPoint Endpoint { get; }
  • ClusterMemberId Id { get; }
  • event ClusterMemberStatusChanged MemberStatusChanged
  • ValueTask<IReadOnlyDictionary<string, string>> GetMetadata(bool refresh = false, CancellationToken token = default)
  • event Action<ClusterMemberStatusChangedEventArgs> MemberStatusChanged
  • void OnMemberStatusChanged<TMember>(TMember member, ref AtomicEnum status, ClusterMemberStatus newState, ref InvocationList memberStatusChanged) where TMember : IClusterMember
  • ValueTask<IReadOnlyDictionary<string, string>> GetMetadataAsync(bool refresh = false, CancellationToken token = default)
• public interface IExpandableCluster : ICluster

DotNext.Net.Cluster.Consensus.Raft

• public struct BufferedRaftLogEntry : IRaftLogEntry, ILogEntry, IDataTransferObject, IDisposable
  • public bool IsSnapshot { get; }
  • public long Length { get; }
  • public long Term { get; }
  • public DateTimeOffset Timestamp { get; }
  • public static ValueTask<BufferedRaftLogEntry> CopyAsync<TEntry>(TEntry entry, RaftLogEntryBufferingOptions options, CancellationToken token) where TEntry : IRaftLogEntry
  • public void Dispose()
• public struct BufferedRaftLogEntryList : IDisposable, IReadOnlyList<BufferedRaftLogEntry>, IEnumerable<BufferedRaftLogEntry>, IEnumerable, IReadOnlyCollection<BufferedRaftLogEntry>
  • public int Count { get; }
  • public BufferedRaftLogEntry& modreq(System.Runtime.InteropServices.InAttribute) this[int index] { get; }
  • public static Task<BufferedRaftLogEntryList> CopyAsync<TEntry>(ILogEntryProducer<TEntry> producer, RaftLogEntriesBufferingOptions options, CancellationToken token = default) where TEntry : IRaftLogEntry
  • public static Task<BufferedRaftLogEntryList> CopyAsync<TEntry, TList>(TList list, RaftLogEntriesBufferingOptions options, CancellationToken token = default) where TEntry : IRaftLogEntry where TList : IReadOnlyList<TEntry>
  • public void Dispose()
  • public ILogEntryProducer<BufferedRaftLogEntry> ToProducer()
• public sealed class ConsensusOnlyState : Disposable, IPersistentState, IAuditTrail<IRaftLogEntry>, IAuditTrail
  • public long LastCommittedEntryIndex { get; }
  • public long LastUncommittedEntryIndex { get; }
  • public ConsensusOnlyState()
  • public ValueTask<TResult> ReadAsync<TResult>(LogEntryConsumer<IRaftLogEntry, TResult> reader, long startIndex, long endIndex, CancellationToken token)
  • public ValueTask<TResult> ReadAsync<TResult>(LogEntryConsumer<IRaftLogEntry, TResult> reader, long startIndex, CancellationToken token)
• public abstract class DiskBasedStateMachine : PersistentState
  • protected struct SnapshotAccessToken : IEquatable<SnapshotAccessToken>
  • protected DiskBasedStateMachine(DirectoryInfo path, int recordsPerPartition, Options configuration = null)
  • protected DiskBasedStateMachine(string path, int recordsPerPartition, Options configuration = null)
  • protected abstract ValueTask<long?> ApplyAsync(LogEntry entry)
  • protected abstract ValueTask<IAsyncBinaryReader> BeginReadSnapshotAsync(SnapshotAccessToken session, MemoryAllocator<byte> allocator, CancellationToken token)
  • protected abstract void EndReadSnapshot(SnapshotAccessToken session)
  • protected abstract ValueTask<long> InstallSnapshotAsync<TSnapshot>(TSnapshot snapshot) where TSnapshot : IRaftLogEntry
• public struct ElectionTimeout
  • public ElectionTimeout(int lowerValue, int upperValue)
  • public ElectionTimeout Modify(int lowerValue, int upperValue)
  • public int RandomTimeout()
  • public void Deconstruct(out int lowerValue, out int upperValue)
  • public int RandomTimeout(Random random)
• public struct EmptyLogEntry : IRaftLogEntry, ILogEntry, IDataTransferObject
  • public long Term { get; }
  • public DateTimeOffset Timestamp { get; }
  • public EmptyLogEntry(long term)
• public interface IClusterMemberConfiguration
  • double ClockDriftBound { get; }
  • bool Standby { get; }
• public class InMemoryAuditTrail : Disposable, IPersistentState, IAuditTrail<IRaftLogEntry>, IAuditTrail
• public interface ILeaderLease
  • bool IsExpired { get; }
• public interface IPersistentState : IAuditTrail<IRaftLogEntry>, IAuditTrail
  • ValueTask EnsureConsistencyAsync(CancellationToken token = default)
  • bool IsVotedFor(IRaftClusterMember member)
  • ValueTask UpdateTermAsync(long term)
  • ValueTask UpdateVotedForAsync(IRaftClusterMember member)
  • bool IsVotedFor(Nullable id)
  • ValueTask UpdateTermAsync(long term, bool resetLastVote)
  • ValueTask UpdateVotedForAsync(ClusterMemberId? member)
• public interface IRaftCluster : IReplicationCluster<IRaftLogEntry>, IReplicationCluster, ICluster, IPeerMesh<IClusterMember>, IPeerMesh, IPeerMesh<IRaftClusterMember>
  • CancellationToken LeadershipToken { get; }
  • ILeaderLease Lease { get; }
  • IReadOnlyCollection<IRaftClusterMember> Members { get; }
  • Task Readiness { get; }
  • ValueTask ApplyReadBarrierAsync(CancellationToken token = default)
• public interface IRaftClusterMember : IClusterMember, IPeer
  • ref long ConfigurationFingerprint { get; }
  • Task<Result<bool>> AppendEntriesAsync<TEntry, TList>(long term, TList entries, long prevLogIndex, long prevLogTerm, long commitIndex, CancellationToken token) where TEntry : IRaftLogEntry where TList : IReadOnlyList<TEntry>
  • void CancelPendingRequests()
  • Task<Result<bool>> AppendEntriesAsync<TEntry, TList>(long term, TList entries, long prevLogIndex, long prevLogTerm, long commitIndex, IClusterConfiguration config, bool applyConfig, CancellationToken token) where TEntry : IRaftLogEntry where TList : IReadOnlyList<TEntry>
  • ValueTask CancelPendingRequestsAsync()
  • Task<Result<bool>> PreVoteAsync(long term, long lastLogIndex, long lastLogTerm, CancellationToken token)
  • Task<long?> SynchronizeAsync(CancellationToken token)
• public interface IRaftLogEntry : ILogEntry, IDataTransferObject
  • int? CommandId { get; }
• public struct JsonLogEntry<T> : IRaftLogEntry, ILogEntry, IDataTransferObject
  • public T Content { get; }
  • public long Term { get; }
  • public DateTimeOffset Timestamp { get; }
• public abstract class MemoryBasedStateMachine : PersistentState
  • public enum CompactionMode
  • protected abstract class IncrementalSnapshotBuilder : SnapshotBuilder, IRaftLogEntry, ILogEntry, IDataTransferObject
  • protected abstract class InlineSnapshotBuilder : SnapshotBuilder
  • public enum LogEntryCacheEvictionPolicy
  • public class Options : Options
  • protected abstract class SnapshotBuilder : Disposable
  • protected struct SnapshotBuilderContext
  • public long CompactionCount { get; }
  • public bool IsBackgroundCompaction { get; }
  • protected MemoryBasedStateMachine(DirectoryInfo path, int recordsPerPartition, Options configuration = null)
  • protected MemoryBasedStateMachine(string path, int recordsPerPartition, Options configuration = null)
  • protected abstract ValueTask ApplyAsync(LogEntry entry)
  • protected abstract SnapshotBuilder CreateSnapshotBuilder(SnapshotBuilderContext& modreq(System.Runtime.InteropServices.InAttribute) context)
  • public ValueTask ForceCompactionAsync(long count, CancellationToken token)
  • public Task ReplayAsync(CancellationToken token = default)
• public abstract class PersistentState : Disposable, IPersistentState, IAuditTrail<IRaftLogEntry>, IAuditTrail
  • protected struct LogEntry : IRaftLogEntry, ILogEntry, IDataTransferObject
  • public sealed class MissingPartitionException : IntegrityException
  • protected abstract class SnapshotBuilder : Disposable, IRaftLogEntry, ILogEntry, IDataTransferObject
  • protected byte[] Buffer { get; }
  • protected AsyncLock SyncRoot { get; }
  • public PersistentState(DirectoryInfo path, int recordsPerPartition, Options configuration = null)
  • public PersistentState(string path, int recordsPerPartition, Options configuration = null)
  • public ValueTask AppendAsync<TEntry>(TEntry entry, long startIndex) where TEntry : IRaftLogEntry
  • public ValueTask<long> AppendAsync<TEntry>(ILogEntryProducer<TEntry> entries, CancellationToken token = default) where TEntry : IRaftLogEntry
  • protected virtual ValueTask ApplyAsync(LogEntry entry)
  • public long LastCommittedEntryIndex { get; }
  • public long LastUncommittedEntryIndex { get; }
  • protected DirectoryInfo Location { get; }
  • public long Term { get; }
  • public static Task RestoreFromBackupAsync(Stream backup, DirectoryInfo destination, CancellationToken token = default)
  • public ValueTask AppendAsync<TEntry>(TEntry entry, long startIndex, CancellationToken token = default) where TEntry : IRaftLogEntry
  • public ValueTask<long> AppendAsync<TEntry>(TEntry entry, CancellationToken token = default) where TEntry : IRaftLogEntry
  • public ValueTask<long> AppendAsync<TEntry>(TEntry entry, bool addToCache, CancellationToken token = default) where TEntry : IRaftLogEntry
  • public ValueTask<long> AppendAsync<TEntry>(ILogEntryProducer<TEntry> entries, CancellationToken token = default) where TEntry : IRaftLogEntry
  • protected virtual SnapshotBuilder CreateSnapshotBuilder()
  • public ValueTask<long> DropAsync(long startIndex, CancellationToken token)
  • public Task EnsureConsistencyAsync(CancellationToken token)
  • protected virtual ValueTask FlushAsync()
  • public long GetLastIndex(bool committed)
  • public ValueTask<TResult> ReadAsync<TReader, TResult>(TReader reader, long startIndex, long endIndex, CancellationToken token) where TReader : ILogEntryConsumer<IRaftLogEntry, TResult>
  • public ValueTask<TResult> ReadAsync<TReader, TResult>(TReader reader, long startIndex, CancellationToken token) where TReader : ILogEntryConsumer<IRaftLogEntry, TResult>
  • public Task WaitForCommitAsync(long index, TimeSpan timeout, CancellationToken token)
  • public Task CreateBackupAsync(Stream output, CancellationToken token = default)
  • public JsonLogEntry<T> CreateJsonLogEntry<T>(T content, string typeId = null, JsonSerializerOptions options = null)
  • public void DbgChangeLastIndex(long index)
  • public ValueTask<long> DropAsync(long startIndex, bool reuseSpace = false, CancellationToken token = default)
  • public ValueTask EnsureConsistencyAsync(CancellationToken token)
  • public abstract Task InitializeAsync(CancellationToken token = default)
  • public ValueTask<TResult> ReadAsync<TResult>(LogEntryConsumer<IRaftLogEntry, TResult> reader, long startIndex, long endIndex, CancellationToken token = default)
  • public ValueTask<TResult> ReadAsync<TResult>(LogEntryConsumer<IRaftLogEntry, TResult> reader, long startIndex, CancellationToken token = default)
  • public ValueTask WaitForCommitAsync(CancellationToken token = default)
  • public ValueTask WaitForCommitAsync(long index, CancellationToken token = default)
• public class RaftCluster : RaftCluster<RaftClusterMember>, ILocalMember
  • public abstract class NodeConfiguration : IClusterMemberConfiguration
  • public sealed class TcpConfiguration : NodeConfiguration
  • public sealed class UdpConfiguration : NodeConfiguration
  • protected IClusterConfigurationStorage<IPEndPoint> ConfigurationStorage { get; }
  • public IPEndPoint LocalMemberAddress { get; }
  • public RaftCluster(NodeConfiguration configuration)
  • public Task<bool> AddMemberAsync(ClusterMemberId id, IPEndPoint address, CancellationToken token = default)
  • public Task<bool> RemoveMemberAsync(IPEndPoint address, CancellationToken token = default)
• public abstract class RaftCluster<TMember> : Disposable, IRaftCluster, IReplicationCluster<IRaftLogEntry>, IReplicationCluster, ICluster, IPeerMesh<IClusterMember>, IPeerMesh, IPeerMesh<IRaftClusterMember>, IRaftStateMachine, IAsyncDisposable where TMember : IRaftClusterMember, IDisposable
  • protected sealed delegate MemberCollectionMutator<TMember> : MulticastDelegate where TMember : IRaftClusterMember, IDisposable
  • protected struct MemberHolder<TMember> where TMember : IRaftClusterMember, IDisposable
  • protected struct MutableMemberCollection<TMember> where TMember : IRaftClusterMember, IDisposable
  • protected abstract IClusterConfigurationStorage ConfigurationStorage { get; }
  • public TimeSpan ElectionTimeout { get; }
  • public CancellationToken LeadershipToken { get; }
  • public ILeaderLease Lease { get; }
  • protected CancellationToken LifecycleToken { get; }
  • public ClusterMemberId& modreq(System.Runtime.InteropServices.InAttribute) LocalMemberId { get; }
  • public Task Readiness { get; }
  • protected CancellationToken Token { get; }
  • public event ClusterLeaderChangedEventHandler LeaderChanged
  • protected RaftCluster(IClusterMemberConfiguration config, out MutableMemberCollection members)
  • protected Task ChangeMembersAsync(MemberCollectionMutator<TMember> mutator)
  • protected TMember FindMember(Predicate<TMember> matcher)
  • protected Task<Result<bool>> ReceiveEntries<TEntry>(TMember sender, long senderTerm, ILogEntryProducer<TEntry> entries, long prevLogIndex, long prevLogTerm, long commitIndex) where TEntry : IRaftLogEntry
  • protected Task<bool> ReceiveResign()
  • protected Task<Result<bool>> ReceiveSnapshot(TMember sender, long senderTerm, IRaftLogEntry snapshot, long snapshotIndex)
  • protected Task<Result<bool>> ReceiveVote(TMember sender, long senderTerm, long lastLogIndex, long lastLogTerm)
  • public event Action<RaftCluster<TMember>, TMember> LeaderChanged
  • public event Action<RaftCluster<TMember>, RaftClusterMemberEventArgs<TMember>> MemberAdded
  • public event Action<RaftCluster<TMember>, RaftClusterMemberEventArgs<TMember>> MemberRemoved
  • public event Action<RaftCluster<TMember>, TMember> ReplicationCompleted
  • protected RaftCluster(IClusterMemberConfiguration config)
  • protected ValueTask<bool> AddMemberAsync(TMember member, CancellationToken token)
  • protected Task<bool> AddMemberAsync<TAddress>(TMember member, int rounds, IClusterConfigurationStorage<TAddress> configurationStorage, Func<TMember, TAddress> addressProvider, CancellationToken token = default)
  • protected Task<Result<bool>> AppendEntriesAsync<TEntry>(ClusterMemberId sender, long senderTerm, ILogEntryProducer<TEntry> entries, long prevLogIndex, long prevLogTerm, long commitIndex, IClusterConfiguration config, bool applyConfig, CancellationToken token) where TEntry : IRaftLogEntry
  • public ValueTask ApplyReadBarrierAsync(CancellationToken token = default)
  • public ValueTask DisposeAsync()
  • public Task ForceReplicationAsync(CancellationToken token = default)
  • protected Task<Result<bool>> InstallSnapshotAsync<TSnapshot>(ClusterMemberId sender, long senderTerm, TSnapshot snapshot, long snapshotIndex, CancellationToken token) where TSnapshot : IRaftLogEntry
  • protected Task<Result<bool>> PreVoteAsync(long nextTerm, long lastLogIndex, long lastLogTerm, CancellationToken token)
  • protected ValueTask<TMember> RemoveMemberAsync(ClusterMemberId id, CancellationToken token)
  • public Task<bool> RemoveMemberAsync<TAddress>(ClusterMemberId id, IClusterConfigurationStorage<TAddress> configurationStorage, CancellationToken token = default)
  • public Task<bool> ReplicateAsync<TEntry>(TEntry entry, CancellationToken token) where TEntry : IRaftLogEntry
  • protected Task<bool> ResignAsync(CancellationToken token)
  • public Task WriteAsync<TEntry>(ILogEntryProducer<TEntry> entries, WriteConcern concern, TimeSpan timeout) where TEntry : IRaftLogEntry
  • protected Task<long?> SynchronizeAsync(CancellationToken token)
  • protected TMember TryGetMember(ClusterMemberId id)
  • public ValueTask TurnIntoRegularNodeAsync(CancellationToken token)
  • protected Task<Result<bool>> VoteAsync(ClusterMemberId sender, long senderTerm, long lastLogIndex, long lastLogTerm, CancellationToken token)
• public abstract class RaftClusterMember : Disposable, IRaftClusterMember, IClusterMember, IPeer
  • public IPEndPoint EndPoint { get; }
  • public bool IsLeader { get; }
  • public bool IsRemote { get; }
  • public ClusterMemberStatus Status { get; }
  • public event Action<ClusterMemberStatusChangedEventArgs<RaftClusterMember>> MemberStatusChanged
  • public abstract ValueTask CancelPendingRequestsAsync()
• public class RaftClusterMemberEventArgs<TMember> : ClusterMemberEventArgs where TMember : IRaftClusterMember
  • public TMember Member { get; }
  • public RaftClusterMemberEventArgs(TMember member)
• public class RaftLogEntriesBufferingOptions : RaftLogEntryBufferingOptions
  • public int MemoryLimit { get; set; }
  • public RaftLogEntriesBufferingOptions()
• public class RaftLogEntryBufferingOptions
  • public int BufferSize { get; set; }
  • public MemoryAllocator<byte> MemoryAllocator { get; set; }
  • public int MemoryThreshold { get; set; }
  • public string TempPath { get; set; }
  • public RaftLogEntryBufferingOptions()
• public struct Result<T>
  • public readonly long Term
  • public readonly T Value
  • public long Term { get; }
  • public T Value { get; set; }

DotNext.Net.Cluster.Consensus.Raft.Commands

• public abstract class CommandAttribute : Attribute
  • public int Id { get; }
  • protected CommandAttribute(int id)
• public sealed class CommandAttribute<TCommand> : CommandAttribute where TCommand : ISerializable<TCommand>
  • public CommandAttribute(int id)
• public class CommandInterpreter : Disposable
  • public sealed class Builder : ISupplier<CommandInterpreter>
  • protected sealed class CommandHandlerAttribute : Attribute
  • public sealed class UnknownCommandException : IntegrityException
  • protected CommandInterpreter()
  • public LogEntry<TCommand> CreateLogEntry<TCommand>(TCommand command, long term) where TCommand : ISerializable<TCommand>
  • public ValueTask<int> InterpretAsync<TEntry>(TEntry entry, CancellationToken token = default) where TEntry : struct, IRaftLogEntry
• public struct LogEntry<TCommand> : IRaftLogEntry, ILogEntry, IDataTransferObject where TCommand : ISerializable<TCommand>
  • public TCommand Command { get; }
  • public int CommandId { get; }
  • public long Term { get; }
  • public DateTimeOffset Timestamp { get; }

DotNext.Net.Cluster.Consensus.Raft.Membership

• public struct ClusterConfigurationEvent<TAddress>
  • public TAddress Address { get; set; }
  • public ClusterMemberId Id { get; set; }
  • public bool IsAdded { get; set; }
• public abstract class ClusterConfigurationStorage<TAddress> : Disposable, IClusterConfigurationStorage<TAddress>, IClusterConfigurationStorage, IDisposable
  • protected readonly MemoryAllocator<byte> allocator
  • public abstract IClusterConfiguration ActiveConfiguration { get; }
  • public abstract bool HasProposal { get; }
  • public abstract IClusterConfiguration ProposedConfiguration { get; }
  • public abstract ValueTask<bool> AddMemberAsync(ClusterMemberId id, TAddress address, CancellationToken token = default)
  • public abstract ValueTask ApplyAsync(CancellationToken token = default)
  • protected abstract TAddress Decode(ref SequenceReader reader)
  • protected abstract void Encode(TAddress address, ref BufferWriterSlim output)
  • public virtual ValueTask LoadConfigurationAsync(CancellationToken token = default)
  • public abstract ValueTask ProposeAsync(IClusterConfiguration configuration, CancellationToken token = default)
  • public abstract ValueTask<bool> RemoveMemberAsync(ClusterMemberId id, CancellationToken token = default)
• public sealed delegate ClusterMemberAnnouncer<TAddress> : MulticastDelegate
  • public ClusterMemberAnnouncer(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ClusterMemberId id, TAddress address, CancellationToken token, AsyncCallback callback, object object)
  • public virtual Task EndInvoke(IAsyncResult result)
  • public virtual Task Invoke(ClusterMemberId id, TAddress address, CancellationToken token)
• public interface IClusterConfiguration : IDataTransferObject
  • long Fingerprint { get; }
  • long Length { get; }
  • IClusterConfiguration CreateEmpty(long fingerprint)
• public interface IClusterConfigurationStorage : IDisposable
  • IClusterConfiguration ActiveConfiguration { get; }
  • IClusterConfiguration ProposedConfiguration { get; }
  • ValueTask ApplyAsync(CancellationToken token = default)
  • ValueTask LoadConfigurationAsync(CancellationToken token)
  • ValueTask ProposeAsync(IClusterConfiguration configuration, CancellationToken token = default)
  • Task WaitForApplyAsync(CancellationToken token = default)
• public interface IClusterConfigurationStorage<TAddress> : IClusterConfigurationStorage, IDisposable
  • IReadOnlyDictionary<ClusterMemberId, TAddress> ActiveConfiguration { get; }
  • IReadOnlyDictionary<ClusterMemberId, TAddress> ProposedConfiguration { get; }
  • ValueTask<bool> AddMemberAsync(ClusterMemberId id, TAddress address, CancellationToken token = default)
  • IAsyncEnumerable<ClusterConfigurationEvent<TAddress>> PollChangesAsync(CancellationToken token = default)
  • ValueTask<bool> RemoveMemberAsync(ClusterMemberId id, CancellationToken token = default)
• public abstract class InMemoryClusterConfigurationStorage<TAddress> : ClusterConfigurationStorage<TAddress>
  • public sealed class ConfigurationBuilder<TAddress> : Dictionary<ClusterMemberId, TAddress>
  • protected InMemoryClusterConfigurationStorage(MemoryAllocator<byte> allocator = null)
  • public bool AddMember(ClusterMemberId id, TAddress address)
  • public ConfigurationBuilder<TAddress> CreateActiveConfigurationBuilder()
  • public bool RemoveMember(ClusterMemberId id)
• public abstract class PersistentClusterConfigurationStorage<TAddress> : ClusterConfigurationStorage<TAddress>, IAsyncDisposable
  • protected PersistentClusterConfigurationStorage(string path, int fileBufferSize = 512, MemoryAllocator<byte> allocator = null)
  • public ValueTask DisposeAsync()

DotNext.Net.Cluster.Consensus.Raft.Metrics

• public interface IClientMetricsCollector
  • void ReportResponseTime(TimeSpan value)

DotNext.Net.Cluster.Discovery

• public abstract class DiscoveryProtocolException : ProtocolViolationException
  • protected DiscoveryProtocolException(string message)
  • protected DiscoveryProtocolException(SerializationInfo info, StreamingContext context)

DotNext.Net.Cluster.Discovery.HyParView

• public class HyParViewProtocolException : DiscoveryProtocolException
  • public HyParViewProtocolException(string message)
  • protected HyParViewProtocolException(SerializationInfo info, StreamingContext context)
• public interface IPeerConfiguration
  • int ActiveRandomWalkLength { get; }
  • int ActiveViewCapacity { get; }
  • int PassiveRandomWalkLength { get; }
  • int PassiveViewCapacity { get; }
  • int QueueCapacity { get; }
  • int ShuffleActiveViewCount { get; }
  • int ShufflePassiveViewCount { get; }
  • TimeSpan? ShufflePeriod { get; }
  • int ShuffleRandomWalkLength { get; }
• public abstract class PeerController : Disposable, IPeerMesh, IAsyncDisposable
  • protected CancellationToken LifecycleToken { get; }
  • protected virtual ILogger Logger { get; }
  • public IReadOnlySet<EndPoint> Neighbors { get; }
  • public event Action<PeerController, PeerEventArgs> PeerDiscovered
  • public event Action<PeerController, PeerEventArgs> PeerGone
  • protected PeerController(IPeerConfiguration configuration, IEqualityComparer<EndPoint> peerComparer = null)
  • protected virtual void Destroy(EndPoint peer)
  • protected virtual ValueTask DestroyAsync(EndPoint peer)
  • protected abstract Task DisconnectAsync(EndPoint peer, bool isAlive, CancellationToken token)
  • protected virtual ValueTask DisconnectAsync(EndPoint peer)
  • public ValueTask DisposeAsync()
  • public ValueTask EnqueueBroadcastAsync(Func<PeerController, IRumorSender> senderFactory, CancellationToken token = default)
  • protected ValueTask EnqueueDisconnectAsync(EndPoint sender, bool isAlive, CancellationToken token = default)
  • protected ValueTask EnqueueForwardJoinAsync(EndPoint sender, EndPoint joinedPeer, int timeToLive, CancellationToken token = default)
  • protected ValueTask EnqueueJoinAsync(EndPoint joinedPeer, CancellationToken token = default)
  • protected ValueTask EnqueueNeighborAsync(EndPoint sender, bool highPriority, CancellationToken token = default)
  • public ValueTask EnqueueShuffleAsync(CancellationToken token = default)
  • protected ValueTask EnqueueShuffleAsync(EndPoint sender, EndPoint origin, IReadOnlyCollection<EndPoint> peers, int timeToLive, CancellationToken token = default)
  • protected ValueTask EnqueueShuffleReplyAsync(IReadOnlyCollection<EndPoint> peers, CancellationToken token = default)
  • protected abstract Task ForwardJoinAsync(EndPoint receiver, EndPoint joinedPeer, int timeToLive, CancellationToken token)
  • protected abstract bool IsLocalNode(EndPoint peer)
  • protected abstract Task JoinAsync(EndPoint contactNode, CancellationToken token)
  • protected abstract Task NeighborAsync(EndPoint neighbor, bool highPriority, CancellationToken token)
  • protected virtual void OnError(EndPoint peer, Exception e)
  • public ValueTask ReportFailedPeerAsync(EndPoint failedPeer, CancellationToken token)
  • protected abstract Task ShuffleAsync(EndPoint receiver, EndPoint origin, IReadOnlyCollection<EndPoint> peers, int timeToLive, CancellationToken token = default)
  • protected abstract Task ShuffleReplyAsync(EndPoint receiver, IReadOnlyCollection<EndPoint> peers, CancellationToken token = default)
  • public Task StartAsync(EndPoint contactNode, CancellationToken token)
  • public virtual Task StopAsync(CancellationToken token)

DotNext.Net.Cluster.Messaging

• public class BinaryMessage<T> : BinaryTransferObject<T>, IMessage, IDataTransferObject where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static readonly MessageReader<T> Reader
  • public string Name { get; }
  • public ContentType Type { get; }
  • public BinaryMessage(string name, ContentType type)
• public interface IInputChannel
  • bool IsSupported(string messageName, bool oneWay)
  • Task<IMessage> ReceiveMessage(ISubscriber sender, IMessage message, object context, CancellationToken token)
  • Task ReceiveSignal(ISubscriber sender, IMessage signal, object context, CancellationToken token)
• public interface IMessageBus : ICluster, IPeerMesh<IClusterMember>, IPeerMesh, IPeerMesh<ISubscriber>
  • IOutputChannel LeaderRouter { get; }
  • Task<TResponse> SendMessageToLeaderAsync<TResponse>(IMessage message, MessageReader<TResponse> responseReader, CancellationToken token = default)
  • Task SendSignalToLeaderAsync(IMessage message, CancellationToken token = default)
  • void AddListener(IInputChannel handler)
  • void RemoveListener(IInputChannel handler)
• public interface IOutputChannel
  • Task<TResponse> SendMessageAsync<TResponse>(IMessage message, MessageReader<TResponse> responseReader, CancellationToken token = default)
  • Task SendSignalAsync(IMessage message, CancellationToken token = default)
• public interface ISubscriber : IClusterMember, IPeer, IOutputChannel
  • Task<TResponse> SendMessageAsync<TResponse>(IMessage message, MessageReader<TResponse> responseReader, CancellationToken token = default)
• public sealed class JsonMessage<T> : IMessage, IDataTransferObject
  • public T Content { get; }
  • public string Name { get; }
  • public JsonSerializerOptions Options { get; set; }
  • public JsonMessage(string name, T content)
  • public static ValueTask<T> FromJsonAsync(IDataTransferObject message, JsonSerializerOptions options = null, MemoryAllocator<byte> allocator = null, CancellationToken token = default)
  • public static ValueTask<T> FromJsonAsync(IDataTransferObject message, CancellationToken token = default)
• public abstract class MessageAttribute : Attribute
  • public string MimeType { get; set; }
  • public string Name { get; }
  • protected MessageAttribute(string name)
• public sealed class MessageAttribute<TMessage> : MessageAttribute where TMessage : ISerializable<TMessage>
  • public MessageAttribute(string name)
• public class MessageHandler : IInputChannel
  • public sealed class Builder : ISupplier<MessageHandler>
  • protected MessageHandler()
• public sealed delegate MessageReader<T> : MulticastDelegate
  • public virtual Task<T> EndInvoke(IAsyncResult result)
  • public virtual Task<T> Invoke(IMessage message, CancellationToken token)
  • public virtual ValueTask<T> EndInvoke(IAsyncResult result)
  • public virtual ValueTask<T> Invoke(IMessage message, CancellationToken token)
• public class MessagingClient
  • public MessagingClient(IOutputChannel channel)
  • protected virtual ValueTuple<string, ContentType> GetMessageInfo<TMessage>() where TMessage : ISerializable<TMessage>
  • public MessagingClient RegisterMessage<TMessage>(string name, ContentType type = null) where TMessage : ISerializable<TMessage>
  • public MessagingClient RegisterMessage<TMessage>(MessageAttribute<TMessage> messageInfo) where TMessage : ISerializable<TMessage>
  • public Task<TOutput> SendMessageAsync<TInput, TOutput>(TInput input, CancellationToken token = default) where TInput : ISerializable<TInput> where TOutput : ISerializable<TOutput>
  • public Task SendSignalAsync<TInput>(TInput input, CancellationToken token = default) where TInput : ISerializable<TInput>
• public static class Messenger
  • public static Task<TResponse> SendJsonMessageAsync<TRequest, TResponse>(this ISubscriber messenger, MessageReader<TResponse> responseReader, string messageName, TRequest request, CancellationToken token)
  • public static Task SendJsonSignalAsync<TSignal>(this ISubscriber messenger, string messageName, TSignal signal, bool requiresConfirmation = true, CancellationToken token = default)
• public class StreamMessage : StreamTransferObject, IDisposableMessage, IMessage, IDataTransferObject, IDisposable, IAsyncDisposable
  • public static Task<StreamMessage> CreateBufferedMessageAsync(IMessage message, CancellationToken token = default)

DotNext.Net.Cluster.Messaging.Gossip

• public interface IRumorSender : IAsyncDisposable
  • Task SendAsync(EndPoint peer, CancellationToken token)

DotNext.Net.Cluster.Replication

• public interface IAuditTrail
• public interface IAuditTrail<TEntry> : IAuditTrail where TEntry : ILogEntry
• public interface ILogEntry : IDataTransferObject
• public interface ILogEntryConsumer<TEntry, TResult> where TEntry : ILogEntry
• public interface ILogEntryProducer<TEntry> where TEntry : ILogEntry
• public interface IReplicationCluster : ICluster, IPeerMesh<IClusterMember>, IPeerMesh
  • IAuditTrail AuditTrail { get; }
  • IAuditTrail AuditTrail { get; }
  • event Action<IReplicationCluster, IClusterMember> ReplicationCompleted
  • Task ForceReplicationAsync(CancellationToken token = default)
• public interface IReplicationCluster<TEntry> : IReplicationCluster, ICluster, IPeerMesh<IClusterMember>, IPeerMesh where TEntry : ILogEntry
  • IAuditTrail<TEntry> AuditTrail { get; }
  • Task WriteAsync<TEntryImpl>(ILogEntryProducer<TEntryImpl> entries, WriteConcern concern, TimeSpan timeout) where TEntryImpl : TEntry
  • IAuditTrail<TEntry> AuditTrail { get; }
  • Task<bool> ReplicateAsync<TEntryImpl>(TEntryImpl entry, CancellationToken token = default) where TEntryImpl : TEntry
• public sealed class LogEntryProducer<TEntry> : ILogEntryProducer<TEntry> where TEntry : ILogEntry
• public enum WriteConcern

DotNext.Net.ConsistentHash

• public static class JumpHash
  • public static int GetBucket(ulong key, int buckets)
  • public static int GetBucket(long key, int buckets)

DotNext.Net.Security

• public class SslOptions
  • public SslClientAuthenticationOptions ClientOptions { get; }
  • public SslServerAuthenticationOptions ServerOptions { get; }
  • public SslOptions(SslServerAuthenticationOptions serverOptions, SslClientAuthenticationOptions clientOptions)
  • public SslOptions()