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