public MockPartitionEnumerationManager(params Partition[] partitions) { var servicePartitionListType = typeof(ServicePartitionList); var servicePartitionList = ReflectionUtils.CreateInstanceOfInternal(servicePartitionListType, new List <Partition>(partitions)) as ServicePartitionList; _servicePartitionList = servicePartitionList; }
// Maps the paritions of the applications from primary cluster and secondary cluster public async Task MapPartitionsOfApplication(Uri applicationName, ClusterDetails primaryCluster, ClusterDetails secondaryCluster, String reliableDictionary) { FabricClient primaryFabricClient = new FabricClient(primaryCluster.address + ':' + primaryCluster.clientConnectionEndpoint); FabricClient secondaryFabricClient = new FabricClient(secondaryCluster.address + ':' + secondaryCluster.clientConnectionEndpoint); IReliableDictionary <Guid, PartitionWrapper> myDictionary = await this.StateManager.GetOrAddAsync <IReliableDictionary <Guid, PartitionWrapper> >(reliableDictionary); ServiceList services = await primaryFabricClient.QueryManager.GetServiceListAsync(applicationName); foreach (Service service in services) { ServicePartitionList primaryPartitions = await primaryFabricClient.QueryManager.GetPartitionListAsync(service.ServiceName); ServicePartitionList secondaryPartitions = await secondaryFabricClient.QueryManager.GetPartitionListAsync(service.ServiceName); await MapPartitions(applicationName, service.ServiceName, primaryCluster, primaryPartitions, secondaryCluster, secondaryPartitions, reliableDictionary); using (var tx = this.StateManager.CreateTransaction()) { var result = await myDictionary.GetCountAsync(tx); ServiceEventSource.Current.ServiceMessage(this.Context, "The number of items in dictionary are : {0}", result); await tx.CommitAsync(); } } }
private async Task InitializeAsync() { bool initPartitionList = false; if (InitializePartitionList() || RefreshPartitionList()) { lock (_lock) { if (InitializePartitionList()) { _context.WriteEvent($"CacheController::InitializeAsync: Initialize"); _fabricClient = new FabricClient(); initPartitionList = true; } if (RefreshPartitionList()) { _context.WriteEvent($"CacheController::InitializeAsync: Refresh {_lastInitializeTime}"); initPartitionList = true; } } } if (initPartitionList && RefreshPartitionList()) { // Note: there is a small chance that this gets executed multiple times when _servicePartitionList == null _context.WriteEvent($"CacheController::InitializeAsync: GetPartitionListAsync"); _servicePartitionList = await _fabricClient.QueryManager.GetPartitionListAsync(_context.StatefulServiceContext.ServiceUri); } _lastInitializeTime = DateTime.UtcNow; }
public async Task <IActionResult> GetAsync() { var result = new List <SmilrEvent>(); // the stateful service service may have more than one partition. // this sample code uses a very basic loop to aggregate the results from each partition to illustrate aggregation. // note that this can be optimized in multiple ways for production code. ServicePartitionList partitions = await this.fabricClient.QueryManager.GetPartitionListAsync(new Uri(serviceUri)); foreach (Partition partition in partitions) { var proxyUrl = GetEventStoreUri(partition); HttpResponseMessage response = await this.httpClient.GetAsync(proxyUrl); if (response.StatusCode != System.Net.HttpStatusCode.OK) { // if one partition returns a failure, you can either fail the entire request or skip that partition. return(this.StatusCode((int)response.StatusCode)); } //Convert this into the format expected from Node var list = JsonConvert.DeserializeObject <List <SmilrEvent> >(await response.Content.ReadAsStringAsync()); if (list != null && list.Any()) { result.AddRange(list); } } return(this.Json(result)); }
/// <summary> /// get partition key for the given Service Fabric service uri. /// </summary> /// <param name="customerId"></param> /// <param name="serviceUri"></param> /// <returns></returns> private ServicePartitionKey GetPartitionKey(int customerId, Uri serviceUri) { ServicePartitionList partitionList = fabricClient.QueryManager.GetPartitionListAsync(serviceUri).Result; // simple approach is used here -- just get the first available partition // for more information on partitioning, refer to the Microsoft documentation: // https://azure.microsoft.com/en-us/documentation/articles/service-fabric-concepts-partitioning/ var partitionInformation = partitionList.First().PartitionInformation; if (partitionInformation.Kind == ServicePartitionKind.Int64Range) { var intRangePartitionInfo = (Int64RangePartitionInformation)partitionInformation; return(new ServicePartitionKey(intRangePartitionInfo.LowKey)); } // a singleton has only one partition, use the default constructor else if (partitionInformation.Kind == ServicePartitionKind.Singleton) { return(new ServicePartitionKey()); } else if (partitionInformation.Kind == ServicePartitionKind.Named) { var stringNamedPartitionInfo = (NamedPartitionInformation)partitionInformation; return(new ServicePartitionKey(stringNamedPartitionInfo.Name)); } else { throw new Exception(string.Format("Unexpected partition type: {0}", partitionInformation.Kind)); } }
public async Task <IActionResult> Get() { Uri serviceName = GetBackEndServiceName(serviceContext); ServicePartitionList partitions = await fabricClient.QueryManager.GetPartitionListAsync(serviceName); List <Team> result = new List <Team>(); foreach (Partition partition in partitions) { long partitionKey = ((Int64RangePartitionInformation)partition.PartitionInformation).LowKey; string proxyUrl = GetProxyUrl(serviceContext, partitionKey); using (HttpResponseMessage response = await httpClient.GetAsync(proxyUrl)) { if (response.StatusCode != System.Net.HttpStatusCode.OK) { continue; } result.AddRange(JsonConvert.DeserializeObject <List <Team> >(await response.Content.ReadAsStringAsync())); } } return(Json(result)); }
/// <summary> /// Get ID for all partitions of a service. If the partition do not fit in a page, one /// page of results is returned as well as a continuation token which can be used to get the next page. Let PartitionFilter to be null because we are getting all partition. /// </summary> public async Task <IEnumerable <Guid> > GetPartitionListAsync(Uri serviceName, TimeSpan timeout, CancellationToken cancellationToken) { var partitionList = new List <Guid>(); ServicePartitionList previousResult = null; // Set up the counter that record the time lapse. var stopWatch = ValueStopwatch.StartNew(); do { cancellationToken.ThrowIfCancellationRequested(); var remaining = timeout - stopWatch.Elapsed; if (remaining.Ticks < 0) { // If the passing time is longer than the timeout duration. throw new TimeoutException($"Unable to enumerate all partition pages in the allotted time budget of {timeout.TotalSeconds} seconds"); } previousResult = await ExceptionsHelper.TranslateCancellations( () => _queryClient.GetPartitionListAsync( serviceName: serviceName, partitionIdFilter: null, continuationToken: previousResult?.ContinuationToken, timeout: remaining, cancellationToken: cancellationToken), cancellationToken); foreach (var partition in previousResult) { partitionList.Add(partition.PartitionInformation.Id); } }while (!string.IsNullOrEmpty(previousResult?.ContinuationToken)); return(partitionList); }
public async Task <IActionResult> Get(int id) { ServicePartitionList partitionList = await _fabricClient.QueryManager.GetPartitionListAsync(new Uri("fabric:/SFPerfMonitoring/StatefulBackEnd")); foreach (Partition partition in partitionList) { long partitionKey = ((Int64RangePartitionInformation)partition.PartitionInformation).LowKey; string proxyUrl = $"http://localhost:{19081}/SFPerfMonitoring/StatefulBackEnd/api/users/{id}?PartitionKind={partition.PartitionInformation.Kind}&PartitionKey={partitionKey}"; HttpResponseMessage response = await _httpClient.GetAsync(proxyUrl); if (response.StatusCode != System.Net.HttpStatusCode.OK) { // if one partition returns a failure, you can either fail the entire request or skip that partition. return(this.StatusCode((int)response.StatusCode)); } string stringResult = await response.Content.ReadAsStringAsync(); var result = JsonConvert.DeserializeObject <Models.User>(stringResult); return(this.Json(result)); } return(null); }
private async Task PopulateServiceEntityAsync( ServiceEntity serviceEntity, CancellationToken cancellationToken) { // Get all partitions in this service ServicePartitionList partitionListResult = await FabricClientRetryHelper.ExecuteFabricActionWithRetryAsync( () => this.testContext.FabricClient.QueryManager.GetPartitionListAsync( serviceEntity.Service.ServiceName, null, this.requestTimeOut, cancellationToken), FabricClientRetryErrors.GetPartitionListFabricErrors.Value, this.timer.GetRemainingTime(), cancellationToken).ConfigureAwait(false); if (partitionListResult != null) { GetClusterStateSnapshotAction.PartitionCount += partitionListResult.Count; foreach (var partitionResultItem in partitionListResult) { var partitionEntity = serviceEntity.AddPartition(partitionResultItem); await this.PopulatePartitionEntityAsync(partitionEntity, cancellationToken).ConfigureAwait(false); } } }
public async Task <HashSet <String> > GetConfiguredApplications(String primarycs, String secondarycs) { FabricClient fabricClient = new FabricClient(); ServicePartitionList partitionList = fabricClient.QueryManager.GetPartitionListAsync(new Uri("fabric:/SFAppDRTool/RestoreService")).Result; List <String> configuredApplicationNames = new List <String>(); foreach (Partition partition in partitionList) { List <String> configAppNames = new List <String>(); var int64PartitionInfo = partition.PartitionInformation as Int64RangePartitionInformation; long lowKey = (long)int64PartitionInfo?.LowKey; IRestoreService restoreServiceClient = ServiceProxy.Create <IRestoreService>(new Uri("fabric:/SFAppDRTool/RestoreService"), new ServicePartitionKey(lowKey)); try { configAppNames = await restoreServiceClient.GetConfiguredApplicationNames(primarycs, secondarycs); configuredApplicationNames.AddRange(configAppNames); } catch (Exception ex) { ServiceEventSource.Current.Message("Web Service: Exception getting all configured application names {0}", ex); throw; } } return(new HashSet <String>(configuredApplicationNames)); }
public async Task WaitForStatefulService(Uri serviceInstanceUri) { StatefulServiceDescription description = await this.Client.ServiceManager.GetServiceDescriptionAsync(serviceInstanceUri) as StatefulServiceDescription; int targetTotalReplicas = description.TargetReplicaSetSize; if (description.PartitionSchemeDescription is UniformInt64RangePartitionSchemeDescription) { targetTotalReplicas *= ((UniformInt64RangePartitionSchemeDescription)description.PartitionSchemeDescription).PartitionCount; } ServicePartitionList partitions = await this.Client.QueryManager.GetPartitionListAsync(serviceInstanceUri); int replicaTotal = 0; while (replicaTotal < targetTotalReplicas) { await Task.Delay(this.interval); //ServiceEventSource.Current.ServiceMessage(this, "CountyService waiting for National Service to come up."); replicaTotal = 0; foreach (Partition partition in partitions) { ServiceReplicaList replicaList = await this.Client.QueryManager.GetReplicaListAsync(partition.PartitionInformation.Id); replicaTotal += replicaList.Count(x => x.ReplicaStatus == System.Fabric.Query.ServiceReplicaStatus.Ready); } } }
public async Task <IEnumerable <Tuple <ClusterDetails, ClusterDetails> > > GetClusterCombinations() { FabricClient fabricClient = new FabricClient(); ServicePartitionList partitionList = fabricClient.QueryManager.GetPartitionListAsync(new Uri("fabric:/SFAppDRTool/RestoreService")).Result; List <Tuple <ClusterDetails, ClusterDetails> > allClusterCombinations = new List <Tuple <ClusterDetails, ClusterDetails> >(); foreach (Partition partition in partitionList) { List <Tuple <ClusterDetails, ClusterDetails> > localClusterCombinations = new List <Tuple <ClusterDetails, ClusterDetails> >(); var int64PartitionInfo = partition.PartitionInformation as Int64RangePartitionInformation; long lowKey = (long)int64PartitionInfo?.LowKey; IRestoreService restoreServiceClient = ServiceProxy.Create <IRestoreService>(new Uri("fabric:/SFAppDRTool/RestoreService"), new ServicePartitionKey(lowKey)); try { localClusterCombinations = await restoreServiceClient.GetClusterCombinations(); allClusterCombinations.AddRange(localClusterCombinations); } catch (Exception ex) { ServiceEventSource.Current.Message("Web Service: Exception getting cluster combinations {0}", ex); throw; } } return(allClusterCombinations); }
public async Task <IEnumerable <PartitionWrapper> > GetPartitionStatus() { FabricClient fabricClient = new FabricClient(); ServicePartitionList partitionList = fabricClient.QueryManager.GetPartitionListAsync(new Uri("fabric:/SFAppDRTool/RestoreService")).Result; List <PartitionStatusModel> partitionStatusList = new List <PartitionStatusModel>(); List <PartitionWrapper> mappedPartitions = new List <PartitionWrapper>(); foreach (Partition partition in partitionList) { List <PartitionWrapper> servicePartitions = new List <PartitionWrapper>(); var int64PartitionInfo = partition.PartitionInformation as Int64RangePartitionInformation; long lowKey = (long)int64PartitionInfo?.LowKey; IRestoreService restoreServiceClient = ServiceProxy.Create <IRestoreService>(new Uri("fabric:/SFAppDRTool/RestoreService"), new ServicePartitionKey(lowKey)); try { servicePartitions = await restoreServiceClient.GetStatus(); mappedPartitions.AddRange(servicePartitions); } catch (Exception ex) { ServiceEventSource.Current.Message("Web Service: Exception getting the status {0}", ex); throw; } } //if (mappedPartitions.Count == 0) return null; return(mappedPartitions); }
public async Task <IActionResult> Get() { //return this.Json(new string[] { "value1", "value2" }); Uri serviceName = eCommerceGatewaySvc.GetVotingDataServiceName(this.serviceContext); //Uri proxyAddress = this.GetProxyAddress(serviceName); ServicePartitionList partitions = await this.fabricClient.QueryManager.GetPartitionListAsync(serviceName); List <KeyValuePair <string, int> > result = new List <KeyValuePair <string, int> >(); foreach (Partition partition in partitions) { string proxyUrl = "http://localhost:19081/eCommerce/eCommerceOrderAPI/API/Values?PartitionKey=1&PartitionKind=Int64Range"; //$"{proxyAddress}/api/values?PartitionKey={((Int64RangePartitionInformation)partition.PartitionInformation).LowKey}&PartitionKind=Int64Range"; using (HttpResponseMessage response = await this.httpClient.GetAsync(proxyUrl)) { if (response.StatusCode != System.Net.HttpStatusCode.OK) { continue; } result.AddRange(JsonConvert.DeserializeObject <List <KeyValuePair <string, int> > >(await response.Content.ReadAsStringAsync())); } } return(this.Json(result)); }
public async Task <IActionResult> GetQueueLengthAsync() { ServiceUriBuilder uriBuilder = new ServiceUriBuilder(TenantDataServiceName); Uri serviceUri = uriBuilder.Build(); // service may be partitioned. // this will aggregate the queue lengths from each partition ServicePartitionList partitions = await this.fabricClient.QueryManager.GetPartitionListAsync(serviceUri); HttpClient httpClient = new HttpClient(new HttpServiceClientHandler()); long count = 0; foreach (Partition partition in partitions) { Uri getUrl = new HttpServiceUriBuilder() .SetServiceName(serviceUri) .SetPartitionKey(((Int64RangePartitionInformation)partition.PartitionInformation).LowKey) .SetServicePathAndQuery($"/api/devices/queue/length") .Build(); HttpResponseMessage response = await httpClient.GetAsync(getUrl, this.cancellationSource.Token); if (response.StatusCode != System.Net.HttpStatusCode.OK) { return(this.StatusCode((int)response.StatusCode)); } string result = await response.Content.ReadAsStringAsync(); count += Int64.Parse(result); } return(this.Ok(count)); }
static void Main(string[] args) { FabricClient fabricClient = new FabricClient("localhost:19000"); ServicePartitionList partitionList = fabricClient.QueryManager.GetPartitionListAsync(new Uri("fabric:/Codit.Core.Application/DeviceActorService")).Result; ContinuationToken continuationToken = null; var cancellationTokenSource = new CancellationTokenSource(); List <ActorInformation> activeActors = new List <ActorInformation>(); foreach (var partition in partitionList) { var key = partition.PartitionInformation as Int64RangePartitionInformation; IActorService actorServiceProxy = ActorServiceProxy.Create(new Uri("fabric:/Codit.Core.Application/DeviceActorService"), key.LowKey); do { PagedResult <ActorInformation> page = actorServiceProxy.GetActorsAsync(continuationToken, cancellationTokenSource.Token).Result; activeActors.AddRange(page.Items.Where(x => x.IsActive)); continuationToken = page.ContinuationToken; }while (continuationToken != null); } foreach (var actor in activeActors) { Console.WriteLine($"Active Actor: {actor.ActorId.ToString()}"); } Console.WriteLine("Press any key to exit..."); Console.ReadLine(); }
/// <summary> /// Resolves the <see cref="ServicePartitionKey"/> to send the message to, based on message type name. /// </summary> /// <param name="messageTypeName">Full type name of message object.</param> /// <param name="brokerServiceName"></param> /// <returns></returns> private async Task <ServicePartitionKey> GetPartitionForMessageAsync(string messageTypeName, Uri brokerServiceName) { if (_cachedPartitions == null) { _cachedPartitions = await _fabricClient.QueryManager.GetPartitionListAsync(brokerServiceName ?? await LocateAsync()); } int hashCode; unchecked { hashCode = (int)_hashingHelper.HashString(messageTypeName); } int index = Math.Abs(hashCode % _cachedPartitions.Count); var partition = _cachedPartitions[index]; if (partition.PartitionInformation.Kind != ServicePartitionKind.Int64Range) { throw new InvalidOperationException("Sorry, only Int64 Range Partitions are supported."); } var info = (Int64RangePartitionInformation)partition.PartitionInformation; var resolvedPartition = new ServicePartitionKey(info.LowKey); return(resolvedPartition); }
public async Task <ServicePartitionList> GetPartitionsAsync(CancellationToken ct) { ReleaseAssert.AssertIfNull(FabricClientRetryErrors.GetPartitionListFabricErrors.Value, "partition list error code"); var retryableErrors = new FabricClientRetryErrors(); retryableErrors.RetryableFabricErrorCodes.AddRangeNullSafe(FabricClientRetryErrors.GetPartitionListFabricErrors.Value.RetryableFabricErrorCodes); retryableErrors.RetryableExceptions.AddRangeNullSafe(FabricClientRetryErrors.GetPartitionListFabricErrors.Value.RetryableExceptions); retryableErrors.RetryableFabricErrorCodes.Add(FabricErrorCode.PartitionNotFound); ServicePartitionList servicePartitionList = new ServicePartitionList(); string continuationToken = null; do { ServicePartitionList queryResult = await FabricClientRetryHelper.ExecuteFabricActionWithRetryAsync( () => this.TestContext.FabricClient.QueryManager.GetPartitionListAsync( this.serviceName, null, continuationToken, this.requestTimeout, ct), retryableErrors, this.operationTimeout, ct).ConfigureAwait(false); servicePartitionList.AddRangeNullSafe(queryResult); continuationToken = queryResult.ContinuationToken; } while (!string.IsNullOrEmpty(continuationToken)); return(servicePartitionList); }
public async Task <ActionResult <IEnumerable <Blog> > > Get() { try { var results = new List <Blog>(); FabricClient client = new FabricClient(); ServicePartitionList partitions = await client.QueryManager.GetPartitionListAsync(new Uri(rssCatalogUrl)); foreach (var partition in partitions) { long minKey = (partition.PartitionInformation as Int64RangePartitionInformation).LowKey; var service = ServiceProxy.Create <IRssCatalog>(new Uri(rssCatalogUrl), new ServicePartitionKey(minKey)); IEnumerable <Blog> subResult = await service.GetAllBlogs(); if (subResult != null) { results.AddRange(subResult); } } return(StatusCode(StatusCodes.Status200OK, results)); } catch (Exception ex) { return(StatusCode(StatusCodes.Status500InternalServerError, ex.ToString())); } }
public async Task <IEnumerable <Vehicle> > GetAllVehicles() { ServiceEventSource.Current.Message("Called GetAllVehicles in STATELESS GATEWAY service to return collection of ALL the Vehicles"); List <Vehicle> aggregatedVehiclesList = new List <Vehicle>(); ServicePartitionList partitions = await _fabricClient.QueryManager.GetPartitionListAsync(_vehiclesStatefulServiceUriInstance); foreach (Partition p in partitions) { long minKey = (p.PartitionInformation as Int64RangePartitionInformation).LowKey; IVehiclesStatefulService vehiclesServiceClient = ServiceProxy.Create <IVehiclesStatefulService>(_vehiclesStatefulServiceUriInstance, new ServicePartitionKey(minKey)); //Async call aggregating the results IList <Vehicle> currentPartitionResult; //(CDLTLL) This method should be substituted by a paginated method (20 vehicles per page or so). //No method should return ALL the vehicles as potentially there could be thousands or millions... currentPartitionResult = await vehiclesServiceClient.GetAllVehiclesAsync(); if (currentPartitionResult.Count > 0) { //Aggregate List from current partition to our global result aggregatedVehiclesList.AddRange(currentPartitionResult); } } //Return the aggregated list from all the partitions return(aggregatedVehiclesList); }
public async Task <IActionResult> Get() { logger.Debug("Requesting to load vote data"); Uri serviceName = VotingWeb.GetVotingDataServiceName(this.serviceContext); Uri proxyAddress = this.GetProxyAddress(serviceName); ServicePartitionList partitions = await fabricClient.QueryManager.GetPartitionListAsync(serviceName); List <KeyValuePair <string, int> > result = new List <KeyValuePair <string, int> >(); foreach (Partition partition in partitions) { string proxyUrl = $"{proxyAddress}/api/VoteData?PartitionKey={((Int64RangePartitionInformation)partition.PartitionInformation).LowKey}&PartitionKind=Int64Range"; using (HttpResponseMessage response = await this.httpClient.GetAsync(proxyUrl)) { if (response.StatusCode != System.Net.HttpStatusCode.OK) { continue; } result.AddRange(JsonConvert.DeserializeObject <List <KeyValuePair <string, int> > >(await response.Content.ReadAsStringAsync())); } } return(this.Json(result)); }
public async Task <IEnumerable <Vehicle> > GetTenantVehicles([FromUri] string tenantId) { ServiceEventSource.Current.Message("Called GetTenantVehicles in STATELESS GATEWAY service to return collection of Vehicles for Tenant {0}", tenantId); List <Vehicle> aggregatedVehiclesList = new List <Vehicle>(); ServicePartitionList partitions = await _fabricClient.QueryManager.GetPartitionListAsync(_vehiclesStatefulServiceUriInstance); foreach (Partition p in partitions) { long minKey = (p.PartitionInformation as Int64RangePartitionInformation).LowKey; IVehiclesStatefulService vehiclesServiceClient = ServiceProxy.Create <IVehiclesStatefulService>(_vehiclesStatefulServiceUriInstance, new ServicePartitionKey(minKey)); //Async call aggregating the results IList <Vehicle> currentPartitionResult; currentPartitionResult = await vehiclesServiceClient.GetTenantVehiclesAsync(tenantId); if (currentPartitionResult.Count > 0) { //Aggregate List from current partition to our global result aggregatedVehiclesList.AddRange(currentPartitionResult); } } //Return the aggregated list from all the partitions return(aggregatedVehiclesList); }
/// <summary> /// Resolves the <see cref="ServicePartitionKey"/> to send the message to, based on message type. /// </summary> /// <param name="message">The message to publish</param> /// <param name="brokerServiceName"></param> /// <returns></returns> public async Task <ServicePartitionKey> GetPartitionForMessageAsync(object message, Uri brokerServiceName) { if (message == null) { throw new ArgumentNullException(nameof(message)); } if (brokerServiceName == null) { throw new ArgumentNullException(nameof(brokerServiceName)); } string messageTypeName = (message.GetType().FullName); if (_cachedPartitions == null) { var fabricClient = new FabricClient(); _cachedPartitions = await fabricClient.QueryManager.GetPartitionListAsync(brokerServiceName); } int index = Math.Abs(messageTypeName.GetHashCode() % _cachedPartitions.Count); var partition = _cachedPartitions[index]; if (partition.PartitionInformation.Kind != ServicePartitionKind.Int64Range) { throw new InvalidOperationException("Sorry, only Int64 Range Partitions are supported."); } var info = (Int64RangePartitionInformation)partition.PartitionInformation; var resolvedPartition = new ServicePartitionKey(info.LowKey); return(resolvedPartition); }
/// <summary> /// Returns the list of employees from all the partitions. In our sample we have only 1 partition /// Also, we are making use of proxy to determine the right partition to connect to. /// Please refer this link for more details. https://docs.microsoft.com/en-us/azure/service-fabric/service-fabric-reverseproxy /// </summary> /// <returns></returns> public async Task <List <Employee> > GetEmployees() { Uri serviceName = EmployeeWeb.GetEmployeeDataServiceName(_context); Uri proxyAddress = this.GetProxyAddress(serviceName); ServicePartitionList partitions = await _fabricClient.QueryManager.GetPartitionListAsync(serviceName); List <Employee> employees = new List <Employee>(); foreach (Partition partition in partitions) { string proxyUrl = $"{proxyAddress}/api/Employee?PartitionKey={((Int64RangePartitionInformation)partition.PartitionInformation).LowKey}&PartitionKind=Int64Range"; using (HttpResponseMessage response = await _httpClient.GetAsync(proxyUrl)) { if (response.StatusCode != System.Net.HttpStatusCode.OK) { continue; } employees.AddRange(JsonConvert.DeserializeObject <List <Employee> >(await response.Content.ReadAsStringAsync())); } } return(employees); }
public async Task <IActionResult> GetAsync() { string serviceUri = this.serviceContext.CodePackageActivationContext.ApplicationName + "/" + this.configSettings.ActorBackendServiceName; ServicePartitionList partitions = await this.fabricClient.QueryManager.GetPartitionListAsync(new Uri(serviceUri)); long count = 0; foreach (Partition partition in partitions) { long partitionKey = ((Int64RangePartitionInformation)partition.PartitionInformation).LowKey; IActorService actorServiceProxy = ActorServiceProxy.Create(new Uri(serviceUri), partitionKey); ContinuationToken continuationToken = null; do { PagedResult <ActorInformation> page = await actorServiceProxy.GetActorsAsync(continuationToken, CancellationToken.None); count += page.Items.Where(x => x.IsActive).LongCount(); continuationToken = page.ContinuationToken; }while (continuationToken != null); } return(this.Json(new { Count = count, Date = DateTime.Now })); }
public async Task <IEnumerable <string> > Get() { ServicePartitionList partitions = await fabricClient.QueryManager.GetPartitionListAsync(new ServiceUriBuilder("WorkService").Build()); List <string> result = new List <string>(); foreach (Partition partition in partitions) { HttpClient client = new HttpClient(new HttpServiceClientHandler()); Int64RangePartitionInformation partitionInfo = (Int64RangePartitionInformation)partition.PartitionInformation; Uri serviceUri = new HttpServiceUriBuilder() .SetServiceName(new ServiceUriBuilder("WorkService").Build()) .SetPartitionKey(partitionInfo.LowKey) .SetServicePathAndQuery($"api/work/") .Build(); HttpResponseMessage response = await client.GetAsync(serviceUri); string responseContent = await response.Content.ReadAsStringAsync(); if (responseContent != null) { JArray responseJson = JArray.Parse(responseContent); result.AddRange(responseJson.Select(x => x.Value <string>())); } } return(result); }
private async Task <Int64RangePartitionInformation[]> GetServicePartitionsListAsync() { if (this.servicePartitionsTaskCompletionSource == null) { bool isNewTaskCompletionSourceCreated = false; lock (tcsLockObject) { if (this.servicePartitionsTaskCompletionSource == null) { this.servicePartitionsTaskCompletionSource = new TaskCompletionSource <Int64RangePartitionInformation[]>(); isNewTaskCompletionSourceCreated = true; } } if (isNewTaskCompletionSourceCreated) { using (var fabricClient = new FabricClient()) { ServicePartitionList partitionList = await fabricClient.QueryManager.GetPartitionListAsync(this.serviceUri); Int64RangePartitionInformation[] orderedPartitions = partitionList.Select(x => x.PartitionInformation) .OfType <Int64RangePartitionInformation>() .OrderBy(x => x.LowKey).ToArray(); if (partitionList.Count != orderedPartitions.Length) { throw new NotSupportedException("FabricPartitionEndpointResolver doesn't support non Int64RangePartitionInformation partitions"); } this.servicePartitionsTaskCompletionSource.SetResult(orderedPartitions); } } } return(this.servicePartitionsTaskCompletionSource.Task.Result); }
public async Task <IActionResult> GetAsync() { string serviceUri = this.serviceContext.CodePackageActivationContext.ApplicationName + "/" + this.configSettings.ActorBackendServiceName; ServicePartitionList partitions = await this.fabricClient.QueryManager.GetPartitionListAsync(new Uri(serviceUri)); long count = 0; foreach (Partition partition in partitions) { long partitionKey = ((Int64RangePartitionInformation)partition.PartitionInformation).LowKey; IActorService actorServiceProxy = ActorServiceProxy.Create(new Uri(serviceUri), partitionKey); // https://docs.microsoft.com/it-it/azure/service-fabric/service-fabric-reliable-actors-enumerate // Gli Actors sono ranged partitioned stateful service, quindi l'enumeration è fatta per partizione. // Ogni partizione contiene più attori, e il risultato è un loop su un elenco di "pagine". ContinuationToken continuationToken = null; do { PagedResult <ActorInformation> page = await actorServiceProxy.GetActorsAsync(continuationToken, CancellationToken.None); count += page.Items.Where(x => x.IsActive).LongCount(); continuationToken = page.ContinuationToken; }while (continuationToken != null); } return(this.Json(new CountViewModel() { Count = count })); }
/// <summary> /// Gets the partitions information. /// </summary> /// <param name="serviceUri">The service URI.</param> /// <returns></returns> private async Task GetPartitionsInfo(Uri serviceUri) { this.partitionList = await fabricClient.QueryManager.GetPartitionListAsync(serviceUri); this.partitionInfoList = this.partitionList.Select(p => p.PartitionInformation as Int64RangePartitionInformation).ToList(); this.numberOfPartitions = partitionList.Count; }
public async Task <string> Disconfigure(string applicationName) { bool successfullyRemoved = true; FabricClient fabricClient = new FabricClient(); ServicePartitionList partitionList = fabricClient.QueryManager.GetPartitionListAsync(new Uri("fabric:/SFAppDRTool/RestoreService")).Result; foreach (Partition partition in partitionList) { var int64PartitionInfo = partition.PartitionInformation as Int64RangePartitionInformation; long lowKey = (long)int64PartitionInfo?.LowKey; IRestoreService restoreServiceClient = ServiceProxy.Create <IRestoreService>(new Uri("fabric:/SFAppDRTool/RestoreService"), new ServicePartitionKey(lowKey)); try { string applicationRemoved = await restoreServiceClient.Disconfigure("fabric:/" + applicationName); if (applicationRemoved == null) { successfullyRemoved = false; } } catch (Exception ex) { ServiceEventSource.Current.Message("Web Service: Exception Disconfiguring {0}", ex); throw; } } if (successfullyRemoved) { return(applicationName); } return(null); }