source: branches/3.2/sources/HeuristicLab.Hive.Client.Core/3.2/PluginCache.cs @ 4140

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using HeuristicLab.PluginInfrastructure;
using HeuristicLab.Hive.Client.Communication;
using HeuristicLab.Hive.Client.Common;
using HeuristicLab.Hive.Contracts.BusinessObjects;
using HeuristicLab.Tracing;
using System.IO;
using HeuristicLab.PluginInfrastructure.Manager;

namespace HeuristicLab.Hive.Client.Core {

  

  public class PluginCache {

    private static PluginCache instance = null;

    public const string PLUGIN_REPO = @"plugins\";

    private List<PluginDescription> cachedPlugins = new List<PluginDescription>();

    private PluginManager pm = new PluginManager(PLUGIN_REPO);
  
    public static PluginCache Instance {
      get {
        if (instance == null)
          instance = new PluginCache();
        return instance;
      }
    } 
    

    public PluginCache() {      
      DoUpdateRun();
    }

    private void DoUpdateRun() {
      pm.DiscoverAndCheckPlugins();
      cachedPlugins = new List<PluginDescription>(pm.Plugins);
    }


    [MethodImpl(MethodImplOptions.Synchronized)]
    public bool CopyPluginsForJob(List<HivePluginInfoDto> requests, Guid jobId) {

      String targetDir = PLUGIN_REPO + jobId.ToString() + "\\";

      if(Directory.Exists(targetDir)) {
        Directory.Delete(targetDir, true);
      }

      DirectoryInfo di = Directory.CreateDirectory(targetDir);

      foreach (HivePluginInfoDto requestedPlugin in requests) {
        PluginDescription pd =
          cachedPlugins.Where(
            cp =>
            cp.Name == requestedPlugin.Name && 
            cp.Version.Major == requestedPlugin.Version.Major && 
            cp.Version.Minor == requestedPlugin.Version.Minor && 
            cp.Version.Revision >= requestedPlugin.Version.Revision).
            SingleOrDefault();
        if (pd == null) {
          return false;
        }

        foreach(IPluginFile ipf in pd.Files) {
          File.Copy(ipf.Name, targetDir + ipf.Name.Split('\\').Last());
        }
      }
      return true;                                                                                                       
    }

    [MethodImpl(MethodImplOptions.Synchronized)]
    internal void PreparePlugins(List<HivePluginInfoDto> requiredPlugins) {
      Logger.Debug("Fetching plugins for job");
      List<HivePluginInfoDto> localPlugins = new List<HivePluginInfoDto>();
      List<HivePluginInfoDto> neededPlugins = new List<HivePluginInfoDto>();
      List<HivePluginInfoDto> missingPlugins = new List<HivePluginInfoDto>();
      bool found = false;

      foreach (HivePluginInfoDto info in requiredPlugins) {
        //we MAY run in problems here - if there is a plugin twice in requests, there may be added two different versions of the plugin
        foreach (PluginDescription cachedPlugin in cachedPlugins) {
          if (info.Name.Equals(cachedPlugin.Name)) {
            Logger.Debug("Found plugin " + info.Name + ", " + info.Version);
            localPlugins.Add(new HivePluginInfoDto() { BuildDate = DateTime.Now, Id = new Guid(), Name = info.Name, Version = info.Version, Update =  true});
            neededPlugins.Add(info);
            found = true;

            break;
          }
        }
        if (!found) {
          Logger.Debug("Plugin NOT found " + info.Name + ", " + info.Version);
          missingPlugins.Add(info);
        }
        found = false;
      }

      Logger.Debug("First run - Update the plugins in the cache");

      localPlugins.AddRange(missingPlugins);

      List<CachedHivePluginInfoDto> updateablePlugins = WcfService.Instance.RequestPlugins(localPlugins);      

      foreach (CachedHivePluginInfoDto updateablePlugin in updateablePlugins) {
        PluginDescription pd =
          cachedPlugins.Where(cachedPlugin => cachedPlugin.Name.Equals(updateablePlugin.Name)).SingleOrDefault();

        if (pd != null) {
          Logger.Debug("deleting old files");
          foreach (IPluginFile ipf in pd.Files) {
            File.Delete(ipf.Name);
          }
        }

        Logger.Debug("deleted old files");
        Logger.Debug("creating new files");

        

        foreach (HivePluginFile pf in updateablePlugin.PluginFiles) {
          File.WriteAllBytes(PLUGIN_REPO + pf.Name.Split('\\').Last(), pf.BinaryFile);
        }

        Logger.Debug("created new files");
        DoUpdateRun();
      }
    }

    internal void DeletePluginsForJob(Guid id) {
      try {
        Logger.Debug("unloading...");
        Directory.Delete(Path.Combine(PLUGIN_REPO, id.ToString()), true);
      } catch (Exception ex) {
        Logger.Debug("failed while unloading " + id + " with exception " + ex);
      }
    }
  }
}