public static async Task <IActionResult> Run(
// Using /a/p/i route prefix, to let Functions Host distinguish api methods from statics
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "a/p/i/delete-task-hub")] HttpRequest req
)
{
// Checking that the call is authenticated properly
try
{
Globals.ValidateIdentity(req.HttpContext.User, req.Headers);
}
catch (UnauthorizedAccessException ex)
{
return(new OkObjectResult(ex.Message)
{
StatusCode = 401
});
}
string hubName = Environment.GetEnvironmentVariable(EnvVariableNames.DFM_HUB_NAME);
string connectionString = Environment.GetEnvironmentVariable(EnvVariableNames.AzureWebJobsStorage);
var orcService = new AzureStorageOrchestrationService(new AzureStorageOrchestrationServiceSettings
{
StorageConnectionString = connectionString,
TaskHubName = hubName,
});
await orcService.DeleteAsync();
return(new OkResult());
}
public async Task DeleteTaskHub(string connectionStringKey, string taskHubName)
{
Initialize(out _orchestrationService, out _client, connectionStringKey, taskHubName);
await _orchestrationService.DeleteAsync();
ColoredConsole.Write(Green($"Task hub '{_taskHubName}' successfully deleted."));
}
public async Task MonitorIdleTaskHubDisconnected()
{
var settings = new AzureStorageOrchestrationServiceSettings
{
StorageConnectionString = TestHelpers.GetTestStorageAccountConnectionString(),
TaskHubName = nameof(MonitorIdleTaskHubDisconnected),
PartitionCount = 4,
};
var service = new AzureStorageOrchestrationService(settings);
var monitor = new DisconnectedPerformanceMonitor(settings.StorageConnectionString, settings.TaskHubName);
await service.DeleteAsync();
// A null heartbeat is expected when the task hub does not exist.
PerformanceHeartbeat heartbeat = await monitor.PulseAsync(currentWorkerCount : 0);
Assert.IsNull(heartbeat);
await service.CreateAsync();
ScaleRecommendation recommendation;
for (int i = 0; i < 10; i++)
{
heartbeat = await monitor.PulseAsync(currentWorkerCount : 0);
Assert.IsNotNull(heartbeat);
Assert.AreEqual(settings.PartitionCount, heartbeat.PartitionCount);
Assert.AreEqual(settings.PartitionCount, heartbeat.ControlQueueLengths.Count);
Assert.AreEqual(settings.PartitionCount, heartbeat.ControlQueueLatencies.Count);
Assert.AreEqual(0, heartbeat.ControlQueueLengths.Count(l => l != 0));
Assert.AreEqual(0, heartbeat.ControlQueueLatencies.Count(l => l != TimeSpan.Zero));
Assert.AreEqual(0, heartbeat.WorkItemQueueLength);
Assert.AreEqual(0.0, heartbeat.WorkItemQueueLatencyTrend);
Assert.AreEqual(TimeSpan.Zero, heartbeat.WorkItemQueueLatency);
recommendation = heartbeat.ScaleRecommendation;
Assert.IsNotNull(recommendation);
Assert.AreEqual(ScaleAction.None, recommendation.Action);
Assert.AreEqual(false, recommendation.KeepWorkersAlive);
Assert.IsNotNull(recommendation.Reason);
}
// If any workers are assigned, the recommendation should be to have them removed.
heartbeat = await monitor.PulseAsync(currentWorkerCount : 1);
recommendation = heartbeat.ScaleRecommendation;
Assert.IsNotNull(recommendation);
Assert.AreEqual(ScaleAction.RemoveWorker, recommendation.Action);
Assert.AreEqual(false, recommendation.KeepWorkersAlive);
Assert.IsNotNull(recommendation.Reason);
}
public static Task DeleteTaskHubResources(string testName, bool enableExtendedSessions)
{
string hubName = GetTaskHubNameFromTestName(testName, enableExtendedSessions);
var settings = new AzureStorageOrchestrationServiceSettings
{
TaskHubName = hubName,
StorageConnectionString = GetStorageConnectionString(),
};
var service = new AzureStorageOrchestrationService(settings);
return(service.DeleteAsync());
}
public static async Task <IActionResult> DfmDeleteTaskHubFunction(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = Globals.ApiRoutePrefix + "/delete-task-hub")] HttpRequest req,
string taskHubName,
ILogger log
)
{
// Checking that the call is authenticated properly
try
{
await Auth.ValidateIdentityAsync(req.HttpContext.User, req.Headers, taskHubName);
}
catch (Exception ex)
{
log.LogError(ex, "Failed to authenticate request");
return(new UnauthorizedResult());
}
// Checking that we're not in ReadOnly mode
if (DfmEndpoint.Settings.Mode == DfmMode.ReadOnly)
{
log.LogError("Endpoint is in ReadOnly mode");
return(new StatusCodeResult(403));
}
string connectionString = Environment.GetEnvironmentVariable(EnvVariableNames.AzureWebJobsStorage);
var orcService = new AzureStorageOrchestrationService(new AzureStorageOrchestrationServiceSettings
{
StorageConnectionString = connectionString,
TaskHubName = taskHubName,
});
// .DeleteAsync() tends to throw "The requested operation cannot be performed on this container because of a concurrent operation"
// (though still seems to do its job). So just wrapping with try-catch
try
{
await orcService.DeleteAsync();
}
catch (Exception ex)
{
log.LogError(ex, "AzureStorageOrchestrationService.DeleteAsync() failed");
}
return(new OkResult());
}
private async Task DeleteTaskHub(string taskHub, string connectionString)
{
var settings = new AzureStorageOrchestrationServiceSettings()
{
TaskHubName = taskHub,
StorageConnectionString = connectionString,
};
var service = new AzureStorageOrchestrationService(settings);
await service.StartAsync();
this.output.WriteLine($"Deleting task hub : {taskHub}");
try
{
await service.DeleteAsync();
}
catch (Exception ex)
{
// Log error, but don't fail the test, as it can be cleaned up later.
this.output.WriteLine($"Encountered exception deleting task hub: : {ex.ToString()}");
}
}
public static async Task <IActionResult> DeleteTaskHubFunction(
// Using /a/p/i route prefix, to let Functions Host distinguish api methods from statics
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "a/p/i/delete-task-hub")] HttpRequest req,
ILogger log
)
{
// Checking that the call is authenticated properly
try
{
await Auth.ValidateIdentityAsync(req.HttpContext.User, req.Headers);
}
catch (Exception ex)
{
log.LogError(ex, "Failed to authenticate request");
return(new UnauthorizedResult());
}
string hubName = Environment.GetEnvironmentVariable(EnvVariableNames.DFM_HUB_NAME);
string connectionString = Environment.GetEnvironmentVariable(EnvVariableNames.AzureWebJobsStorage);
var orcService = new AzureStorageOrchestrationService(new AzureStorageOrchestrationServiceSettings
{
StorageConnectionString = connectionString,
TaskHubName = hubName,
});
// .DeleteAsync() tends to throw "The requested operation cannot be performed on this container because of a concurrent operation"
// (though still seems to do its job). So just wrapping with try-catch
try
{
await orcService.DeleteAsync();
}
catch (Exception ex)
{
log.LogError(ex, "AzureStorageOrchestrationService.DeleteAsync() failed");
}
return(new OkResult());
}
public Task <IActionResult> DfmDeleteTaskHubFunction(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = Globals.ApiRoutePrefix + "/delete-task-hub")] HttpRequest req,
[DurableClient(TaskHub = Globals.HubNameRouteParamName)] IDurableClient defaultDurableClient,
string connName,
string hubName,
ILogger log
)
{
return(this.HandleAuthAndErrors(defaultDurableClient, req, connName, hubName, log, async(_) => {
// Checking that we're not in ReadOnly mode
if (DfmEndpoint.Settings.Mode == DfmMode.ReadOnly)
{
log.LogError("Endpoint is in ReadOnly mode");
return new StatusCodeResult(403);
}
string connectionString = Environment.GetEnvironmentVariable(Globals.GetFullConnectionStringEnvVariableName(connName));
var orcService = new AzureStorageOrchestrationService(new AzureStorageOrchestrationServiceSettings
{
StorageConnectionString = connectionString,
TaskHubName = hubName,
});
// .DeleteAsync() tends to throw "The requested operation cannot be performed on this container because of a concurrent operation"
// (though still seems to do its job). So just wrapping with try-catch
try
{
await orcService.DeleteAsync();
}
catch (Exception ex)
{
log.LogError(ex, "AzureStorageOrchestrationService.DeleteAsync() failed");
}
return new OkResult();
}));
}
static async Task Main(string[] args)
{
var listener = new CustomEventListener();
listener.EnableEvents(DefaultEventSource.Log, EventLevel.Warning);
string storageConnectionString = Storage.StorageConnectionString;
var settings = new AzureStorageOrchestrationServiceSettings
{
StorageConnectionString = storageConnectionString,
//TaskHubName = "PartitionTest",
TaskHubName = "PartitionTest",
PartitionCount = 1,
//MaxConcurrentTaskOrchestrationWorkItems = 100,
//MaxConcurrentTaskActivityWorkItems = 10,
//MaxStorageOperationConcurrency = Environment.ProcessorCount * 25,
};
var orchestrationServiceAndClient = new AzureStorageOrchestrationService(settings);
//just for test
await orchestrationServiceAndClient.DeleteAsync();
//await Task.Delay(TimeSpan.FromSeconds(60));
await orchestrationServiceAndClient.CreateIfNotExistsAsync();
var taskHubClient = new TaskHubClient(orchestrationServiceAndClient);
var taskHubWorker = new TaskHubWorker(orchestrationServiceAndClient);
//1.create 1000** instance
await Test.CreateMockOrchestrationInstancesAsync(40, 5, taskHubClient);
//
await Test.StartWorker(taskHubWorker);
Console.WriteLine("Press any key to quit.");
Console.ReadLine();
}
async Task <AzureStorageOrchestrationService> EnsureTaskHubAsync(
string testName,
bool testDeletion,
bool deleteBeforeCreate = true,
string workerId = "test")
{
string storageConnectionString = TestHelpers.GetTestStorageAccountConnectionString();
var storageAccount = CloudStorageAccount.Parse(storageConnectionString);
string taskHubName = testName;
var settings = new AzureStorageOrchestrationServiceSettings
{
TaskHubName = taskHubName,
StorageConnectionString = storageConnectionString,
WorkerId = workerId,
};
Trace.TraceInformation($"Task Hub name: {taskHubName}");
var service = new AzureStorageOrchestrationService(settings);
if (deleteBeforeCreate)
{
await service.CreateAsync();
}
else
{
await service.CreateIfNotExistsAsync();
}
// Control queues
Assert.IsNotNull(service.AllControlQueues, "Control queue collection was not initialized.");
ControlQueue[] controlQueues = service.AllControlQueues.ToArray();
Assert.AreEqual(4, controlQueues.Length, "Expected to see the default four control queues created.");
foreach (ControlQueue queue in controlQueues)
{
Assert.IsTrue(await queue.InnerQueue.ExistsAsync(), $"Queue {queue.Name} was not created.");
}
// Work-item queue
WorkItemQueue workItemQueue = service.WorkItemQueue;
Assert.IsNotNull(workItemQueue, "Work-item queue client was not initialized.");
Assert.IsTrue(await workItemQueue.InnerQueue.ExistsAsync(), $"Queue {workItemQueue.Name} was not created.");
// TrackingStore
ITrackingStore trackingStore = service.TrackingStore;
Assert.IsNotNull(trackingStore, "Tracking Store was not initialized.");
try
{
Assert.IsTrue(trackingStore.ExistsAsync().Result, $"Tracking Store was not created.");
}
catch (NotSupportedException)
{ }
string expectedContainerName = taskHubName.ToLowerInvariant() + "-leases";
CloudBlobContainer taskHubContainer = storageAccount.CreateCloudBlobClient().GetContainerReference(expectedContainerName);
Assert.IsTrue(await taskHubContainer.ExistsAsync(), $"Task hub blob container {expectedContainerName} was not created.");
// Task Hub config blob
CloudBlob infoBlob = taskHubContainer.GetBlobReference("taskhub.json");
Assert.IsTrue(await infoBlob.ExistsAsync(), $"The blob {infoBlob.Name} was not created.");
// Task Hub lease container
CloudBlobDirectory leaseDirectory = taskHubContainer.GetDirectoryReference("default");
IListBlobItem[] leaseBlobs = (await this.ListBlobsAsync(leaseDirectory)).ToArray();
Assert.AreEqual(controlQueues.Length, leaseBlobs.Length, "Expected to see the same number of control queues and lease blobs.");
foreach (IListBlobItem blobItem in leaseBlobs)
{
string path = blobItem.Uri.AbsolutePath;
Assert.IsTrue(
controlQueues.Where(q => path.Contains(q.Name)).Any(),
$"Could not find any known control queue name in the lease name {path}");
}
if (testDeletion)
{
await service.DeleteAsync();
foreach (ControlQueue queue in controlQueues)
{
Assert.IsFalse(await queue.InnerQueue.ExistsAsync(), $"Queue {queue.Name} was not deleted.");
}
Assert.IsFalse(await workItemQueue.InnerQueue.ExistsAsync(), $"Queue {workItemQueue.Name} was not deleted.");
try
{
Assert.IsFalse(trackingStore.ExistsAsync().Result, $"Tracking Store was not deleted.");
}
catch (NotSupportedException)
{ }
Assert.IsFalse(await taskHubContainer.ExistsAsync(), $"Task hub blob container {taskHubContainer.Name} was not deleted.");
}
return(service);
}