source: branches/3.3-Hive/sources/HeuristicLab.Hive/HeuristicLab.Hive.Slave.Core/3.3/PluginCache.cs @ 4424

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

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

namespace HeuristicLab.Hive.Slave.Core {
  public class PluginCache {

    private static PluginCache instance = null;

    public string PluginRepositoryDir { get; set; }

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

    private PluginManager pm;

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

    public PluginCache() {
      PluginRepositoryDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "plugins");
      
      this.pm = new PluginManager(PluginRepositoryDir);
      DoUpdateRun();
    }

    private void DoUpdateRun() {
      if (!Directory.Exists(PluginRepositoryDir)) {
        Directory.CreateDirectory(PluginRepositoryDir);
      }
      pm.DiscoverAndCheckPlugins();
      cachedPlugins = new List<PluginDescription>(pm.Plugins);
    }

    [MethodImpl(MethodImplOptions.Synchronized)]
    public bool CopyPluginsForJob(List<HivePluginInfoDto> requests, Guid jobId) {
      String targetDir = Path.Combine(PluginRepositoryDir, 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) {
          string x = targetDir + ipf.Name.Split('\\').Last();
          string y = Path.Combine(targetDir, Path.GetFileName(ipf.Name));

          //File.Copy(ipf.Name, targetDir + ipf.Name.Split('\\').Last());
          File.Copy(ipf.Name, Path.Combine(targetDir, Path.GetFileName(ipf.Name)));
        }
      }
      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() { 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);
      IEnumerable<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) {
          string x = PluginRepositoryDir + pf.Name.Split('\\').Last();
          string y = Path.Combine(PluginRepositoryDir, Path.GetFileName(pf.Name));
          File.WriteAllBytes(Path.Combine(PluginRepositoryDir, Path.GetFileName(pf.Name)), pf.BinaryFile);
        }

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

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