public void ProcessHostStarted_UpdatesOrCreatesHostSnapshotIfLatest()
{
// Arrange
const string hostId = "abc";
string[] expectedFunctionIds = new string[] { "a", "b" };
DateTimeOffset expectedHostVersion = DateTimeOffset.Now;
IHostIndexManager hostIndexManager = CreateFakeHostIndexManager();
IHostIndexer product = CreateProductUnderTest(hostIndexManager);
HostStartedMessage message = new HostStartedMessage
{
SharedQueueName = hostId,
EnqueuedOn = expectedHostVersion,
Functions = new FunctionDescriptor[]
{
new FunctionDescriptor {
Id = expectedFunctionIds[0]
},
new FunctionDescriptor {
Id = expectedFunctionIds[1]
}
}
};
// Act
product.ProcessHostStarted(message);
// Assert
HostSnapshot hostSnapshot = hostIndexManager.Read(hostId);
Assert.NotNull(hostSnapshot);
Assert.Equal(expectedHostVersion, hostSnapshot.HostVersion);
Assert.Equal(expectedFunctionIds, hostSnapshot.FunctionIds);
}
public Indexer(IPersistentQueueReader<PersistentQueueMessage> queueReader,
IHostIndexer hostIndexer,
IFunctionIndexer functionIndexer,
IIndexerLogWriter logWriter)
{
_queueReader = queueReader;
_hostIndexer = hostIndexer;
_functionIndexer = functionIndexer;
_logWriter = logWriter;
}
public Indexer(IPersistentQueueReader <PersistentQueueMessage> queueReader,
IHostIndexer hostIndexer,
IFunctionIndexer functionIndexer,
IIndexerLogWriter logWriter)
{
_queueReader = queueReader;
_hostIndexer = hostIndexer;
_functionIndexer = functionIndexer;
_logWriter = logWriter;
}
public void ProcessHostStarted_IfHostConcurrentlyUpdated_DeletesKnownFunctionsIfLatest()
{
// Arrange
const string hostId = "host";
string[] originalFunctionIds = new string[] { "a", "b" };
string[] finalFunctionIds = new string[] { "b", "d" };
IHostIndexManager concurrentlyRemoveFunctionsHostIndexManager = CreateStubHostIndexManager(
existingSnapshot: CreateHostSnapshot(DateTimeOffset.MaxValue, finalFunctionIds), persistSucceeds: true);
IFunctionIndexManager functionIndexManager = CreateFakeFunctionIndexManager();
DateTimeOffset earlierHostVersion = DateTimeOffset.MinValue;
AddFunctionToIndex(functionIndexManager, hostId, originalFunctionIds[0], earlierHostVersion);
AddFunctionToIndex(functionIndexManager, hostId, originalFunctionIds[1], earlierHostVersion);
IHostIndexer product = CreateProductUnderTest(concurrentlyRemoveFunctionsHostIndexManager,
functionIndexManager);
HostStartedMessage message = new HostStartedMessage
{
SharedQueueName = hostId,
EnqueuedOn = DateTimeOffset.Now,
Functions = new FunctionDescriptor[]
{
new FunctionDescriptor {
Id = originalFunctionIds[0]
},
new FunctionDescriptor {
Id = originalFunctionIds[1]
},
new FunctionDescriptor {
Id = "c"
},
new FunctionDescriptor {
Id = "d"
}
}
};
// Act
product.ProcessHostStarted(message);
// Assert
IEnumerable <VersionedMetadata> functions = functionIndexManager.List(hostId);
Assert.NotNull(functions); // Guard
IEnumerable <string> functionIds = functions.Select(f => f.Id).ToArray();
Assert.Equal(finalFunctionIds, functionIds);
}
public void ProcessHostStarted_UpdatesExistingFunctionsIfLatest()
{
// Arrange
const string hostId = "host";
DateTimeOffset expectedVersion = DateTimeOffset.Now;
string[] expectedFunctionIds = new string[] { "a", "b", "c" };
IHostIndexManager hostIndexManager = CreateStubHostIndexManager(
CreateHostSnapshot(expectedVersion, expectedFunctionIds), persistSucceeds: true);
IFunctionIndexManager functionIndexManager = CreateFakeFunctionIndexManager();
DateTimeOffset earlierHostVersion = DateTimeOffset.MinValue;
AddFunctionToIndex(functionIndexManager, hostId, expectedFunctionIds[0], earlierHostVersion);
AddFunctionToIndex(functionIndexManager, hostId, expectedFunctionIds[1], earlierHostVersion);
AddFunctionToIndex(functionIndexManager, hostId, expectedFunctionIds[2], earlierHostVersion);
IHostIndexer product = CreateProductUnderTest(hostIndexManager, functionIndexManager);
HostStartedMessage message = new HostStartedMessage
{
SharedQueueName = hostId,
EnqueuedOn = expectedVersion,
Functions = new FunctionDescriptor[]
{
new FunctionDescriptor {
Id = expectedFunctionIds[0]
},
new FunctionDescriptor {
Id = expectedFunctionIds[1]
},
new FunctionDescriptor {
Id = expectedFunctionIds[2]
}
}
};
// Act
product.ProcessHostStarted(message);
// Assert
IEnumerable <VersionedMetadata> functions = functionIndexManager.List(hostId);
Assert.NotNull(functions); // Guard
IEnumerable <string> functionIds = functions.Select(f => f.Id).ToArray();
Assert.Equal(expectedFunctionIds, functionIds);
IEnumerable <DateTimeOffset> versions = functions.Select(f => f.Version).ToArray();
Assert.Equal(new DateTimeOffset[] { expectedVersion, expectedVersion, expectedVersion }, versions);
}
public UpgradeIndexer(IPersistentQueueReader <PersistentQueueMessage> queueReader,
IHostIndexer hostIndexer,
IFunctionIndexer functionIndexer,
IIndexerLogWriter logWriter,
IDashboardVersionManager dashboardVersionReader,
CloudBlobClient client)
: base(queueReader, hostIndexer, functionIndexer, logWriter)
{
_dashboardVersionManager = dashboardVersionReader;
_client = client;
_functionsStore = ConcurrentTextStore.CreateBlobStore(_client, DashboardContainerNames.Dashboard, DashboardDirectoryNames.FunctionsFlat);
_logsStore = ConcurrentTextStore.CreateBlobStore(_client, DashboardContainerNames.Dashboard, DashboardDirectoryNames.Logs);
// From archive back to output
_upgradeQueueReader = new PersistentQueueReader <PersistentQueueMessage>(client.GetContainerReference(ContainerNames.HostArchive),
client.GetContainerReference(ContainerNames.HostOutput));
}
public UpgradeIndexer(IPersistentQueueReader<PersistentQueueMessage> queueReader,
IHostIndexer hostIndexer,
IFunctionIndexer functionIndexer,
IIndexerLogWriter logWriter,
IDashboardVersionManager dashboardVersionReader,
CloudBlobClient client)
: base(queueReader, hostIndexer, functionIndexer, logWriter)
{
_dashboardVersionManager = dashboardVersionReader;
_client = client;
_functionsStore = ConcurrentTextStore.CreateBlobStore(_client, DashboardContainerNames.Dashboard, DashboardDirectoryNames.FunctionsFlat);
_logsStore = ConcurrentTextStore.CreateBlobStore(_client, DashboardContainerNames.Dashboard, DashboardDirectoryNames.Logs);
// From archive back to output
_upgradeQueueReader = new PersistentQueueReader<PersistentQueueMessage>(client.GetContainerReference(ContainerNames.HostArchive),
client.GetContainerReference(ContainerNames.HostOutput));
}
public void ProcessHostStarted_UpdatesOrCreatesFunctionIndexVersionIfLatest()
{
// Arrange
DateTimeOffset expectedVersion = DateTimeOffset.Now;
FakeFunctionIndexVersionManager functionIndexVersionManager = new FakeFunctionIndexVersionManager();
IHostIndexer product = CreateProductUnderTest(functionIndexVersionManager);
HostStartedMessage message = new HostStartedMessage
{
EnqueuedOn = expectedVersion
};
// Act
product.ProcessHostStarted(message);
// Assert
Assert.Equal(expectedVersion, functionIndexVersionManager.Current);
}
public void ProcessHostStarted_IfHostPreviouslyRemovedButProcessingAborted_DeletesKnownFunctionsIfLatest()
{
// Arrange
const string hostId = "host";
DateTimeOffset hostVersion = DateTimeOffset.Now;
string[] previouslyProcessedFunctionIds = new string[] { "a", "b", "c" };
IHostIndexManager concurrentlyRemoveFunctionsHostIndexManager = CreateStubHostIndexManager(
existingSnapshot: null, persistSucceeds: false);
IFunctionIndexManager functionIndexManager = CreateFakeFunctionIndexManager();
AddFunctionToIndex(functionIndexManager, hostId, previouslyProcessedFunctionIds[0], hostVersion);
AddFunctionToIndex(functionIndexManager, hostId, previouslyProcessedFunctionIds[1], hostVersion);
AddFunctionToIndex(functionIndexManager, hostId, previouslyProcessedFunctionIds[2], hostVersion);
IHostIndexer product = CreateProductUnderTest(concurrentlyRemoveFunctionsHostIndexManager,
functionIndexManager);
HostStartedMessage message = new HostStartedMessage
{
SharedQueueName = hostId,
EnqueuedOn = hostVersion,
Functions = new FunctionDescriptor[]
{
new FunctionDescriptor {
Id = previouslyProcessedFunctionIds[0]
},
new FunctionDescriptor {
Id = previouslyProcessedFunctionIds[1]
},
new FunctionDescriptor {
Id = previouslyProcessedFunctionIds[2]
}
}
};
// Act
product.ProcessHostStarted(message);
// Assert
IEnumerable <VersionedMetadata> functions = functionIndexManager.List(hostId);
Assert.NotNull(functions); // Guard
IEnumerable <string> functionIds = functions.Select(f => f.Id).ToArray();
Assert.Equal(new string[0], functionIds);
}
