public NotificationsForMeRequest(IMemberId member, IEnumerable<NotificationType> filter, ReadFilter readFilter, Paging paging)
: base(member, "notifications")
{
AddTypeFilter(filter);
this.AddFilter(readFilter, "read_filter");
this.AddPaging(paging);
}
static void Main(string[] args)
{
//TraceStoreConnectionInformation info = new LocalTraceStoreConnectionInformation(
// @"D:\Repos\WindowsFabric\out\debug-amd64\bin\WinFabricTest\test\FabActFiveNodelCluster.test\TC",
// @"E:\crm_duplicate",
// @"D:\Repos\WindowsFabric\out\debug-amd64\bin\WinFabricTest\test\FabActFiveNodelCluster.test\TC");
TraceStoreConnectionInformation info = new AzureTraceStoreConnectionInformation(
"winfablrc",
HandyUtil.SecureStringFromCharArray("<Insert key Here>"),
"vipinrtobitlogsqt",
"blobContainerRandmom",
"e98a88aa63aa42b4",
LocalDiskLogger.LogProvider);
TraceStoreConnection connection = new TraceStoreConnection(info, LocalDiskLogger.LogProvider);
ReadFilter filter = ReadFilter.CreateReadFilter(typeof(NodeOpeningTraceRecord));
// SET your Duration.
var duration = new Duration(
DateTime.SpecifyKind(DateTime.Parse("2018-04-10 01:01:19.155"), DateTimeKind.Utc),
DateTime.SpecifyKind(DateTime.UtcNow, DateTimeKind.Utc));
var results = connection.EventStoreReader.WithinBound(duration).ReadBackwardAsync(filter, 500, CancellationToken.None).GetAwaiter().GetResult();
Console.WriteLine("Count {0}", results.Count());
foreach (var one in results)
{
Console.WriteLine(one.TimeStamp.ToString("yyyy-MM-dd HH:mm:ss.fff", CultureInfo.InvariantCulture) + " " + one);
Console.WriteLine();
}
Console.Read();
}
/// <summary>
/// 发送并读取报文
/// </summary>
/// <param name="agent">通信代理</param>
/// <param name="cmd">命令</param>
/// <param name="data">正文</param>
/// <returns>响应的报文</returns>
internal static byte[] SendAndRead(this SerialPortsUtils.Agents.Agent agent, byte cmd, byte[] data = null)
{
var packet = PacketUtils.BuildSend(cmd, data);
var reader = new ReadFilter(cmd);
return(agent.SendAndRead(packet, reader));
}
private static IQueryable <Game> FilterGames(ReadFilter filter, IQueryable <Game> games)
{
if (!filter.SearchTerm.IsNullOrWhiteSpace())
{
games = games.Where(
g => g.Name.ToLower().Contains(filter.SearchTerm.ToLower()));
}
return(games);
}
public async Task <IReadOnlyList <UserOffer> > GetAsync(ReadFilter filter)
{
var userOffers = _mnpContext.UserOffers.AsNoTracking().AsQueryable();
if (filter.PageSize.HasValue && filter.PageNumber.HasValue)
{
userOffers = userOffers.TakePage(filter.PageSize.Value, filter.PageNumber.Value);
}
return(await userOffers.ToArrayAsync());
}
public static ReadFilter CreateTypeAndIdFilter(ITraceStoreReader traceStoreReader, Type type, Guid eventInstanceId)
{
var filter = ReadFilter.CreateReadFilter(type);
if (eventInstanceId != Guid.Empty && traceStoreReader.IsPropertyLevelFilteringSupported())
{
filter.AddFilter(type, EventInstanceFilterName, eventInstanceId);
}
return(filter);
}
/// <inheritdoc />
protected override async Task <IDictionary <Scenario, IList <TraceRecord> > > GetSignalsForScenarioAsync(
IList <Scenario> scenarios,
Duration duration,
CancellationToken token)
{
var allTypes = this.GetTypesFromScenarios(scenarios);
ReadFilter filter = ReadFilter.CreateReadFilter(allTypes);
var allTraceRecords = await this.traceStoreReader.ReadTraceRecordsAsync(duration, filter, token).ConfigureAwait(false);
return(this.GroupTraceRecordsByScenario(allTraceRecords));
}
public async Task <IReadOnlyList <Game> > GetAsync(ReadFilter filter)
{
var games = _mnpContext.Games.AsNoTracking().AsQueryable();
games = FilterGames(filter, games);
if (filter.PageSize.HasValue && filter.PageNumber.HasValue)
{
games = games.TakePage(filter.PageSize.Value, filter.PageNumber.Value);
}
return(await games.ToArrayAsync());
}
public async Task <CountArray <UserOffer> > GetAsyncAsCountArray(ReadFilter filter)
{
var userOffers = _mnpContext.UserOffers.AsNoTracking().AsQueryable();
var count = await userOffers.CountAsync();
if (filter.PageSize.HasValue && filter.PageNumber.HasValue)
{
userOffers = userOffers.TakePage(filter.PageSize.Value, filter.PageNumber.Value);
}
var resultOffers = await userOffers.ToArrayAsync();
return(new CountArray <UserOffer>(resultOffers, count));
}
public static ReadFilter CreateNodeFilter(ITraceStoreReader traceStoreReader, IList <Type> types, string nodeName)
{
var filter = ReadFilter.CreateReadFilter(types);
if (!string.IsNullOrEmpty(nodeName) && traceStoreReader.IsPropertyLevelFilteringSupported())
{
foreach (var oneType in types)
{
filter.AddFilter(oneType, NodeFilterName, nodeName);
}
}
return(filter);
}
public static ReadFilter CreatePartitionFilter(ITraceStoreReader traceStoreReader, IList <Type> types, Guid partitionId)
{
var filter = ReadFilter.CreateReadFilter(types);
if (partitionId != Guid.Empty && traceStoreReader.IsPropertyLevelFilteringSupported())
{
foreach (var oneType in types)
{
filter.AddFilter(oneType, PartitionFilterName, partitionId);
}
}
return(filter);
}
public async Task <IEnumerable <ReportFaultTraceRecord> > GetReportFaultTraceRecordsAsync(PrimaryMoveAnalysisEvent analysisEvent)
{
var records = await this.queryStoreReader.ReadTraceRecordsAsync(
analysisEvent.GetDuration(),
ReadFilter.CreateReadFilter(
new[]
{
typeof(ReportFaultTraceRecord)
}
),
this.cancellationToken).ConfigureAwait(false);
var interstingRecords = records.Select(item => item as ReportFaultTraceRecord).Where(item => item.ReasonActivityId == analysisEvent.ReasonActivityId);
return(interstingRecords);
}
public async Task <IEnumerable <ReplicaStateChangeTraceRecord> > GetReplicaStateChangeTraceRecordsAsync(PrimaryMoveAnalysisEvent analysisEvent)
{
var records = await this.queryStoreReader.ReadTraceRecordsAsync(
analysisEvent.GetDuration(),
ReadFilter.CreateReadFilter(
new[]
{
typeof(ReplicaStateChangeTraceRecord)
}
),
this.cancellationToken).ConfigureAwait(false);
var interstingRecords = records.Select(item => item as ReplicaStateChangeTraceRecord).Where(item => item.PartitionId == analysisEvent.TriggerReconfigurationCompletedTraceRecord.PartitionId && item.Role == global::ReplicaRole.P && item.Status == ReplicaLifeCycleState.Closing && item.NodeInstanceId.StartsWith(analysisEvent.PreviousPrimaryContext.NodeId) && item.ReasonActivityId != Guid.Empty);
return(interstingRecords);
}
public async Task <IEnumerable <NodeUpTraceRecord> > GetNodeUpTraceRecordsAsync(PrimaryMoveAnalysisEvent analysisEvent)
{
var records = await this.queryStoreReader.ReadTraceRecordsAsync(
analysisEvent.GetDuration(),
ReadFilter.CreateReadFilter(
new[]
{
typeof(NodeUpTraceRecord)
}
),
this.cancellationToken).ConfigureAwait(false);
var interstingRecords = records.Select(item => item as NodeUpTraceRecord).Where(item => item.NodeName.Equals(analysisEvent.PreviousPrimaryContext.NodeName, StringComparison.OrdinalIgnoreCase));
return(interstingRecords);
}
private async Task <FabricEvent> GetPartitionEventsAsync(Duration duration, Guid instanceId, CancellationToken token)
{
var records = await this.traceStoreReader.ReadTraceRecordsAsync(
duration,
ReadFilter.CreateReadFilter(Mapping.EntityToEventsMap[EntityType.Partition].Select(item => item.UnderlyingType).ToList()),
token).ConfigureAwait(false);
var recordOfInterest = records.SingleOrDefault(item => item.ObjectInstanceId?.Id == instanceId);
if (recordOfInterest != null)
{
return(PartitionEventAdapter.Convert(recordOfInterest));
}
return(null);
}
public async Task <CountArray <Game> > GetAsyncAsCountArray(ReadFilter filter)
{
var games = _mnpContext.Games.AsNoTracking().AsQueryable();
games = FilterGames(filter, games);
var count = await games.CountAsync();
if (filter.PageSize.HasValue && filter.PageNumber.HasValue)
{
games = games.TakePage(filter.PageSize.Value, filter.PageNumber.Value);
}
var resultGames = await games.ToArrayAsync();
return(new CountArray <Game>(resultGames, count));
}
public static ReadFilter CreateCorrelationEventFilter(ITraceStoreReader reader, IList <Guid> eventInstances)
{
var type = typeof(CorrelationTraceRecord);
var filter = ReadFilter.CreateReadFilter(type);
if (!reader.IsPropertyLevelFilteringSupported())
{
return(filter);
}
foreach (var oneInstance in eventInstances)
{
filter.AddFilter(type, CorrelationTraceRecord.RelatedFromIdPropertyName, oneInstance);
filter.AddFilter(type, CorrelationTraceRecord.RelatedToIdPropertyName, oneInstance);
}
return(filter);
}
public async Task <IEnumerable <OperationTraceRecord> > GetEffectiveOperationTraceRecordsAsync(PrimaryMoveAnalysisEvent analysisEvent)
{
var records = await this.queryStoreReader.ReadTraceRecordsAsync(
analysisEvent.GetDuration(),
ReadFilter.CreateReadFilter(
new[]
{
typeof(OperationTraceRecord),
typeof(OperationIgnoredTraceRecord)
}
),
this.cancellationToken).ConfigureAwait(false);
HashSet <Guid> ignoredDecisions = new HashSet <Guid>();
Dictionary <Guid, OperationTraceRecord> decisionOperationMap = new Dictionary <Guid, OperationTraceRecord>();
List <OperationTraceRecord> effectiveOperationRecords = new List <OperationTraceRecord>();
foreach (var r in records)
{
OperationTraceRecord operation = r as OperationTraceRecord;
if (operation == null)
{
OperationIgnoredTraceRecord ignored = r as OperationIgnoredTraceRecord;
if (ignored != null && ignored.FailoverUnitId == analysisEvent.TriggerReconfigurationCompletedTraceRecord.PartitionId)
{
ignoredDecisions.Add(ignored.DecisionId);
if (decisionOperationMap.ContainsKey(ignored.DecisionId))
{
effectiveOperationRecords.Remove(decisionOperationMap[ignored.DecisionId]);
}
}
}
else if (this.MatchPartitionSourceAndDestination(operation, analysisEvent) && !ignoredDecisions.Contains(operation.DecisionId))
{
effectiveOperationRecords.Add(operation);
decisionOperationMap[operation.DecisionId] = operation;
}
}
var effectiveOperationRecordsMatchingSourceTarget = effectiveOperationRecords.Where(r => r.SourceNode.StartsWith(analysisEvent.PreviousNode) && r.TargetNode.StartsWith(analysisEvent.CurrentNode));
return(effectiveOperationRecords);
}
private async Task DecorateCorrelationAttributeAsync(Duration duration, IList <FabricEvent> partitionEvents, CancellationToken token)
{
var newTimeDuration = new Duration(
duration.StartTime,
DateTime.UtcNow - duration.EndTime > MaxDurationForCorrelatingEvent ? duration.EndTime + MaxDurationForCorrelatingEvent : DateTime.UtcNow);
var filter = ReadFilter.CreateReadFilter(typeof(CorrelationTraceRecord));
var allCorrelationTraces = (await this.traceStoreReader.ReadTraceRecordsAsync(newTimeDuration, filter, token).ConfigureAwait(false));
foreach (var oneCorrelationTrace in allCorrelationTraces)
{
var castedRecord = (CorrelationTraceRecord)oneCorrelationTrace;
var matchingEvents = partitionEvents.Where(item => item.EventInstanceId == castedRecord.RelatedFromId || item.EventInstanceId == castedRecord.RelatedToId);
if (matchingEvents.Any())
{
foreach (var oneEvent in matchingEvents)
{
oneEvent.HasCorrelatedEvents = true;
}
}
}
}
public Task <IEnumerable <Notification> > ForMe(IEnumerable <NotificationType> types = null, ReadFilter readFilter = ReadFilter.All, Paging paging = null)
{
return(_restClient.RequestListAsync <Notification>(new NotificationsForMeRequest(new Me(), types, readFilter, paging)));
}
/// <inheritdoc />
public async Task <IEnumerable <TraceRecord> > ReadTraceRecordsAsync(Duration duration, ReadFilter filter, CancellationToken token)
{
var parser = this.GetParser(this.GetTraceRecordSession(duration));
var typesInFilter = filter.TraceRecordFilters.Select(item => item.RecordType).ToList();
var allRecords = new List <TraceRecord>();
Func <TraceRecord, CancellationToken, Task> traceReceiver = (record, cancellationToken) =>
{
if (filter.TraceFilter != null)
{
if (filter.TraceFilter(record))
{
return(CompletedTask);
}
}
allRecords.Add(record.Clone());
return(CompletedTask);
};
foreach (var type in typesInFilter)
{
await parser.SubscribeAsync(type, traceReceiver, token).ConfigureAwait(false);
}
if (parser.TraceSession.IsServerSideFilteringAvailable)
{
await parser.TraceSession.StartReadingAsync(filter.TraceRecordFilters, duration.StartTime, duration.EndTime, token).ConfigureAwait(false);
}
else
{
await parser.TraceSession.StartReadingAsync(duration.StartTime, duration.EndTime, token).ConfigureAwait(false);
}
return(allRecords);
}
/// <summary>
/// Reads applications that are visible to an organization and can be linked to it - returns apps that require auth and apps that are non-public (specific to that very org)
/// </summary>
/// <param name="dbCtx"></param>
/// <param name="sort"></param>
/// <param name="filter"></param>
/// <param name="start"></param>
/// <param name="limit"></param>
/// <returns></returns>
public async Task <(IEnumerable <Application> applications, int count)?> GetOrganizationLinkableAppsAsync(DbContext dbCtx, string sort = null, string filter = null,
int start = 0,
int limit = 25)
{
//first need to get objects for an organization, and then add an extra filter with object guids
var orgObjIds = await GetOrganizationObjectIdsAsync <Application>(dbCtx);
//do make sure there is something to read!
var filters = filter.ExtJsJsonFiltersToReadFilters();
//return all the apps
var preFilter = new ReadFilter
{
Property = nameof(Application.RequiresAuth),
Value = true,
Operator = "==",
ExactMatch = true, //make the whole filter exact
AndJoin = true,
NestedFilters = new List <ReadFilter>
{
//need common apps
new ReadFilter
{
Property = nameof(Application.IsCommon),
Value = true
},
//but not the dashboard. users always can access the dashboard!
new ReadFilter
{
Property = nameof(Application.IsDefault),
Value = false
}
}
};
//if there are org specific apps always return them in addition to the ones filtered by default
if (orgObjIds.Any())
{
preFilter = new ReadFilter
{
Property = "Uuid",
Value = orgObjIds.AsReadFilterList(),
Operator = "in",
ExactMatch = true,
AndJoin = false,
NestedFilters = new List <ReadFilter>
{
preFilter
}
};
}
filters.Add(preFilter);
var app = new Application();
var apps = await app.ReadAsync(dbCtx, sort.ExtJsJsonSortersToReadSorters(), filters, start, limit);
if (!apps.Any())
{
return(null);
}
var count = await apps.First().ReadCountAsync(dbCtx, filters);
return(apps, count);
}
public static ReadFilter CreateClusterFilter(IList <Type> types)
{
return(ReadFilter.CreateReadFilter(types));
}
public IEnumerable <Notification> ForMe(IEnumerable <NotificationType> filter = null, ReadFilter readFilter = ReadFilter.All)
{
var currentPage = 0;
return(AutoPage(() => _trelloNotifications.ForMe(filter, readFilter, new Paging(_pageSize, currentPage++))));
}
public Task<IEnumerable<Notification>> ForMe(IEnumerable<NotificationType> types = null, ReadFilter readFilter = ReadFilter.All, Paging paging = null)
{
return _restClient.RequestListAsync<Notification>(new NotificationsForMeRequest(new Me(), types, readFilter, paging));
}
public NotificationsForMeRequest(IMemberId member, IEnumerable <NotificationType> filter, ReadFilter readFilter, Paging paging)
: base(member, "notifications")
{
AddTypeFilter(filter);
this.AddFilter(readFilter, "read_filter");
this.AddPaging(paging);
}
public IEnumerable<Notification> ForMe(IEnumerable<NotificationType> filter = null, ReadFilter readFilter = ReadFilter.All)
{
var currentPage = 0;
return AutoPage(() => _trelloNotifications.ForMe(filter, readFilter, new Paging(_pageSize, currentPage++)));
}
public IEnumerable<Notification> ForMe(IEnumerable<NotificationType> types = null, ReadFilter readFilter = ReadFilter.Default, Paging paging = null)
{
return _restClient.Request<List<Notification>>(new NotificationsForMeRequest(new Me(), types, readFilter, paging));
}
