public async Task<StreamHandshakeToken> DeliverBatch(GuidId subscriptionId, Immutable<IBatchContainer> batch, StreamHandshakeToken handshakeToken)
{
foreach (var each in batch.Value.GetEvents<object>())
await handler(each.Item1);
return null;
}
public void Test_That_Original_Object_Cannot_Be_Modified()
{
var testClass = new Immutable<TestClass>();
var newTestClass = testClass.Modify(x => x.Test, 1);
Assert.Equal(testClass.Get(x => x.Test), 0);
}
public void Test_That_Returned_Object_Contains_Modifications()
{
var testClass = new Immutable<TestClass>();
var newTestClass = testClass.Modify(x => x.Test, 2);
Assert.Equal(newTestClass.Get(x => x.Test), 2);
}
public void Test_That_Modifying_Nested_Object_Keeps_Original_Unmodified()
{
var testClass = new Immutable<TestClass>();
var newTestClass = testClass.Modify(x => x.Data,
testClass.Get(x => x.Data)
.Modify(x => x.Member, 2)
);
Assert.Equal(testClass.Get(x => x.Data.Get(y => y.Member)), 0);
}
/// <summary>
/// Take responsibility for a new queues that was assigned to me via a new range.
/// We first store the new queue in our internal data structure, try to initialize it and start a pumping timer.
/// ERROR HANDLING:
/// The resposibility to handle initializatoion and shutdown failures is inside the INewQueueAdapterReceiver code.
/// The agent will call Initialize once and log an error. It will not call initiliaze again.
/// The receiver itself may attempt later to recover from this error and do initialization again.
/// The agent will assume initialization has succeeded and will subsequently start calling pumping receive.
/// Same applies to shutdown.
/// </summary>
/// <param name="qAdapter"></param>
/// <param name="queueAdapterCache"></param>
/// <param name="failureHandler"></param>
/// <returns></returns>
public async Task Initialize(Immutable<IQueueAdapter> qAdapter, Immutable<IQueueAdapterCache> queueAdapterCache, Immutable<IStreamFailureHandler> failureHandler)
{
if (qAdapter.Value == null) throw new ArgumentNullException("qAdapter", "Init: queueAdapter should not be null");
if (failureHandler.Value == null) throw new ArgumentNullException("failureHandler", "Init: streamDeliveryFailureHandler should not be null");
logger.Info((int)ErrorCode.PersistentStreamPullingAgent_02, "Init of {0} {1} on silo {2} for queue {3}.",
GetType().Name, GrainId.ToDetailedString(), Silo, QueueId.ToStringWithHashCode());
// Remove cast once we cleanup
queueAdapter = qAdapter.Value;
streamFailureHandler = failureHandler.Value;
lastTimeCleanedPubSubCache = DateTime.UtcNow;
try
{
receiver = queueAdapter.CreateReceiver(QueueId);
}
catch (Exception exc)
{
logger.Error((int)ErrorCode.PersistentStreamPullingAgent_02, "Exception while calling IQueueAdapter.CreateNewReceiver.", exc);
return;
}
try
{
if (queueAdapterCache.Value != null)
{
queueCache = queueAdapterCache.Value.CreateQueueCache(QueueId);
}
}
catch (Exception exc)
{
logger.Error((int)ErrorCode.PersistentStreamPullingAgent_23, "Exception while calling IQueueAdapterCache.CreateQueueCache.", exc);
return;
}
try
{
var task = OrleansTaskExtentions.SafeExecute(() => receiver.Initialize(config.InitQueueTimeout));
task = task.LogException(logger, ErrorCode.PersistentStreamPullingAgent_03, String.Format("QueueAdapterReceiver {0} failed to Initialize.", QueueId.ToStringWithHashCode()));
await task;
}
catch
{
// Just ignore this exception and proceed as if Initialize has succeeded.
// We already logged individual exceptions for individual calls to Initialize. No need to log again.
}
// Setup a reader for a new receiver.
// Even if the receiver failed to initialise, treat it as OK and start pumping it. It's receiver responsibility to retry initialization.
var randomTimerOffset = safeRandom.NextTimeSpan(config.GetQueueMsgsTimerPeriod);
timer = base.RegisterTimer(AsyncTimerCallback, QueueId, randomTimerOffset, config.GetQueueMsgsTimerPeriod);
logger.Info((int) ErrorCode.PersistentStreamPullingAgent_04, "Taking queue {0} under my responsibility.", QueueId.ToStringWithHashCode());
}
/// <summary>
/// This method checks the list of cached indexes, and if any index does not have a before-image, it will create
/// one for it. As before-images are stored as an immutable field, a new map is created in this process.
///
/// This method is called on activation of the grain, and when the UpdateIndexes method detects an inconsistency
/// between the indexes in the index handler and the cached indexes of the current grain.
/// </summary>
private void AddMissingBeforeImages()
{
IDictionary <string, object> oldBefImgs = this._beforeImages.Value;
IDictionary <string, object> newBefImgs = new Dictionary <string, object>();
foreach (var idxOp in this._grainIndexes)
{
var indexID = idxOp.Key;
var oldBefImg = oldBefImgs.ContainsKey(indexID)
? oldBefImgs[indexID]
: idxOp.Value.UpdateGenerator.ExtractIndexImage(this.Properties);
newBefImgs.Add(indexID, oldBefImg);
}
this._beforeImages = newBefImgs.AsImmutable();
}
public Task PingImmutableDictionary(Immutable <Dictionary <int, string> > data, long nextGrain,
bool nextGrainIsRemote)
{
if (nextGrain > 0)
{
if (nextGrainIsRemote)
{
return(this.GrainFactory.GetGrain <IReentrantStressTestGrain>(nextGrain)
.PingImmutableDictionary(data, -1, false));
}
return(this.GrainFactory.GetGrain <IReentrantLocalStressTestGrain>(nextGrain)
.PingImmutableDictionary(data, -1, false));
}
return(Task.CompletedTask);
}
/// <summary>
/// Upon activation, the list of index update generators is retrieved from the index handler. It is cached in
/// this grain for use in creating before-images, and also for later calls to UpdateIndexes.
///
/// Then, the before-images are created and stored in memory.
/// </summary>
public override Task OnActivateAsync()
{
this.Logger.Trace($"Activating indexable grain {base.GrainReference} of type {this.GetIIndexableGrainTypes()[0]} in silo {this.SiloIndexManager.SiloAddress}.");
// Load indexes
this._grainIndexes = this.SiloIndexManager.IndexFactory.GetGrainIndexes(GetIIndexableGrainTypes()[0]);
this._isThereAnyUniqueIndex = this._grainIndexes.HasAnyUniqueIndex;
// Initialize before images
this._beforeImages = new Dictionary <string, object>().AsImmutable <IDictionary <string, object> >();
AddMissingBeforeImages();
// Insert the current grain to the active indexes defined on this grain and at the same time call OnActivateAsync of the base class
return(Task.WhenAll(InsertIntoActiveIndexes(), base.OnActivateAsync()));
}
public async Task AddAllToQueue(Immutable <List <IndexWorkflowRecord> > workflowRecords)
{
await this.EnsureStorage();
// Note: this can be called with an empty enumeration, to just "wake up" the thread in FT recovery.
List <IndexWorkflowRecord> newWorkflows = workflowRecords.Value;
foreach (IndexWorkflowRecord newWorkflow in newWorkflows)
{
AddToQueueNonPersistent(newWorkflow);
}
InitiateWorkerThread();
await(IsFaultTolerant ? PersistState() : Task.CompletedTask);
}
/// <summary>
/// An extension method to intercept the calls to DirectApplyIndexUpdate on an Index
/// </summary>
internal static Task <bool> ApplyIndexUpdate(this IIndexInterface index, SiloIndexManager siloIndexManager,
IIndexableGrain updatedGrain, Immutable <IMemberUpdate> update,
IndexMetaData idxMetaData, SiloAddress siloAddress = null)
{
if (index is IActiveHashIndexPartitionedPerSilo)
{
var bucketInCurrentSilo = siloIndexManager.GetGrainService <IActiveHashIndexPartitionedPerSiloBucket>(
GetAHashIndexPartitionedPerSiloGrainReference(siloIndexManager,
IndexUtils.GetIndexNameFromIndexGrain((IAddressable)index), index.GetType().GetGenericArguments()[1],
siloAddress
));
return(bucketInCurrentSilo.DirectApplyIndexUpdate(updatedGrain, update, idxMetaData.IsUniqueIndex, idxMetaData /*, siloAddress*/));
}
return(index.DirectApplyIndexUpdate(updatedGrain, update, idxMetaData.IsUniqueIndex, idxMetaData, siloAddress));
}
public async Task <BookInventoryApplication> AcquireInventory(Immutable <long> orderId, Immutable <int> amount)
{
var bookId = this.GetPrimaryKeyLong();
using (
var connection =
new SqlConnection(ConfigurationManager.ConnectionStrings["BookInventory"].ConnectionString))
{
await connection.OpenAsync();
using (var transaction = connection.BeginTransaction())
{
var remainInventory =
await connection.QueryFirstOrDefaultAsync <decimal>(
"SELECT [Inventory] FROM [BookInventory] WHERE [BookId]=@Id", new { Id = bookId }, transaction);
if (remainInventory < amount.Value)
{
throw new NoEnoughInventoryException(
$"No enough book inventory, current is {remainInventory}, need {amount.Value}");
}
if (await connection.ExecuteAsync(
"UPDATE [BookInventory] SET [Inventory]=[Inventory]-@Inventory WHERE [BookId]=@Id",
new { Inventory = amount.Value, Id = bookId }, transaction) != 1)
{
throw new DbOperationFailedException();
}
var newApplication = new BookInventoryApplication
{
OrderId = orderId.Value,
BookId = bookId,
Amount = amount.Value,
Status = (int)BookInventoryApplicationStatus.Granted
};
await connection.ExecuteAsync(
"INSERT INTO [BookInventoryApplication] ([OrderId], [BookId], [Amount], [Status]) VALUES " +
"(@OrderId, @BookId, @Amount, @Status)",
newApplication
, transaction);
transaction.Commit();
return(newApplication);
}
}
}
public async Task SerializeImmutableBigInteger_Success()
{
var yamlSerializer = new YamlSerializer($"{Default}");
var sourceString = string.Join(string.Empty, Enumerable.Repeat("1234567890", 10));
var source = new Immutable <BigInteger>(BigInteger.Parse(sourceString));
var expected = _encoding.GetBytes($@"
property: {sourceString}
".TrimStart());
var actual = await yamlSerializer.Serialize(source);
Assert.Equal(expected, actual);
}
public Task AddAllToQueue(Immutable <List <IndexWorkflowRecord> > workflowRecords)
{
List <IndexWorkflowRecord> newWorkflows = workflowRecords.Value;
foreach (IndexWorkflowRecord newWorkflow in newWorkflows)
{
AddToQueueNonPersistent(newWorkflow);
}
InitiateWorkerThread();
if (IsFaultTolerant)
{
return(PersistState());
}
return(TaskDone.Done);
}
public void Test_Protobuf_Serialization_Round_Trip()
{
var testClass = new Immutable <TestClassMember>();
testClass = testClass.Modify(x => x.Member = 1);
var stream = new MemoryStream();
Serializer.Serialize(stream, testClass);
stream.Seek(0, SeekOrigin.Begin);
var deserialized = Serializer.Deserialize <Immutable <TestClassMember> >(stream);
deserialized.Get(x => x.Member).ShouldBe(1);
deserialized.Get(x => x.Member2).ShouldBe(0);
}
public Task IndexAsync(NamedId <Guid> schemaId, Immutable <IndexCommand[]> updates)
{
foreach (var command in updates.Value)
{
switch (command)
{
case DeleteIndexEntry delete:
index.Writer.DeleteDocuments(new Term(MetaId, delete.DocId));
break;
case UpdateIndexEntry update:
try
{
var values = GetValue(update.ServeAll, update.ServePublished);
index.Writer.UpdateBinaryDocValue(new Term(MetaId, update.DocId), MetaFor, values);
}
catch (ArgumentException)
{
}
break;
case UpsertIndexEntry upsert:
{
var document = new Document();
document.AddStringField(MetaId, upsert.DocId, Field.Store.YES);
document.AddStringField(MetaContentId, upsert.ContentId.ToString(), Field.Store.YES);
document.AddStringField(MetaSchemaId, schemaId.Id.ToString(), Field.Store.YES);
document.AddStringField(MetaSchemaName, schemaId.Name, Field.Store.YES);
document.AddBinaryDocValuesField(MetaFor, GetValue(upsert.ServeAll, upsert.ServePublished));
foreach (var(key, value) in upsert.Texts)
{
document.AddTextField(key, value, Field.Store.NO);
}
index.Writer.UpdateDocument(new Term(MetaId, upsert.DocId), document);
break;
}
}
}
return(TryCommitAsync());
}
async Task <Immutable <CfnResponse> > CreateSeed(CfnRequest cfnRequest, Immutable <CfnResponse> cfnResponse, ILambdaContext context)
{
try
{
var seedData = cfnRequest.ResourceProperties.SeedData;
if (seedData == null ||
seedData.Count() == 0 ||
(seedData.Count() == 1 && string.IsNullOrEmpty(seedData.First())))
{
return(cfnResponse);
}
var request = seedData.Select(seed =>
{
return(new SaveItemRequest
{
Id = "U1",
Name = "This is a custom data inserted using a custom resource",
Key = seed
});
});
var result = await _itemService.BatchWrite(request);
if (result != null)
{
LogHandler.LogMessage(context, "Db seeding successful");
return(cfnResponse.Modify(r => r.Status = "SUCCESS"));
}
else
{
LogHandler.LogMessage(context, "Db seeding failed");
return(cfnResponse.ToBuilder()
.Modify(r => r.Status = "FAILED")
.Modify(r => r.Reason = $"Resource: {_tableName} not found")
.ToImmutable());
}
}
catch (Exception ex)
{
LogHandler.LogMessage(context, ex.StackTrace);
return(cfnResponse.ToBuilder()
.Modify(r => r.Status = "FAILED")
.Modify(r => r.Reason = ex.Message)
.ToImmutable());
}
}
public async Task <bool> DirectApplyIndexUpdate(IIndexableGrain g, Immutable <IMemberUpdate> iUpdate, bool isUniqueIndex, IndexMetaData idxMetaData, SiloAddress siloAddress)
{
IMemberUpdate update = iUpdate.Value;
IndexOperationType opType = update.GetOperationType();
if (opType == IndexOperationType.Update)
{
int befImgHash = update.GetBeforeImage().GetHashCode();
int aftImgHash = update.GetAfterImage().GetHashCode();
BucketT befImgBucket = InsideRuntimeClient.Current.InternalGrainFactory.GetGrain <BucketT>(
IndexUtils.GetIndexGrainID(typeof(V), _indexName) + "_" + befImgHash
);
if (befImgHash == aftImgHash)
{
return(await befImgBucket.DirectApplyIndexUpdate(g, iUpdate, isUniqueIndex, idxMetaData));
}
else
{
BucketT aftImgBucket = InsideRuntimeClient.Current.InternalGrainFactory.GetGrain <BucketT>(
IndexUtils.GetIndexGrainID(typeof(V), _indexName) + "_" + befImgHash
);
var befTask = befImgBucket.DirectApplyIndexUpdate(g, new MemberUpdateOverridenOperation(iUpdate.Value, IndexOperationType.Delete).AsImmutable <IMemberUpdate>(), isUniqueIndex, idxMetaData);
var aftTask = aftImgBucket.DirectApplyIndexUpdate(g, new MemberUpdateOverridenOperation(iUpdate.Value, IndexOperationType.Insert).AsImmutable <IMemberUpdate>(), isUniqueIndex, idxMetaData);
bool[] results = await Task.WhenAll(befTask, aftTask);
return(results[0] && results[1]);
}
}
else if (opType == IndexOperationType.Insert)
{
int aftImgHash = update.GetAfterImage().GetHashCode();
BucketT aftImgBucket = InsideRuntimeClient.Current.InternalGrainFactory.GetGrain <BucketT>(
IndexUtils.GetIndexGrainID(typeof(V), _indexName) + "_" + aftImgHash
);
return(await aftImgBucket.DirectApplyIndexUpdate(g, iUpdate, isUniqueIndex, idxMetaData));
}
else if (opType == IndexOperationType.Delete)
{
int befImgHash = update.GetBeforeImage().GetHashCode();
BucketT befImgBucket = InsideRuntimeClient.Current.InternalGrainFactory.GetGrain <BucketT>(
IndexUtils.GetIndexGrainID(typeof(V), _indexName) + "_" + befImgHash
);
return(await befImgBucket.DirectApplyIndexUpdate(g, iUpdate, isUniqueIndex, idxMetaData));
}
return(true);
}
private async Task <Immutable <byte[]> > Query <TRessourceType>(Immutable <QueryDefinition> queryDef)
{
try {
var ret = await GrainFactory.GetGrain <IDistributedHashTable <Guid, TRessourceType> >(0).Query(queryDef);
IFormatter formatter = new BinaryFormatter();
var stream = new MemoryStream(5000000);
formatter.Serialize(stream, ret.Value);
stream.Close();
Console.WriteLine("Returning query's result");
return(stream.GetBuffer().AsImmutable());
}
catch (Exception e) {
throw new Exception(e.Message);
}
}
public void ShouldReturnImmutableObject_WhenObjectIsArray()
{
// Arrange
var value = new SimpleTestClass[3]
{
new SimpleTestClass(),
new SimpleTestClass(),
new SimpleTestClass()
};
var immutable = new Immutable <SimpleTestClass[]>(value);
// Act
var result = immutable[0];
// Assert
result.Should().BeOfType <Immutable <SimpleTestClass> >();
}
public void ShouldThrowException_WhenObjectIsArrayAndIndexIsOutOfBounds()
{
// Arrange
var value = new SimpleTestClass[3]
{
new SimpleTestClass(),
new SimpleTestClass(),
new SimpleTestClass()
};
var immutable = new Immutable <SimpleTestClass[]>(value);
// Act
Action result = () => _ = immutable[4];
// Assert
result.Should().Throw <IndexOutOfRangeException>().WithMessage("Index was out of range. Must be non-negative and less than the size of the collection.");
}
public Task PingImmutableArray(Immutable <byte[]> data, long nextGrain, bool nextGrainIsRemote)
{
if (nextGrain > 0)
{
if (nextGrainIsRemote)
{
return(GrainFactory.GetGrain <IReentrantStressTestGrain>(nextGrain)
.PingImmutableArray(data, -1, false));
}
else
{
return(GrainFactory.GetGrain <IReentrantLocalStressTestGrain>(nextGrain)
.PingImmutableArray(data, -1, false));
}
}
return(TaskDone.Done);
}
private async Task <IGrainReminder> CreateNewOrderFO(Immutable <long> userId, Immutable <long> bookId, Immutable <int> amount, long orderId)
{
var reminder = await RegisterOrUpdateReminder(GetCreateOrderReminderName(), CheckDuration, CheckDuration);
using (var connection = GetConnection())
{
await connection.ExecuteAsync("INSERT INTO [Order] ([Id], [UserId], [BookId], [Amount], [Status]) VALUES " +
"(@Id, @UserId, @BookId, @Amount, @Status)", new OrderFO
{
Amount = amount.Value,
BookId = bookId.Value,
Id = orderId,
UserId = userId.Value,
Status = OrderStatus.Created
});
}
return(reminder);
}
public Task Dispatch(Immutable <EventGridEvent[]> events)
{
var eventGridEvents = events.Value;
if (eventGridEvents?.Length == 0)
{
return(Task.CompletedTask);
}
var tasks = new List <Task>();
foreach (var @event in eventGridEvents)
{
tasks.Add(TryDispatch(@event));
}
return(Task.WhenAll(tasks));
}
public Task Initialize(Immutable<IQueueAdapter> qAdapter)
{
if (qAdapter.Value == null) throw new ArgumentNullException("qAdapter", "Init: queueAdapter should not be null");
Log(ErrorCode.PersistentStreamPullingManager_02, "Init.");
// Remove cast once we cleanup
queueAdapter = qAdapter.Value;
var meAsQueueBalanceListener = this.AsReference<IStreamQueueBalanceListener>();
queueBalancer.SubscribeToQueueDistributionChangeEvents(meAsQueueBalanceListener);
List<QueueId> myQueues = queueBalancer.GetMyQueues().ToList();
Log(ErrorCode.PersistentStreamPullingManager_03, String.Format("Initialize: I am now responsible for {0} queues: {1}.", myQueues.Count, PrintQueues(myQueues)));
managerState = PersistentStreamProviderState.Initialized;
return TaskDone.Done;
}
public Task SendPacket(uint packetId, Immutable <byte[]> data)
{
var packet = new UncompressedPacket
{
PacketId = packetId,
Data = new ArraySegment <byte>(data.Value)
};
if (_subsManager.Count == 0)
{
DeactivateOnIdle();
}
else
{
_subsManager.Notify(n => n.ReceivePacket(packet));
}
return(Task.CompletedTask);
}
public Task Set(Immutable <TKey> key, Immutable <TValue> value)
{
Task Set()
{
if (State.ContainsKey(key.Value))
{
State[key.Value] = value.Value;
}
else
{
State.Add(key.Value, value.Value);
}
return(Task.CompletedTask);
}
CommitChanges();
return(SerialExecutor.AddNext(Set));
}
public Task OnEventAsync(Immutable <IEventSubscription> subscription, Immutable <StoredEvent> storedEvent)
{
if (subscription.Value != currentSubscription)
{
return(TaskHelper.Done);
}
return(DoAndUpdateStateAsync(async() =>
{
var @event = ParseKnownEvent(storedEvent.Value);
if (@event != null)
{
await DispatchConsumerAsync(@event);
}
State = State.Handled(storedEvent.Value.EventPosition);
}));
}
/// <summary>
/// This method assumes that a set of changes is applied to the indexes, and then it replaces the current before-images
/// with after-images produced by the update.
/// </summary>
/// <param name="updates">the member updates that were successfully applied to the current indexes</param>
protected void UpdateBeforeImages(IDictionary <string, IMemberUpdate> updates)
{
IDictionary <string, object> befImgs = new Dictionary <string, object>(this._beforeImages.Value);
foreach (KeyValuePair <string, IMemberUpdate> updt in updates)
{
var indexID = updt.Key;
var opType = updt.Value.OperationType;
if (opType == IndexOperationType.Update || opType == IndexOperationType.Insert)
{
befImgs[indexID] = _grainIndexes[indexID].UpdateGenerator.ExtractIndexImage(this.Properties);
}
else if (opType == IndexOperationType.Delete)
{
befImgs[indexID] = null;
}
}
this._beforeImages = befImgs.AsImmutable();
}
/// <summary>
/// Take responsibility for a new queues that was assigned to me via a new range.
/// We first store the new queue in our internal data structure, try to initialize it and start a pumping timer.
/// ERROR HANDLING:
/// The resposibility to handle initializatoion and shutdown failures is inside the INewQueueAdapterReceiver code.
/// The agent will call Initialize once and log an error. It will not call initiliaze again.
/// The receiver itself may attempt later to recover from this error and do initialization again.
/// The agent will assume initialization has succeeded and will subsequently start calling pumping receive.
/// Same applies to shutdown.
/// </summary>
/// <param name="qAdapter"></param>
/// <returns></returns>
public async Task Initialize(Immutable <IQueueAdapter> qAdapter)
{
if (qAdapter.Value == null)
{
throw new ArgumentNullException("qAdapter", "Init: queueAdapter should not be null");
}
logger.Info((int)ErrorCode.PersistentStreamPullingAgent_02, "Init of {0} {1} on silo {2} for queue {3}.",
this.GetType().Name, this.GrainId.ToDetailedString(), base.Silo, QueueId.ToStringWithHashCode());
// Remove cast once we cleanup
queueAdapter = qAdapter.Value;
try
{
receiver = queueAdapter.CreateReceiver(QueueId);
}
catch (Exception exc)
{
logger.Error((int)ErrorCode.PersistentStreamPullingAgent_02, String.Format("Exception while calling INewQueueAdapter.CreateNewReceiver."), exc);
return;
}
try
{
var task = OrleansTaskExtentions.SafeExecute(() => receiver.Initialize(initQueueTimeout));
task = task.LogException(logger, ErrorCode.PersistentStreamPullingAgent_03, String.Format("QueueAdapterReceiver {0} failed to Initialize.", QueueId.ToStringWithHashCode()));
await task;
}
catch (Exception)
{
// Just ignore this exception and proceed as if Initialize has succeeded.
// We already logged individual exceptions for individual calls to Initialize. No need to log again.
}
// Setup a reader for a new receiver.
// Even if the receiver failed to initialise, treat it as OK and start pumping it. It's receiver responsibility to retry initialization.
var randomTimerOffset = safeRandom.NextTimeSpan(queueGetPeriod);
timer = providerRuntime.RegisterTimer(AsyncTimerCallback, QueueId, randomTimerOffset, queueGetPeriod);
logger.Info((int)ErrorCode.PersistentStreamPullingAgent_04, "Taking queue {0} under my responsibility.", QueueId.ToStringWithHashCode());
}
/// <summary>
/// This method checks the list of cached indexes, and if
/// any index does not have a before-image, it will create
/// one for it. As before-images are stored as an immutable
/// field, a new map is created in this process.
///
/// This method is called on activation of the grain, and when the
/// UpdateIndexes method detects an inconsistency between the indexes
/// in the index handler and the cached indexes of the current grain.
/// </summary>
private void AddMissingBeforeImages()
{
IDictionary <string, Tuple <object, object, object> > iUpdateGens = _iUpdateGens;
IDictionary <string, object> oldBefImgs = _beforeImages.Value;
IDictionary <string, object> newBefImgs = new Dictionary <string, object>();
foreach (KeyValuePair <string, Tuple <object, object, object> > idxOp in iUpdateGens)
{
var indexID = idxOp.Key;
if (!oldBefImgs.ContainsKey(indexID))
{
newBefImgs.Add(indexID, ((IIndexUpdateGenerator)idxOp.Value.Item3).ExtractIndexImage(Properties));
}
else
{
newBefImgs.Add(indexID, oldBefImgs[indexID]);
}
}
_beforeImages = newBefImgs.AsImmutable();
}
public Task <StreamSequenceToken> DeliverBatch(GuidId subscriptionId, Immutable <IBatchContainer> batch, StreamSequenceToken handshakeToken)
{
if (logger.IsVerbose3)
{
logger.Verbose3("DeliverBatch {0} for subscription {1}", batch.Value, subscriptionId);
}
IStreamSubscriptionHandle observer;
if (allStreamObservers.TryGetValue(subscriptionId, out observer))
{
return(observer.DeliverBatch(batch.Value, handshakeToken));
}
logger.Warn((int)(ErrorCode.StreamProvider_NoStreamForBatch), "{0} got an item for subscription {1}, but I don't have any subscriber for that stream. Dropping on the floor.",
providerRuntime.ExecutingEntityIdentity(), subscriptionId);
// We got an item when we don't think we're the subscriber. This is a normal race condition.
// We can drop the item on the floor, or pass it to the rendezvous, or ...
return(Task.FromResult(default(StreamSequenceToken)));
}
public Task <StreamSequenceToken> DeliverItem(GuidId subscriptionId, Immutable <object> item, StreamSequenceToken currentToken, StreamSequenceToken prevToken)
{
if (logger.IsVerbose3)
{
logger.Verbose3("DeliverItem {0} for subscription {1}", item.Value, subscriptionId);
}
IStreamSubscriptionHandle observer;
if (allStreamObservers.TryGetValue(subscriptionId, out observer))
{
return(observer.DeliverItem(item.Value, currentToken, prevToken));
}
logger.Warn((int)(ErrorCode.StreamProvider_NoStreamForItem), "{0} got an item for subscription {1}, but I don't have any subscriber for that stream. Dropping on the floor.",
providerRuntime.ExecutingEntityIdentity(), subscriptionId);
// We got an item when we don't think we're the subscriber. This is a normal race condition.
// We can drop the item on the floor, or pass it to the rendezvous, or ...
return(Task.FromResult <StreamSequenceToken>(null));
}
public override string ToString()
{
var b = new StringBuilder("Validation Item (")
.Append(ItemId)
.Append(") ")
.Append(Valid ? "[Valid]" : "[Invalid]")
.Append(" {")
.Append(string.Join(",", Messages ?? Immutable.ReadOnlyList <string>()))
.Append(" }");
if (CollectionUtil.IsNotNullOrEmpty(NestedResults))
{
b.Append(" Nested (").Append(NestedResults.Count).Append(") [")
.Append(Environment.NewLine)
.Append(string.Join(Environment.NewLine, NestedResults ?? Immutable.ReadOnlyList <IValidationResult>()))
.Append(Environment.NewLine)
.Append("]");
}
return(b.ToString());
}
async Task <Immutable <CfnResponse> > DeleteTable(CfnRequest cfnRequest, Immutable <CfnResponse> cfnResponse, ILambdaContext context)
{
try
{
await _itemService.DeleteTable();
await _userService.DeleteTable();
LogHandler.LogMessage(context, $"Request {cfnRequest.RequestType} executed Successfully");
return(cfnResponse.Modify(r => r.Status = "SUCCESS"));
}
catch (Exception ex)
{
LogHandler.LogMessage(context, $"Message: {ex.Message} /Trace: {ex.StackTrace}");
return(cfnResponse.ToBuilder()
.Modify(r => r.Status = "FAILED")
.Modify(r => r.Reason = ex.Message)
.ToImmutable());
}
}
/// <summary>
/// Upon activation, the list of index update generators
/// is retrieved from the index handler. It is cached in
/// this grain for use in creating before-images, and also
/// for later calls to UpdateIndexes.
///
/// Then, the before-images are created and stored in memory.
/// </summary>
public override Task OnActivateAsync()
{
if (logger.IsVerbose)
{
logger.Verbose("Activating indexable grain {0} of type {1} in silo {2}.", Orleans.GrainExtensions.GetGrainId(this), GetIIndexableGrainTypes()[0], RuntimeAddress);
}
//load indexes
_iUpdateGens = IndexHandler.GetIndexes(GetIIndexableGrainTypes()[0]);
//initialized _isThereAnyUniqueIndex field
InitUniqueIndexCheck();
//Initialize before images
_beforeImages = new Dictionary <string, object>().AsImmutable <IDictionary <string, object> >();
AddMissingBeforeImages();
//insert the current grain to the active indexes defined on this grain
//and at the same time call OnActivateAsync of the base class
return(Task.WhenAll(InsertIntoActiveIndexes(), base.OnActivateAsync()));
}
/// <summary>
/// This method assumes that a set of changes is applied to the
/// indexes, and then it replaces the current before-images with
/// after-images produced by the update.
/// </summary>
/// <param name="updates">the member updates that were successfully
/// applied to the current indexes</param>
protected void UpdateBeforeImages(IDictionary <string, IMemberUpdate> updates)
{
IDictionary <string, Tuple <object, object, object> > iUpdateGens = _iUpdateGens;
IDictionary <string, object> befImgs = new Dictionary <string, object>(_beforeImages.Value);
foreach (KeyValuePair <string, IMemberUpdate> updt in updates)
{
var indexID = updt.Key;
var opType = updt.Value.GetOperationType();
if (opType == IndexOperationType.Update || opType == IndexOperationType.Insert)
{
befImgs[indexID] = ((IIndexUpdateGenerator)iUpdateGens[indexID].Item3).ExtractIndexImage(Properties);
}
else if (opType == IndexOperationType.Delete)
{
befImgs[indexID] = null;
}
}
_beforeImages = befImgs.AsImmutable();
}
public TestClass()
{
Data = new Immutable<TestClassMember>();
}
public async Task<StreamHandshakeToken> DeliverItem(GuidId subscriptionId, Immutable<object> item, StreamSequenceToken currentToken, StreamHandshakeToken handshakeToken)
{
await handler(item.Value);
return null;
}
public void Test_That_Modify_Can_Alter_Converted_Nullables()
{
var testClass = new Immutable<TestNullableClass>();
decimal? testDecimal = null;
testClass = testClass.Modify(x => x.Nullable, testDecimal);
Assert.Null(testClass.Get(x => x.Nullable));
}
public void Immutable_Microbenchmark()
{
var stopwatch = new Stopwatch();
var testClass = new TestClass();
var testClassImmutable = new Immutable<TestClass>();
stopwatch.Start();
for(var i = 0; i < 100000; i++)
{
testClass.Test = i;
}
stopwatch.Stop();
var setterTime = stopwatch.ElapsedMilliseconds;
stopwatch.Reset();
stopwatch.Start();
for(var i = 0; i < 100000; i++)
{
testClassImmutable.Modify(x => x.Test, i);
}
stopwatch.Stop();
var immutableTime = stopwatch.ElapsedMilliseconds;
}
/// <summary>
/// Take responsibility for a new queues that was assigned to me via a new range.
/// We first store the new queue in our internal data structure, try to initialize it and start a pumping timer.
/// ERROR HANDLING:
/// The resposibility to handle initializatoion and shutdown failures is inside the INewQueueAdapterReceiver code.
/// The agent will call Initialize once and log an error. It will not call initiliaze again.
/// The receiver itself may attempt later to recover from this error and do initialization again.
/// The agent will assume initialization has succeeded and will subsequently start calling pumping receive.
/// Same applies to shutdown.
/// </summary>
/// <param name="qAdapter"></param>
/// <param name="queueAdapterCache"></param>
/// <param name="failureHandler"></param>
/// <returns></returns>
public Task Initialize(Immutable<IQueueAdapter> qAdapter, Immutable<IQueueAdapterCache> queueAdapterCache, Immutable<IStreamFailureHandler> failureHandler)
{
if (qAdapter.Value == null) throw new ArgumentNullException("qAdapter", "Init: queueAdapter should not be null");
if (failureHandler.Value == null) throw new ArgumentNullException("failureHandler", "Init: streamDeliveryFailureHandler should not be null");
return OrleansTaskExtentions.WrapInTask(() => InitializeInternal(qAdapter.Value, queueAdapterCache.Value, failureHandler.Value));
}
public Task PingImmutableArray(Immutable<byte[]> data, long nextGrain, bool nextGrainIsRemote)
{
if (nextGrain > 0)
{
if (nextGrainIsRemote)
{
return GrainFactory.GetGrain<IReentrantStressTestGrain>(nextGrain)
.PingImmutableArray(data, -1, false);
}
else
{
return GrainFactory.GetGrain<IReentrantLocalStressTestGrain>(nextGrain)
.PingImmutableArray(data, -1, false);
}
}
return TaskDone.Done;
}
internal Task DeliverItem(StreamId streamId, object item, bool fireAndForgetDelivery)
{
var tasks = fireAndForgetDelivery ? null : new List<Task>();
var immutableItem = new Immutable<object>(item);
foreach (KeyValuePair<GuidId, Tuple<IStreamConsumerExtension, IStreamFilterPredicateWrapper>> subscriptionKvp in consumers)
{
IStreamConsumerExtension remoteConsumer = subscriptionKvp.Value.Item1;
// Apply filter(s) to see if we should forward this item to this consumer
IStreamFilterPredicateWrapper filter = subscriptionKvp.Value.Item2;
if (filter != null)
{
if (!filter.ShouldReceive(streamId, filter.FilterData, item))
continue;
}
Task task = remoteConsumer.DeliverItem(subscriptionKvp.Key, immutableItem, null, null);
if (fireAndForgetDelivery) task.Ignore();
else tasks.Add(task);
}
// If there's no subscriber, presumably we just drop the item on the floor
return fireAndForgetDelivery ? TaskDone.Done : Task.WhenAll(tasks);
}
public Task PingImmutableDictionary(Immutable<Dictionary<int, string>> data, long nextGrain,
bool nextGrainIsRemote)
{
if (nextGrain > 0)
{
if (nextGrainIsRemote)
{
return GrainFactory.GetGrain<IReentrantStressTestGrain>(nextGrain)
.PingImmutableDictionary(data, -1, false);
}
else
{
return GrainFactory.GetGrain<IReentrantLocalStressTestGrain>(nextGrain)
.PingImmutableDictionary(data, -1, false);
}
}
return TaskDone.Done;
}
public Task Initialize(Immutable<IQueueAdapter> qAdapter)
{
if (qAdapter.Value == null) throw new ArgumentNullException("qAdapter", "Init: queueAdapter should not be null");
logger.Info((int)ErrorCode.PersistentStreamPullingManager_02, "Init.");
// Remove cast once we cleanup
queueAdapter = qAdapter.Value;
var meAsQueueBalanceListener = this.AsReference<IStreamQueueBalanceListener>();
queueBalancer.SubscribeToQueueDistributionChangeEvents(meAsQueueBalanceListener);
List<QueueId> myQueues = queueBalancer.GetMyQueues().ToList();
logger.Info((int)ErrorCode.PersistentStreamPullingManager_03, PrintMyState(myQueues));
return AddNewQueues(myQueues, true);
}
public void Test_That_ToBuilder_Returns_New_Instance()
{
var testClass = new Immutable<TestClass>();
var builder = testClass.ToBuilder();
Assert.NotSame(testClass, builder);
}
public void Test_That_Modifying_Nested_Returns_Modifications()
{
var testClass = new Immutable<TestClass>();
var newTestClass = testClass.Modify(x => x.Data,
testClass.Get(x => x.Data)
.Modify(x => x.Member, 2)
);
Assert.Equal(newTestClass.Get(x => x.Data.Get(y => y.Member)), 2);
}
public void Test_Modify_Nested_With_Implicit_Conversion()
{
var testClass = new Immutable<TestClass>();
var newTestClass = testClass.Modify(x => x.Data,
testClass.Get(x => x.Data)
.Modify(x => x.Member, 2.0M)
);
Assert.Equal(newTestClass.Get(x => x.Data.Get(y => y.Member)), 2);
}
