public async Task ExecuteAsync(CancellationToken cancellationToken)
{
try
{
var ds = new DeleteServiceDescription(new Uri(_orphan.ServiceName, UriKind.RelativeOrAbsolute))
{
ForceDelete = true
};
await _fabricClient.ServiceManager.DeleteServiceAsync(ds).ConfigureAwait(false);
if (cancellationToken.IsCancellationRequested)
{
return;
}
var properties = new Dictionary <string, string>
{
{ "EventName", $"{OrphanEventPrefix} successfully removed orphaned service {_orphan}." },
{ "ServiceName", _orphan.ServiceName },
{ "ServiceTypeUri", _orphan.ServiceTypeUri }
};
_telemetryClient.TrackEvent($"{OrphanEventPrefix} removed orphaned service {_orphan}.", properties);
}
catch (Exception ex)
{
// Log the exception and continue removing orphans
var properties = new Dictionary <string, string>
{
{ "ServiceName", _orphan.ServiceName },
{ "ServiceTypeUri", _orphan.ServiceTypeUri }
};
_telemetryClient.TrackException(ex, properties);
}
}
private async Task DeleteActor(int index)
{
var description = new DeleteServiceDescription(new Uri($"{this.context.CodePackageActivationContext.ApplicationName}/SimulationActorService{GetSimulationActorNameSuffix(index)}"));
await this.fabricClient.ServiceManager.DeleteServiceAsync(description);
poolInfo.pool.Remove(index);
}
public override async Task Execute(TriggerItem triggerItem)
{
var serviceDescription = new DeleteServiceDescription(triggerItem.Service.Properties.ServiceName)
{
ForceDelete = true
};
await _fabricClient.ServiceManager.DeleteServiceAsync(serviceDescription);
}
public async Task IncreaseDecreaseServiceInstances(bool increase, string appName, string serviceName, string serviceType)
{
//string appName = "fabric:/MyApplication";
//string serviceName = "fabric:/MyApplication/Stateless1";
//string serviceType = "Stateless1Type";
using (var fabricClient = new FabricClient())
{
if (increase)
{
// Create the stateless service description. For stateful services, use a StatefulServiceDescription object.
StatelessServiceDescription serviceDescription = new StatelessServiceDescription
{
ApplicationName = new Uri(appName),
InstanceCount = 1,
PartitionSchemeDescription = new SingletonPartitionSchemeDescription(),
ServiceName = new Uri(serviceName),
ServiceTypeName = serviceType
};
// Create the service instance.
try
{
fabricClient.ServiceManager.CreateServiceAsync(serviceDescription).Wait();
ServiceEventSource.Current.ServiceMessage(_serviceContext, "Created service instance {0}", serviceName);
}
catch (AggregateException ae)
{
ServiceEventSource.Current.ServiceMessage(_serviceContext, "CreateService failed.");
foreach (Exception ex in ae.InnerExceptions)
{
ServiceEventSource.Current.ServiceMessage(_serviceContext, "HResult: {0} Message: {1}", ex.HResult, ex.Message);
}
}
}
else
{
// Delete a service instance.
try
{
DeleteServiceDescription deleteServiceDescription = new DeleteServiceDescription(new Uri(serviceName));
await fabricClient.ServiceManager.DeleteServiceAsync(deleteServiceDescription);
ServiceEventSource.Current.ServiceMessage(_serviceContext, "Deleted service instance {0}", serviceName);
}
catch (AggregateException ae)
{
ServiceEventSource.Current.ServiceMessage(_serviceContext, "DeleteService failed.");
foreach (Exception ex in ae.InnerExceptions)
{
ServiceEventSource.Current.ServiceMessage(_serviceContext, "HResult: {0} Message: {1}", ex.HResult, ex.Message);
}
}
}
}
}
public DeleteServiceRequest(IFabricClient fabricClient, DeleteServiceDescription deleteServiceDescription, TimeSpan timeout, bool serviceDoesNotExist)
: base(fabricClient, timeout)
{
ThrowIf.Null(deleteServiceDescription, "deleteServiceDescription");
this.DeleteServiceDescription = deleteServiceDescription;
this.serviceDoesNotExist = serviceDoesNotExist;
this.ConfigureErrorCodes();
}
public async Task <IActionResult> Delete(string name)
{
Uri serviceUri = this.CreateTopicUri(name);
var description = new DeleteServiceDescription(serviceUri);
await fabric.ServiceManager.DeleteServiceAsync(description);
return(Ok());
}
public void DeleteServiceDescriptionSerializationTest()
{
Uri serviceName = new Uri("fabric:/" + "testSvc" + this.random.CreateRandom <string>());
DeleteServiceDescription deleteServiceDescription = new DeleteServiceDescription(serviceName)
{
ForceDelete = this.random.CreateRandom <bool>()
};
TestUsingSerializer(this.Serializer, deleteServiceDescription);
}
private async Task DeleteService(Uri targetUri)
{
var description = new DeleteServiceDescription(targetUri);
try
{
await fabric.ServiceManager.DeleteServiceAsync(description);
}
catch (FabricElementNotFoundException)
{
// service doesn't exist; nothing to delete
}
}
public async Task Handle(PeriodEndStartedEvent message, IMessageHandlerContext context)
{
logger.LogDebug($"Received period end started event. Details: {message.ToJson()}");
var fabricClient = new FabricClient();
var serviceDescription = new DeleteServiceDescription(new Uri(ServiceNames.DatalockApprovalsService))
{
ForceDelete = true,
};
await fabricClient.ServiceManager.DeleteServiceAsync(serviceDescription);
logger.LogInfo($"Finished period end started handler. Details: {message.ToJson()}");
}
private async Task FinishRemovalOfSubscriptions(IReliableDictionary <string, string> subscriptions)
{
using (ITransaction tx = this.StateManager.CreateTransaction())
{
var unregisteredServices = new List <string>();
IAsyncEnumerable <KeyValuePair <string, string> > asyncEnumerable = await subscriptions.CreateEnumerableAsync(tx).ConfigureAwait(false);
using (IAsyncEnumerator <KeyValuePair <string, string> > asyncEnumerator = asyncEnumerable.GetAsyncEnumerator())
{
while (await asyncEnumerator.MoveNextAsync(CancellationToken.None).ConfigureAwait(false))
{
string subscriber = asyncEnumerator.Current.Key;
string topic = asyncEnumerator.Current.Value;
try
{
// https://social.msdn.microsoft.com/Forums/en-US/ce8aff1d-6246-4b53-9075-13b738a24b13/best-way-to-determine-if-a-service-already-exists?forum=AzureServiceFabric
// treat as "Desired state management"
// "Instead treat this more like desired state management - create the service until you are told it already exists."
Uri serviceUri = this.Context.CreateSubscriptionUri(topic, subscriber);
var description = new DeleteServiceDescription(serviceUri);
using (var fabric = new FabricClient())
{
await fabric.ServiceManager.DeleteServiceAsync(description);
}
}
catch (FabricElementNotFoundException)
{
await UnregisterSubscriberFromTopic(subscriber, topic);
unregisteredServices.Add(subscriber);
}
}
}
// do after enumerator is complete.
foreach (var sub in unregisteredServices)
{
await subscriptions.TryRemoveAsync(tx, sub);
}
await tx.CommitAsync();
}
}
public async Task DeleteServiceAsync(Uri serviceInstanceUri, bool force = false)
{
var ds = new DeleteServiceDescription(serviceInstanceUri)
{
ForceDelete = force
};
try { await _fabricClient.ServiceManager.DeleteServiceAsync(ds); }
catch (TimeoutException ex)
{
var properties = new Dictionary <string, string>
{
{ "ServiceName", ds.ServiceName?.ToString() }, { "ForceDelete", ds.ForceDelete.ToString() },
{ "ExceptionMessage", ex.Message }, { "ExceptionStack", ex.StackTrace }
};
_telemetryClient.TrackTrace("Remove instance timed out", properties);
}
}
public async Task <IActionResult> Delete(string topicName, string name)
{
var subscriptions = await this.stateManager.GetRemoveSubscriptionsDictionary();
using (var tx = this.stateManager.CreateTransaction())
{
var subAlreadyDeleting = await subscriptions.ContainsKeyAsync(tx, name);
if (subAlreadyDeleting)
{
tx.Abort(); // explicity close transaction
return(Accepted("Subscription has been registered for deletion and is processing."));
}
tx.Abort(); // explicity close transaction
}
Uri serviceUri = this.serviceContext.CreateSubscriptionUri(topicName, name);
var description = new DeleteServiceDescription(serviceUri);
using (var tx = this.stateManager.CreateTransaction())
{
// save id so can deregister with topic service once the service is gone.
// this is done in RunAsync on this service
await subscriptions.SetAsync(tx, name, topicName);
try
{
await fabric.ServiceManager.DeleteServiceAsync(description);
}
catch (FabricElementNotFoundException)
{
// service doesn't exist; nothing to delete
}
await tx.CommitAsync();
}
return(Ok());
}
protected void RemoveService(DeleteServiceDescription deleteDescription)
{
var clusterConnection = this.GetClusterConnection();
try
{
clusterConnection.DeleteServiceAsync(
deleteDescription,
this.GetTimeout(),
this.GetCancellationToken()).Wait();
this.WriteObject(StringResources.Info_RemoveServiceSucceeded);
}
catch (AggregateException aggregateException)
{
aggregateException.Handle((ae) =>
{
this.ThrowTerminatingError(
ae,
Constants.RemoveServiceErrorId,
clusterConnection);
return(true);
});
}
}
public DeleteServiceRequest(IFabricClient fabricClient, DeleteServiceDescription deleteServiceDescription, TimeSpan timeout)
: this(fabricClient, deleteServiceDescription, timeout, false)
{
}
