Esempio n. 1
0
        public void Initialize(List <FileDescriptor> fileDescriptors)
        {
            if (fileDescriptors == null)
            {
                throw new ArgumentNullException();
            }
            this.fileDescriptors = fileDescriptors;
            int x   = 5;
            int num = 5;

            foreach (FileDescriptor fileDescriptor in this.fileDescriptors)
            {
                FileBlockInfoControl fileBlockInfoControl = new FileBlockInfoControl(fileDescriptor);
                fileBlockInfoControl.Location = new Point(x, num);
                num += 75;
                fileBlockInfoControl.Visible = true;
                reportPanel.Controls.Add(fileBlockInfoControl);
            }
            dateTimeRange    = TraceDataSource.CalculateFileTimeRange(this.fileDescriptors);
            selectedDateTime = dateTimeRange;
            DTRangeControl dTRangeControl = timeRangeControl;

            dTRangeControl.TimeRangeChangeCallback = (DTRangeControl.TimeRangeChange)Delegate.Combine(dTRangeControl.TimeRangeChangeCallback, new DTRangeControl.TimeRangeChange(timeRangeControl_OnTimeRangeChanged));
            timeRangeControl.RefreshTimeRange(dateTimeRange.StartTime, dateTimeRange.EndTime);
            timeRangeControl.RefreshSelectedTimeRange(dateTimeRange.StartTime, dateTimeRange.EndTime);
            timeRangeControl_OnTimeRangeChanged(dateTimeRange.StartTime, dateTimeRange.EndTime);
        }
Esempio n. 2
0
 private void timeRangeControl_OnTimeRangeChanged(DateTime start, DateTime end)
 {
     if (start > end)
     {
         start = end;
     }
     foreach (FileBlockInfoControl control in reportPanel.Controls)
     {
         control.RefreshByTimeRange(start, end);
     }
     selectedDateTime = new DateTimePair(start, end);
 }
Esempio n. 3
0
 private void UpdateTimeFilterRange()
 {
     if (currentDataSource != null)
     {
         DateTimePair traceTimeRange = currentDataSource.TraceTimeRange;
         if (traceTimeRange != null)
         {
             DateTime dateTime  = traceTimeRange.StartTime.AddSeconds(-1.0);
             DateTime dateTime2 = traceTimeRange.EndTime.AddSeconds(1.0);
             if (dateTime >= dtpTimeFrom.MinDate && dateTime <= dtpTimeFrom.MaxDate && dateTime2 >= dtpTimeFrom.MinDate && dateTime2 <= dtpTimeFrom.MaxDate)
             {
                 dtpTimeFrom.Value = dateTime;
                 dtpTimeTo.Value   = dateTime2;
                 dtpTime.Value     = dateTime;
                 return;
             }
         }
         dtpTimeFrom.Value = DateTime.Now.AddSeconds(-1.0);
         dtpTimeTo.Value   = DateTime.Now;
     }
 }
Esempio n. 4
0
        public static bool MatchFilter(SourceLevels level, SearchOptions searchOption, object searchCondition, TraceRecord trace)
        {
            if (filterOptionSettings != null && filterOptionSettings.IsSet)
            {
                if (!filterOptionSettings.ShowWCFTraces && IsWCFTraceRecord(trace))
                {
                    return(false);
                }
                if (IsWCFTraceRecord(trace))
                {
                    if (!filterOptionSettings.ShowTransfer && IsTraceRecordTransfer(trace))
                    {
                        return(false);
                    }
                    if (!filterOptionSettings.ShowMessageSentReceived && (trace.IsMessageSentRecord || trace.IsMessageReceivedRecord))
                    {
                        return(false);
                    }
                    if (!filterOptionSettings.ShowSecurityMessage)
                    {
                        if (CheckActionForTrace(trace.Action, securityMessageActionIndex))
                        {
                            return(false);
                        }
                        if (CheckTraceIdentifierForTrace(trace.TraceCode, securityMessageTraceIdentifierIndex))
                        {
                            return(false);
                        }
                    }
                    if (!filterOptionSettings.ShowReliableMessage)
                    {
                        if (CheckActionForTrace(trace.Action, reliableMessageActionIndex))
                        {
                            return(false);
                        }
                        if (CheckTraceIdentifierForTrace(trace.TraceCode, reliableMessageTraceIdentifierIndex))
                        {
                            return(false);
                        }
                    }
                    if (!filterOptionSettings.ShowTransactionMessage)
                    {
                        if (CheckActionForTrace(trace.Action, transactionMessageActionIndex))
                        {
                            return(false);
                        }
                        if (CheckTraceIdentifierForTrace(trace.TraceCode, transactionMessageTraceIdentifierIndex))
                        {
                            return(false);
                        }
                        if (!string.IsNullOrEmpty(trace.Xml) && (trace.Xml.Contains("<CoordinationType>http://schemas.xmlsoap.org/ws/2004/10/wsat</CoordinationType>") || trace.Xml.Contains("<wscoor:Identifier xmlns:wscoor=\"http://schemas.xmlsoap.org/ws/2004/10/wscoor\">")))
                        {
                            return(false);
                        }
                    }
                }
            }
            if (level == SourceLevels.All || trace.Level == (TraceEventType)0 || trace.IsMessageLogged || ((int)trace.Level & (int)(level + 65280)) > 0)
            {
                switch (searchOption)
                {
                case SearchOptions.None:
                    return(true);

                case SearchOptions.ProcessName:
                {
                    string      text           = (string)searchCondition;
                    CultureInfo currentCulture = CultureInfo.CurrentCulture;
                    if (trace.ProcessName == null)
                    {
                        return(string.IsNullOrEmpty(text));
                    }
                    return(trace.ProcessName.ToUpper(currentCulture).Contains(text.ToUpper(currentCulture)));
                }

                case SearchOptions.Description:
                {
                    string      text6           = (string)searchCondition;
                    CultureInfo currentCulture5 = CultureInfo.CurrentCulture;
                    if (trace.Description == null)
                    {
                        return(string.IsNullOrEmpty(text6));
                    }
                    return(trace.Description.ToUpper(currentCulture5).Contains(text6.ToUpper(currentCulture5)));
                }

                case SearchOptions.EndpointAddress:
                {
                    string      text5           = (string)searchCondition;
                    CultureInfo currentCulture4 = CultureInfo.CurrentCulture;
                    if (trace.EndpointAddress == null)
                    {
                        return(string.IsNullOrEmpty(text5));
                    }
                    return(trace.EndpointAddress.ToUpper(currentCulture4).Contains(text5.ToUpper(currentCulture4)));
                }

                case SearchOptions.EventID:
                {
                    string text2 = (string)searchCondition;
                    if (trace.EventID == null)
                    {
                        return(string.IsNullOrEmpty(text2));
                    }
                    return(trace.EventID == text2);
                }

                case SearchOptions.SourceName:
                {
                    string      text4           = (string)searchCondition;
                    CultureInfo currentCulture3 = CultureInfo.CurrentCulture;
                    if (trace.SourceName == null)
                    {
                        return(string.IsNullOrEmpty(text4));
                    }
                    return(trace.SourceName.ToUpper(currentCulture3) == text4.ToUpper(currentCulture3));
                }

                case SearchOptions.TraceCode:
                {
                    string      text3           = (string)searchCondition;
                    CultureInfo currentCulture2 = CultureInfo.CurrentCulture;
                    if (trace.TraceCode == null)
                    {
                        return(string.IsNullOrEmpty(text3));
                    }
                    return(trace.TraceCode.ToUpper(currentCulture2).Contains(text3.ToUpper(currentCulture2)));
                }

                case SearchOptions.StartTime:
                {
                    DateTime t2 = (DateTime)searchCondition;
                    return(trace.Time >= t2);
                }

                case SearchOptions.StopTime:
                {
                    DateTime t = (DateTime)searchCondition;
                    return(trace.Time <= t);
                }

                case SearchOptions.TimeRange:
                {
                    DateTimePair dateTimePair = (DateTimePair)searchCondition;
                    if (trace.Time >= dateTimePair.StartTime)
                    {
                        return(trace.Time <= dateTimePair.EndTime);
                    }
                    return(false);
                }

                case SearchOptions.AppDataSection:
                {
                    string xml3   = trace.Xml;
                    string value2 = (string)searchCondition;
                    if (!string.IsNullOrEmpty(xml3) && !string.IsNullOrEmpty(value2))
                    {
                        try
                        {
                            XmlDocument xmlDocument3 = new XmlDocument();
                            xmlDocument3.LoadXml(xml3);
                            if (xmlDocument3.DocumentElement != null && xmlDocument3.DocumentElement.HasChildNodes)
                            {
                                XmlElement xmlElement = xmlDocument3.DocumentElement["ApplicationData"];
                                if (xmlElement != null)
                                {
                                    string outerXml2 = xmlElement.OuterXml;
                                    if (!string.IsNullOrEmpty(outerXml2))
                                    {
                                        return(outerXml2.IndexOf(value2, StringComparison.OrdinalIgnoreCase) != -1);
                                    }
                                }
                            }
                        }
                        catch (XmlException)
                        {
                        }
                    }
                    return(false);
                }

                case SearchOptions.EntireRawData:
                {
                    string xml2  = trace.Xml;
                    string value = (string)searchCondition;
                    if (!string.IsNullOrEmpty(xml2) && !string.IsNullOrEmpty(value))
                    {
                        try
                        {
                            XmlDocument xmlDocument2 = new XmlDocument();
                            xmlDocument2.LoadXml(xml2);
                            if (xmlDocument2.DocumentElement != null)
                            {
                                string outerXml = xmlDocument2.DocumentElement.OuterXml;
                                if (!string.IsNullOrEmpty(outerXml))
                                {
                                    return(outerXml.IndexOf(value, StringComparison.OrdinalIgnoreCase) != -1);
                                }
                            }
                        }
                        catch (XmlException)
                        {
                        }
                    }
                    return(false);
                }

                case SearchOptions.CustomFilter:
                {
                    string xml = trace.Xml;
                    if (string.IsNullOrEmpty(xml))
                    {
                        return(false);
                    }
                    try
                    {
                        CustomFilterCondition customFilterCondition = (CustomFilterCondition)searchCondition;
                        XmlDocument           xmlDocument           = new XmlDocument();
                        xmlDocument.LoadXml(xml);
                        if (customFilterCondition.customFilter.Namespaces.Count == 0)
                        {
                            try
                            {
                                if (xmlDocument.SelectSingleNode(customFilterCondition.customFilter.ContainsParameters ? customFilterCondition.parsedXPathExpress : customFilterCondition.customFilter.Expression) != null)
                                {
                                    return(true);
                                }
                            }
                            catch (XPathException)
                            {
                                return(false);
                            }
                            catch (XsltException)
                            {
                                return(false);
                            }
                        }
                        else
                        {
                            XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(xmlDocument.NameTable);
                            foreach (string key in customFilterCondition.customFilter.Namespaces.Keys)
                            {
                                xmlNamespaceManager.AddNamespace(key, customFilterCondition.customFilter.Namespaces[key]);
                            }
                            try
                            {
                                if (xmlDocument.SelectSingleNode(customFilterCondition.customFilter.ContainsParameters ? customFilterCondition.parsedXPathExpress : customFilterCondition.customFilter.Expression, xmlNamespaceManager) != null)
                                {
                                    return(true);
                                }
                            }
                            catch (XPathException)
                            {
                                return(false);
                            }
                            catch (XsltException)
                            {
                                return(false);
                            }
                        }
                    }
                    catch (XmlException)
                    {
                        return(false);
                    }
                    return(false);
                }

                default:
                    return(false);
                }
            }
            return(false);
        }