/// <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 = Stopwatch.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);
        }
        /// <summary>
        /// Gets the details for all applications or for a specific application created in the system.
        /// Also takes in timeout interval, which is the maximum of time the system will allow this operation to continue before returning.
        /// </summary>
        public async Task <IEnumerable <ApplicationWrapper> > GetApplicationListAsync(Uri applicationNameFilter, TimeSpan timeout, CancellationToken cancellationToken)
        {
            var             applicationList = new List <ApplicationWrapper>();
            ApplicationList previousResult  = null;

            // Set up the counter that record the time lapse.
            var stopWatch = Stopwatch.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 application pages in the allotted time budget of {timeout.TotalSeconds} seconds");
                }

                previousResult = await ExceptionsHelper.TranslateCancellations(
                    () => _queryClient.GetApplicationListAsync(
                        applicationNameFilter: applicationNameFilter,
                        continuationToken: previousResult?.ContinuationToken,
                        timeout: remaining,
                        cancellationToken: cancellationToken),
                    cancellationToken);

                applicationList.AddRange(previousResult.Select(MapApp));
            }while (!string.IsNullOrEmpty(previousResult?.ContinuationToken));

            return(applicationList);

            ApplicationWrapper MapApp(Application app) =>
            new ApplicationWrapper
            {
                ApplicationName        = app.ApplicationName,
                ApplicationTypeName    = app.ApplicationTypeName,
                ApplicationTypeVersion = app.ApplicationTypeVersion,
                ApplicationParameters  = MapAppParameters(app),
            };

            IDictionary <string, string> MapAppParameters(Application app)
            {
                // NOTE: App Params in Service Fabric are case insensitive (verified on version 7.0.457.9590).
                // Since this is not documented behavior, the code below tries to play it safe by ignoring
                // duplicated app params instead of throwing and preventing such service from working at all
                // behind the Proxy.
                var result = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);

                foreach (var param in app.ApplicationParameters)
                {
                    if (!result.TryAdd(param.Name, param.Value))
                    {
                        Log.DuplicateAppParameter(_logger, param.Name, app.ApplicationName);
                    }
                }

                return(result);
            }
        }
        /// <summary>
        /// Get the specified NamedProperty.
        /// Also takes in timeout interval, which is the maximum of time the system will allow this operation to continue before returning.
        /// </summary>
        public async Task <string> GetPropertyAsync(Uri parentName, string propertyName, TimeSpan timeout, CancellationToken cancellationToken)
        {
            var result = await ExceptionsHelper.TranslateCancellations(
                () => _propertyManagementClient.GetPropertyAsync(parentName, propertyName, timeout, cancellationToken),
                cancellationToken);

            if (result != null)
            {
                // Transform Nameproperty type to plain string, Nameproperty is a sealed class that is not unit-testable.
                return(result.GetValue <string>());
            }

            return(null);
        }
        /// <summary>
        /// Gets the ServiceManifestName for a specific service,
        /// Also takes in timeout interval, which is the maximum of time the system will allow this operation to continue before returning.
        /// </summary>
        public async Task <string> GetServiceManifestName(string applicationTypeName, string applicationTypeVersion, string serviceTypeName, TimeSpan timeout, CancellationToken cancellationToken)
        {
            var serviceTypes = await ExceptionsHelper.TranslateCancellations(
                () => _queryClient.GetServiceTypeListAsync(
                    applicationTypeName: applicationTypeName,
                    applicationTypeVersion: applicationTypeVersion,
                    serviceTypeNameFilter: serviceTypeName,
                    timeout: timeout,
                    cancellationToken: cancellationToken),
                cancellationToken);

            if (serviceTypes.Count == 0)
            {
                throw new InvalidOperationException($"Did not find a service manifest for ApplicationTypeName={applicationTypeName} ApplicationTypeVersion={applicationTypeVersion} ServiceTypeName={serviceTypeName}");
            }
            return(serviceTypes[0].ServiceManifestName);
        }
        public async Task <IEnumerable <ReplicaWrapper> > GetReplicaListAsync(Guid partitionId, TimeSpan timeout, CancellationToken cancellationToken)
        {
            var replicaList = new List <ReplicaWrapper>();
            ServiceReplicaList previousResult = null;

            // Set up the counter that record the time lapse.
            var stopWatch = Stopwatch.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 replicas pages in the allotted time budget of {timeout.TotalSeconds} seconds");
                }

                previousResult = await ExceptionsHelper.TranslateCancellations(
                    () => _queryClient.GetReplicaListAsync(
                        partitionId: partitionId,
                        continuationToken: previousResult?.ContinuationToken,
                        timeout: remaining,
                        cancellationToken: cancellationToken),
                    cancellationToken);

                foreach (var replica in previousResult)
                {
                    replicaList.Add(
                        new ReplicaWrapper
                    {
                        Id             = replica.Id,
                        ReplicaAddress = replica.ReplicaAddress,
                        ReplicaStatus  = replica.ReplicaStatus,
                        HealthState    = replica.HealthState,
                        ServiceKind    = replica.ServiceKind,
                        Role           = replica.ServiceKind == ServiceKind.Stateful ? ((StatefulServiceReplica)replica).ReplicaRole : (ReplicaRole?)null,
                    });
                }
            }while (!string.IsNullOrEmpty(previousResult?.ContinuationToken));

            return(replicaList);
        }
        /// <summary>
        /// Gets the details for all services of an application or just the specified service. If the services 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 serviceNameFilter to be null because we are getting all ServiceName.
        /// </summary>
        public async Task <IEnumerable <ServiceWrapper> > GetServiceListAsync(Uri applicationName, TimeSpan timeout, CancellationToken cancellationToken)
        {
            var         serviceList    = new List <ServiceWrapper>();
            ServiceList previousResult = null;

            // Set up the counter that record the time lapse.
            var stopWatch = Stopwatch.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 service pages in the allotted time budget of {timeout.TotalSeconds} seconds");
                }

                previousResult = await ExceptionsHelper.TranslateCancellations(
                    () => _queryClient.GetServiceListAsync(
                        applicationName: applicationName,
                        serviceNameFilter: null,
                        continuationToken: previousResult?.ContinuationToken,
                        timeout: remaining,
                        cancellationToken: cancellationToken),
                    cancellationToken);

                foreach (var service in previousResult)
                {
                    serviceList.Add(
                        new ServiceWrapper
                    {
                        ServiceName            = service.ServiceName,
                        ServiceTypeName        = service.ServiceTypeName,
                        ServiceManifestVersion = service.ServiceManifestVersion,
                        ServiceKind            = service.ServiceKind,
                    });
                }
            }while (!string.IsNullOrEmpty(previousResult?.ContinuationToken));

            return(serviceList);
        }
        /// <summary>
        /// Enumerates all Service Fabric properties under a given name.
        /// Also takes in timeout interval, which is the maximum of time the system will allow this operation to continue before returning.
        /// </summary>
        public async Task <IDictionary <string, string> > EnumeratePropertiesAsync(Uri parentName, TimeSpan timeout, CancellationToken cancellationToken)
        {
            var namedProperties = new Dictionary <string, string>(StringComparer.Ordinal);
            PropertyEnumerationResult previousResult = null;

            // Set up the counter that record the time lapse.
            var stopWatch = Stopwatch.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 property pages in the allotted time budget of {timeout.TotalSeconds} seconds");
                }

                previousResult = await ExceptionsHelper.TranslateCancellations(
                    () => _propertyManagementClient.EnumeratePropertiesAsync(
                        name: parentName,
                        includeValues: true,
                        previousResult: previousResult,
                        timeout: remaining,
                        cancellationToken: cancellationToken),
                    cancellationToken);

                foreach (var p in previousResult)
                {
                    if (!namedProperties.TryAdd(p.Metadata.PropertyName, p.GetValue <string>()))
                    {
                        // TODO: Add warning message such as "$PropertyName already exist"
                    }
                }
            }while (previousResult.HasMoreData);
            return(namedProperties);
        }
Esempio n. 8
0
 /// <summary>
 /// Gets the provisioned service manifest document in the specified application type name and application type version.
 /// Also takes in timeout interval, which is the maximum of time the system will allow this operation to continue before returning.
 /// </summary>
 public async Task <string> GetServiceManifestAsync(string applicationTypeName, string applicationTypeVersion, string serviceManifestName, TimeSpan timeout, CancellationToken cancellationToken)
 {
     return(await ExceptionsHelper.TranslateCancellations(
                () => _serviceManagementClient.GetServiceManifestAsync(applicationTypeName, applicationTypeVersion, serviceManifestName, timeout, cancellationToken),
                cancellationToken));
 }