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)); }