/// <summary> /// Disposes a temporal <see cref="IaonSession"/> created using <see cref="CreateTemporalSession"/>. /// </summary> /// <param name="adapter"><see cref="IClientSubscription"/> source instance.</param> /// <param name="session"><see cref="IaonSession"/> instance to dispose.</param> public static void DisposeTemporalSession(this IClientSubscription adapter, ref IaonSession session) { if (session != null) { EventHandler<EventArgs<string, UpdateType>> statusMessageFunction; EventHandler<EventArgs<Exception>> processExceptionFunction; EventHandler processingCompletedFunction; // Remove and detatch from event handlers if (s_statusMessageHandlers.TryRemove(adapter, out statusMessageFunction)) session.StatusMessage -= statusMessageFunction; if (s_processExceptionHandlers.TryRemove(adapter, out processExceptionFunction)) session.ProcessException -= processExceptionFunction; if (s_processingCompletedHandlers.TryRemove(adapter, out processingCompletedFunction)) session.ProcessingComplete -= processingCompletedFunction; session.Dispose(); } session = null; }
/// <summary> /// Returns a new temporal <see cref="IaonSession"/> for a <see cref="IClientSubscription"/>. /// </summary> /// <param name="clientSubscription"><see cref="IClientSubscription"/> instance to create temporal <see cref="IaonSession"/> for.</param> /// <returns>New temporal <see cref="IaonSession"/> for a <see cref="IClientSubscription"/>.</returns> public static IaonSession CreateTemporalSession(this IClientSubscription clientSubscription) { IaonSession session; // Cache the specified input measurement keys requested by the remote subscription // internally since these will only be needed in the private Iaon session MeasurementKey[] inputMeasurementKeys = clientSubscription.InputMeasurementKeys; IMeasurement[] outputMeasurements = clientSubscription.OutputMeasurements; // Since historical data is requested, we "turn off" interaction with the outside real-time world // by removing this adapter from external routes. To accomplish this we expose I/O demands for an // undefined measurement. Note: assigning to null would mean "broadcast" of all data is desired. clientSubscription.InputMeasurementKeys = new MeasurementKey[] { MeasurementKey.Undefined }; clientSubscription.OutputMeasurements = new IMeasurement[] { Measurement.Undefined }; // Create a new Iaon session session = new IaonSession(); session.Name = "<" + clientSubscription.HostName.ToNonNullString("unavailable") + ">@" + clientSubscription.StartTimeConstraint.ToString("yyyy-MM-dd HH:mm:ss"); // Assign requested input measurement keys as a routing restriction session.InputMeasurementKeysRestriction = inputMeasurementKeys; // Setup default bubbling event handlers associated with the client session adapter EventHandler<EventArgs<string, UpdateType>> statusMessageHandler = (sender, e) => { if (e.Argument2 == UpdateType.Information) clientSubscription.OnStatusMessage(e.Argument1); else clientSubscription.OnStatusMessage("0x" + (int)e.Argument2 + e.Argument1); }; EventHandler<EventArgs<Exception>> processExceptionHandler = (sender, e) => clientSubscription.OnProcessException(e.Argument); EventHandler processingCompletedHandler = (sender, e) => clientSubscription.OnProcessingCompleted(sender, e); // Cache dynamic event handlers so they can be detached later s_statusMessageHandlers[clientSubscription] = statusMessageHandler; s_processExceptionHandlers[clientSubscription] = processExceptionHandler; s_processingCompletedHandlers[clientSubscription] = processingCompletedHandler; // Attach handlers to new session - this will proxy all temporal session messages through the client session adapter session.StatusMessage += statusMessageHandler; session.ProcessException += processExceptionHandler; session.ProcessingComplete += processingCompletedHandler; // Send the first message indicating a new temporal session is being established statusMessageHandler(null, new EventArgs<string, UpdateType>( string.Format("Initializing temporal session for host \"{0}\" spanning {1} to {2} processing data {3}...", clientSubscription.HostName.ToNonNullString("unknown"), clientSubscription.StartTimeConstraint.ToString("yyyy-MM-dd HH:mm:ss.fff"), clientSubscription.StopTimeConstraint.ToString("yyyy-MM-dd HH:mm:ss.fff"), clientSubscription.ProcessingInterval == 0 ? "as fast as possible" : clientSubscription.ProcessingInterval == -1 ? "at the default rate" : "at " + clientSubscription.ProcessingInterval + "ms intervals"), UpdateType.Information)); // Duplicate current real-time session configuration for adapters that report temporal support session.DataSource = IaonSession.ExtractTemporalConfiguration(clientSubscription.DataSource); // Define an in-situ action adapter for the temporal Iaon session used to proxy data back to the client subscription DataTable actionAdapters = session.DataSource.Tables["ActionAdapters"]; DataRow proxyAdapterRow = actionAdapters.NewRow(); // Define connection string for proxy adapter based on original inputs and ouputs as requested by client subscription StringBuilder connectionString = new StringBuilder(); if (inputMeasurementKeys != null && inputMeasurementKeys.Length > 0) connectionString.AppendFormat("inputMeasurementKeys={{{0}}}", inputMeasurementKeys.Select(key => key.SignalID).ToDelimitedString(";")); if (outputMeasurements != null && outputMeasurements.Length > 0) { if (connectionString.Length > 0) connectionString.Append("; "); connectionString.AppendFormat("outputMeasurements={{{0}}}", outputMeasurements.Select(m => m.ID).ToDelimitedString(";")); } // Assign critical adapter properties proxyAdapterRow["ID"] = 0; proxyAdapterRow["AdapterName"] = "PROXY!SERVICES"; proxyAdapterRow["AssemblyName"] = "TimeSeriesFramework.dll"; proxyAdapterRow["TypeName"] = "TimeSeriesFramework.Transport.TemporalClientSubscriptionProxy"; proxyAdapterRow["ConnectionString"] = connectionString.ToString(); // Add proxy row to Iaon action adapter definitions actionAdapters.Rows.Add(proxyAdapterRow); // Initialize temporal session adapters without starting them session.Initialize(false); // Get reference to temporal session proxy adapter to it can be associated with the client subscription TemporalClientSubscriptionProxy proxyAdapter = null; IActionAdapter adapter0; // Lookup proxy adapter defined with reserved ID zero if (session.ActionAdapters.TryGetAdapterByID(0, out adapter0)) proxyAdapter = adapter0 as TemporalClientSubscriptionProxy; if ((object)proxyAdapter == null) throw new InvalidOperationException("Failed to define temporal subscription proxy adapter - cannot complete temporal session initialization."); // Associate proxy with client subscription proxyAdapter.Parent = clientSubscription; // Load current temporal constraint parameters Dictionary<string, string> settings = clientSubscription.Settings; string startTime, stopTime, parameters; settings.TryGetValue("startTimeConstraint", out startTime); settings.TryGetValue("stopTimeConstraint", out stopTime); settings.TryGetValue("timeConstraintParameters", out parameters); // Assign requested temporal constraints to all private session adapters session.AllAdapters.SetTemporalConstraint(startTime, stopTime, parameters); session.AllAdapters.ProcessingInterval = clientSubscription.ProcessingInterval; // Start temporal session adapters session.AllAdapters.Start(); // Recalculate routing tables to accomodate addtion of proxy adapter and handle // input measurement keys restriction session.RecalculateRoutingTables(); return session; }
/// <summary> /// Event handler for service starting operations. /// </summary> /// <param name="sender">Event source.</param> /// <param name="e">Event arguments containing command line arguments passed into service at startup.</param> /// <remarks> /// Time-series framework uses this handler to load settings from configuration file as service is starting. /// </remarks> protected virtual void ServiceStartingHandler(object sender, EventArgs<string[]> e) { // Initialize Iaon session m_iaonSession = new IaonSession(); m_iaonSession.StatusMessage += m_iaonSession_StatusMessage; m_iaonSession.ProcessException += m_iaonSession_ProcessException; // Create a handler for unobserved task exceptions TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException; // Make sure default service settings exist ConfigurationFile configFile = ConfigurationFile.Current; string cachePath = string.Format("{0}\\ConfigurationCache\\", FilePath.GetAbsolutePath("")); // System settings CategorizedSettingsElementCollection systemSettings = configFile.Settings["systemSettings"]; systemSettings.Add("ConfigurationType", "Database", "Specifies type of configuration: Database, WebService, BinaryFile or XmlFile"); systemSettings.Add("ConnectionString", "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=IaonHost.mdb", "Configuration database connection string"); systemSettings.Add("DataProviderString", "AssemblyName={System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089};ConnectionType=System.Data.OleDb.OleDbConnection;AdapterType=System.Data.OleDb.OleDbDataAdapter", "Configuration database ADO.NET data provider assembly type creation string"); systemSettings.Add("ConfigurationCachePath", cachePath, "Defines the path used to cache serialized configurations"); systemSettings.Add("CachedConfigurationFile", "SystemConfiguration.xml", "File name for last known good system configuration (only cached for a Database or WebService connection)"); systemSettings.Add("UniqueAdaptersIDs", "True", "Set to true if all runtime adapter ID's will be unique to allow for easier adapter specification"); systemSettings.Add("ProcessPriority", "High", "Sets desired process priority: Normal, AboveNormal, High, RealTime"); systemSettings.Add("AllowRemoteRestart", "True", "Controls ability to remotely restart the host service."); systemSettings.Add("MinThreadPoolWorkerThreads", DefaultMinThreadPoolSize, "Defines the minimum number of allowed thread pool worker threads."); systemSettings.Add("MaxThreadPoolWorkerThreads", DefaultMaxThreadPoolSize, "Defines the maximum number of allowed thread pool worker threads."); systemSettings.Add("MinThreadPoolIOPortThreads", DefaultMinThreadPoolSize, "Defines the minimum number of allowed thread pool I/O completion port threads (used by socket layer)."); systemSettings.Add("MaxThreadPoolIOPortThreads", DefaultMaxThreadPoolSize, "Defines the maximum number of allowed thread pool I/O completion port threads (used by socket layer)."); systemSettings.Add("GCGenZeroInterval", DefaultGCGenZeroInterval, "Defines the interval, in milliseconds, over which to force a generation zero garbage collection. Set to -1 to disable."); systemSettings.Add("ConfigurationBackups", DefaultConfigurationBackups, "Defines the total number of older backup configurations to maintain."); systemSettings.Add("PreferCachedConfiguration", "False", "Set to true to try the cached configuration first, before loading database configuration - typically used when cache is updated by external process."); // Example connection settings CategorizedSettingsElementCollection exampleSettings = configFile.Settings["exampleConnectionSettings"]; exampleSettings.Add("SqlServer.ConnectionString", "Data Source=serverName; Initial Catalog=databaseName; User ID=userName; Password=password", "Example SQL Server database connection string"); exampleSettings.Add("SqlServer.DataProviderString", "AssemblyName={System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089}; ConnectionType=System.Data.SqlClient.SqlConnection; AdapterType=System.Data.SqlClient.SqlDataAdapter", "Example SQL Server database .NET provider string"); exampleSettings.Add("MySQL.ConnectionString", "Server=serverName;Database=databaseName; Uid=root; Pwd=password; allow user variables = true;", "Example MySQL database connection string"); exampleSettings.Add("MySQL.DataProviderString", "AssemblyName={MySql.Data, Version=6.3.6.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d}; ConnectionType=MySql.Data.MySqlClient.MySqlConnection; AdapterType=MySql.Data.MySqlClient.MySqlDataAdapter", "Example MySQL database .NET provider string"); exampleSettings.Add("Oracle.ConnectionString", "Data Source=tnsName; User ID=schemaUserName; Password=schemaPassword", "Example Oracle database connection string"); exampleSettings.Add("Oracle.DataProviderString", "AssemblyName={Oracle.DataAccess, Version=2.112.2.0, Culture=neutral, PublicKeyToken=89b483f429c47342}; ConnectionType=Oracle.DataAccess.Client.OracleConnection; AdapterType=Oracle.DataAccess.Client.OracleDataAdapter", "Example Oracle database .NET provider string"); exampleSettings.Add("SQLite.ConnectionString", "Data Source=databaseName.db; Version=3", "Example SQLite database connection string"); exampleSettings.Add("SQLite.DataProviderString", "AssemblyName={System.Data.SQLite, Version=1.0.74.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139}; ConnectionType=System.Data.SQLite.SQLiteConnection; AdapterType=System.Data.SQLite.SQLiteDataAdapter", "Example SQLite database .NET provider string"); exampleSettings.Add("OleDB.ConnectionString", "Provider=Microsoft.Jet.OLEDB.4.0; Data Source=databaseName.mdb", "Example Microsoft Access (via OleDb) database connection string"); exampleSettings.Add("OleDB.DataProviderString", "AssemblyName={System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089}; ConnectionType=System.Data.OleDb.OleDbConnection; AdapterType=System.Data.OleDb.OleDbDataAdapter", "Example OleDb database .NET provider string"); exampleSettings.Add("Odbc.ConnectionString", "Driver={SQL Server Native Client 10.0}; Server=serverName; Database=databaseName; Uid=userName; Pwd=password;", "Example ODBC database connection string"); exampleSettings.Add("Odbc.DataProviderString", "AssemblyName={System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089}; ConnectionType=System.Data.Odbc.OdbcConnection; AdapterType=System.Data.Odbc.OdbcDataAdapter", "Example ODBC database .NET provider string"); exampleSettings.Add("WebService.ConnectionString", "http://localhost/ConfigSource/SystemConfiguration.xml", "Example web service connection string"); exampleSettings.Add("XmlFile.ConnectionString", "SystemConfiguration.xml", "Example XML configuration file connection string"); // Retrieve configuration cache directory as defined in the config file cachePath = systemSettings["ConfigurationCachePath"].Value; // Make sure configuration cache directory exists try { if (!Directory.Exists(cachePath)) Directory.CreateDirectory(cachePath); } catch (Exception ex) { DisplayStatusMessage("Failed to create configuration cache directory due to exception: {0}", UpdateType.Alarm, ex.Message); m_serviceHelper.ErrorLogger.Log(ex); } // Initialize system settings m_configurationType = systemSettings["ConfigurationType"].ValueAs<ConfigurationType>(); m_connectionString = systemSettings["ConnectionString"].Value; m_dataProviderString = systemSettings["DataProviderString"].Value; m_cachedXmlConfigurationFile = FilePath.AddPathSuffix(cachePath) + systemSettings["CachedConfigurationFile"].Value; m_cachedBinaryConfigurationFile = FilePath.AddPathSuffix(cachePath) + FilePath.GetFileNameWithoutExtension(m_cachedXmlConfigurationFile) + ".bin"; m_configurationBackups = systemSettings["ConfigurationBackups"].ValueAs<int>(DefaultConfigurationBackups); m_uniqueAdapterIDs = systemSettings["UniqueAdaptersIDs"].ValueAsBoolean(true); m_allowRemoteRestart = systemSettings["AllowRemoteRestart"].ValueAsBoolean(true); m_preferCachedConfiguration = systemSettings["PreferCachedConfiguration"].ValueAsBoolean(false); m_configurationCacheComplete = new AutoResetEvent(true); m_queuedConfigurationCachePending = new object(); // Setup default thread pool size try { ThreadPool.SetMinThreads(systemSettings["MinThreadPoolWorkerThreads"].ValueAs<int>(DefaultMinThreadPoolSize), systemSettings["MinThreadPoolIOPortThreads"].ValueAs<int>(DefaultMinThreadPoolSize)); ThreadPool.SetMaxThreads(systemSettings["MaxThreadPoolWorkerThreads"].ValueAs<int>(DefaultMaxThreadPoolSize), systemSettings["MaxThreadPoolIOPortThreads"].ValueAs<int>(DefaultMaxThreadPoolSize)); } catch (Exception ex) { DisplayStatusMessage("Failed to set desired thread pool size due to exception: {0}", UpdateType.Alarm, ex.Message); m_serviceHelper.ErrorLogger.Log(ex); } // Define a generation zero garbage collection timer int gcGenZeroInterval = systemSettings["GCGenZeroInterval"].ValueAs<int>(DefaultGCGenZeroInterval); if (gcGenZeroInterval > 0) { m_gcGenZeroTimer = new System.Timers.Timer(); m_gcGenZeroTimer.Elapsed += m_gcGenZeroTimer_Elapsed; m_gcGenZeroTimer.Interval = gcGenZeroInterval; m_gcGenZeroTimer.Enabled = true; } // Define guid with query string delimeters according to database needs Dictionary<string, string> settings = m_connectionString.ParseKeyValuePairs(); string setting; if (settings.TryGetValue("Provider", out setting)) { // Check if provider is for Access since it uses braces as Guid delimeters if (setting.StartsWith("Microsoft.Jet.OLEDB", StringComparison.OrdinalIgnoreCase)) { m_nodeIDQueryString = "{" + m_iaonSession.NodeID + "}"; // Make sure path to Access database is fully qualified if (settings.TryGetValue("Data Source", out setting)) { settings["Data Source"] = FilePath.GetAbsolutePath(setting); m_connectionString = settings.JoinKeyValuePairs(); } } } if (string.IsNullOrWhiteSpace(m_nodeIDQueryString)) m_nodeIDQueryString = "'" + m_iaonSession.NodeID + "'"; #if !MONO try { // Attempt to assign desired process priority. Note that process will require SeIncreaseBasePriorityPrivilege or // Administrative privileges to make this change Process.GetCurrentProcess().PriorityClass = systemSettings["ProcessPriority"].ValueAs<ProcessPriorityClass>(); } catch (Exception ex) { m_serviceHelper.ErrorLogger.Log(ex, false); } #endif }
/// <summary> /// Event handler for service stopping operation. /// </summary> /// <param name="sender">Event source.</param> /// <param name="e">Event arguments.</param> /// <remarks> /// Time-series framework uses this handler to un-wire events and dispose of system objects. /// </remarks> protected virtual void ServiceStoppingHandler(object sender, EventArgs e) { // Stop generation zero garbage collection timer if (m_gcGenZeroTimer != null) { m_gcGenZeroTimer.Enabled = false; m_gcGenZeroTimer.Elapsed -= m_gcGenZeroTimer_Elapsed; m_gcGenZeroTimer.Dispose(); } m_gcGenZeroTimer = null; // Dispose system health exporter if (m_healthExporter != null) { m_healthExporter.Enabled = false; m_serviceHelper.ServiceComponents.Remove(m_healthExporter); m_healthExporter.Dispose(); m_healthExporter.StatusMessage -= m_iaonSession.StatusMessageHandler; m_healthExporter.ProcessException -= m_iaonSession.ProcessExceptionHandler; } m_healthExporter = null; // Dispose system status exporter if (m_statusExporter != null) { m_statusExporter.Enabled = false; m_serviceHelper.ServiceComponents.Remove(m_statusExporter); m_statusExporter.Dispose(); m_statusExporter.StatusMessage -= m_iaonSession.StatusMessageHandler; m_statusExporter.ProcessException -= m_iaonSession.ProcessExceptionHandler; } m_statusExporter = null; // Dispose Iaon session if (m_iaonSession != null) { m_serviceHelper.ServiceComponents.Remove(m_iaonSession.InputAdapters); m_serviceHelper.ServiceComponents.Remove(m_iaonSession.ActionAdapters); m_serviceHelper.ServiceComponents.Remove(m_iaonSession.OutputAdapters); m_iaonSession.Dispose(); m_iaonSession.StatusMessage -= m_iaonSession_StatusMessage; m_iaonSession.ProcessException -= m_iaonSession_ProcessException; } m_iaonSession = null; m_serviceHelper.ServiceStarting -= ServiceStartingHandler; m_serviceHelper.ServiceStarted -= ServiceStartedHandler; m_serviceHelper.ServiceStopping -= ServiceStoppingHandler; if (m_serviceHelper.StatusLog != null) { m_serviceHelper.StatusLog.Flush(); m_serviceHelper.StatusLog.LogException -= LogExceptionHandler; } if (m_serviceHelper.ErrorLogger != null && m_serviceHelper.ErrorLogger.ErrorLog != null) { m_serviceHelper.ErrorLogger.ErrorLog.Flush(); m_serviceHelper.ErrorLogger.ErrorLog.LogException -= LogExceptionHandler; } if ((object)m_configurationCacheComplete != null) { // Release any waiting threads before disposing wait handle m_configurationCacheComplete.Set(); m_configurationCacheComplete.Dispose(); } m_configurationCacheComplete = null; // Unattach from handler for unobserved task exceptions TaskScheduler.UnobservedTaskException -= TaskScheduler_UnobservedTaskException; }
/// <summary> /// Initializes <see cref="SynchronizedClientSubscription"/>. /// </summary> public override void Initialize() { base.Initialize(); base.UsePrecisionTimer = false; if (!Settings.TryGetValue("inputMeasurementKeys", out m_requestedInputFilter)) m_requestedInputFilter = null; // Handle temporal session intialization if (this.TemporalConstraintIsDefined()) m_iaonSession = this.CreateTemporalSession(); }