source: branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive.Slave/3.4/PluginCache.cs @ 5156

#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.Clients.Hive.Salve;
using HeuristicLab.PluginInfrastructure;
using HeuristicLab.PluginInfrastructure.Manager;
using HeuristicLab.Services.Hive.Common.DataTransfer;

namespace HeuristicLab.Clients.Hive.Slave {
  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);
      }
      pm.DiscoverAndCheckPlugins();
      cachedPlugins = new List<PluginDescription>(pm.Plugins);
    }

    [MethodImpl(MethodImplOptions.Synchronized)]
    public void CopyPluginsForJob(List<Plugin> 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 (Plugin 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);
        CopyFile(baseDir, targetDir, "HeuristicLab.PluginInfrastructure-3.3.dll");
        CopyFile(baseDir, targetDir, "ICSharpCode.SharpZipLib.dll");
        CopyFile(baseDir, targetDir, "ICSharpCode.SharpZipLib License.txt");

        // copy slave plugins, otherwise its not possible to register the UnhandledException handler to the appdomain
        CopyFile(baseDir, targetDir, "HeuristicLab.Clients.Hive.Slave-3.4.dll");
        CopyFile(baseDir, targetDir, "HeuristicLab.Clients.Hive-3.4.dll");
        CopyFile(baseDir, targetDir, "HeuristicLab.Services.Hive.Common-3.4.dll");
        CopyFile(baseDir, targetDir, "HeuristicLab.Hive-3.4.dll");

        //TODO: remove, just needed for unit tests
        CopyFile(baseDir, targetDir, "HeuristicLab.Clients.Hive.Slave.Tests-3.4.dll");
      }
    }

    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(Job myJob, JobData jobData) {
      lock (locker) {
        SlaveClientCom.Instance.ClientCom.LogMessage("Fetching plugins for job");

        IEnumerable<Plugin> pluginDescriptions = WcfService.Instance.GetPlugins();
        List<Plugin> requiredPlugins = new List<Plugin>();
        foreach (Guid pluginId in myJob.PluginsNeededIds) {
          Plugin pl = pluginDescriptions.FirstOrDefault(p => p.Id == pluginId);
          if (pl != null)
            requiredPlugins.Add(pl);
        }

        List<Plugin> localPlugins = new List<Plugin>();
        List<Plugin> missingPlugins = new List<Plugin>();
        List<Guid> missingGuids = new List<Guid>();
        bool found = false;

        foreach (Plugin 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 Plugin() { Id = new Guid(), Name = info.Name, Version = info.Version });
              found = true;

              break;
            }
          }
          if (!found) {
            SlaveClientCom.Instance.ClientCom.LogMessage("Plugin NOT found " + info.Name + ", " + info.Version);
            missingPlugins.Add(info);
            missingGuids.Add(info.Id);
          }
          found = false;
        }

        SlaveClientCom.Instance.ClientCom.LogMessage("First run - Update the plugins in the cache");
        localPlugins.AddRange(missingPlugins);

        IEnumerable<PluginData> updateablePlugins = WcfService.Instance.GetPluginDatas(missingGuids);

        foreach (PluginData updateablePlugin in updateablePlugins) {
          Plugin pluginDescription = pluginDescriptions.Where(desc => desc.Id == updateablePlugin.PluginId).SingleOrDefault();
          if (pluginDescription != null) {

            PluginDescription pd = cachedPlugins.Where(cachedPlugin =>
                cachedPlugin.Name == pluginDescription.Name &&
                cachedPlugin.Version.Major == pluginDescription.Version.Major &&
                cachedPlugin.Version.Minor == pluginDescription.Version.Major).SingleOrDefault();

            if (pd != null) {
              foreach (IPluginFile ipf in pd.Files) {
                SlaveClientCom.Instance.ClientCom.LogMessage(string.Format("deleting {0}", Path.GetFileName(ipf.Name)));
                File.Delete(ipf.Name);
              }
            }
            File.WriteAllBytes(Path.Combine(PluginCacheDir, Path.GetFileName(pluginDescription.Name)), updateablePlugin.Data);
          }
          //TODO: error handling on pluginDescription, should be found
        }

        PluginData configFile = WcfService.Instance.GetConfigurationFile();
        File.WriteAllBytes(ConfigFilePath, configFile.Data);

        DoUpdateRun();
        CopyPluginsForJob(requiredPlugins, myJob.Id);
      }
    }

    internal void DeletePluginsForJob(Guid id) {
      try {
        SlaveClientCom.Instance.ClientCom.LogMessage("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) {
        SlaveClientCom.Instance.ClientCom.LogMessage("failed while unloading " + id + " with exception " + ex);
      }
    }


  }
}