public static async Task <IDictionary <ActorId, ActorInformation> > GetFromAllActors <TActorType>(IPartitionEnumerationManager partitionEnumerationManager, IActorProxyFactory actorProxyFactory,
Uri serviceUri, CancellationToken cancellationToken = default(CancellationToken), int maxResults = 100)
where TActorType : IActor
{
var servicePartitionKeysAsync = await ServiceContextExtensions.GetServicePartitionKeysAsync(partitionEnumerationManager, serviceUri);
var result = new Dictionary <ActorId, ActorInformation>();
var results = 0;
foreach (var partitionInformation in servicePartitionKeysAsync)
{
var actorServiceProxy = actorProxyFactory.CreateActorServiceProxy <IActorService>(serviceUri, partitionInformation.LowKey);
ContinuationToken continuationToken = null;
do
{
var page = await actorServiceProxy.GetActorsAsync(continuationToken, cancellationToken);
foreach (var actor in page.Items)
{
result.Add(actor.ActorId, actor);
results++;
}
if (results >= maxResults)
{
return(result);
}
continuationToken = page.ContinuationToken;
}while (continuationToken != null);
}
return(result);
}
/// <summary>
/// Convert a base64 string to a continuation token.
/// </summary>
/// <param name="query">The <see cref="IContinuationQuery"/> to use.</param>
/// <returns>A <see cref="LimitOffsetContinuationToken"/>.</returns>
public static LimitOffsetContinuationToken FromContinuationQuery(IContinuationQuery query)
{
return(ContinuationToken.FromContinuationToken <LimitOffsetContinuationToken>(query.ContinuationToken)
?? new LimitOffsetContinuationToken {
Limit = query.Limit
});
}
/// <summary>
/// Get the next page token.
/// </summary>
/// <returns>A bse64 encoded next page token.</returns>
public string GetNextPageContinuationToken()
{
return(ContinuationToken.ToContinuationToken(
new LimitOffsetContinuationToken {
Offset = Offset + Limit, Limit = Limit
}));
}
/// <inheritdoc />
public Task <PagedData <BackupEntity> > GetAllEntitiesBackedUpByPolicyAsync(
string backupPolicyName,
ContinuationToken continuationToken = default(ContinuationToken),
long?maxResults = 0,
long?serverTimeout = 60,
CancellationToken cancellationToken = default(CancellationToken))
{
backupPolicyName.ThrowIfNull(nameof(backupPolicyName));
maxResults?.ThrowIfLessThan("maxResults", 0);
serverTimeout?.ThrowIfOutOfInclusiveRange("serverTimeout", 1, 4294967295);
var requestId = Guid.NewGuid().ToString();
var url = "BackupRestore/BackupPolicies/{backupPolicyName}/$/GetBackupEnabledEntities";
url = url.Replace("{backupPolicyName}", Uri.EscapeDataString(backupPolicyName));
var queryParams = new List <string>();
// Append to queryParams if not null.
continuationToken?.AddToQueryParameters(queryParams, $"ContinuationToken={continuationToken.ToString()}");
maxResults?.AddToQueryParameters(queryParams, $"MaxResults={maxResults}");
serverTimeout?.AddToQueryParameters(queryParams, $"timeout={serverTimeout}");
queryParams.Add("api-version=6.2-preview");
url += "?" + string.Join("&", queryParams);
HttpRequestMessage RequestFunc()
{
var request = new HttpRequestMessage()
{
Method = HttpMethod.Get,
};
return(request);
}
return(this.httpClient.SendAsyncGetResponseAsPagedData(RequestFunc, url, BackupEntityConverter.Deserialize, requestId, cancellationToken));
}
/// <inheritdoc />
public Task <PagedData <BackupConfigurationInfo> > GetServiceBackupConfigurationInfoAsync(
string serviceId,
ContinuationToken continuationToken = default(ContinuationToken),
long?maxResults = 0,
long?serverTimeout = 60,
CancellationToken cancellationToken = default(CancellationToken))
{
serviceId.ThrowIfNull(nameof(serviceId));
maxResults?.ThrowIfLessThan("maxResults", 0);
serverTimeout?.ThrowIfOutOfInclusiveRange("serverTimeout", 1, 4294967295);
var requestId = Guid.NewGuid().ToString();
var url = "Services/{serviceId}/$/GetBackupConfigurationInfo";
url = url.Replace("{serviceId}", serviceId);
var queryParams = new List <string>();
// Append to queryParams if not null.
continuationToken?.AddToQueryParameters(queryParams, $"ContinuationToken={continuationToken.ToString()}");
maxResults?.AddToQueryParameters(queryParams, $"MaxResults={maxResults}");
serverTimeout?.AddToQueryParameters(queryParams, $"timeout={serverTimeout}");
queryParams.Add("api-version=6.2-preview");
url += "?" + string.Join("&", queryParams);
HttpRequestMessage RequestFunc()
{
var request = new HttpRequestMessage()
{
Method = HttpMethod.Get,
};
return(request);
}
return(this.httpClient.SendAsyncGetResponseAsPagedData(RequestFunc, url, BackupConfigurationInfoConverter.Deserialize, requestId, cancellationToken));
}
public override string ToString()
{
var sb = new StringBuilder("GetJoinedSquareChatsRequest(");
bool __first = true;
if (ContinuationToken != null && __isset.continuationToken)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("ContinuationToken: ");
ContinuationToken.ToString(sb);
}
if (__isset.limit)
{
if (!__first)
{
sb.Append(", ");
}
__first = false;
sb.Append("Limit: ");
Limit.ToString(sb);
}
sb.Append(")");
return(sb.ToString());
}
/// <inheritdoc />
public Task <PagedData <LoadedPartitionInformationResult> > GetLoadedPartitionInfoListAsync(
string metricName,
string serviceName = default(string),
Ordering?ordering = Ordering.Desc,
long?maxResults = 0,
ContinuationToken continuationToken = default(ContinuationToken),
CancellationToken cancellationToken = default(CancellationToken))
{
metricName.ThrowIfNull(nameof(metricName));
maxResults?.ThrowIfLessThan("maxResults", 0);
var requestId = Guid.NewGuid().ToString();
var url = "$/GetLoadedPartitionInfoList";
var queryParams = new List <string>();
// Append to queryParams if not null.
metricName?.AddToQueryParameters(queryParams, $"MetricName={metricName}");
serviceName?.AddToQueryParameters(queryParams, $"ServiceName={serviceName}");
ordering?.AddToQueryParameters(queryParams, $"Ordering={ordering.ToString()}");
maxResults?.AddToQueryParameters(queryParams, $"MaxResults={maxResults}");
continuationToken?.AddToQueryParameters(queryParams, $"ContinuationToken={continuationToken.ToString()}");
queryParams.Add("api-version=8.0");
url += "?" + string.Join("&", queryParams);
HttpRequestMessage RequestFunc()
{
var request = new HttpRequestMessage()
{
Method = HttpMethod.Get,
};
return(request);
}
return(this.httpClient.SendAsyncGetResponseAsPagedData(RequestFunc, url, LoadedPartitionInformationResultConverter.Deserialize, requestId, cancellationToken));
}
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();
}
public async Task <IEnumerable <int> > GetCountsAsync(CancellationToken cancellationToken)
{
ContinuationToken continuationToken = null;
var result = new List <int>();
do
{
var page = await StateProvider.GetActorsAsync(10000, continuationToken, cancellationToken);
foreach (var actorId in page.Items)
{
var state = await StateProvider.LoadStateAsync <int>(
actorId : actorId,
stateName : "count",
cancellationToken : cancellationToken);
result.Add(state);
}
continuationToken = page.ContinuationToken;
} while (continuationToken != null);
return(result);
}
public void ItShouldThrowOnMalformedTokens()
{
var malformedToken = new Faker().Random.Hash();
Action act = () => ContinuationToken.FromContinuationToken <DeserializedToken>(malformedToken);
act.Should().Throw <System.ComponentModel.DataAnnotations.ValidationException>().WithMessage($"*{malformedToken}*");
}
/// <summary>
///
/// </summary>
/// <param name="kpuIdSearchFor"></param>
/// <returns></returns>
public Task <IToHActor> GetActorFromKpuId(string kpuIdSearchFor)
{
CancellationTokenSource source = new CancellationTokenSource();
CancellationToken cancellationToken = source.Token;
int partitionKey = 0;
IActorService actorServiceProxy = ActorServiceProxy.Create(new Uri("fabric:/CWF.Fabric.Services/ToHActorService"), 0);
ContinuationToken continuationToken = null;
List <ActorInformation> activeActors = new List <ActorInformation>();
do
{
Task <PagedResult <ActorInformation> > pageTask = actorServiceProxy.GetActorsAsync(continuationToken, cancellationToken);
PagedResult <ActorInformation> page = pageTask.Result;
activeActors.AddRange(page.Items.Where(x => x.IsActive));
continuationToken = page.ContinuationToken;
}while (continuationToken != null);
foreach (ActorInformation info in activeActors)
{
var proxy = ActorProxy.Create <IToHActor>(info.ActorId, "fabric:/CWF.Fabric.Services");
Task <string> kpuId = proxy.GetKpuId();
var kpuid = kpuId.Result;
if (kpuid.CompareTo(kpuIdSearchFor) == 0)
{
return(Task.FromResult <IToHActor>(proxy));
}
}
return(null);
}
/// <inheritdoc />
public Task <PagedData <string> > GetSubNameInfoListAsync(
string nameId,
bool?recursive = false,
ContinuationToken continuationToken = default(ContinuationToken),
long?serverTimeout = 60,
CancellationToken cancellationToken = default(CancellationToken))
{
nameId.ThrowIfNull(nameof(nameId));
serverTimeout?.ThrowIfOutOfInclusiveRange("serverTimeout", 1, 4294967295);
var requestId = Guid.NewGuid().ToString();
var url = "Names/{nameId}/$/GetSubNames";
url = url.Replace("{nameId}", nameId);
var queryParams = new List <string>();
// Append to queryParams if not null.
recursive?.AddToQueryParameters(queryParams, $"Recursive={recursive}");
continuationToken?.AddToQueryParameters(queryParams, $"ContinuationToken={continuationToken.ToString()}");
serverTimeout?.AddToQueryParameters(queryParams, $"timeout={serverTimeout}");
queryParams.Add("api-version=6.0");
url += "?" + string.Join("&", queryParams);
HttpRequestMessage RequestFunc()
{
var request = new HttpRequestMessage()
{
Method = HttpMethod.Get,
};
return(request);
}
return(this.httpClient.SendAsyncGetResponseAsPagedData(RequestFunc, url, JsonReaderExtensions.ReadValueAsString, requestId, cancellationToken));
}
public static async Task <IDictionary <ActorId, TResult> > GetFromAllActors <TActorType, TResult>(IPartitionEnumerationManager partitionEnumerationManager,
IActorProxyFactory actorProxyFactory, Uri serviceUri, Func <TActorType, Task <KeyValuePair <ActorId, TResult> > > onEachActor, CancellationToken cancellationToken = default(CancellationToken))
where TActorType : IActor
{
var servicePartitionKeysAsync = await ServiceContextExtensions.GetServicePartitionKeysAsync(partitionEnumerationManager, serviceUri);
var activeActors = new List <ActorInformation>();
foreach (var partitionInformation in servicePartitionKeysAsync)
{
var actorServiceProxy = actorProxyFactory.CreateActorServiceProxy <IActorService>(serviceUri, partitionInformation.LowKey);
ContinuationToken continuationToken = null;
do
{
var page = await actorServiceProxy.GetActorsAsync(continuationToken, cancellationToken);
activeActors.AddRange(page.Items);
continuationToken = page.ContinuationToken;
} while (continuationToken != null);
}
var tasks = activeActors.Select(activeActor => actorProxyFactory.CreateActorProxy <TActorType>(activeActor.ActorId)).Select(onEachActor).ToList();
return((await Task.WhenAll(tasks)).ToDictionary(task => task.Key, task => task.Value));
}
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
}));
}
public async Task <IReadOnlyList <IPackageSearchMetadata> > GetAllPackagesAsync(CancellationToken cancellationToken)
{
// Go off the UI thread to perform non-UI operations
await TaskScheduler.Default;
ActivityCorrelationId.StartNew();
var packages = new List <IPackageSearchMetadata>();
ContinuationToken nextToken = null;
do
{
var searchResult = await SearchAsync(nextToken, cancellationToken);
while (searchResult.RefreshToken != null)
{
searchResult = await _packageFeed.RefreshSearchAsync(searchResult.RefreshToken, cancellationToken);
}
nextToken = searchResult.NextToken;
packages.AddRange(searchResult.Items);
} while (nextToken != null);
return(packages);
}
/// <inheritdoc />
public Task <PagedData <ComposeDeploymentStatusInfo> > GetComposeDeploymentStatusListAsync(
ContinuationToken continuationToken = default(ContinuationToken),
long?maxResults = 0,
long?serverTimeout = 60,
CancellationToken cancellationToken = default(CancellationToken))
{
maxResults?.ThrowIfLessThan("maxResults", 0);
serverTimeout?.ThrowIfOutOfInclusiveRange("serverTimeout", 1, 4294967295);
var requestId = Guid.NewGuid().ToString();
var url = "ComposeDeployments";
var queryParams = new List <string>();
// Append to queryParams if not null.
continuationToken?.AddToQueryParameters(queryParams, $"ContinuationToken={continuationToken.ToString()}");
maxResults?.AddToQueryParameters(queryParams, $"MaxResults={maxResults}");
serverTimeout?.AddToQueryParameters(queryParams, $"timeout={serverTimeout}");
queryParams.Add("api-version=6.0-preview");
url += "?" + string.Join("&", queryParams);
HttpRequestMessage RequestFunc()
{
var request = new HttpRequestMessage()
{
Method = HttpMethod.Get,
};
return(request);
}
return(this.httpClient.SendAsyncGetResponseAsPagedData(RequestFunc, url, ComposeDeploymentStatusInfoConverter.Deserialize, requestId, cancellationToken));
}
/// <inheritdoc />
public Task <ChaosEventsSegment> GetChaosEventsAsync(
ContinuationToken continuationToken = default(ContinuationToken),
string startTimeUtc = default(string),
string endTimeUtc = default(string),
long?maxResults = 0,
long?serverTimeout = 60,
CancellationToken cancellationToken = default(CancellationToken))
{
maxResults?.ThrowIfLessThan("maxResults", 0);
serverTimeout?.ThrowIfOutOfInclusiveRange("serverTimeout", 1, 4294967295);
var requestId = Guid.NewGuid().ToString();
var url = "Tools/Chaos/Events";
var queryParams = new List <string>();
// Append to queryParams if not null.
continuationToken?.AddToQueryParameters(queryParams, $"ContinuationToken={continuationToken.ToString()}");
startTimeUtc?.AddToQueryParameters(queryParams, $"StartTimeUtc={startTimeUtc}");
endTimeUtc?.AddToQueryParameters(queryParams, $"EndTimeUtc={endTimeUtc}");
maxResults?.AddToQueryParameters(queryParams, $"MaxResults={maxResults}");
serverTimeout?.AddToQueryParameters(queryParams, $"timeout={serverTimeout}");
queryParams.Add("api-version=6.2");
url += "?" + string.Join("&", queryParams);
HttpRequestMessage RequestFunc()
{
var request = new HttpRequestMessage()
{
Method = HttpMethod.Get,
};
return(request);
}
return(this.httpClient.SendAsyncGetResponse(RequestFunc, url, ChaosEventsSegmentConverter.Deserialize, requestId, cancellationToken));
}
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<SearchResult<IPackageSearchMetadata>> ContinueSearchAsync(ContinuationToken continuationToken, CancellationToken cancellationToken)
{
var searchToken = continuationToken as AggregatedContinuationToken;
if (searchToken?.SourceSearchCursors == null)
{
throw new InvalidOperationException("Invalid token");
}
var searchTokens = _sourceRepositories
.Join(searchToken.SourceSearchCursors,
r => r.PackageSource.Name,
c => c.Key,
(r, c) => new { Repository = r, NextToken = c.Value });
var searchTasks = TaskCombinators.ObserveErrorsAsync(
searchTokens,
j => j.Repository.PackageSource.Name,
(j, t) => j.Repository.SearchAsync(j.NextToken, PageSize, t),
LogError,
cancellationToken);
return await WaitForCompletionOrBailOutAsync(
searchToken.SearchString,
searchTasks,
searchToken.TelemetryState?.NextPage(),
cancellationToken);
}
/// <inheritdoc />
public Task <PagedData <ReplicaInfo> > GetReplicaInfoListAsync(
PartitionId partitionId,
ContinuationToken continuationToken = default(ContinuationToken),
long?serverTimeout = 60,
CancellationToken cancellationToken = default(CancellationToken))
{
partitionId.ThrowIfNull(nameof(partitionId));
serverTimeout?.ThrowIfOutOfInclusiveRange("serverTimeout", 1, 4294967295);
var requestId = Guid.NewGuid().ToString();
var url = "Partitions/{partitionId}/$/GetReplicas";
url = url.Replace("{partitionId}", partitionId.ToString());
var queryParams = new List <string>();
// Append to queryParams if not null.
continuationToken?.AddToQueryParameters(queryParams, $"ContinuationToken={continuationToken.ToString()}");
serverTimeout?.AddToQueryParameters(queryParams, $"timeout={serverTimeout}");
queryParams.Add("api-version=6.0");
url += "?" + string.Join("&", queryParams);
HttpRequestMessage RequestFunc()
{
var request = new HttpRequestMessage()
{
Method = HttpMethod.Get,
};
return(request);
}
return(this.httpClient.SendAsyncGetResponseAsPagedData(RequestFunc, url, ReplicaInfoConverter.Deserialize, requestId, cancellationToken));
}
protected override async Task RunAsync(CancellationToken cancellationToken)
{
await base.RunAsync(cancellationToken);
ContinuationToken continuationToken = null;
try
{
do
{
cancellationToken.ThrowIfCancellationRequested();
var actors = await this.StateProvider.GetActorsAsync(MaxItemsToReturn, continuationToken, cancellationToken);
foreach (var actorId in actors.Items)
{
var nodeName = actorId.GetStringId();
var aliveContainerValue = await this.StateProvider.LoadStateAsync <int>(actorId, nodeName);
containerLivenessCounter.ReportAlive(nodeName, aliveContainerValue);
}
continuationToken = actors.ContinuationToken;
} while (continuationToken != null);
}
catch (FabricNotPrimaryException)
{
// Swallow
}
}
/// <inheritdoc />
public Task <PagedData <ApplicationTypeInfo> > GetApplicationTypeInfoListAsync(
int?applicationTypeDefinitionKindFilter = 0,
bool?excludeApplicationParameters = false,
ContinuationToken continuationToken = default(ContinuationToken),
long?maxResults = 0,
long?serverTimeout = 60,
CancellationToken cancellationToken = default(CancellationToken))
{
maxResults?.ThrowIfLessThan("maxResults", 0);
serverTimeout?.ThrowIfOutOfInclusiveRange("serverTimeout", 1, 4294967295);
var requestId = Guid.NewGuid().ToString();
var url = "ApplicationTypes";
var queryParams = new List <string>();
// Append to queryParams if not null.
applicationTypeDefinitionKindFilter?.AddToQueryParameters(queryParams, $"ApplicationTypeDefinitionKindFilter={applicationTypeDefinitionKindFilter}");
excludeApplicationParameters?.AddToQueryParameters(queryParams, $"ExcludeApplicationParameters={excludeApplicationParameters}");
continuationToken?.AddToQueryParameters(queryParams, $"ContinuationToken={continuationToken.ToString()}");
maxResults?.AddToQueryParameters(queryParams, $"MaxResults={maxResults}");
serverTimeout?.AddToQueryParameters(queryParams, $"timeout={serverTimeout}");
queryParams.Add("api-version=6.0");
url += "?" + string.Join("&", queryParams);
HttpRequestMessage RequestFunc()
{
var request = new HttpRequestMessage()
{
Method = HttpMethod.Get,
};
return(request);
}
return(this.httpClient.SendAsyncGetResponseAsPagedData(RequestFunc, url, ApplicationTypeInfoConverter.Deserialize, requestId, cancellationToken));
}
public async Task <IDictionary <string, Person> > GetPersons(CancellationToken cancellationToken)
{
ContinuationToken continuationToken = null;
//var actors = await this.StateProvider.GetActorsAsync(100, continuationToken, cancellationToken);
var results = 0;
var maxResults = 500;
var result = new Dictionary <string, Person>();
do
{
var page = await this.StateProvider.GetActorsAsync(100, continuationToken, cancellationToken);
foreach (var actor in page.Items)
{
var actorState = await this.StateProvider.LoadStateAsync <Person>(actor, "state", cancellationToken);
result.Add(actor.GetStringId(), actorState);
results++;
}
if (results >= maxResults)
{
return(result);
}
continuationToken = page.ContinuationToken;
} while (continuationToken != null);
return(result);
}
/// <inheritdoc />
public Task <PagedData <NodeInfo> > GetNodeInfoListAsync(
ContinuationToken continuationToken = default(ContinuationToken),
NodeStatusFilter?nodeStatusFilter = NodeStatusFilter.Default,
long?serverTimeout = 60,
CancellationToken cancellationToken = default(CancellationToken))
{
serverTimeout?.ThrowIfOutOfInclusiveRange("serverTimeout", 1, 4294967295);
var requestId = Guid.NewGuid().ToString();
var url = "Nodes";
var queryParams = new List <string>();
// Append to queryParams if not null.
continuationToken?.AddToQueryParameters(queryParams, $"ContinuationToken={continuationToken.ToString()}");
nodeStatusFilter?.AddToQueryParameters(queryParams, $"NodeStatusFilter={nodeStatusFilter.ToString()}");
serverTimeout?.AddToQueryParameters(queryParams, $"timeout={serverTimeout}");
queryParams.Add("api-version=6.0");
url += "?" + string.Join("&", queryParams);
HttpRequestMessage RequestFunc()
{
var request = new HttpRequestMessage()
{
Method = HttpMethod.Get,
};
return(request);
}
return(this.httpClient.SendAsyncGetResponseAsPagedData(RequestFunc, url, NodeInfoConverter.Deserialize, requestId, cancellationToken));
}
private static async Task <TableQuerySegment <AnalysisEntity> > GetAsync(HttpRequest req, CloudTable table)
{
TableContinuationToken token = null;
var tokenParam = (string)req.Query["t"];
if (!string.IsNullOrEmpty(tokenParam))
{
token = ContinuationToken.Unzip(tokenParam);
}
var idParam = (string)req.Query["id"];
if (string.IsNullOrEmpty(idParam))
{
throw new ArgumentException("id is empty");
}
var args = idParam.Split('|');
var partKey = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, args[0]);
var rowKey = TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, args[1]);
var query = new TableQuery <AnalysisEntity>
{
TakeCount = 10,
FilterString = TableQuery.CombineFilters(partKey, TableOperators.And, rowKey)
};
return(await table.ExecuteQuerySegmentedAsync(query, token));
}
public async Task <PagedQueryResult <KeyValuePair <Key, Value>, Continuation> > Query(Range <string> partitionRange, Range <string> rowRange,
int?pageSize = null, Continuation continuationToken = null)
{
if ((pageSize ?? 1) <= 0)
{
throw new ArgumentOutOfRangeException(paramName: nameof(pageSize));
}
if ((PageSizeLimit ?? int.MaxValue) < (pageSize ?? 1))
{
throw new ArgumentOutOfRangeException(paramName: nameof(pageSize), message: "Too many records requested");
}
var filter = TableQuery.CombineFilters(
RangeFilter(nameof(ITableEntity.RowKey), rowRange),
TableOperators.And,
RangeFilter(nameof(ITableEntity.PartitionKey), partitionRange));
var query = new TableQuery <DynamicTableEntity> {
TakeCount = pageSize,
}.Where(filter);
var actualToken = ContinuationToken.Deserialize(continuationToken);
var page = await this.table.ExecuteQuerySegmentedAsync(query, actualToken).ConfigureAwait(false);
var results = page.Results.Select(entity => new KeyValuePair <Key, Value>(
key: new Key(partition: KeyDecode(entity.PartitionKey), row: KeyDecode(entity.RowKey)),
value: ParseValue(entity)
)).ToArray();
var serializedContinuation = ContinuationToken.Serialize(page.ContinuationToken);
return(new PagedQueryResult <KeyValuePair <Key, Value>, Continuation>(results, serializedContinuation));
}
public override int GetHashCode()
{
int hashcode = 157;
unchecked {
if (__isset.squares)
{
hashcode = (hashcode * 397) + TCollections.GetHashCode(Squares);
}
if (__isset.squareStatuses)
{
hashcode = (hashcode * 397) + TCollections.GetHashCode(SquareStatuses);
}
if (__isset.myMemberships)
{
hashcode = (hashcode * 397) + TCollections.GetHashCode(MyMemberships);
}
if (__isset.continuationToken)
{
hashcode = (hashcode * 397) + ContinuationToken.GetHashCode();
}
if (__isset.noteStatuses)
{
hashcode = (hashcode * 397) + TCollections.GetHashCode(NoteStatuses);
}
}
return(hashcode);
}
public override Result <IEnumerable <ArdCategoryInfoDto> > GetCategories(string targetUrl, ContinuationToken continuationToken = null)
{
continuationToken ??= new ContinuationToken()
{
{ _categoryLevel, 0 }
};
var currentLevel = continuationToken.GetValueOrDefault(_categoryLevel) as int? ?? 0;
Log.Debug($"GetCategories current Level: {currentLevel}");
var json = WebClient.GetWebData <JObject>(targetUrl, proxy: WebRequest.GetSystemWebProxy());
var categoryInfos = currentLevel switch
{
0 => CategoryDeserializer.ParseWidgets(json, hasSubCategories: true), // load A - Z
1 => LoadCategoriesWithDetails(json), // load e.g. Abendschau - skip level, (load infos from nextlevel) for each category load url and read synopsis
//2 => categoryDeserializer.ParseTeasers(json), // videos...
_ => throw new ArgumentOutOfRangeException(),
};
var newToken = new ContinuationToken(continuationToken);
newToken[_categoryLevel] = currentLevel + 1;
return(new Result <IEnumerable <ArdCategoryInfoDto> >
{
ContinuationToken = newToken,
Value = categoryInfos
});
}
/// <inheritdoc/>
public override async Task <DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default)
{
if (options is CancellationToken)
{
throw new ArgumentException($"{nameof(options)} cannot be a cancellation token");
}
if (Disabled != null && Disabled.GetValue(dc.State))
{
return(await dc.EndDialogAsync(cancellationToken : cancellationToken).ConfigureAwait(false));
}
if (dc.Context.Activity.ChannelId != Channels.Msteams)
{
throw new InvalidOperationException($"{Kind} works only on the Teams channel.");
}
string continuationToken = ContinuationToken.GetValueOrNull(dc.State);
int? pageSize = PageSize.GetValueOrNull(dc.State);
var result = await TeamsInfo.GetPagedMembersAsync(dc.Context, pageSize, continuationToken, cancellationToken : cancellationToken).ConfigureAwait(false);
if (Property != null)
{
dc.State.SetValue(Property.GetValue(dc.State), result);
}
return(await dc.EndDialogAsync(result, cancellationToken : cancellationToken).ConfigureAwait(false));
}
// NOTE: Prerequsites for running this sample:
// 1. Create SampleTable in your SQL database:
// CREATE TABLE SampleTable
// (
// Id int NOT NULL,
// Text nvarchar(10) NULL
// CONSTRAINT PK_Id PRIMARY KEY(Id)
// )
// 2. Provide valid endpoint, scheme, accessToken values
// in the connection string below.
private static async Task TableClientTestAsync()
{
const string connectionStringFormat = "endpoint={0};scheme={1};accesstoken={2}";
var connectionString = string.Format(connectionStringFormat,
"Valid endpoint goes here",
"Valid scheme goes here",
"Valid accessToken goes here");
var connection = new Connection(connectionString);
var tableClient = connection.CreateTableClient();
var datasetsSegment = await tableClient.ListDataSetsAsync();
foreach (var dataset in datasetsSegment.Items)
{
Console.WriteLine(dataset.DataSetName);
var tablesSegment = await dataset.ListTablesAsync();
foreach (var table in tablesSegment.Items)
{
Console.WriteLine(table.TableName);
var metadata = await table.GetMetadataAsync();
Console.WriteLine(metadata.Schema.ToString());
ContinuationToken continuationToken = null;
do
{
var entitiesSegment = await table.ListEntitiesAsync(
continuationToken : continuationToken);
foreach (var entity in entitiesSegment.Items)
{
foreach (var kvp in entity)
{
Console.WriteLine(kvp.Key + ": " + kvp.Value);
}
}
continuationToken = entitiesSegment.ContinuationToken;
}while (continuationToken != null);
var newEntity = new JObject();
newEntity["Id"] = 2;
newEntity["Text"] = "foo";
//await table.CreateEntityAsync(newEntity);
//await table.UpdateEntityAsync("2", newEntity);
//await table.DeleteEntityAsync("2");
}
}
//var table1 = tableClient.GetDataSetReference().GetTableReference<SampleEntity>("SampleTable");
//var entity1 = await table1.GetEntityAsync("1");
}
public Task<SearchResult<IPackageSearchMetadata>> ContinueSearchAsync (ContinuationToken continuationToken, CancellationToken cancellationToken)
{
var results = new SearchResult<IPackageSearchMetadata> ();
results.SourceSearchStatus = new Dictionary<string, LoadingStatus> {
{ "Test", LoadingStatus.NoMoreItems }
};
return Task.FromResult (results);
}
public static async Task<SearchResult<IPackageSearchMetadata>> SearchAsync(
this SourceRepository sourceRepository, ContinuationToken continuationToken, int pageSize, CancellationToken cancellationToken)
{
var searchToken = continuationToken as FeedSearchContinuationToken;
if (searchToken == null)
{
throw new InvalidOperationException("Invalid token");
}
var searchResource = await sourceRepository.GetResourceAsync<PackageSearchResource>(cancellationToken);
IEnumerable<IPackageSearchMetadata> searchResults = null;
if (searchResource != null) {
searchResults = await searchResource.SearchAsync(
searchToken.SearchString,
searchToken.SearchFilter,
searchToken.StartIndex,
pageSize + 1,
Logging.NullLogger.Instance,
cancellationToken);
}
var items = searchResults?.ToArray() ?? new IPackageSearchMetadata[] { };
var hasMoreItems = items.Length > pageSize;
if (hasMoreItems)
{
items = items.Take(items.Length - 1).ToArray();
}
var result = SearchResult.FromItems(items);
var loadingStatus = hasMoreItems
? LoadingStatus.Ready
: items.Length == 0
? LoadingStatus.NoItemsFound
: LoadingStatus.NoMoreItems;
result.SourceSearchStatus = new Dictionary<string, LoadingStatus>
{
{ sourceRepository.PackageSource.Name, loadingStatus }
};
if (hasMoreItems)
{
result.NextToken = new FeedSearchContinuationToken
{
SearchString = searchToken.SearchString,
SearchFilter = searchToken.SearchFilter,
StartIndex = searchToken.StartIndex + items.Length
};
}
return result;
}
public async Task<SearchResult<IPackageSearchMetadata>> ContinueSearchAsync(ContinuationToken continuationToken, CancellationToken cancellationToken)
{
var searchToken = continuationToken as AggregatedContinuationToken;
if (searchToken?.SourceSearchCursors == null)
{
throw new InvalidOperationException("Invalid token");
}
var searchTokens = _sourceRepositories
.Join(searchToken.SourceSearchCursors,
r => r.PackageSource.Name,
c => c.Key,
(r, c) => new { Repository = r, NextToken = c.Value });
var searchTasks = TaskCombinators.ObserveErrorsAsync(
searchTokens,
j => j.Repository.PackageSource.Name,
(j, t) => j.Repository.SearchAsync(j.NextToken, PageSize, t),
LogError,
cancellationToken);
return await WaitForCompletionOrBailOutAsync(searchToken.SearchString, searchTasks, cancellationToken);
}
