/// <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();
}