Пример #1
0
 /// <summary>
 /// Constructs a new <see cref="Frame"/> given the specified parameters.
 /// </summary>
 /// <param name="timestamp">Timestamp, in ticks, for this <see cref="Frame"/>.</param>
 /// <param name="measurements">Initial set of measurements to load into the <see cref="Frame"/>, if any.</param>
 public Frame(Ticks timestamp, IDictionary<MeasurementKey, IMeasurement> measurements)
 {
     m_timestamp = timestamp;
     m_receivedTimestamp = DateTime.UtcNow.Ticks;
     m_measurements = new ConcurrentDictionary<MeasurementKey, IMeasurement>(measurements);
     m_sortedMeasurements = -1;
 }
Пример #2
0
 /// <summary>
 /// Initializes a new instance of the <see cref="TimestampTest"/> class.
 /// </summary>
 public TimestampTest()
 {
     m_badTimestampMeasurements = new Dictionary<Ticks, LinkedList<IMeasurement>>();
     m_timeToPurge = Ticks.FromSeconds(1.0);
     m_warnInterval = Ticks.FromSeconds(4.0);
     m_purgeTimer = new System.Timers.Timer();
     m_warningTimer = new System.Timers.Timer();
 }
Пример #3
0
        /// <summary>
        /// Creates a new instance of the <see cref="FlatlineTest"/> class.
        /// </summary>
        public FlatlineTest()
        {
            m_minFlatline = Ticks.FromSeconds(4);
            m_warnInterval = Ticks.FromSeconds(4);
            m_emailInterval = Ticks.FromSeconds(3600);
            m_smtpServer = Mail.DefaultSmtpServer;

            m_lastChange = new Dictionary<MeasurementKey, IMeasurement>();
            m_lastNotified = new Dictionary<MeasurementKey, Ticks>();
            m_warningTimer = new System.Timers.Timer();
        }
Пример #4
0
        private IMeasurement m_lastSortedMeasurement;                               // Last measurement sorted into this frame

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Constructs a new <see cref="Frame"/> given the specified parameters.
        /// </summary>
        /// <param name="timestamp">Timestamp, in ticks, for this <see cref="Frame"/>.</param>
        /// <param name="expectedMeasurements">Expected number of measurements for the <see cref="Frame"/>.</param>
        public Frame(Ticks timestamp, int expectedMeasurements = -1)
        {
            m_timestamp = timestamp;
            m_receivedTimestamp = DateTime.UtcNow.Ticks;

            if (expectedMeasurements > 0)
                m_measurements = new ConcurrentDictionary<MeasurementKey, IMeasurement>(s_defaultConcurrencyLevel, expectedMeasurements * 2);
            else
                m_measurements = new ConcurrentDictionary<MeasurementKey, IMeasurement>();

            m_sortedMeasurements = -1;
        }
Пример #5
0
        private void AddMeasurementWithBadTimestamp(Ticks timeArrived, IMeasurement measurement)
        {
            lock (m_badTimestampMeasurements)
            {
                LinkedList<IMeasurement> measurementList;

                if (!m_badTimestampMeasurements.TryGetValue(timeArrived, out measurementList))
                {
                    measurementList = new LinkedList<IMeasurement>();
                    m_badTimestampMeasurements.Add(timeArrived, measurementList);
                }

                measurementList.AddLast(measurement);
                m_totalBadTimestampMeasurements++;
            }
        }
Пример #6
0
        /// <summary>
        /// Initializes <see cref="FlatlineTest"/>.
        /// </summary>
        public override void Initialize()
        {
            base.Initialize();

            Dictionary<string, string> settings = Settings;
            string setting;

            if (settings.TryGetValue("minFlatline", out setting))
                m_minFlatline = Ticks.FromSeconds(double.Parse(setting));

            if (settings.TryGetValue("warnInterval", out setting))
                m_warnInterval = Ticks.FromSeconds(double.Parse(setting));

            if (settings.TryGetValue("adminEmailAddress", out m_adminEmailAddress))
            {
                // emailInterval is entered in minutes.
                if (settings.TryGetValue("emailInterval", out setting))
                    m_emailInterval = Ticks.FromSeconds(long.Parse(setting) * 60L);
            }

            if (settings.TryGetValue("smtpServer", out setting))
                m_smtpServer = setting;

            m_warningTimer.Interval = m_warnInterval.ToMilliseconds();
            m_warningTimer.Elapsed += m_warningTimer_Elapsed;

            m_flatlineService = new FlatlineService(this);
            m_flatlineService.SettingsCategory = base.Name + m_flatlineService.SettingsCategory;
            m_flatlineService.ServiceProcessException += m_flatlineService_ServiceProcessException;
            m_flatlineService.Initialize();

            InitializeLastChange();
        }
Пример #7
0
 /// <summary>
 /// Raises the <see cref="DataStartTime"/> event.
 /// </summary>
 /// <param name="startTime">Start time, in <see cref="Ticks"/>, of first measurement transmitted.</param>
 protected void OnDataStartTime(Ticks startTime)
 {
     try
     {
         if (DataStartTime != null)
             DataStartTime(this, new EventArgs<Ticks>(startTime));
     }
     catch (Exception ex)
     {
         // We protect our code from consumer thrown exceptions
         OnProcessException(new InvalidOperationException(string.Format("Exception in consumer handler for DataStartTime event: {0}", ex.Message), ex));
     }
 }
Пример #8
0
 /// <summary>
 /// Creates a new instance of the <see cref="RangeTest"/> class.
 /// </summary>
 public RangeTest()
 {
     m_outOfRangeMeasurements = new Dictionary<MeasurementKey, LinkedList<IMeasurement>>();
     m_timeToPurge = Ticks.FromSeconds(1.0);
     m_warnInterval = Ticks.FromSeconds(4.0);
     m_warningTimer = new System.Timers.Timer();
     m_purgeTimer = new System.Timers.Timer();
 }
Пример #9
0
 /// <summary>
 /// Gets proper NTP offset based on <paramref name="timestamp"/> value, see RFC-2030.
 /// </summary>
 /// <param name="timestamp"><see cref="Ticks"/> timestamp value.</param>
 /// <returns>Proper NTP offset.</returns>
 protected static long GetBaseDateOffsetTicks(Ticks timestamp)
 {
     if (timestamp < NtpDateOffsetTicksAlt)
         return NtpDateOffsetTicks;
     else
         return NtpDateOffsetTicksAlt;
 }
Пример #10
0
        /// <summary>Sets numeric value and timestamp, as ticks, of this <see cref="TemporalMeasurement"/>.</summary>
        /// <remarks>
        /// <para>Operation will only store a value that is newer than the cached value.</para>
        /// </remarks>
        /// <param name="timestamp">New timestamp, in ticks, for <see cref="TemporalMeasurement"/>.</param>
        /// <param name="value">New value for <see cref="TemporalMeasurement"/>, only stored if <paramref name="timestamp"/> are newer than current <see cref="Ticks"/>.</param>
        /// <returns><c>true</c> if value was updated; otherwise <c>false</c>.</returns>
        public bool SetValue(Ticks timestamp, double value)
        {
            // We only store a value that is is newer than the current value
            if (timestamp > Timestamp)
            {
                base.Value = value;
                Timestamp = timestamp;
                return true;
            }

            return false;
        }
Пример #11
0
        // Determines whether the given value has
        // flatlined over the configured delay interval.
        private bool CheckFlatline(IMeasurement signal)
        {
            long dist, diff;

            if (signal.Value != m_lastValue)
            {
                m_lastChanged = signal.Timestamp;
                m_lastValue = signal.Value;
            }

            dist = Ticks.FromSeconds(Delay.Value);
            diff = signal.Timestamp - m_lastChanged;

            return diff >= dist;
        }
Пример #12
0
        // Tests the given measurement to determine whether
        // its value indicates that the signal has been in
        // the alarming range for the configured delay time.
        private bool CheckRange(IMeasurement signal)
        {
            bool result = GetTestResult(signal);
            Ticks dist;

            if (!result)
            {
                // Keep track of the last time
                // the signal was in range
                m_lastNegative = signal.Timestamp;
            }
            else
            {
                // Get the amount of time since the
                // last time the value was in range
                dist = signal.Timestamp - m_lastNegative;

                // If the amount of time is larger than
                // the delay threshold, raise the alarm
                if (dist >= Ticks.FromSeconds(Delay.Value))
                    return true;
            }

            return false;
        }
Пример #13
0
 /// <summary>
 /// Creates a new <see cref="IFrame"/> for the given <paramref name="timestamp"/>.
 /// </summary>
 /// <param name="timestamp">Timestamp for new <see cref="IFrame"/> in <see cref="Ticks"/>.</param>
 /// <returns>New <see cref="IFrame"/> at given <paramref name="timestamp"/>.</returns>
 /// <remarks>
 /// Derived classes can override this method to create a new custom <see cref="IFrame"/>. Default
 /// behavior creates a basic <see cref="Frame"/> to hold synchronized measurements.
 /// </remarks>
 protected internal virtual IFrame CreateNewFrame(Ticks timestamp)
 {
     return new Frame(timestamp, m_expectedMeasurements);
 }
Пример #14
0
 /// <summary>
 /// Returns the deviation, in milliseconds, that the given number of ticks is from real-time (i.e., <see cref="ConcentratorBase.RealTime"/>).
 /// </summary>
 /// <param name="timestamp">Timestamp to calculate distance from real-time.</param>
 /// <returns>A <see cref="Double"/> value indicating the deviation in milliseconds.</returns>
 public double MillisecondsFromRealTime(Ticks timestamp)
 {
     return SecondsFromRealTime(timestamp) / SI.Milli;
 }
Пример #15
0
        /// <summary>
        /// Returns the deviation, in seconds, that the given number of ticks is from real-time (i.e., <see cref="ConcentratorBase.RealTime"/>).
        /// </summary>
        /// <param name="timestamp">Timestamp to calculate distance from real-time.</param>
        /// <returns>A <see cref="Double"/> value indicating the deviation, in seconds, from real-time.</returns>
        public double SecondsFromRealTime(Ticks timestamp)
        {
            // Make sure real-time is initialized for initial distance calculation
            if (Thread.VolatileRead(ref m_realTimeTicks) == 0)
            {
                long currentTimeTicks;

                if (m_performTimestampReasonabilityCheck)
                    currentTimeTicks = DateTime.UtcNow.Ticks;
                else
                    currentTimeTicks = timestamp;

                Thread.VolatileWrite(ref m_realTimeTicks, currentTimeTicks);
            }

            return (RealTime - timestamp).ToSeconds();
        }
Пример #16
0
 /// <summary>Gets numeric value of this <see cref="TemporalMeasurement"/>, constrained within specified ticks.</summary>
 /// <remarks>
 /// <para>Operation will return NaN if ticks are outside of time deviation tolerances.</para>
 /// </remarks>
 /// <param name="timestamp">Timestamp, in ticks, used to constrain <see cref="TemporalMeasurement"/> (typically set to real-time, i.e. "now").</param>
 /// <returns>Raw value of this measurement (i.e., value that is not offset by adder and multiplier).</returns>
 public double GetValue(Ticks timestamp)
 {
     // We only return a measurement value that is up-to-date...
     return Timestamp.TimeIsValid(timestamp, m_lagTime, m_leadTime) ? base.Value : double.NaN;
 }
Пример #17
0
 public void ToTicksTest()
 {
     Time target = new Time(10F);
     Ticks expected = new Ticks(100000000);
     Ticks actual;
     actual = target.ToTicks();
     Assert.AreEqual(expected, actual);
 }
Пример #18
0
 /// <summary>
 /// Creates a new <see cref="NtpTimeTag"/>, given specified <see cref="Ticks"/>.
 /// </summary>
 /// <param name="timestamp">Timestamp in <see cref="Ticks"/> to create Unix timetag from (minimum valid date is 1/1/1900).</param>
 /// <remarks>
 /// This constructor will accept a <see cref="DateTime"/> parameter since <see cref="Ticks"/> is implicitly castable to a <see cref="DateTime"/>.
 /// </remarks>
 public NtpTimeTag(Ticks timestamp)
     : base(GetBaseDateOffsetTicks(timestamp), timestamp)
 {
 }
Пример #19
0
        /// <summary>
        /// Creates or updates cipher keys.
        /// </summary>
        internal void UpdateKeyIVs()
        {
            using (AesManaged symmetricAlgorithm = new AesManaged())
            {
                symmetricAlgorithm.KeySize = 256;
                symmetricAlgorithm.GenerateKey();
                symmetricAlgorithm.GenerateIV();

                if (m_keyIVs == null)
                {
                    // Initialize new key set
                    m_keyIVs = new byte[2][][];
                    m_keyIVs[EvenKey] = new byte[2][];
                    m_keyIVs[OddKey] = new byte[2][];

                    m_keyIVs[EvenKey][KeyIndex] = symmetricAlgorithm.Key;
                    m_keyIVs[EvenKey][IVIndex] = symmetricAlgorithm.IV;

                    symmetricAlgorithm.GenerateKey();
                    symmetricAlgorithm.GenerateIV();

                    m_keyIVs[OddKey][KeyIndex] = symmetricAlgorithm.Key;
                    m_keyIVs[OddKey][IVIndex] = symmetricAlgorithm.IV;

                    m_cipherIndex = EvenKey;
                }
                else
                {
                    // Generate a new key set for current cipher index
                    m_keyIVs[m_cipherIndex][KeyIndex] = symmetricAlgorithm.Key;
                    m_keyIVs[m_cipherIndex][IVIndex] = symmetricAlgorithm.IV;

                    // Set run-time to the other key set
                    m_cipherIndex ^= 1;
                }
            }

            m_lastCipherKeyUpdateTime = DateTime.UtcNow.Ticks;
        }
Пример #20
0
        protected static ulong GetNTPTimestampFromTicks(Ticks timestamp)
        {
            timestamp -= GetBaseDateOffsetTicks(timestamp);

            uint seconds = (uint)Math.Truncate(timestamp.ToSeconds());
            uint fraction = (uint)(timestamp.DistanceBeyondSecond().ToSeconds() * uint.MaxValue);

            return Word.MakeQword(seconds, fraction);
        }
Пример #21
0
 /// <summary>
 /// Creates a copy of the specified measurement using a new value and timestamp.
 /// </summary>
 /// <param name="measurementToClone">Specified measurement to clone.</param>
 /// <param name="value">New value for cloned measurement.</param>
 /// <param name="timestamp">New timestamp, in ticks, for cloned measurement.</param>
 /// <returns>A copy of the <see cref="Measurement"/> object.</returns>
 public static Measurement Clone(IMeasurement measurementToClone, double value, Ticks timestamp)
 {
     return new Measurement()
     {
         ID = measurementToClone.ID,
         Key = measurementToClone.Key,
         Value = value,
         Adder = measurementToClone.Adder,
         Multiplier = measurementToClone.Multiplier,
         Timestamp = timestamp,
         TagName = measurementToClone.TagName,
         StateFlags = measurementToClone.StateFlags
     };
 }
Пример #22
0
        /// <summary>
        /// Initializes this <see cref="RangeTest"/>.
        /// </summary>
        public override void Initialize()
        {
            base.Initialize();

            string errorMessage = "{0} is missing from Settings - Example: lowRange=59.95; highRange=60.05";
            bool rangeSet = false;

            Dictionary<string, string> settings = Settings;
            string setting;

            if (settings.TryGetValue("signalType", out m_signalType))
                rangeSet = TrySetRange(m_signalType);

            if(!rangeSet)
            {
                // Load required parameters
                if (!settings.TryGetValue("lowRange", out setting))
                    throw new ArgumentException(string.Format(errorMessage, "lowRange"));

                m_lowRange = double.Parse(setting);

                if (!settings.TryGetValue("highRange", out setting))
                    throw new ArgumentException(string.Format(errorMessage, "highRange"));

                m_highRange = double.Parse(setting);

                rangeSet = true;
            }

            // Load optional parameters
            if (settings.TryGetValue("timeToPurge", out setting))
                m_timeToPurge = Ticks.FromSeconds(double.Parse(setting));

            if (settings.TryGetValue("warnInterval", out setting))
                m_warnInterval = Ticks.FromSeconds(double.Parse(setting));

            m_warningTimer.Interval = m_warnInterval.ToMilliseconds();
            m_warningTimer.Elapsed += m_warningTimer_Elapsed;

            m_purgeTimer.Interval = m_timeToPurge.ToMilliseconds();
            m_purgeTimer.Elapsed += m_purgeTimer_Elapsed;
        }
Пример #23
0
 /// <summary>
 /// Constructs a new <see cref="Measurement"/> using default settings.
 /// </summary>
 public Measurement()
 {
     m_receivedTimestamp = DateTime.UtcNow.Ticks;
     m_multiplier = 1.0D;
 }
Пример #24
0
        static void ShowConnectedClients(object state)
        {
            Ticks displayTime = DateTime.UtcNow.Ticks;

            // Don't show client enumeration more than every two seconds...
            if ((displayTime - lastDisplayTime).ToSeconds() > 2.0D)
            {
                lastDisplayTime = displayTime;
                publisher.EnumerateClients();
            }
        }
Пример #25
0
 /// <summary>
 /// Creates a new <see cref="UnixTimeTag"/>, given specified <see cref="Ticks"/>.
 /// </summary>
 /// <param name="timestamp">Timestamp in <see cref="Ticks"/> to create Unix timetag from (minimum valid date is 1/1/1970).</param>
 /// <remarks>
 /// This constructor will accept a <see cref="DateTime"/> parameter since <see cref="Ticks"/> is implicitly castable to a <see cref="DateTime"/>.
 /// </remarks>
 public UnixTimeTag(Ticks timestamp)
     : base(UnixDateOffsetTicks, timestamp)
 {
 }
Пример #26
0
        /// <summary>
        /// Initializes <see cref="TimestampTest"/>.
        /// </summary>
        public override void Initialize()
        {
            base.Initialize();

            string errorMessage = "{0} is missing from Settings - Example: concentratorName=TESTSTREAM";
            Dictionary<string, string> settings = Settings;
            string setting;

            // Load optional parameters
            if (settings.TryGetValue("timeToPurge", out setting))
                m_timeToPurge = Ticks.FromSeconds(double.Parse(setting));

            if (settings.TryGetValue("warnInterval", out setting))
                m_warnInterval = Ticks.FromSeconds(double.Parse(setting));

            // Load required parameters
            string concentratorName;

            if (!settings.TryGetValue("concentratorName", out concentratorName))
                throw new ArgumentException(string.Format(errorMessage, "concentratorName"));

            m_discardingAdapter = null;

            // Find the adapter whose name matches the specified concentratorName
            foreach (IAdapter adapter in Parent)
            {
                IActionAdapter concentrator = adapter as IActionAdapter;

                if (concentrator != null && string.Compare(adapter.Name, concentratorName, true) == 0)
                {
                    m_discardingAdapter = concentrator;
                    break;
                }
            }

            if (m_discardingAdapter == null)
                throw new ArgumentException(string.Format("Concentrator {0} not found.", concentratorName));

            // Wait for associated adapter to initialize
            int timeout = m_discardingAdapter.InitializationTimeout;
            m_discardingAdapter.WaitForInitialize(timeout);

            if (!m_discardingAdapter.Initialized)
                throw new TimeoutException(string.Format("Timeout waiting for concentrator {0} to initialize.", concentratorName));

            // Attach to adapter's discarding measurements and disposed events
            m_discardingAdapter.DiscardingMeasurements += m_discardingAdapter_DiscardingMeasurements;
            m_discardingAdapter.Disposed += m_discardingAdapter_Disposed;

            m_purgeTimer.Interval = m_timeToPurge.ToMilliseconds();
            m_purgeTimer.Elapsed += m_purgeTimer_Elapsed;

            m_warningTimer.Interval = m_warnInterval.ToMilliseconds();
            m_warningTimer.Elapsed += m_warningTimer_Elapsed;

            m_timestampService = new TimestampService(this);
            m_timestampService.ServiceProcessException += m_timestampService_ServiceProcessException;
            m_timestampService.SettingsCategory = base.Name + m_timestampService.SettingsCategory;
            m_timestampService.Initialize();
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="SerializableBadTimestampMeasurement"/> class.
 /// </summary>
 /// <param name="measurement"><see cref="IMeasurement"/> from which <see cref="SerializableOutOfRangeMeasurement"/> is to be initialized.</param>
 /// <param name="arrivalTime">The arrival time of the <see cref="IMeasurement"/>.</param>
 public SerializableBadTimestampMeasurement(IMeasurement measurement, Ticks arrivalTime)
     : base(measurement)
 {
     TimeOfArrival = ((DateTime)arrivalTime).ToString("yyyy-MM-dd HH:mm:ss.fff");
 }