init

Framework/Util/SDAServer.cs

@@ -0,0 +1,746 @@
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Reflection;
+using System.Security.Permissions;
+using System.Text;
+using System.Xml;
+using Kreta.Framework.Caching;
+using Kreta.Framework.Exceptions;
+using Kreta.Framework.Logging;
+using Kreta.Framework.Session;
+using SDA.DataProvider;
+
+namespace Kreta.Framework
+{
+    /// <summary>
+    /// A kiszolgáló.
+    /// </summary>
+    /// <remarks>
+    /// Az osztály nem engedi meg, hogy egyszerre több példány is létezzen egyidejűleg.
+    /// </remarks>
+    public abstract class SDAServer : IDisposable
+    {
+        #region Mezők
+
+        /// <summary>
+        /// Szálbiztos védelem az egyedüli példány létrehozásához.
+        /// </summary>
+        protected static readonly object SyncClass = new object();
+
+        /// <summary>
+        /// Szálbiztos védelem.
+        /// </summary>
+        protected readonly object Sync = new object();
+
+        /// <summary>
+        /// A kiszolgáló konfigurációs XML címkéje.
+        /// </summary>
+        protected XmlNode ConfigurationNode;
+
+        /// <summary>
+        /// A leállást okozó kivétel.
+        /// </summary>
+        Exception _stopException;
+
+        /// <summary>
+        /// Többszörös felszabadítás elleni védelem.
+        /// </summary>
+        bool _disposed;
+
+        #endregion
+
+        #region Konstruktorok
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        protected SDAServer()
+        {
+            const string errorMessage = "There is a running server.";
+
+            if (Instance != null)
+            {
+                throw new InvalidOperationException(errorMessage);
+            }
+
+            lock (SyncClass)
+            {
+                if (Instance != null)
+                {
+                    throw new InvalidOperationException(errorMessage);
+                }
+
+                Instance = this;
+            }
+        }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="configNode">A konfigurációt tartalmazó XmlNode</param>
+        protected SDAServer(XmlNode configNode)
+            : this()
+        {
+            try
+            {
+                ConfigurationNode = configNode ?? throw new ArgumentNullException(nameof(configNode));
+            }
+            catch
+            {
+                Dispose();
+                throw;
+            }
+        }
+
+        #endregion
+
+        #region Tulajdonságok
+
+        /// <summary>
+        /// A kiszolgáló egyetlen példánya, ha van.
+        /// </summary>
+        public static SDAServer Instance { get; protected set; }
+
+        /// <summary>
+        /// A kiszolgáló futási állapota.
+        /// </summary>
+        public bool IsRunning { get; private set; }
+
+        /// <summary>
+        /// A kiszolgáló utolsó indítási ideje.
+        /// </summary>
+        public DateTime LastStartup { get; private set; }
+
+        /// <summary>
+        /// A kiszolgáló konfigurációja.
+        /// </summary>
+        public Configuration Configuration { get; private set; }
+
+        /// <summary>
+        /// A kiszolgáló naplózó funkciókat tartalmazó objektuma.
+        /// </summary>
+        public Logger Logger { get; protected set; }
+
+        /// <summary>
+        /// A kiszolgáló munkamenet-kezelő objektuma.
+        /// </summary>
+        public SessionManager SessionManager { get; private set; }
+
+        /// <summary>
+        /// A kiszolgáló gyorsítótárait kezelő segédobjektuma.
+        /// </summary>
+        public Kreta.Framework.Caching.CacheManager CacheManager { get; private set; }
+
+        /// <summary>
+        /// Session kapcsolatot kezelő szolgáltatás.
+        /// </summary>
+        public ConnectionManager ConnectionManager { get; protected set; }
+
+        #endregion
+
+        #region Absztrakt tulajdonságok
+
+        public abstract bool ConsoleEnabled { get; set; }
+
+        #endregion
+
+        #region Nyilvános felület
+
+        /// <summary>
+        /// Eldönti hogy egy assembly feldolgozása engedélyezett-e a szerver reflexiós metódusainak.
+        /// </summary>
+        /// <param name="assembly">Az adott assembly.</param>
+        /// <returns><see langword="true"/> ha igen, <see langword="false"/> egyébként.</returns>
+        internal protected virtual bool IsAssemblyAllowed(Assembly assembly)
+        {
+            return true;
+        }
+
+        /// <summary>
+        /// Adatbázis kapcsolathoz egy példány létrehozása, zárt állapotban.
+        /// </summary>
+        public SDAConnection CreateConnection()
+        {
+            // <<Factory Method>>
+            return new SDAConnection(Configuration.DBConnection);
+        }
+
+        public SDAConnection CreateConnection(string connectionString)
+        {
+            // <<Factory Method>>
+            return new SDAConnection(connectionString);
+        }
+
+        public virtual string GetOrganizationIdentifier()
+        {
+            return string.Empty;
+        }
+
+        public virtual string GetIntezmenyConnectionString(string intezmenyAzonosito)
+        {
+            return Configuration.DBConnection;
+        }
+
+        public virtual string GetSystemConnectionString(string intezmenyAzonosito)
+        {
+            return Configuration.DBConnection;
+        }
+
+        /// <summary>
+        /// Karakterlánccá alakítja az objektumot.
+        /// </summary>
+        /// <remarks>
+        /// A karakterlánc tartalmazza a kiszolgáló nevét, hálózati portszámát, állapotát (fut/nem fut).
+        /// </remarks>
+        /// <returns>Az objektumot leíró karakterlánc.</returns>
+        public override string ToString()
+        {
+            if (Configuration == null)
+            {
+                return "SDAServer";
+            }
+            return string.Format(
+                IsRunning ? "{0} (running)" : "{0} (stopped)",
+                Configuration.ServerName);
+        }
+
+        /// <summary>
+        /// A konfiguráció adott nevű tulajdonsága.
+        /// </summary>
+        /// <param name="parametername">A tulajdonság neve.</param>
+        /// <returns>A tulajdonság aktuális értéke.</returns>
+        public virtual object GetConfigurationParameter(string parametername)
+        {
+            return Configuration.GetType().InvokeMember(parametername, BindingFlags.GetProperty, null, Configuration, null);
+        }
+
+        #region Indítás, leállítás
+
+        /// <summary>
+        /// Elindítja a kiszolgálót.
+        /// </summary>
+        public void Start()
+        {
+            // <<Template Method>>
+            lock (Sync)
+            {
+                if (IsRunning)
+                {
+                    return;
+                }
+                try
+                {
+                    IsRunning = true;
+                    DoStart();
+                    Logger.ServerStarted();
+                    LastStartup = DateTime.Now;
+                }
+                catch (ServerStartException)
+                {
+                    IsRunning = false;
+                    throw;
+                }
+                catch (PanicException)
+                {
+                    IsRunning = false;
+                }
+                catch (Exception exception)
+                {
+                    if (Logger != null)
+                    {
+                        try
+                        {
+                            Logger.ExceptionThrown(exception);
+                        }
+                        catch (Exception logException)
+                        {
+                            exception = new AggregateException(exception, logException);
+                        }
+                    }
+                    IsRunning = false;
+                    throw new ServerStartException(exception);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Leállítja a kiszolgálót.
+        /// </summary>
+        public void Stop()
+        {
+            lock (Sync)
+            {
+                if (!IsRunning)
+                {
+                    return;
+                }
+                IsRunning = false;
+                DoStop();
+            }
+        }
+
+        /// <summary>
+        /// Újraindítja a kiszolgálót.
+        /// </summary>
+        /// <remarks>
+        /// A végrehajtás egyenértékű egy leállítással és egy indítással.
+        /// </remarks>
+        public void Restart()
+        {
+            // <<Template Method>>
+            lock (Sync)
+            {
+                if (!IsRunning)
+                {
+                    return;
+                }
+                Stop();
+                Start();
+            }
+        }
+
+        /// <summary>
+        /// Biztonságosan leállítja a kiszolgálót, és hibaüzenetet hagy maga után, a leállás pontos okáról.
+        /// </summary>
+        public void Panic(Exception panicException)
+        {
+            lock (Sync)
+            {
+                if (_stopException != null)
+                {
+                    throw panicException;
+                }
+                _stopException = panicException;
+                try
+                {
+                    DoPanic(panicException);
+                }
+                finally
+                {
+                    try
+                    {
+                        Stop();
+                    }
+                    catch (Exception stopexception)
+                    {
+                        // még leállítani sem lehet...
+                        ConsoleLogWriter.WriteLine("A kiszolgáló leállítása nem sikerült.");
+                        ConsoleLogWriter.WriteLine(ExceptionUtil.ExceptionToString(stopexception));
+                    }
+                }
+            }
+            throw new PanicException(panicException);
+        }
+
+        #endregion
+
+        #endregion
+
+        #region Indítás, leállítás
+
+        /// <summary>
+        /// Elvégzi a kiszolgáló indítását.
+        /// </summary>
+        protected virtual void DoStart()
+        {
+            lock (Sync)
+            {
+                _stopException = null;
+                Configuration = DoReadConfiguration(ConfigurationNode);
+                Logger = new Logger(CreatePrimaryLogWriter());
+                Logger.ConfigurationLoaded();
+                DoInitDatabase(Configuration);
+                CacheManager = CreateCacheManager();
+                InitCacheManager();
+                LanguageContext.Initialize(new LanguageContext(Configuration.LCID));
+                SessionManager = CreateSessionManager(Configuration, CacheManager);
+            }
+        }
+
+        /// <summary>
+        /// Elvégzi a kiszolgáló leállítását.
+        /// </summary>
+        protected virtual void DoStop()
+        {
+            lock (Sync)
+            {
+                if (SessionManager != null)
+                {
+                    SessionManager.Dispose();
+                    SessionManager = null;
+                }
+                if (Logger != null)
+                {
+                    Logger.ServerStopped();
+                    Logger = null;
+                }
+                CacheManager = null;
+            }
+        }
+
+        /// <summary>
+        /// Konfiguráció felolvasása.
+        /// </summary>
+        /// <param name="configNode">A beállításokat tartalmazó Xml leíró.</param>
+        protected virtual Configuration DoReadConfiguration(XmlNode configNode)
+        {
+            // <<Factory Method>>
+            return new Configuration(configNode);
+        }
+
+        /// <summary>
+        /// Létrehozza az alapértelmezett naplóvezető szolgáltatást. 
+        /// </summary>
+        protected virtual ILogWriter CreatePrimaryLogWriter()
+        {
+            // <<Factory Method>>
+            return LogUtil.ConfigureLogWriters(Configuration);
+        }
+
+        /// <summary>
+        /// Létrehozza a kiszolgáló munkamenet-kezelőjét.
+        /// </summary>
+        protected virtual SessionManager CreateSessionManager(Configuration configuration, Caching.CacheManager cacheManager)
+        {
+            // <<Factory Method>>
+            return new SessionManager(configuration, cacheManager);
+        }
+
+        /// <summary>
+        /// Létrehozza a kiszolgáló gyorsítótár-kezelőjét.
+        /// </summary>
+        protected virtual Kreta.Framework.Caching.CacheManager CreateCacheManager()
+        {
+            // <<Factory Method>>
+            return new Kreta.Framework.Caching.CacheManager();
+        }
+
+        /// <summary>
+        /// Inicializálja a kiszolgáló gyorsítótár-kezelőjét, és létrehozza az alap gyorsítótárakat.
+        /// </summary>
+        protected virtual void InitCacheManager()
+        {
+            CacheManager.AquireCache<StringResourcesCache>();
+            CacheManager.AquireCache<ManualEnumCache>();
+        }
+
+        /// <summary>
+        /// Inicializálja az adatbázis-kapcsolatot.
+        /// </summary>
+        /// <remarks>
+        /// A metódus létrehozza és megnyitja az adatbázis-kapcsolatot és ellenőrzi, hogy
+        /// megfelelő-e az adatbázis verziója.
+        /// </remarks>
+        /// <param name="configuration">Konfigurációs objektum.</param>
+        protected virtual void DoInitDatabase(Configuration configuration)
+        {
+            Initializer.Initialize(DatabaseType.NativeMSSQL);
+            SDA.DataProvider.Configuration.ErrorRecovery = true;
+            SDA.DataProvider.Configuration.MaxTries = 10;
+        }
+
+        #endregion
+
+        #region Pánik
+
+        /// <summary>
+        /// Ismeretlen eredetű kivételt kezel le.
+        /// </summary>
+        /// <param name="exception">A kivétel, ami történt.</param>
+        /// <returns><see langword="true"/>, ha a kiszolgáló újraindítható; egyébként <see langword="false"/>.</returns>
+        protected virtual void DoPanic(Exception exception)
+        {
+            string panicmessage = BuildPanicMessage(exception);
+            LogLastWords(panicmessage);
+            WriteLastWords(panicmessage);
+        }
+
+        /// <summary>
+        /// A leállás naplózása a rendszernaplóba.
+        /// </summary>
+        /// <param name="panicmessage">A naplóbejegyzés szövege.</param>
+        [EventLogPermission(SecurityAction.Demand, PermissionAccess = EventLogPermissionAccess.Write)]
+        protected virtual void LogLastWords(string panicmessage)
+        {
+            try
+            {
+                if (!EventLog.SourceExists(Configuration.ServerName))
+                {
+                    EventLog.CreateEventSource(Configuration.ServerName, "SDA");
+                }
+                var log = new EventLog
+                {
+                    Log = "SDA",
+                    Source = Configuration.ServerName
+                };
+                log.WriteEntry(panicmessage, EventLogEntryType.Error, (int)Events.CRITICAL_EXCEPTION);
+            }
+            catch (System.Security.SecurityException) { }
+            catch (InvalidOperationException) { }
+            catch (Win32Exception) { }
+        }
+
+        /// <summary>
+        /// Elkészíti a pánik üzenetet.
+        /// </summary>
+        /// <param name="exception">A pánikot okozó kivétel.</param>
+        /// <returns>A szöveges üzenet.</returns>
+        protected virtual string BuildPanicMessage(Exception exception)
+        {
+            var builder = new StringBuilder();
+            builder.AppendLine("Server panic:");
+            builder.AppendLine(DateTime.Now.ToString("yyyy.MM.dd. HH:mm:ss"));
+            if (exception != null)
+            {
+                builder.AppendLine("Exception:");
+                builder.Append(exception).AppendLine();
+            }
+            builder.AppendLine("Call stack:");
+            builder.Append(new StackTrace()).AppendLine();
+            return builder.ToString();
+        }
+
+        /// <summary>
+        /// Kiírja a pánik üzenetet konzolra és fájlba.
+        /// </summary>
+        /// <param name="panicMessage">A hátrahagyandó üzenet</param>
+        /// <returns><see langword="true"/>, ha sikerült; egyébként <see langword="false"/></returns>
+        protected virtual void WriteLastWords(string panicMessage)
+        {
+            try
+            {
+                ConsoleLogWriter.WriteLine(panicMessage, LogLevel.FATAL);
+                if (!ConsoleLogWriter.ConsoleEnabled)
+                {
+                    Console.ForegroundColor = ConsoleColor.Magenta;
+                    Console.WriteLine(panicMessage);
+                    Console.ResetColor();
+                }
+            }
+            catch (Exception exception)
+            {
+                Console.ForegroundColor = ConsoleColor.Magenta;
+                Console.WriteLine("SDAServer.WriteLastWords():");
+                Console.WriteLine(exception);
+                Console.ResetColor();
+            }
+            try
+            {
+                string directory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "LastWords");
+                string fileName = string.Format(CultureInfo.InvariantCulture, @"LW{0:yyyyMMddHHmmss}.txt", DateTime.Now);
+                if (!Directory.Exists(directory))
+                {
+                    Directory.CreateDirectory(directory);
+                }
+                using (var writer = new StreamWriter(Path.Combine(directory, fileName), true))
+                {
+                    writer.WriteLine(panicMessage);
+                    writer.WriteLine();
+                }
+            }
+            catch (Exception exception)
+            {
+                Console.ForegroundColor = ConsoleColor.Magenta;
+                Console.WriteLine("SDAServer.WriteLastWords():");
+                Console.WriteLine(exception);
+                Console.ResetColor();
+            }
+        }
+
+        #endregion
+
+        #region IDisposable
+
+        protected virtual void Dispose(bool disposing)
+        {
+            try
+            {
+                if (_disposed)
+                {
+                    return;
+                }
+                if (disposing)
+                {
+                    DoStop();
+                }
+                _disposed = true;
+            }
+            finally
+            {
+                lock (SyncClass)
+                {
+                    Instance = null;
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        ~SDAServer()
+        {
+            Dispose(false);
+        }
+
+        #endregion
+    }
+
+    public abstract class SDAApplicationServer : SDAServer
+    {
+        #region Mezők
+
+        /// <summary>
+        /// A kiszolgáló konfigurációs XML fájljának elérési útvonala.
+        /// </summary>
+        readonly string _configurationPath;
+
+        #endregion
+
+        #region Tulajdonságok
+
+        public override bool ConsoleEnabled
+        {
+            get { return ConsoleLogWriter.ConsoleEnabled; }
+            set { ConsoleLogWriter.ConsoleEnabled = value; }
+        }
+
+        #endregion
+
+        #region Konstruktorok
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        SDAApplicationServer()
+        {
+            try
+            {
+                Entities.EntityHandler.Init();
+            }
+            catch
+            {
+                Dispose();
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Az osztály konstruktora.
+        /// </summary>
+        /// <param name="configPath">A konfigurációs XML állomány elérési útvonala</param>
+        protected SDAApplicationServer(string configPath)
+            : this()
+        {
+            try
+            {
+                if (string.IsNullOrWhiteSpace(configPath))
+                {
+                    throw new ArgumentNullException(nameof(configPath));
+                }
+
+                _configurationPath = configPath;
+            }
+            catch
+            {
+                Dispose();
+                throw;
+            }
+        }
+
+        protected SDAApplicationServer(XmlNode configNode)
+            : this()
+        {
+            try
+            {
+                ConfigurationNode = configNode ?? throw new ArgumentNullException(nameof(configNode));
+            }
+            catch
+            {
+                Dispose();
+                throw;
+            }
+        }
+
+        #endregion
+
+        protected virtual XmlNode LoadConfig(string path)
+        {
+            var doc = new XmlDocument();
+            using (var reader = new StreamReader(path))
+            {
+                doc.LoadXml(reader.ReadToEnd());
+            }
+            return doc.SelectSingleNode(".//config");
+        }
+
+        protected override void DoStart()
+        {
+            lock (Sync)
+            {
+                Logger = new Logger(new ConsoleLogWriter());
+                if (_configurationPath != null)
+                {
+                    ConfigurationNode = LoadConfig(_configurationPath);
+                }
+                base.DoStart();
+            }
+        }
+
+        void DoStopImpl()
+        {
+        }
+
+        protected override void DoStop()
+        {
+            lock (Sync)
+            {
+                try
+                {
+                    DoStopImpl();
+                }
+                finally
+                {
+                    base.DoStop();
+                }
+            }
+        }
+
+        internal protected override bool IsAssemblyAllowed(Assembly assembly)
+        {
+            return
+                assembly.FullName.IndexOf(@"interop", StringComparison.OrdinalIgnoreCase) == -1
+                &&
+                assembly.FullName.IndexOf(@"fastreport", StringComparison.OrdinalIgnoreCase) == -1
+                &&
+                assembly.FullName.IndexOf(@"barcode", StringComparison.OrdinalIgnoreCase) == -1
+                &&
+                assembly.FullName.IndexOf(@"manageddataaccessdtc", StringComparison.OrdinalIgnoreCase) == -1;
+        }
+
+        #region IDisposable
+
+        bool _disposed;
+
+        protected override void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+            if (disposing)
+            {
+                DoStopImpl();
+            }
+            base.Dispose(disposing);
+            _disposed = true;
+        }
+
+        #endregion
+    }
+}