/// <summary>
/// Refreshs the update intervals for all indicators.
/// </summary>
private void RefreshUpdateIntervals()
{
Dictionary <string, TimeSpan> intervals = new Dictionary <string, TimeSpan>();
List <string> pluginNames = new List <string>();
List <Core.IPlugin> plugins = PluginManager.Instance.LoadAvailablePlugins();
foreach (Core.IPlugin current in plugins)
{
pluginNames.Add(current.GetName());
}
List <Tuple <string, string, long?> > tmpUpdateIntervals = GetAllUpdateIntervals(pluginNames);
string ID;
TimeSpan currentInterval;
foreach (Tuple <string, string, long?> current in tmpUpdateIntervals)
{
WorkstationLogger.WriteLog("New intervals: " + current.Item1 + " " +
current.Item2 + " " + current.Item3 / 10000000 + " seconds");
ID = current.Item1 + "." + current.Item2;
currentInterval = TimeSpan.FromTicks((long)current.Item3);
intervals.Add(ID, currentInterval);
}
Scheduler.Instance.RefreshUpdateInterval(intervals);
}
/// <summary>
/// Store a plugin to the assembly folder
/// </summary>
/// <param name="plugin">Plugin to store</param>
/// /// <returns>Result of this method</returns>
private Boolean StorePlugin(PluginFile plugin)
{
// Convert the Base64 UUEncoded input into binary output.
byte[] binaryData;
try
{
binaryData = System.Convert.FromBase64String(plugin.FileAsBase64);
}
catch (System.ArgumentNullException)
{
//Logging "Base 64 string is null."
var messageEx1 = new StringBuilder();
messageEx1.Append(ServerConnection.GetWorkstationName() + "_PluginManager_StorePlugin: ");
messageEx1.Append("Can't store the plugin. " + "Base 64 string is null.");
ServerConnection.WriteLog(messageEx1.ToString(), LogType.Exception);
return(false);
}
catch (System.FormatException)
{
//Logging "Base 64 string length is not 4 or is not an even multiple of 4."
var messageEx2 = new StringBuilder();
messageEx2.Append(
ServerConnection.GetWorkstationName() +
"Base 64 string length is not 4 or is not an even multiple of 4.");
messageEx2.Append("Can't store the plugin. " + "Base 64 string is null.");
ServerConnection.WriteLog(messageEx2.ToString(), LogType.Exception);
return(false);
}
// Write out the decoded data.
System.IO.FileStream outFile;
string outputFileName =
pluginPath +
Path.DirectorySeparatorChar +
plugin.FileName;
WorkstationLogger.WriteLog("Storing plugin into: " + outputFileName);
try
{
outFile = new System.IO.FileStream(outputFileName,
System.IO.FileMode.Create,
System.IO.FileAccess.Write);
outFile.Write(binaryData, 0, binaryData.Length);
outFile.Close();
}
catch (System.Exception exp)
{
//Logging
//Logging "Base 64 string is null."
var messageEx3 = new StringBuilder();
messageEx3.Append(ServerConnection.GetWorkstationName() + "_PluginManager_StorePlugin: ");
messageEx3.Append("Can't store the plugin. " + exp.ToString());
ServerConnection.WriteLog(messageEx3.ToString(), LogType.Exception);
return(false);
}
return(true);
}
/// <summary>
/// Check for new plugins on the MISD server, download of the new plugins and load them.
/// </summary>
/// <returns>Empty list if new plugins are loaded, otherwise all plugins.</returns>
public List <IPlugin> UpdatePlugins()
{
List <string> pluginsToChange = new List <string>();
//download plugin metadata
var metadata = ServerConnection.GetPluginList();
//check for changes and delete old plugins
if (metadata == null)
{
ServerConnection.WriteLog(
ServerConnection.GetWorkstationName() +
"_PluginManager_UpdatePlugins: Error in GetPluginList, object was null.", LogType.Exception);
}
else
{
foreach (PluginMetadata data in metadata)
{
WorkstationLogger.WriteLog("Received metadata for: " + data.Name);
if (!this.PluginIsUptodate(data))
{
pluginsToChange.Add(data.Name);
}
}
}
// check if new plugins are loaded
WorkstationLogger.WriteLog("Updating " + pluginsToChange.Count + " plugins");
if (pluginsToChange.Count > 0)
{
this.ReleasePluginContainer();
foreach (string pluginName in pluginsToChange)
{
//delete plugin
this.DeletePlugin(this.plugins.FirstOrDefault(p => p.GetName() == pluginName));
}
//download new plugins
WorkstationLogger.WriteLog("Downloading " + pluginsToChange.Count + " plugins");
var pluginFiles = ServerConnection.DownloadPlugins(pluginsToChange.ToArray());
//store new plugins
Boolean result = true;
foreach (PluginFile file in pluginFiles)
{
result = result && this.StorePlugin(file);
}
//load all available plugins
this.LoadAvailablePlugins();
return(this.plugins.ToList());
}
else
{
return(new List <IPlugin>());
}
}
private PluginManager()
{
this.LoadAvailablePlugins();
//create directory
if (!Directory.Exists(pluginPath))
{
WorkstationLogger.WriteLog("Creating: " + pluginPath);
Directory.CreateDirectory(pluginPath);
}
}
/// <summary>
/// Method to aquire data with the plugin.
/// </summary>
/// <returns>A list containing IndicatorName | IndicatorValue | IndicatorValueDataType.</returns>
private List <Tuple <string, object, MISD.Core.DataType> > GetValues()
{
List <string> indicatorName = new List <String>();
indicatorName.Add(this.Indicator);
try
{
List <Tuple <string, object, MISD.Core.DataType> > l = this.Plugin.AcquireData(indicatorName);
WorkstationLogger.WriteLog("Indicator: " + this.Indicator + " Value: " + l.First().Item2.ToString());
return(l);
}
catch (Exception e)
{
WorkstationLogger.WriteLog("Couldn't acquire value for: " + this.Indicator + ". Error: " + e.Message);
ServerConnection.WriteLog(ServerConnection.GetWorkstationName() +
" GetValues(): Couldn't acquire data for " + this.Indicator + " Error Message: " + e.Message, LogType.Exception);
}
return(new List <Tuple <string, object, MISD.Core.DataType> >());
}
/// <summary>
/// The method that gets the new update interval and start the refresh for all timerjobs.
/// </summary>
protected override void TimerTickAsync()
{
WorkstationLogger.WriteLog("Main update interval expired.");
// Update its own interval
TimeSpan oldInterval = this.Interval;
this.Interval = ServerConnection.GetMainUpdateInterval(oldInterval);
// Update plugins
if (PluginManager.Instance.UpdatePlugins().Count > 0)
{
// PluginManager.Instance.UpdatePlugins() deletes all timerjobs, so the timerjobs have to be reinitialized
Scheduler.Instance.RefreshJobs();
RefreshUpdateIntervals();
}
else
{
// If no new plugins are loaded, the intervals need to be refreshed
RefreshUpdateIntervals();
}
}
/// <summary>
/// Initializes the scheduler.
/// </summary>
protected override void Initialize()
{
// Load plugins
try
{
WorkstationLogger.WriteLog("Loading local plugins.");
PluginManager.Instance.LoadAvailablePlugins();
WorkstationLogger.WriteLog("Loaded plugins: " + PluginManager.Instance.GetLoadedPlugins().Count);
WorkstationLogger.WriteLog("Updating plugins from remote computer...");
PluginManager.Instance.UpdatePlugins();
// Add the schedulers for all indicators
foreach (IPlugin p in PluginManager.Instance.GetLoadedPlugins())
{
foreach (IndicatorSettings indicatorSetting in p.GetIndicatorSettings())
{
WorkstationLogger.WriteLog("Registering " + p.GetName() + "." + indicatorSetting.IndicatorName +
" at: " + indicatorSetting.UpdateInterval.Ticks / 10000000 + " seconds");
TimeSpan updateInterval = new TimeSpan(indicatorSetting.UpdateInterval.Ticks);
Jobs.Add(new IndicatorTimerJob(p, indicatorSetting.IndicatorName, updateInterval));
}
}
// Add the main update scheduler
Jobs.Add(new MainUpdateTimerJob());
// Start all timerjobs
foreach (TimerJobBase job in Jobs)
{
job.Start();
}
}
catch (Exception e)
{
WorkstationLogger.WriteLog("Error: " + e.Message);
}
}