private void StateManager_TransactionChanged(object sender, NotifyTransactionChangedEventArgs e)
{
// transaction commited
if (e.Action == NotifyTransactionChangedAction.Commit)
{
Task.Run(() => DuplicateMessages(CancellationToken.None));
}
}
private void NotifyTransactionChangedEventArgsHandler(object obj, NotifyTransactionChangedEventArgs n, NotifyStateManagerChangedEventArgs s)
{
EventHandler <NotifyTransactionChangedEventArgs> transactionChangedEventHandler = TransactionChanged;
EventHandler <NotifyStateManagerChangedEventArgs> stateManagerChangedEventHandler = StateManagerChanged;
transactionChangedEventHandler(obj, n);
stateManagerChangedEventHandler(obj, s);
}
private void StateManagerReplica_TransactionChanged(object sender, NotifyTransactionChangedEventArgs e)
{
EventHandler <NotifyTransactionChangedEventArgs> handler = this.TransactionChanged;
if (handler != null)
{
handler(sender, e);
}
}
private void StateManager_TransactionChanged(object sender, NotifyTransactionChangedEventArgs e)
{
// TODO : check if event target inputQueue only (no need to react on over state change)
// transaction commited
if (e.Action == NotifyTransactionChangedAction.Commit)
{
Task.Run(() => DuplicateMessages(CancellationToken.None));
}
}
private void OnStateManagerTransactionChangedHandler(object sender, NotifyTransactionChangedEventArgs e)
{
if (e.Action == NotifyTransactionChangedAction.Commit)
{
long transactionId = e.Transaction.TransactionId;
long commitSequenceNumber = e.Transaction.CommitSequenceNumber;
ServiceFabricPersistenceEventSource.Log.TransactionCommitted(transactionId, commitSequenceNumber);
this.instrumentation?.TransactionCommitted(transactionId, commitSequenceNumber);
this.instrumentation?.ReportStatistics(this.TotalNodes, this.TotalData);
}
}
// private void ProcessStateManagerSingleEntityNotification(NotifyStateManagerChangedEventArgs e)
// {
// var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
// if (operation.Action == NotifyStateManagerChangedAction.Add)
// {
// if (operation.ReliableState is IReliableDictionary<TKey, TValue>)
// {
// var dictionary = (IReliableDictionary<TKey, TValue>)operation.ReliableState;
// dictionary.RebuildNotificationAsyncCallback = this.OnDictionaryRebuildNotificationHandlerAsync;
// dictionary.DictionaryChanged += this.OnDictionaryChangedHandler;
// }
// }
// }
// public async Task OnDictionaryRebuildNotificationHandlerAsync(
//IReliableDictionary<TKey, TValue> origin,
//NotifyDictionaryRebuildEventArgs<TKey, TValue> rebuildNotification)
// {
// this.secondaryIndex.Clear();
// var enumerator = e.State.GetAsyncEnumerator();
// while (await enumerator.MoveNextAsync(CancellationToken.None))
// {
// this.secondaryIndex.Add(enumerator.Current.Key, enumerator.Current.Value);
// }
// }
/// <summary>
/// 事务通知
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnTransactionChangedHadler(object sender, NotifyTransactionChangedEventArgs e)
{
if (e.Action == NotifyTransactionChangedAction.Commit)
{
this.lastCommitLsn = e.Transaction.CommitSequenceNumber;
this.lastTransactionId = e.Transaction.TransactionId;
//TODO 发生改变时 进行通知
// this.lastCommittedTransactionList.Add(e.Transaction.TransactionId);
}
}
private void OnTransactionChanged(object sender, NotifyTransactionChangedEventArgs e)
{
log.Info($"Transaction Changed Event Called for Id: {e.Transaction.TransactionId}");
if (e.Action == NotifyTransactionChangedAction.Commit)
{
// If this is first transaction we have seen, open Replica for reads
// before notifying about committed transactions.
if (!this.seenFirstTransaction)
{
this.SetUpReplicaForReads();
this.seenFirstTransaction = true;
}
this.OnTransactionCommitted(sender, e);
}
}
private void OnTransactionChangedHandler(object sender, NotifyTransactionChangedEventArgs e)
{
if (e.Action == NotifyTransactionChangedAction.Commit)
{
var allEvents = changeCollector.GetAllChanges();
var transactionMock = new TransactionMock(e.Transaction.TransactionId, e.Transaction.CommitSequenceNumber);
var trAppliedEvent = new NotifyTransactionAppliedEvent(transactionMock, allEvents);
Byte[] byteStream = messageConverter.Serialize(trAppliedEvent);
long currentLsn = e.Transaction.CommitSequenceNumber;
// handle the failure of Task here.
EventCollector.TransactionApplied(this.partitionId, previousLsn, currentLsn, byteStream);
previousLsn = currentLsn;
// Flush previous items.
this.changeCollector.CreateNew();
}
}
private void OnTransactionCommitted(object sender, NotifyTransactionChangedEventArgs e)
{
var transactionApplied = this.TransactionApplied;
if (null == transactionApplied)
{
return;
}
try
{
var transactionAppliedEventArgs = new NotifyTransactionAppliedEventArgs(
e.Transaction,
this.transactionChangeManager.GetAllChanges());
transactionApplied.Invoke(this, transactionAppliedEventArgs);
}
catch (Exception ex)
{
log.Info(ex);
Console.WriteLine($"Exception in Transaction {e.Transaction.TransactionId} \n {ex} ");
}
}
public void OnTransactionChanged(NotifyTransactionChangedEventArgs e)
{
TransactionChanged?.Invoke(this, e);
}
