SeciMgr.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Remoting.Channels.Tcp;
using Seci.Definitions;
using System.IO;
[assembly: CLSCompliant(true)]

namespace Seci.Managers
{
    public static class SeciMgr
    {
        private static int _maxLVFileAge = 7; //In days (for example: 7 = a week)
        private static Tools.ValuesUpdater _valuesUpdater;
        private static Boolean _valuesUpdaterEnabled;
        private static LabView.LvmqUpdater _lvmqUpdater;
        private static Boolean _lvmqUpdaterEnabled;
        public delegate void RemotingEventHandler(String[] vars);
        public static event RemotingEventHandler ClearGraphRequested;

        public static Boolean WebDashboardEnabled { get; set; }
        public static Boolean WebDashboardShowTitle { get; set; }

        //Indicates whether something significant is going on
        //For example: changing configuration, editing blocks etc.
        public static Boolean IsBusy { get; set; }

        public delegate void ValuesUpdatedEventHandler(Boolean timeout);
        public static event ValuesUpdatedEventHandler OnValuesUpdated;

        public static event EventHandler OnNewLVMessage;
        public static event EventHandler OnLVNotThere;

        public static void InitialiseSeci(String exeDir)
        {
            Status.ReadAppSettings();
            //Set up directories
            Status.ExecutionDir = exeDir;
            Status.ErrorDir = Status.BaseLogDir + "\\Seci messages\\";
            Status.ConfigDir = exeDir + "\\Configurations\\";
            Status.LabViewErrorDir = Status.BaseLogDir + "\\LabVIEW messages\\";
            Status.HelpDir = exeDir + "\\Help\\";

            Status.CreateDirectories();

            //Clear out any old log files
            clearOutLabViewLogs();

            //Set event handlers
            _valuesUpdater = new Tools.ValuesUpdater(Status.BlockUpdateRate);
            _valuesUpdater.OnValuesUpdated += new Tools.ValuesUpdater.ValuesUpdatedEventHandler(daeValuesUpdated);

            _lvmqUpdater = new LabView.LvmqUpdater(3000);
            _lvmqUpdater.OnChangeToLVMessages += new EventHandler(messageQNewLVMessage);
            _lvmqUpdater.OnLabviewNotThere +=new EventHandler(messageQLabviewNotThere);

            //Enable remoting
            enableDotNetRemoting();
            Seci.Helpers.MessageLogger.WriteMessage("SeciGui", "User started SECI");

            if (Seci.Definitions.Status.LogToDatabase)
            {
                //Enable database logging
                Seci.Helpers.DatabaseLogger.StartLogger();
            }
        }

        private static void clearOutLabViewLogs()
        {
            try
            {
                //Work out the valid log file names
                DateTime today = DateTime.Today;
                List<String> validFiles = new List<String>();

                for (int i = 0; i < _maxLVFileAge; ++i)
                {
                    DateTime pastDate = today.Subtract(new TimeSpan(i, 0, 0, 0));
                    validFiles.Add(pastDate.Day + " " + pastDate.ToString("MMMM") + " - " + pastDate.DayOfWeek + ".txt");
                }

                DirectoryInfo di = new DirectoryInfo(Status.LabViewErrorDir);
                if (di.Exists)
                {
                    List<FileInfo> filist = new List<FileInfo>(di.GetFiles("*.txt"));

                    foreach (FileInfo fi in filist)
                    {
                        if (!validFiles.Contains(fi.Name))
                        {
                            fi.Delete();
                        }
                    }
                }
            }
            catch
            {
                //Just in case - it is not the end of the world if this fails
            }
        }

        public static void CloseSeci()
        {
            if (Seci.Definitions.Status.LogToDatabase)
            {
                Seci.Helpers.DatabaseLogger.StopDatabaseLoggerThread();
                System.Threading.Thread.Sleep(1000);
                Seci.Helpers.DatabaseLogger.CloseDatabase();
            }
        }

        private static void daeValuesUpdated(Boolean timeout)
        {
            //Raise an event so the GUI can tell when the values have been updated.
            //This is forwarding the event from the valuesUpdater.
            if (OnValuesUpdated != null)
            {
                OnValuesUpdated(timeout);
            }
        }

        private static void messageQNewLVMessage(object sender, EventArgs e)
        {
            //Raise an event so the GUI can tell when new LabVIEW messages are received.
            //This is forwarding the event from the LVMQUpdater.
            if (OnNewLVMessage != null)
            {
                OnNewLVMessage(sender, e);
            }
        }

        private static void messageQLabviewNotThere(object sender, EventArgs e)
        {
            //Raise an event so the GUI can tell when new LabVIEW messages are received.
            //This is forwarding the event from the LVMQUpdater.
            if (OnLVNotThere != null)
            {
                OnLVNotThere(sender, e);
            }
        }

        private static Boolean enableDotNetRemoting()
        {
            //Create two channels
            try
            {
                //SECURE - TCP
                //Setup the configuration parameters through a dictionary
                IDictionary properties = new Hashtable();
                properties.Add("port", 8084);
                properties.Add("secure", true);
                properties.Add("impersonate", true);

                //Create an instance of a channel
                TcpServerChannel secureChannel = new TcpServerChannel(properties, null);
                ChannelServices.RegisterChannel(secureChannel, true);

                //Register as an available service with the name SECISecure.rem
                RemotingConfiguration.RegisterWellKnownServiceType(typeof(Remoting.ReadWriteRemoting), "SECISecure.rem", WellKnownObjectMode.Singleton);

                //UNSECURE - HTTP
                //Create an instance of a channel
                HttpChannel Channel = new HttpChannel(8085);
                ChannelServices.RegisterChannel(Channel, false);

                //Register as an available service with the name SECI.rem
                RemotingConfiguration.RegisterWellKnownServiceType(typeof(Remoting.ReadOnlyRemoting), "SECI.rem", WellKnownObjectMode.Singleton);

                return true;
            }
            catch
            {
                return false;
            }
        }

        public static Boolean InitialiseLabView(Boolean loadStandardVIs)
        {
            //Start LabVIEW and initialise the DAE VI
            if (LabView.LabViewApp.StartLabView(Status.ExecutionDir))
            {
                //Initialise LabVIEW Message Queue
                Standard.MessageQueue.InitialiseMessQVI();

                if (loadStandardVIs)
                {
                    //Load DAE
                    initialiseDae();

                    //Initialise BeamLogger
                    Standard.BeamLogger.InitialiseBeamlogger();

                    //Initialise SampleParameters, BeamlineParameters and UserDetails
                    Standard.BeamlineParameters.Initialise();
                    Standard.SampleParameters.Initialise();
                    Standard.UserDetails.Initialise();

                    //Load the DAEMonitor VI, if required
                    if (Status.UseDaeMonitorVI)
                    {
                        Standard.DaeMonitor.Initialise();
                    }
                }
                return true;
            }
            else
            {
                return false;
            }
        }

        private static void initialiseDae()
        {
            Standard.Dae.Initialise(Status.LabViewDir + Status.DaeFile);

            //Make sure add handler only once
            Standard.Dae.RunEnded -= new Standard.DaeEventHandler(runStartedOrEnded);
            Standard.Dae.RunEnded += new Standard.DaeEventHandler(runStartedOrEnded);

            Standard.Dae.RunStarted -= new Seci.Standard.DaeEventHandler(runStartedOrEnded);
            Standard.Dae.RunStarted += new Seci.Standard.DaeEventHandler(runStartedOrEnded);
        }

        static void runStartedOrEnded(DateTime time, string runNumber)
        {
            Tools.ValuesUpdater.LogValuesAtStartOrEndRun(time, runNumber);
        }

        #region Background Threads

        public static void StartThreads(Boolean startBlockUpdater, Boolean startLVMQUpdater)
        {
            if (startBlockUpdater)
            {
                _valuesUpdater.StartUpdater();
                _valuesUpdaterEnabled = true;
            }

            if (startLVMQUpdater)
            {
                _lvmqUpdater.StartUpdater();
                _lvmqUpdaterEnabled = true;
            }
        }

        public static void PauseThreads()
        {
            if (_valuesUpdaterEnabled)
            {
                _valuesUpdater.PauseUpdater();
            }

            if (_lvmqUpdaterEnabled)
            {
                _lvmqUpdater.PauseUpdater();
            }
        }

        public static void ResumeThreads()
        {
            if (_valuesUpdaterEnabled)
            {
                _valuesUpdater.ResumeUpdater();
            }

            if (_lvmqUpdaterEnabled)
            {
                _lvmqUpdater.ResumeUpdater();
            }
        }

        public static void ClearDatabaseQueues()
        {
            Seci.Helpers.DatabaseLogger.ClearQueues();
        }

        #endregion

        public static Boolean LogInAsManager(String password)
        {
            if (Status.CheckManagerPassword(password))
            {
                Status.ManagerLoggedIn = true;
                return true;
            }
            else
            {
                return false;
            }
        }

        public static void ClearGraphs()
        {
            if (ClearGraphRequested != null)
            {
                ClearGraphRequested(null);
            }
        }
    }
}