DatabaseLogger.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace Seci.Helpers
{
    public static class DatabaseLogger
    {
        private static DatabaseWriter _dbWriter;
        private static Queue<LogInfo> _logQueue;
        private static Queue<CurrValInfo> _currValsQueue;
        private static Thread _dbWriterThread;

        public static void StartLogger()
        {
            _logQueue = new Queue<LogInfo>();
            _currValsQueue = new Queue<CurrValInfo>();
            _dbWriter = new DatabaseWriter(_logQueue, _currValsQueue);
            _dbWriterThread = new Thread(_dbWriter.ThreadRun);
            _dbWriterThread.Start();
        }

        public static void AddLogValue(String time, String blockname, String value)
        {
            try
            {
                LogInfo info = new LogInfo(time, blockname, value);

                if (value == Definitions.BlockInfo.ErrorString)
                {
                    info = new LogInfo(time, blockname, "NAN");
                }

                lock (((ICollection)_logQueue).SyncRoot)
                {
                    _logQueue.Enqueue(info);
                }

                //Seci.Helpers.MessageLogger.WriteMessage("DatabaseLogger:AddLogValue", "Queue count = " + _logQueue.Count);
            }
            catch (Exception err)
            {
                Seci.Helpers.ErrorLogger.SeciError("AddLogValue", err);
            }
        }

        public static void AddCurrentValue(String blockname, String value, String setpoint)
        {
            try
            {
                if (setpoint == null)
                {
                    setpoint = "";
                }

                CurrValInfo info = new CurrValInfo(blockname, value, setpoint);

                lock (((ICollection)_currValsQueue).SyncRoot)
                {
                    _currValsQueue.Enqueue(info);
                }

                //Seci.Helpers.MessageLogger.WriteMessage("DatabaseLogger:AddCurrentValue", "Queue count = " + _currValsQueue.Count);
            }
            catch (Exception err)
            {
                Seci.Helpers.ErrorLogger.SeciError("AddCurrentValue", err);
            }
        }

        public static void StopDatabaseLoggerThread()
        {
            _dbWriter.RequestThreadExit();
        }

        public static void LogConfigName(String config)
        {
            _dbWriter.WriteConfigName(config);
        }

        public static void WriteBlockDetails()
        {
            BlockDictionary blocks = Managers.BlockMgr.GetBlocksClone();

            for (int i = 0; i < blocks.Count; ++i)
            {
                //Enabled = 1, Runcontrol = 2, LogAtBegin = 4, LogAtEnd = 8
                int options = 0;

                if (blocks[i].BlockEnabled) options += 1;
                if (blocks[i].UnderRunControl) options += 2;
                if (blocks[i].LogChangesOnly || blocks[i].LogChangesTolerance) options += 12;

                //Check for nulls
                String read = "";
                String write = "";
                String go = "";
                String nexusname = "";
                String units = "";
                String curr = "";
                String set = "";

                if (blocks[i].ReadControl != null && blocks[i].ReadControl.EndsWith(")")) read = blocks[i].ReadControl.Substring(0, blocks[i].ReadControl.LastIndexOf('(') - 1);
                if (blocks[i].WriteControl != null && blocks[i].WriteControl.EndsWith(")")) write = blocks[i].WriteControl.Substring(0, blocks[i].WriteControl.LastIndexOf('(') - 1);
                if (blocks[i].GoButton != null && blocks[i].GoButton.EndsWith(")")) go = blocks[i].GoButton.Substring(0, blocks[i].GoButton.LastIndexOf('(') - 1);
                if (blocks[i].NexusName != null) nexusname = blocks[i].NexusName;
                if (blocks[i].BlockUnits != null) units = blocks[i].BlockUnits;
                if (blocks[i].CurrentValue != null) curr = blocks[i].CurrentValue;
                if (blocks[i].SetPointValue != null) set = blocks[i].SetPointValue;

                _dbWriter.WriteBlockDetails(blocks[i].BlockName, set, blocks[i].ParentVI, read,
                    write, go, options, nexusname, blocks[i].LowerLimit, blocks[i].UpperLimit, units, curr);

                //if (!String.IsNullOrEmpty(blocks[i].Alias))
                //{
                //    _dbWriter.WriteBlockDetails(blocks[i].Alias, set, blocks[i].ParentVI, read,
                //    write, go, options, nexusname, blocks[i].LowerLimit, blocks[i].UpperLimit, units, curr);
                //}
            }
        }

        public static void ClearQueues()
        {
            try
            {
                lock (((ICollection)_currValsQueue).SyncRoot)
                {
                    _currValsQueue.Clear();
                }

                lock (((ICollection)_logQueue).SyncRoot)
                {
                    _logQueue.Clear();
                }
            }
            catch
            {
            }
        }

        public static void CloseDatabase()
        {
            _dbWriter.CloseDatabase();
        }
    }

    class DatabaseWriter
    {
        private Boolean _inError = false;
        private DateTime _firstErrorTime;
        private selogcomLib.selog _dbCom = new selogcomLib.selog();
        private Boolean _exitThread;

        private Queue<LogInfo> _logQueue;
        private List<String> _logTimes = new List<string>();
        private List<String> _logNames = new List<string>();
        private List<String> _logValues = new List<string>();

        private Queue<CurrValInfo> _currValsQueue;
        private List<String> _currValsNames = new List<string>();
        private List<String> _currValsValues = new List<string>();
        private List<String> _currValsSetpoints = new List<string>();

        public DatabaseWriter(Queue<LogInfo> logqueue, Queue<CurrValInfo> currvalsqueue)
        {
            _logQueue = logqueue;
            _currValsQueue = currvalsqueue;
        }

        public void RequestThreadExit()
        {
            _exitThread = true;
        }

        public void ThreadRun()
        {
            while (!_exitThread)
            {
                try
                {
                    //Give the queues time to fill up
                    Thread.Sleep(1000);

                    _logTimes.Clear();
                    _logNames.Clear();
                    _logValues.Clear();

                    _currValsNames.Clear();
                    _currValsValues.Clear();
                    _currValsSetpoints.Clear();

                    //Get values from log queue
                    lock (((ICollection)_logQueue).SyncRoot)
                    {
                        //Keep going until the queue is empty or the number of values to log exceeds 50 items
                        while (_logQueue.Count > 0)// && _logNames.Count < 50)
                        {
                            LogInfo temp = _logQueue.Dequeue();

                            if (temp != null && !String.IsNullOrEmpty(temp.Time) && !String.IsNullOrEmpty(temp.Name) && !String.IsNullOrEmpty(temp.Value))
                            {
                                _logTimes.Add(temp.Time);
                                _logNames.Add(temp.Name);
                                _logValues.Add(temp.Value);
                            }
                        }
                    }

                    //Write to database here using SELogValues
                    int runNumber;
                    if (_logTimes.Count > 0 && int.TryParse(Seci.Standard.Dae.RunNumber, out runNumber))
                    {
                        lock (_dbCom)
                        {
                            _dbCom.SELogValues(runNumber, "SECI", _logTimes.ToArray(), _logNames.ToArray(), _logValues.ToArray());
                        }
                    }

                    //Get values from current values queue
                    lock (((ICollection)_currValsQueue).SyncRoot)
                    {
                        //Keep going until the queue is empty
                        while (_currValsQueue.Count > 0)
                        {
                            CurrValInfo temp = _currValsQueue.Dequeue();
                            _currValsNames.Add(temp.Name);
                            _currValsValues.Add(temp.Value);
                            _currValsSetpoints.Add(temp.Setpoint);
                        }
                    }

                    //Write to database here using SESetBlockValues and SESetBlockSetpoints
                    lock (_dbCom)
                    {
                        if (_currValsNames.Count > 0)
                        {
                            _dbCom.SESetBlockValues(_currValsNames.ToArray(), _currValsValues.ToArray());
                            _dbCom.SESetBlockSetpoints(_currValsNames.ToArray(), _currValsSetpoints.ToArray());
                        }
                    }

                    //No errors
                    _inError = false;
                }
                catch (Exception err)
                {
                    //If it is a first time error then log, otherwise only log an error reminder every ten minutes.
                    if (!_inError)
                    {
                        _inError = true;
                        _firstErrorTime = DateTime.UtcNow;
                        Helpers.ErrorLogger.SeciError("DatabaseWriter ThreadRun", err);
                    }
                    else
                    {
                        TimeSpan diff = DateTime.UtcNow - _firstErrorTime;
                        if (diff >= TimeSpan.FromMinutes(10))
                        {
                            Helpers.ErrorLogger.SeciError("DatabaseWriter ThreadRun - still in error", err);
                            _firstErrorTime = DateTime.UtcNow;
                        }
                    }
                }
            }
        }

        public void WriteConfigName(String name)
        {
            try
            {
                lock (_dbCom)
                {
                    _dbCom.SENewSECIConfig(name);
                }
            }
            catch (Exception err)
            {
                //Log error and hope it works next time!
                Helpers.ErrorLogger.SeciError("WriteConfigName", err);
            }
        }

        public void WriteBlockDetails(String name, String setpoint, String vi, String readcontrol, String setcontrol, String buttoncontrol,
            int options, String nexusname, Double lowlimit, Double highlimit, String units, String currentvalue)
        {
            try
            {
                lock (_dbCom)
                {
                    //Temporary workround
                    Single low = correctLimit((Single)lowlimit);
                    Single high = correctLimit((Single)highlimit);

                    _dbCom.SESetBlockDetails(name, setpoint, vi, readcontrol, setcontrol, buttoncontrol, options, nexusname, low, high, units, currentvalue);
                }
            }
            catch (Exception err)
            {
                Seci.Helpers.ErrorLogger.SeciError("WriteBlockDetails", err);
            }
        }

        private static Single correctLimit(Single value)
        {
            if (Single.IsNegativeInfinity(value))
            {
                value = Single.MinValue;
            }
            else if (Single.IsPositiveInfinity(value))
            {
                value = Single.MaxValue;
            }
            return value;
        }

        public void CloseDatabase()
        {
            try
            {
                lock (_dbCom)
                {
                    _dbCom.SEClose();
                }
            }
            catch
            {

            }
        }
    }

    class LogInfo
    {
        public String Name { get; private set; }
        public String Time { get; private set; }
        public String Value { get; private set; }

        public LogInfo(String time, String name, String value)
        {
            Name = name;
            Time = time;
            Value = value;
        }
    }

    class CurrValInfo
    {
        public String Name { get; private set; }
        public String Value { get; private set; }
        public String Setpoint { get; private set; }

        public CurrValInfo(String name, String value, String setpoint)
        {
            Name = name;
            Value = value;
            Setpoint = setpoint;
        }
    }
}