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

#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.Reflection;
using System.Runtime.CompilerServices;
using System.Threading;
using HeuristicLab.Hive.Contracts.BusinessObjects;
using HeuristicLab.Hive.Slave.Communication;
using HeuristicLab.PluginInfrastructure;
using HeuristicLab.PluginInfrastructure.Manager;

namespace HeuristicLab.Hive.Slave.Core {
  public class PluginCache {
    private static object locker = new object();
    public const string ConfigFileName = "Sandbox.config";

    private static PluginCache instance = null;

    public string PluginCacheDir { get; set; }
    public string PluginTempBaseDir { 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 string ConfigFilePath {
      get {
        return Path.Combine(PluginCacheDir, ConfigFileName);
      }
    }

    public PluginCache() {
      PluginCacheDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "PluginCache");
      PluginTempBaseDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "PluginTemp");

      this.pm = new PluginManager(PluginCacheDir);
      DoUpdateRun();
    }

    private void DoUpdateRun() {
      if (!Directory.Exists(PluginCacheDir)) {
        Directory.CreateDirectory(PluginCacheDir);
        string baseDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
        CopyPluginInfrastructureFiles(baseDir, PluginCacheDir);
      }
      pm.DiscoverAndCheckPlugins();
      cachedPlugins = new List<PluginDescription>(pm.Plugins);
    }

    [MethodImpl(MethodImplOptions.Synchronized)]
    public void CopyPluginsForJob(List<HivePluginInfoDto> requests, Guid jobId) {
      lock (locker) {
        String targetDir = Path.Combine(PluginTempBaseDir, 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).SingleOrDefault();
          if (pd != null) {
            foreach (IPluginFile ipf in pd.Files) {
              File.Copy(ipf.Name, Path.Combine(targetDir, Path.GetFileName(ipf.Name)));
            }
          }
        }

        // copy config file
        File.Copy(ConfigFilePath, Path.Combine(targetDir, ConfigFileName));

        // copy files from PluginInfrastructure, which are not declared
        string baseDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
        CopyPluginInfrastructureFiles(baseDir, targetDir);

        // copy slave plugins, otherwise its not possible to register the UnhandledException handler to the appdomain
        CopySlaveFiles(baseDir, targetDir);
      }
    }

    private void CopySlaveFiles(string sourceDir, String targetDir) {
      CopyFile(sourceDir, targetDir, "HeuristicLab.Hive.Slave.Core-3.3.dll");
      CopyFile(sourceDir, targetDir, "HeuristicLab.Hive.Slave.Common-3.3.dll");
      CopyFile(sourceDir, targetDir, "HeuristicLab.Hive.Slave.Communication-3.3.dll");
      CopyFile(sourceDir, targetDir, "HeuristicLab.Hive.Slave.ExecutionEngine-3.3.dll");
    }

    private void CopyPluginInfrastructureFiles(string sourceDir, String targetDir) {
      CopyFile(sourceDir, targetDir, "HeuristicLab.PluginInfrastructure-3.3.dll");
      CopyFile(sourceDir, targetDir, "ICSharpCode.SharpZipLib.dll");
      CopyFile(sourceDir, targetDir, "ICSharpCode.SharpZipLib License.txt");
    }

    private void CopyFile(string baseDir, string targetDir, string fileName) {
      if (!File.Exists(Path.Combine(targetDir, fileName))) File.Copy(Path.Combine(baseDir, fileName), Path.Combine(targetDir, fileName));
    }

    [MethodImpl(MethodImplOptions.Synchronized)]
    internal void PreparePlugins(List<HivePluginInfoDto> requiredPlugins) {
      lock (locker) {
        Logger.Debug("Fetching plugins for job");
        List<HivePluginInfoDto> localPlugins = 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 == cachedPlugin.Name && info.Version == cachedPlugin.Version) {
              localPlugins.Add(new HivePluginInfoDto() { Id = new Guid(), Name = info.Name, Version = info.Version, Update = true });
              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(missingPlugins);

        foreach (CachedHivePluginInfoDto updateablePlugin in updateablePlugins) {
          PluginDescription pd = cachedPlugins.Where(cachedPlugin =>
            cachedPlugin.Name == updateablePlugin.Name &&
            cachedPlugin.Version.Major == updateablePlugin.Version.Major &&
            cachedPlugin.Version.Minor == updateablePlugin.Version.Major).SingleOrDefault();

          if (pd != null) {
            foreach (IPluginFile ipf in pd.Files) {
              Logger.Debug(string.Format("deleting {0}", Path.GetFileName(ipf.Name)));
              File.Delete(ipf.Name);
            }
          }

          foreach (HivePluginFile pf in updateablePlugin.PluginFiles) {
            Logger.Debug(string.Format("writing {0}", Path.GetFileName(pf.Name)));
            File.WriteAllBytes(Path.Combine(PluginCacheDir, Path.GetFileName(pf.Name)), pf.BinaryFile);
          }
        }

        // download config file
        HivePluginFile configFile = WcfService.Instance.GetConfigurationFile();
        File.WriteAllBytes(ConfigFilePath, configFile.BinaryFile);

        DoUpdateRun();
      }
    }

    internal void DeletePluginsForJob(Guid id) {
      try {
        Logger.Debug("unloading...");
        int tries = 5;
        while (tries > 0) {
          try {
            Directory.Delete(Path.Combine(PluginTempBaseDir, id.ToString()), true);
            tries = 0;
          }
          catch {
            Thread.Sleep(1000);
            tries--;
            if (tries == 0) throw;
          }
        }
      }
      catch (Exception ex) {
        Logger.Debug("failed while unloading " + id + " with exception " + ex);
      }
    }


  }
}