public async Task<ISequence> GetAsync(SequenceKey sequenceKey)
{
var sequence = await DbSet.FirstOrDefaultAsync(s => s.Key == sequenceKey.Value);
return sequence;
}
public async Task <ISequence> GetAsync(SequenceKey sequenceKey)
{
var sequence = await DbSet.FirstOrDefaultAsync(s => s.Key == sequenceKey.Value);
return(sequence);
}
public async Task <bool> UpdateAsync(SequenceKey sequenceKey, ISequence sequence)
{
var sequenceEntity = sequence as Sequences;
sequenceEntity.SetUpdate(() => sequenceEntity.CurrentValue, sequenceEntity.CurrentValue);
var result = await FindOneAndUpdateAsync(p => p.Id == sequenceKey.Value, sequenceEntity.NeedUpdateList);
return(result != null);
}
public async Task <bool> UpdateAsync(SequenceKey sequenceKey, ISequence sequence)
{
var sequenceEntity = (SequenceTableEntity)sequence;
sequenceEntity.RowKey = sequenceKey.Value;
sequenceEntity.PartitionKey = PartitionKey;
var updatedSequenceEntity = await UpdateAsync(sequenceEntity);
return(updatedSequenceEntity != null);
}
public Task <ISequence> GetAsync(SequenceKey sequenceKey)
{
try
{
return(Task.FromResult(dictionary[sequenceKey.Value]));
}
catch (Exception)
{
return(Task.FromResult(default(ISequence)));
}
}
public Task<ISequence> GetAsync(SequenceKey sequenceKey)
{
try
{
return Task.FromResult(dictionary[sequenceKey.Value]);
}
catch (Exception)
{
return Task.FromResult(default(ISequence));
}
}
public async Task<bool> UpdateAsync(SequenceKey sequenceKey, ISequence sequence)
{
var updateResult = await SaveChangesAsync();
if (updateResult != 1)
{
Reload(sequence);
return false;
}
return true;
}
public async Task <bool> UpdateAsync(SequenceKey sequenceKey, ISequence sequence)
{
var updateResult = await SaveChangesAsync();
if (updateResult != 1)
{
Reload(sequence);
return(false);
}
return(true);
}
public Task <bool> UpdateAsync(SequenceKey sequenceKey, ISequence sequence)
{
try
{
dictionary[sequenceKey.Value] = sequence;
return(Task.FromResult(UpdateValue));
}
catch (Exception)
{
return(Task.FromResult(UpdateValue));
}
}
public Task<bool> UpdateAsync(SequenceKey sequenceKey, ISequence sequence)
{
try
{
dictionary[sequenceKey.Value] = sequence;
return Task.FromResult(UpdateValue);
}
catch (Exception)
{
return Task.FromResult(UpdateValue);
}
}
private IEnumerable<CurrentMessageInformation> Pending(SequenceKey key, uint receivedSequence)
{
var toProcess = pendingMessages.GetOrAdd(key, SortedDictionary)
.Where(p => p.Key, (p, c) => c == p + 1, receivedSequence)
.ToArray();
if(toProcess.Any())
log.DebugFormat("Processing {0} out of {1} pending messages for key {2}", toProcess.Length, pendingMessages[key].Count, key);
foreach (var p in toProcess)
pendingMessages[key].Remove(p.Key);
return toProcess.Select(p => p.Value);
}
public Task<SequenceKey> AddAsync(ISequence sequence)
{
try
{
var key = new SequenceKey { Value = Guid.NewGuid().ToString() };
dictionary.Add(key.Value, sequence);
return Task.FromResult(key);
}
catch (Exception)
{
return Task.FromResult(default(SequenceKey));
}
}
public IEnumerable <CurrentMessageInformation> Filter(IEnumerable <CurrentMessageInformation> input, IModel model)
{
foreach (var message in input)
{
if (message.Headers == null)
{
log.Warn("Received message with no headers, perhaps it's coming from an unexpected source?");
TryAckFilteredMessage(model, message);
}
else if (!message.Headers.ContainsKey(Headers.Sequence))
{
yield return(message);
}
else
{
var receivedSequence = BitConverter.ToUInt32((byte[])message.Headers[Headers.Sequence], 0);
var sequenceKey = new SequenceKey(message.Endpoint, message.MessageType);
if (Unknown(sequenceKey) || CorrectSequence(sequenceKey, receivedSequence))
{
nextSequences[sequenceKey] = receivedSequence + 1;
log.TraceFormat("Correct sequence {0} for key {1}", receivedSequence, sequenceKey);
yield return(message);
foreach (var p in Filter(Pending(sequenceKey, receivedSequence), model))
{
yield return(p);
}
}
else if (Unordered(sequenceKey, receivedSequence))
{
log.WarnFormat("Unexpected sequence {0} for key {1}. Was expecting {2}", receivedSequence,
sequenceKey, nextSequences[sequenceKey]);
pendingMessages[sequenceKey].Add(receivedSequence, message);
}
else
{
log.DebugFormat(
"Filtering out (and acking) message sequence {0} - id {1} for key {2} as already processed",
receivedSequence,
message.MessageId,
sequenceKey);
TryAckFilteredMessage(model, message);
}
}
}
}
public async Task <bool> UpdateAsync(SequenceKey sequenceKey, ISequence sequence)
{
var sequenceEntity = sequence as Sequences;
sequenceEntity.Id = sequenceKey.Value;
var query = Query.And(Query.EQ("_id", ObjectId.Parse(sequenceKey.Value)));
var update = MongoDB.Driver.Builders.Update <Sequences> .Set(c => c.CurrentValue, sequenceEntity.CurrentValue);
var updatedSequenceEntity = this.Collection.FindAndModify(new FindAndModifyArgs()
{
Query = query, Update = update, VersionReturned = FindAndModifyDocumentVersion.Original, SortBy = null
});
var doc = updatedSequenceEntity.ModifiedDocument;
return(doc != null);
}
public Task <SequenceKey> AddAsync(ISequence sequence)
{
try
{
var key = new SequenceKey {
Value = Guid.NewGuid().ToString()
};
dictionary.Add(key.Value, sequence);
return(Task.FromResult(key));
}
catch (Exception)
{
return(Task.FromResult(default(SequenceKey)));
}
}
private IEnumerable <CurrentMessageInformation> Pending(SequenceKey key, uint receivedSequence)
{
var toProcess = pendingMessages.GetOrAdd(key, SortedDictionary)
.Where(p => p.Key, (p, c) => c == p + 1, receivedSequence)
.ToArray();
if (toProcess.Any())
{
log.DebugFormat("Processing {0} out of {1} pending messages for key {2}", toProcess.Length, pendingMessages[key].Count, key);
}
foreach (var p in toProcess)
{
pendingMessages[key].Remove(p.Key);
}
return(toProcess.Select(p => p.Value));
}
public IEnumerable<CurrentMessageInformation> Filter(IEnumerable<CurrentMessageInformation> input, IModel model)
{
foreach (var message in input)
{
var receivedSequence = BitConverter.ToUInt32((byte[])message.Headers[Headers.Sequence], 0);
var sequenceKey = new SequenceKey(message.Endpoint, message.MessageType);
if (Unknown(sequenceKey) || CorrectSequence(sequenceKey, receivedSequence))
{
nextSequences[sequenceKey] = receivedSequence + 1;
log.TraceFormat("Correct sequence {0} for key {1}", receivedSequence, sequenceKey);
yield return message;
foreach (var p in Filter(Pending(sequenceKey, receivedSequence), model))
yield return p;
}
else if (Unordered(sequenceKey, receivedSequence))
{
log.WarnFormat("Unexpected sequence {0} for key {1}. Was expecting {2}", receivedSequence, sequenceKey, nextSequences[sequenceKey]);
pendingMessages[sequenceKey].Add(receivedSequence, message);
}
else
{
log.DebugFormat("Filtering out (and acking) message sequence {0} - id {1} for key {2} as already processed",
receivedSequence,
message.MessageId,
sequenceKey);
try
{
model.BasicAck(message.DeliveryTag, false);
}
catch (AlreadyClosedException e)
{
log.Info("Could not ack filtered-out message because model was already closed", e);
}
catch (Exception e)
{
log.Warn("Could not ack filtered-out message for unknown cause", e);
}
}
}
}
public string NextVal()
{
const string YEAR4D_MM = "{YYYYMM}";
const string YEAR4D = "{YYYY}";
const string YEAR2D = "{YY}";
const string YEAR2D_MM = "{YYMM}";
const string YEAR4D_MMM = "{YYYYMMM}";
string[] simpleList = new string[] { YEAR2D, YEAR2D_MM, YEAR4D, YEAR4D, YEAR4D_MM };
CurrentValue += 1;
string currVal = CurrentValue.ToString().PadLeft(SequenceId.SequLength, '0');
Save();
string value = SequenceId.SequMask.Replace("{$}", currVal);
if (value.Contains(YEAR4D_MMM))
{
int monVal = int.Parse(SequenceKey.Substring(4, 2));
string monName = new DateTime(2010, monVal, 1).ToString("MMM", CultureInfo.InvariantCulture);
string yearPart = SequenceKey.Substring(0, 4) + monName;
value = value.Replace(YEAR4D_MMM, yearPart);
}
else
{
foreach (var item in simpleList)
{
if (value.Contains(item) && SequenceKey.Length > (item.Length - 2))
{
value = value.Replace(item, SequenceKey.Substring(0, item.Length));
break;
}
}
}
return(value);
}
public async Task <ISequence> GetAsync(SequenceKey sequenceKey)
{
var sequenceEntity = await base.Get(PartitionKey, sequenceKey.Value);
return(sequenceEntity);
}
private bool Unordered(SequenceKey key, uint sequence)
{
return(sequence > nextSequences[key]);
}
private bool Unknown(SequenceKey key)
{
return(!nextSequences.ContainsKey(key));
}
private bool Unordered(SequenceKey key, uint sequence)
{
return sequence > nextSequences[key];
}
public async Task <ISequence> GetAsync(SequenceKey sequenceKey)
{
var sequenceEntity = base.GetById(sequenceKey.Value);
return(sequenceEntity);
}
private bool CorrectSequence(SequenceKey key, uint sequence)
{
return sequence == nextSequences[key];
}
public async Task <ISequence> GetAsync(SequenceKey sequenceKey)
{
var sequenceEntity = await GetByKeyAsync(sequenceKey.Value);
return(sequenceEntity);
}
private bool Unknown(SequenceKey key)
{
return !nextSequences.ContainsKey(key);
}
private bool CorrectSequence(SequenceKey key, uint sequence)
{
return(sequence == nextSequences[key]);
}
