private JournalEntry ToJournalEntry(IPersistentRepresentation message)
{
object payload = message.Payload;
if (message.Payload is Tagged tagged)
{
payload = tagged.Payload;
message = message.WithPayload(payload); // need to update the internal payload when working with tags
}
var serializer = _serialization.FindSerializerFor(message);
var binary = serializer.ToBinary(message);
return(new JournalEntry
{
Id = message.PersistenceId + "_" + message.SequenceNr,
Ordering = new BsonTimestamp(0), // Auto-populates with timestamp
IsDeleted = message.IsDeleted,
Payload = binary,
PersistenceId = message.PersistenceId,
SequenceNr = message.SequenceNr,
Manifest = string.Empty, // don't need a manifest here - it's embedded inside the PersistentMessage
Tags = tagged.Tags?.ToList(),
SerializerId = null // don't need a serializer ID here either; only for backwards-comat
});
}
private static Guid GetEventIdFromPayload(Type payloadType, IPersistentRepresentation x)
{
var eventIdProperty = payloadType.GetProperty("EventId");
var eventId = (eventIdProperty != null) ? (Guid)eventIdProperty.GetValue(x.Payload) : Guid.NewGuid();
return(eventId);
}
private void OnReplayFailureCompleted(Receive receive, Exception cause, IPersistentRepresentation failed)
{
ChangeState(Idle());
var recoveryFailure = failed != null ? new RecoveryFailure(cause, failed.SequenceNr, failed.Payload) : new RecoveryFailure(cause);
base.AroundReceive(receive, recoveryFailure);
}
private void UpdateLastSequenceNr(IPersistentRepresentation persistent)
{
if (persistent.SequenceNr > LastSequenceNr)
{
LastSequenceNr = persistent.SequenceNr;
}
}
private static JournalRepresentation ToJournalEntry(IPersistentRepresentation message)
{
var jornalEntry = new JournalRepresentation
{
//Id = message.PersistenceId + "_" + message.SequenceNr,
//IsDeleted = message.IsDeleted,
Payload = message.Payload,
PersistenceId = message.PersistenceId,
SequenceNr = message.SequenceNr,
Manifest = message.Manifest,
Tags = null
};
if (message.Payload is Tagged)
{
var tagged = (Tagged)message.Payload;
//message.WithPayload(tagged.Payload);
jornalEntry.Payload = tagged.Payload;
if (tagged.Tags.Count != 0)
{
jornalEntry.Tags = tagged.Tags.ToArray();
}
}
return(jornalEntry);
}
internal JournalEntry(IPersistentRepresentation message, Akka.Serialization.Serialization serialization)
{
Id = $"{DocumentType}-{message.PersistenceId}-{message.SequenceNr}";
IsDeleted = message.IsDeleted;
Payload = message.Payload;
PersistenceId = message.PersistenceId;
SequenceNr = message.SequenceNr;
Manifest = message.Manifest;
if (string.IsNullOrWhiteSpace(message.Manifest))
{
Manifest = message.Payload.GetType().AssemblyQualifiedName;
}
Serializer serializer = serialization.FindSerializerFor(Payload);
if (serializer != null)
{
SerializerId = serializer.Identifier;
if (serializer is SerializerWithStringManifest)
{
Manifest = ((SerializerWithStringManifest)serializer).Manifest(message.Payload);
}
if (SerializerId.HasValue && SerializerId.Value == 1)
{
Payload = message.Payload;
}
else
{
Payload = Convert.ToBase64String(serializer.ToBinary(message.Payload));
}
}
}
protected IPersistentRepresentation MapEntityToPersistentRepresentation(Entity entity)
{
var bytes = entity[JournalFields.Payload].BlobValue.ToByteArray();
IPersistentRepresentation pr = Deserialize(bytes);
return(pr);
}
/// <summary>
/// INTERNAL API
/// </summary>
protected IEnumerable <IPersistentRepresentation> AdaptFromJournal(IPersistentRepresentation representation)
{
return(_eventAdapters.Get(representation.Payload.GetType())
.FromJournal(representation.Payload, representation.Manifest)
.Events
.Select(representation.WithPayload));
}
protected override void WriteEvent(OracleCommand command, IPersistentRepresentation persistent, string tags = "")
{
var payloadType = persistent.Payload.GetType();
var serializer = serialization.FindSerializerForType(payloadType, Setup.DefaultSerializer);
var manifest = " "; // HACK
if (serializer is SerializerWithStringManifest stringManifest)
{
manifest = stringManifest.Manifest(persistent.Payload);
}
else
{
if (serializer.IncludeManifest)
{
manifest = payloadType.TypeQualifiedName();
}
}
var binary = serializer.ToBinary(persistent.Payload);
AddParameter(command, ":PersistenceId", OracleDbType.NVarchar2, persistent.PersistenceId);
AddParameter(command, ":SequenceNr", OracleDbType.Int64, persistent.SequenceNr);
AddParameter(command, ":Timestamp", OracleDbType.Int64, DateTime.UtcNow.Ticks);
AddParameter(command, ":IsDeleted", OracleDbType.Int16, persistent.IsDeleted);
AddParameter(command, ":Manifest", OracleDbType.NVarchar2, manifest);
AddParameter(command, ":Payload", OracleDbType.Blob, binary);
AddParameter(command, ":Tag", OracleDbType.NVarchar2, tags);
AddParameter(command, ":SerializerId", OracleDbType.Int32, serializer.Identifier);
}
public Messages Add(IPersistentRepresentation persistent)
{
var list = _messages.GetOrAdd(persistent.PersistenceId, new LinkedList <IPersistentRepresentation>());
list.AddLast(persistent);
return(_messages);
}
private PersistentMessage GetPersistentMessage(IPersistentRepresentation persistent)
{
PersistentMessage message = new PersistentMessage();
if (persistent.PersistenceId != null)
{
message.PersistenceId = persistent.PersistenceId;
}
if (persistent.Manifest != null)
{
message.Manifest = persistent.Manifest;
}
if (persistent.WriterGuid != null)
{
message.WriterGuid = persistent.WriterGuid;
}
if (persistent.Sender != null)
{
message.Sender = Akka.Serialization.Serialization.SerializedActorPath(persistent.Sender);
}
message.Payload = GetPersistentPayload(persistent.Payload);
message.SequenceNr = persistent.SequenceNr;
message.Deleted = persistent.IsDeleted;
return(message);
}
private byte[] PersistenceMessageSerializer(IPersistentRepresentation obj)
{
var serializer = system.Serialization.FindSerializerFor(obj.Payload);
// get manifest
var manifestSerializer = serializer as SerializerWithStringManifest;
var payloadManifest = "";
if (manifestSerializer != null)
{
var manifest = manifestSerializer.Manifest(obj.Payload);
if (!string.IsNullOrEmpty(manifest))
{
payloadManifest = manifest;
}
}
else
{
if (serializer.IncludeManifest)
{
payloadManifest = obj.Payload.GetType().TypeQualifiedName();
}
}
var persistenceMessage = new PersistenceMessage(
obj.PersistenceId,
obj.SequenceNr,
obj.WriterGuid,
serializer.Identifier,
payloadManifest,
serializer.ToBinary(obj.Payload));
return(MessagePackSerializer.Serialize(persistenceMessage));
}
protected override void WriteEvent(DbCommand command, IPersistentRepresentation e, IImmutableSet <string> tags)
{
var manifest = string.IsNullOrEmpty(e.Manifest) ? QualifiedName(e) : e.Manifest;
var t = _serialize(e);
AddParameter(command, "@PersistenceId", DbType.String, e.PersistenceId);
AddParameter(command, "@SequenceNr", DbType.Int64, e.SequenceNr);
AddParameter(command, "@Timestamp", DbType.Int64, TimestampProvider.GenerateTimestamp(e));
AddParameter(command, "@IsDeleted", DbType.Boolean, false);
AddParameter(command, "@Manifest", DbType.String, manifest);
command.Parameters.Add(new NpgsqlParameter("@Payload", t.Key)
{
Value = t.Value
});
if (tags.Count != 0)
{
var tagBuilder = new StringBuilder(";", tags.Sum(x => x.Length) + tags.Count + 1);
foreach (var tag in tags)
{
tagBuilder.Append(tag).Append(';');
}
AddParameter(command, "@Tag", DbType.String, tagBuilder.ToString());
}
else
{
AddParameter(command, "@Tag", DbType.String, DBNull.Value);
}
}
protected IEnumerable<IPersistentRepresentation> AdaptFromJournal(IPersistentRepresentation representation)
{
return _eventAdapters.Get(representation.Payload.GetType())
.FromJournal(representation.Payload, representation.Manifest)
.Events
.Select(representation.WithPayload);
}
protected virtual void WriteEvent(DbCommand command, IPersistentRepresentation e, IImmutableSet <string> tags)
{
var manifest = string.IsNullOrEmpty(e.Manifest) ? e.Payload.GetType().QualifiedTypeName() : e.Manifest;
var serializer = Serialization.FindSerializerFor(e.Payload);
var binary = serializer.ToBinary(e.Payload);
AddParameter(command, "@PersistenceId", DbType.String, e.PersistenceId);
AddParameter(command, "@SequenceNr", DbType.Int64, e.SequenceNr);
AddParameter(command, "@Timestamp", DbType.Int64, TimestampProvider.GenerateTimestamp(e));
AddParameter(command, "@IsDeleted", DbType.Boolean, false);
AddParameter(command, "@Manifest", DbType.String, manifest);
AddParameter(command, "@Payload", DbType.Binary, binary);
if (tags.Count != 0)
{
var tagBuilder = new StringBuilder(";", tags.Sum(x => x.Length) + tags.Count + 1);
foreach (var tag in tags)
{
tagBuilder.Append(tag).Append(';');
}
AddParameter(command, "@Tag", DbType.String, tagBuilder.ToString());
}
else
{
AddParameter(command, "@Tag", DbType.String, DBNull.Value);
}
}
private PersistentMessage.Builder PersistentToProto(IPersistentRepresentation p)
{
var builder = PersistentMessage.CreateBuilder();
if (p.PersistenceId != null)
{
builder.SetPersistenceId(p.PersistenceId);
}
if (p.Sender != null)
{
builder.SetSender(Akka.Serialization.Serialization.SerializedActorPath(p.Sender));
}
if (p.Manifest != null)
{
builder.SetManifest(p.Manifest);
}
builder
.SetPayload(PersistentPayloadToProto(p.Payload))
.SetSequenceNr(p.SequenceNr);
// deleted is not used in new records
if (p.WriterGuid != null)
{
builder.SetWriterUuid(p.WriterGuid);
}
return(builder);
}
private JournalEntry ToJournalEntry(IPersistentRepresentation message)
{
var payloadType = message.Payload.GetType();
var serializer = _serialization.FindSerializerForType(payloadType);
return(new JournalEntry(message.PersistenceId, message.SequenceNr, message.IsDeleted,
payloadType.QualifiedTypeName(), serializer.ToBinary(message.Payload)));
}
private static JournalEntry ToJournalEntry(IPersistentRepresentation message)
{
var payloadType = message.Payload.GetType();
var serializer = Context.System.Serialization.FindSerializerForType(payloadType);
return new JournalEntry(message.PersistenceId, message.SequenceNr, message.IsDeleted,
payloadType.QualifiedTypeName(), serializer.ToBinary(message.Payload));
}
public Task InterceptAsync(IPersistentRepresentation message)
{
CalledAt = DateTime.Now;
WasCalled = true;
Message = message;
return(Task.CompletedTask);
}
internal JournalEntry(IPersistentRepresentation message)
{
Id = message.PersistenceId + "_" + message.SequenceNr;
IsDeleted = message.IsDeleted;
Payload = message.Payload;
PersistenceId = message.PersistenceId;
SequenceNr = message.SequenceNr;
Manifest = message.Manifest;
}
public async Task InterceptAsync(IPersistentRepresentation message)
{
var type = message.Payload.GetType();
if (_messageType.IsAssignableFrom(type))
{
await _next.InterceptAsync(message);
}
}
public async Task InterceptAsync(IPersistentRepresentation message)
{
var result = await _predicate(message);
if ((_negate && !result) || (!_negate && result))
{
await _next.InterceptAsync(message);
}
}
protected override void WriteEvent(DbCommand command, IPersistentRepresentation e, IImmutableSet <string> tags)
{
var serializationResult = _serialize(e);
var serializer = serializationResult.Serializer;
var hasSerializer = serializer != null;
string manifest = "";
if (hasSerializer && serializer is SerializerWithStringManifest)
{
manifest = ((SerializerWithStringManifest)serializer).Manifest(e.Payload);
}
else if (hasSerializer && serializer.IncludeManifest)
{
manifest = QualifiedName(e);
}
else
{
manifest = string.IsNullOrEmpty(e.Manifest) ? QualifiedName(e) : e.Manifest;
}
AddParameter(command, "@PersistenceId", DbType.String, e.PersistenceId);
AddParameter(command, "@SequenceNr", DbType.Int64, e.SequenceNr);
AddParameter(command, "@Timestamp", DbType.Int64, TimestampProvider.GenerateTimestamp(e));
AddParameter(command, "@IsDeleted", DbType.Boolean, false);
AddParameter(command, "@Manifest", DbType.String, manifest);
if (hasSerializer)
{
AddParameter(command, "@SerializerId", DbType.Int32, serializer.Identifier);
}
else
{
AddParameter(command, "@SerializerId", DbType.Int32, DBNull.Value);
}
command.Parameters.Add(new NpgsqlParameter("@Payload", serializationResult.DbType)
{
Value = serializationResult.Payload
});
if (tags.Count != 0)
{
var tagBuilder = new StringBuilder(";", tags.Sum(x => x.Length) + tags.Count + 1);
foreach (var tag in tags)
{
tagBuilder.Append(tag).Append(';');
}
AddParameter(command, "@Tag", DbType.String, tagBuilder.ToString());
}
else
{
AddParameter(command, "@Tag", DbType.String, DBNull.Value);
}
}
private JournalEntry ToJournalEntry(IPersistentRepresentation message)
{
var payloadType = message.Payload.GetType();
var serializer = _system.Serialization.FindSerializerForType(payloadType);
var manifest = string.IsNullOrEmpty(message.Manifest) ? payloadType.QualifiedTypeName() : message.Manifest;
var timestamp = TimestampProvider.GenerateTimestamp(message);
var payload = serializer.ToBinary(message.Payload);
return(new JournalEntry(message.PersistenceId, message.SequenceNr, message.IsDeleted, manifest, timestamp, payload));
}
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
private (byte[], IImmutableSet <string>) Extract(IPersistentRepresentation pr)
{
if (pr.Payload is Tagged tag)
{
return(_journalHelper.PersistentToBytes(pr.WithPayload(tag.Payload)), tag.Tags);
}
else
{
return(_journalHelper.PersistentToBytes(pr), ImmutableHashSet <string> .Empty);
}
}
public DbCommand InsertBatchMessages(IPersistentRepresentation[] messages)
{
var command = new SQLiteCommand(_insertMessagesSql);
command.Parameters.Add("@PersistenceId", DbType.String);
command.Parameters.Add("@SequenceNr", DbType.Int64);
command.Parameters.Add("@IsDeleted", DbType.Boolean);
command.Parameters.Add("@PayloadType", DbType.String);
command.Parameters.Add("@Payload", DbType.Binary);
return command;
}
/// <summary>
/// Initializes a new instance of the <see cref="WriteMessageRejected"/> class.
/// </summary>
/// <param name="persistent">Message rejected to be written.</param>
/// <param name="cause">Failure cause.</param>
/// <param name="actorInstanceId">TBD</param>
/// <exception cref="ArgumentNullException">
/// This exception is thrown when the specified <paramref name="cause"/> is undefined.
/// </exception>
public WriteMessageRejected(IPersistentRepresentation persistent, Exception cause, int actorInstanceId)
{
if (cause == null)
{
throw new ArgumentNullException(nameof(cause), "WriteMessageRejected cause exception cannot be null");
}
Persistent = persistent;
Cause = cause;
ActorInstanceId = actorInstanceId;
}
private IPersistentRepresentation MapRowToPersistentRepresentation(Row row, long deletedTo)
{
IPersistentRepresentation pr = Deserialize(row.GetValue <byte[]>("message"));
if (pr.SequenceNr <= deletedTo)
{
pr = pr.Update(pr.SequenceNr, pr.PersistenceId, true, pr.Sender);
}
return(pr);
}
private JournalEntry ToJournalEntry(IPersistentRepresentation message)
{
return(new JournalEntry
{
PersistenceId = message.PersistenceId,
SequenceNr = message.SequenceNr,
IsDeleted = message.IsDeleted,
Payload = message.Payload,
Manifest = message.Manifest
});
}
public DbCommand InsertBatchMessages(IPersistentRepresentation[] messages)
{
var command = new SqlCommand(_insertMessagesSql);
command.Parameters.Add("@PersistenceId", SqlDbType.NVarChar);
command.Parameters.Add("@SequenceNr", SqlDbType.BigInt);
command.Parameters.Add("@IsDeleted", SqlDbType.Bit);
command.Parameters.Add("@PayloadType", SqlDbType.NVarChar);
command.Parameters.Add("@Payload", SqlDbType.VarBinary);
return command;
}
private byte[] PersistentToBytes(IPersistentRepresentation message, ActorSystem system)
{
if (_serializeWithTransport)
{
return(Serialization.SerializeWithTransport(system, _transportSerializationFallbackAddress, () => _serializer.ToBinary(message)));
}
else
{
return(_serializer.ToBinary(message));
}
}
public DbCommand InsertBatchMessages(IPersistentRepresentation[] messages)
{
var command = new NpgsqlCommand(_insertMessagesSql);
command.Parameters.Add(":persistence_id", NpgsqlDbType.Varchar);
command.Parameters.Add(":sequence_nr", NpgsqlDbType.Bigint);
command.Parameters.Add(":is_deleted", NpgsqlDbType.Boolean);
command.Parameters.Add(":payload_type", NpgsqlDbType.Varchar);
command.Parameters.Add(":payload", NpgsqlDbType.Bytea);
return command;
}
public WriteMessageFailure(IPersistentRepresentation persistent, Exception cause, int actorInstanceId)
{
if (cause == null)
{
throw new ArgumentNullException("cause", "WriteMessageFailure cause exception cannot be null");
}
Persistent = persistent;
Cause = cause;
ActorInstanceId = actorInstanceId;
}
// IPersistentRepresentation
private CustomSerialization.Protobuf.Msg.PersistentMessage PersistentToProto(IPersistentRepresentation p)
{
var message = new CustomSerialization.Protobuf.Msg.PersistentMessage();
message.PersistenceId = p.PersistenceId;
message.SequenceNr = p.SequenceNr;
message.WriterGuid = p.WriterGuid;
message.Payload = PersistentPayloadBuilder(p.Payload);
return(message);
}
public byte[] PersistentToBytes(IPersistentRepresentation message)
{
/*
* Implementation note: Akka.NET caches the serialization lookups internally here,
* so there's no need to do it again.
*/
var serializer = _actorSystem.Serialization.FindSerializerForType(_persistentRepresentation);
return(serializer.ToBinary(message));
}
protected IPersistentRepresentation AdaptToJournal(IPersistentRepresentation representation)
{
var payload = representation.Payload;
var adapter = _eventAdapters.Get(payload.GetType());
representation = representation.WithPayload(adapter.ToJournal(payload));
// IdentityEventAdapter returns "" as manifest and normally the incoming PersistentRepr
// doesn't have an assigned manifest, but when WriteMessages is sent directly to the
// journal for testing purposes we want to preserve the original manifest instead of
// letting IdentityEventAdapter clearing it out.
return Equals(adapter, IdentityEventAdapter.Instance)
? representation
: representation.WithManifest(adapter.Manifest(payload));
}
public DateTime GenerateTimestamp(IPersistentRepresentation message)
{
return DateTime.UtcNow;
}
private void OnReplayFailureCompleted(Receive receive, Exception cause, IPersistentRepresentation failed)
{
ChangeState(Idle());
var recoveryFailure = failed != null ? new RecoveryFailure(cause, failed.SequenceNr, failed.Payload) : new RecoveryFailure(cause);
base.AroundReceive(receive, recoveryFailure);
}
private PersistentMessage.Builder PersistentToProto(IPersistentRepresentation p)
{
var builder = PersistentMessage.CreateBuilder();
if (p.PersistenceId != null) builder.SetPersistenceId(p.PersistenceId);
if (p.Sender != null) builder.SetSender(Akka.Serialization.Serialization.SerializedActorPath(p.Sender));
builder
.SetPayload(PersistentPayloadToProto(p.Payload))
.SetSequenceNr(p.SequenceNr)
.SetDeleted(p.IsDeleted);
return builder;
}
public long GenerateTimestamp(IPersistentRepresentation message) => DateTime.UtcNow.Ticks;
private PersistentMessage.Builder PersistentToProto(IPersistentRepresentation p)
{
var builder = PersistentMessage.CreateBuilder();
if (p.PersistenceId != null) builder.SetPersistenceId(p.PersistenceId);
if (p.Sender != null) builder.SetSender(Akka.Serialization.Serialization.SerializedActorPath(p.Sender));
if (p.Manifest != null) builder.SetManifest(p.Manifest);
builder
.SetPayload(PersistentPayloadToProto(p.Payload))
.SetSequenceNr(p.SequenceNr);
// deleted is not used in new records
if (p.WriterGuid != null) builder.SetWriterUuid(p.WriterGuid);
return builder;
}
public Messages Add(IPersistentRepresentation persistent)
{
var list = _messages.GetOrAdd(persistent.PersistenceId, new LinkedList<IPersistentRepresentation>());
list.AddLast(persistent);
return _messages;
}
private void UpdateLastSequenceNr(IPersistentRepresentation persistent)
{
if (persistent.SequenceNr > LastSequenceNr) LastSequenceNr = persistent.SequenceNr;
}
public DateTime GenerateTimestamp(IPersistentRepresentation message)
{
return KnownEventTimestampMappings[Tuple.Create(message.PersistenceId, message.SequenceNr)];
}
private static IPersistentRepresentation WithWriter(IPersistentRepresentation p, string writer)
{
return p.Update(p.SequenceNr, p.PersistenceId, p.IsDeleted, p.Sender, writer);
}
private Document<JournalEntry> ToJournalEntry(IPersistentRepresentation message)
{
return new Document<JournalEntry>
{
Id = message.PersistenceId + "_" + message.SequenceNr.ToString(),
Content = new JournalEntry
{
Id = message.PersistenceId + "_" + message.SequenceNr,
isDeleted = message.IsDeleted,
Payload = message.Payload,
PersistenceId = message.PersistenceId,
SequenceNr = message.SequenceNr,
Manifest = message.Manifest
}
};
}
public ReplayedTaggedMessage(IPersistentRepresentation persistent, string tag, long offset)
{
Persistent = persistent;
Tag = tag;
Offset = offset;
}
private JournalEntry ToJournalEntry(IPersistentRepresentation message)
{
var payloadType = message.Payload.GetType();
var serializer = _system.Serialization.FindSerializerForType(payloadType);
var manifest = string.IsNullOrEmpty(message.Manifest)
? payloadType.QualifiedTypeName()
: message.Manifest;
var timestamp = TimestampProvider.GenerateTimestamp(message);
var payload = serializer.ToBinary(message.Payload);
return new JournalEntry(message.PersistenceId, message.SequenceNr, message.IsDeleted, manifest,
timestamp, payload);
}
protected virtual void WriteEvent(DbCommand command, IPersistentRepresentation e, IImmutableSet<string> tags)
{
var manifest = string.IsNullOrEmpty(e.Manifest) ? e.Payload.GetType().QualifiedTypeName() : e.Manifest;
var serializer = Serialization.FindSerializerFor(e.Payload);
var binary = serializer.ToBinary(e.Payload);
AddParameter(command, "@PersistenceId", DbType.String, e.PersistenceId);
AddParameter(command, "@SequenceNr", DbType.Int64, e.SequenceNr);
AddParameter(command, "@Timestamp", DbType.Int64, TimestampProvider.GenerateTimestamp(e));
AddParameter(command, "@IsDeleted", DbType.Boolean, false);
AddParameter(command, "@Manifest", DbType.String, manifest);
AddParameter(command, "@Payload", DbType.Binary, binary);
if (tags.Count != 0)
{
var tagBuilder = new StringBuilder(";", tags.Sum(x => x.Length) + tags.Count + 1);
foreach (var tag in tags)
{
tagBuilder.Append(tag).Append(';');
}
AddParameter(command, "@Tag", DbType.String, tagBuilder.ToString());
}
else AddParameter(command, "@Tag", DbType.String, DBNull.Value);
}
private bool IsCorrupt(IPersistentRepresentation[] events)
{
return events.Any(p => ((string) ((Evt) p.Payload).Data).Contains("corrupt"));
}
