public void Dispose()
{
if (this.resolver != null)
{
this.resolver.Dispose();
this.resolver = null;
}
}
public AutoRunner(Assembly testAssembly)
{
TypeHelper.InvokeFutureStaticMethod(
typeof(System.Windows.Forms.Application), "EnableVisualStyles");
this.resolver = new AssemblyResolverManager();
this.resolver.AddMbUnitDirectories();
this.domain = new AssemblyTestDomain(testAssembly);
}
private static Dictionary <string, PathEntry> GetLocalServices(bool withChildren)
{
return(LocalServicesCache.GetOrAdd(withChildren, wChildren =>
{
var logFilesServices = DiscoveryService.GetLocalRegisteredServices("LOG.FILE");
var logHttpServices = DiscoveryService.GetLocalRegisteredServices("LOG.HTTP");
var traceFilesServices = DiscoveryService.GetLocalRegisteredServices("TRACE.FILE");
var statusHttpServices = DiscoveryService.GetRegisteredServices("STATUS.HTTP");
var statusFilesServices = DiscoveryService.GetLocalRegisteredServices("STATUS.FILE");
var appNames = traceFilesServices.Select(ts => ts.ApplicationName).ToArray();
if (Core.Settings["ImportRemoteAssemblies"].ParseTo(false) && Core.Settings["ImportRemoteAssembliesPath"] != null)
{
var folderServices = DiscoveryService.GetLocalRegisteredServices("FOLDERS");
var folderServicesData = folderServices
.Where((s, names) => names.Contains(s.ApplicationName) && s.ApplicationName != Core.ApplicationName, appNames)
.Select(s => s.Data.GetValue() is string[] strArray ? strArray[0] : null)
.ToArray();
var destinationPath = Core.Settings["ImportRemoteAssembliesPath"];
foreach (var path in folderServicesData)
{
var localExeFiles = Directory.EnumerateFiles(path, "*.exe", SearchOption.AllDirectories);
var localDllFiles = Directory.EnumerateFiles(path, "*.dll", SearchOption.AllDirectories);
var localFiles = localExeFiles.Concat(localDllFiles);
foreach (var file in localFiles)
{
try
{
var name = AssemblyName.GetAssemblyName(file);
if (AssemblyResolver.IsExcludedAssembly(name.Name))
{
continue;
}
var destinationFile = Path.Combine(destinationPath, Path.GetFileName(file));
if (!System.IO.File.Exists(destinationFile))
{
System.IO.File.Copy(file, destinationFile);
}
}
catch (BadImageFormatException)
{
//
}
catch (Exception)
{
//
}
}
}
var asmResolver = AssemblyResolverManager.GetAssemblyResolver();
asmResolver?.AppendPath(destinationPath);
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="assemblyResolveManager"></param>
/// <param name="assemblyFiles"></param>
public DirectoryAssemblyPackage(AssemblyResolverManager assemblyResolveManager, IEnumerable <string> assemblyFiles)
{
_assemblyResolverManager = assemblyResolveManager;
var directories = assemblyFiles.Select(f => System.IO.Path.GetDirectoryName(f)).Distinct().Select(f => new System.IO.DirectoryInfo(f)).Where(f => f.Exists);
var files = new List <string>();
foreach (var dir in directories)
{
files.AddRange(dir.GetFiles("*.dll", System.IO.SearchOption.TopDirectoryOnly).Select(f => f.FullName));
}
_assemblyPaths = assemblyFiles;
_assemblyFiles = files;
}
public void Dispose()
{
if (this.resolver != null)
{
this.resolver.Dispose();
this.resolver = null;
}
if (this.Domain != null)
{
this.Domain.Dispose();
this.domain = null;
}
}
/// <summary>
/// Construtor completo.
/// </summary>
/// <param name="repositoryDirectory">Diretório base do respositório.</param>
/// <param name="assemblyFilesDirectories">Diretórios dos arquivos de assembly.</param>
/// <param name="assemblyResolverManager">Instancia responsável por resolver os assemblies.</param>
/// <param name="downloader">Instancia responsável pelo download dos assemblies.</param>
/// <param name="validator">Instancia do validador dos pacotes.</param>
/// <param name="assemblyInfoRepository">Repositório das informações do assembly.</param>
public AssemblyRepository(string repositoryDirectory, string[] assemblyFilesDirectories, AssemblyResolverManager assemblyResolverManager, IAssemblyPackageDownloader downloader, IAssemblyPackageValidator validator, IAssemblyInfoRepository assemblyInfoRepository)
{
repositoryDirectory = repositoryDirectory ?? DefaultRepositoryDirectory;
if (!System.IO.Directory.Exists(repositoryDirectory))
{
System.IO.Directory.CreateDirectory(repositoryDirectory);
}
_assemblyFilesDirectories = assemblyFilesDirectories ?? new string[0];
_repositoryDirectory = repositoryDirectory;
_assemblyResolverManager = assemblyResolverManager;
_downloader = downloader;
_validator = validator;
_assemblyInfoRepository = assemblyInfoRepository;
if (!System.IO.Directory.Exists(GetRepositoryFolder()))
{
System.IO.Directory.CreateDirectory(GetRepositoryFolder());
}
}
private Assembly[] DefaultGetAllAssemblies()
{
var resolver = AssemblyResolverManager.GetAssemblyResolver();
if (!AllAssembliesLoaded || (!_usedResolver && resolver != null))
{
if (resolver != null)
{
_usedResolver = true;
}
else
{
var loaded = new HashSet <string>(AppDomain.CurrentDomain.GetAssemblies().Select(a => a.GetName().FullName));
foreach (var file in Directory.EnumerateFiles(AppDomain.CurrentDomain.BaseDirectory, "*.dll", SearchOption.TopDirectoryOnly).AsParallel())
{
try
{
var name = AssemblyName.GetAssemblyName(file);
if (loaded.Contains(name.FullName))
{
continue;
}
if (IsExcludedAssembly(name.Name))
{
continue;
}
AppDomain.CurrentDomain.Load(name);
}
catch
{
// ignored
}
}
}
AllAssembliesLoaded = true;
_assemblies = null;
return(DefaultGetAssemblies());
}
return(_assemblies);
}
private Assembly[] DefaultGetAllAssemblies()
{
var resolver = AssemblyResolverManager.GetAssemblyResolver();
if (!AllAssembliesLoaded || (!_usedResolver && resolver != null))
{
if (resolver != null)
{
_usedResolver = true;
}
else
{
var loaded = AppDomain.CurrentDomain.GetAssemblies();
foreach (var file in Directory.EnumerateFiles(AppDomain.CurrentDomain.BaseDirectory, "*.dll", SearchOption.TopDirectoryOnly))
{
try
{
var name = AssemblyName.GetAssemblyName(file);
if (IsExcludedAssembly(name.Name))
{
continue;
}
if (loaded.All((l, fullName) => l.FullName != fullName, name.FullName))
{
AppDomain.CurrentDomain.Load(name);
}
}
catch
{
// ignored
}
}
}
AllAssembliesLoaded = true;
_assemblies = null;
return(DefaultGetAssemblies());
}
return(_assemblies);
}
protected virtual void Dispose(bool disposing)
{
if (_downloader != null)
{
_downloader.Dispose();
_downloader = null;
}
if (_startThread != null)
{
_startThread.Abort();
_startThread = null;
}
if (_assemblyResolverManager != null)
{
_assemblyResolverManager.Dispose();
_assemblyResolverManager = null;
}
foreach (var i in _packages)
{
i.Dispose();
}
_packages.Clear();
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting Serializer TEST");
if (info.Arguments?.Contains("/complex") == true)
{
var file = "c:\\temp\\complex.test.nbin.gz";
var serializer = SerializerManager.GetByFileName(file);
AssemblyResolverManager.RegisterDomain(new[] { @"C:\AGSW_GIT\Travel\src\Flights\Engines\Services\Agsw.Travel.Flights.Engines.Service\bin\Release\netcoreapp2.2" });
//AssemblyResolverManager.RegisterDomain(new[] { @"C:\Repo\AgswGit\Travel\src\Flights\Engines\Services\Agsw.Travel.Flights.Engines.Service\bin\Release\netcoreapp2.2" });
object value = null;
try
{
value = serializer.DeserializeFromFile <object>(file);
//value = rMsg.Body.GetValue();
}
catch (DeserializerException exGO)
{
var jsonSerializer = new JsonTextSerializer {
Indent = true
};
jsonSerializer.SerializeToFile(exGO.Value, "c:\\temp\\complexObject-GenericObject.json");
var val = exGO.Value["Products"][5];
}
RunTestEx(value, 500, null);
//GC.Collect();
//GC.WaitForFullGCComplete();
//RunTestEx(value, 200, new GZipCompressor());
//GC.Collect();
//GC.WaitForFullGCComplete();
//RunTestEx(value, 200, new DeflateCompressor());
return;
}
var sTest = new STest
{
FirstName = "Daniel",
LastName = "Redondo",
Age = 33,
value = 166
};
var collection = new List <List <STest> >();
for (var i = 0; i <= 10; i++)
{
var colSTest = new List <STest>
{
sTest, sTest, sTest, sTest, sTest, sTest,
sTest, sTest, sTest, sTest, sTest, sTest,
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 0, Age = 1, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 1, Age = 2, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 2, Age = 3, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 3, Age = 4, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 4, Age = 5, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 5, Age = 6, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 6, Age = 7, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 7, Age = 8, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 8, Age = 9, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 9, Age = 10, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 10, Age = 11
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 11, Age = 12
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 12, Age = 13
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 13, Age = 14
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 14, Age = 15
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 15, Age = 16
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 16, Age = 17
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 17, Age = 18
},
new STest {
FirstName = "Person", LastName = "Person" + i + "." + i + 18, Age = 19
},
//new STest2 { FirstName = "Person" , LastName = "Person" + i + "." + i+19, Age = 20, New = "This is a test" }
};
collection.Add(colSTest);
}
var lt = new List <STest>
{
new STest {
FirstName = "Name1", LastName = "LName1", Age = 11
},
//new STest2 { FirstName = "Name2" , LastName = "LName2", Age = 20, New = "This is a test" }
};
var lt2 = new List <Test3>
{
new Test3 {
Values = new List <int> {
2, 3, 4, 5
}
},
new Test3 {
Values = new List <int> {
10, 11, 12, 13
}
}
};
var dct = new Dictionary <string, int>
{
["Value1"] = 1,
["Value2"] = 2,
["Value3"] = 3,
};
var colClone = collection[0].DeepClone();
var clone = collection.DeepClone();
if (info.Arguments?.Contains("/parallel") == true)
{
RunSingleTest(collection[0], 2, false);
Core.Log.InfoBasic("Press ENTER to Start:");
Console.ReadLine();
Task.WaitAll(
Enumerable.Range(0, 8).Select(i => Task.Run(() => RunSingleTest(collection[0], 200_000, false))).ToArray()
);
Console.ReadLine();
return;
}
RunTest(collection[0], 200_000, false);
}
/// <summary>
/// Recupera os assemblies contidos na stream informada.
/// </summary>
/// <param name="resolverManager"></param>
/// <param name="assemblyRepositoryDirectory"></param>
/// <param name="packageUid">Identificador do pacote.</param>
/// <param name="packageStream"></param>
/// <param name="canOverride">Identifica se é para sobreescreve os arquivos.</param>
/// <param name="aggregateException"></param>
/// <returns></returns>
public static IEnumerable <System.Reflection.Assembly> LoadPackagedAssemblies(AssemblyResolverManager resolverManager, string assemblyRepositoryDirectory, Guid packageUid, System.IO.Stream packageStream, bool canOverride, out AggregateException aggregateException)
{
resolverManager.Require("resolverManager").NotNull();
packageStream.Require("packageStream").NotNull();
var exceptions = new List <Exception>();
Dictionary <string, System.Reflection.Assembly> domainAssemblies = new Dictionary <string, System.Reflection.Assembly>(StringComparer.InvariantCultureIgnoreCase);
foreach (var i in resolverManager.AppDomain.GetAssemblies())
{
var key = string.Format("{0}.dll", i.GetName().Name);
if (!domainAssemblies.ContainsKey(key))
{
domainAssemblies.Add(key, i);
}
else
{
domainAssemblies[key] = i;
}
}
string packageDirectory = null;
if (!string.IsNullOrEmpty(assemblyRepositoryDirectory))
{
packageDirectory = System.IO.Path.Combine(assemblyRepositoryDirectory, packageUid.ToString());
if (!System.IO.Directory.Exists(packageDirectory))
{
System.IO.Directory.CreateDirectory(packageDirectory);
}
}
using (var zipArchive = new IO.Compression.ZipArchive(packageStream, System.IO.FileAccess.Read))
{
if (packageDirectory != null)
{
zipArchive.CopyToDirectory("", packageDirectory, canOverride);
}
var list = new List <System.Reflection.Assembly>();
IEnumerable <AssemblyPart> deploymentParts = GetDeploymentParts(zipArchive);
var resolver = new LoadPackageAssemblyResolver(resolverManager.AppDomain, domainAssemblies, deploymentParts, zipArchive, packageDirectory);
resolverManager.Add(resolver);
try
{
foreach (AssemblyPart part in deploymentParts)
{
System.Reflection.Assembly assembly = null;
if (!domainAssemblies.TryGetValue(part.Source, out assembly))
{
if (packageDirectory == null)
{
var fileInfo = zipArchive.Files.Where(f => f.Name == part.Source).FirstOrDefault();
var raw = new byte[fileInfo.Length];
using (var file = zipArchive.OpenRead(part.Source))
file.Read(raw, 0, raw.Length);
try
{
assembly = part.Load(resolverManager.AppDomain, raw);
}
catch (Exception ex)
{
exceptions.Add(ex);
continue;
}
}
else
{
try
{
assembly = part.Load(resolverManager.AppDomain, System.IO.Path.Combine(packageDirectory, part.Source));
}
catch (Exception ex)
{
exceptions.Add(ex);
continue;
}
try
{
assembly.GetTypes();
}
catch (System.Reflection.ReflectionTypeLoadException ex)
{
exceptions.Add(new System.Reflection.ReflectionTypeLoadException(ex.Types, ex.LoaderExceptions, string.Format("An error ocurred when load types from assembly '{0}'", assembly.FullName)));
continue;
}
catch (Exception ex)
{
exceptions.Add(new Exception(string.Format("An error ocurred when load types from assembly '{0}'", assembly.FullName), ex));
continue;
}
}
if (!domainAssemblies.ContainsKey(part.Source))
{
domainAssemblies.Add(part.Source, assembly);
}
}
list.Add(assembly);
}
}
finally
{
resolverManager.Remove(resolver);
}
if (exceptions.Count > 0)
{
aggregateException = new AggregateException(exceptions);
}
else
{
aggregateException = null;
}
return(list);
}
}
public MainClass()
{
TypeHelper.InvokeFutureStaticMethod(typeof(System.Windows.Forms.Application), "EnableVisualStyles");
this.resolver = new AssemblyResolverManager();
this.resolver.AddMbUnitDirectories();
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="assemblyResolverManager"></param>
/// <param name="uid"></param>
/// <param name="packageFileName">Nome do arquivo do pacote.</param>
public AssemblyPackageResult(AssemblyResolverManager assemblyResolverManager, Guid uid, string packageFileName)
{
_assemblyResolverManager = assemblyResolverManager;
_packageUid = uid;
_packageFileName = packageFileName;
}
public static void Init(Factories factories)
{
if (_initialized)
{
return;
}
_initialized = true;
UpdateLocalUtc();
Factory.SetFactories(factories);
Status = Factory.CreateStatusEngine();
Log = Factory.CreateLogEngine();
Trace = Factory.CreateTraceEngine();
factories.Init();
GlobalSettings.ReloadSettings();
DebugMode = DebugMode || GlobalSettings.DebugMode;
if (DebugMode)
{
Log.InfoBasic("Core Init - Platform: {0} - OS: {1}", Factory.PlatformType, RuntimeInformation.OSDescription);
Log.InfoBasic("Directory: {0}", Directory.GetCurrentDirectory());
}
AssemblyResolverManager.RegisterDomain();
if (ServiceContainer.HasConsole)
{
Log.AddConsoleStorage();
}
if (Injector?.Settings != null && Injector.Settings.Interfaces.Count > 0)
{
//Init Log
Log.LibDebug("Loading log engine configuration");
var logStorages = Injector.GetNames <ILogStorage>();
if (logStorages?.Any() == true)
{
foreach (var name in logStorages)
{
if (!Settings[$"Core.Log.Storage.{name}.Enabled"].ParseTo(false))
{
continue;
}
Log.LibDebug("Loading log storage: {0}", name);
var lSto = Injector.New <ILogStorage>(name);
if (lSto == null)
{
Log.Warning("The Injection for \"{0}\" with name \"{1}\" is null.", typeof(ILogStorage).Name, name);
continue;
}
if (lSto.GetType() == typeof(ConsoleLogStorage))
{
Log.LibDebug("Console log storage already added, ignoring.");
continue;
}
Log.Storage.Add(lSto, Settings[$"Core.Log.Storage.{name}.LogLevel"].ParseTo(LogLevel.Error | LogLevel.Warning));
}
}
var logStorage = Log.Storage.Get(typeof(ConsoleLogStorage));
if (!Settings["Core.Log.Storage.Console.Enabled"].ParseTo(true))
{
Log.Storage.Remove(logStorage);
}
Log.Storage.ChangeStorageLogLevel(logStorage, Settings["Core.Log.Storage.Console.LogLevel"].ParseTo(LogStorageCollection.AllLevels));
Log.MaxLogLevel = (LogLevel)GlobalSettings.LogMaxLogLevel;
Log.Enabled = GlobalSettings.LogEnabled;
//Init Trace
Log.LibDebug("Loading trace engine configuration");
var traceStorages = Injector.GetNames <ITraceStorage>();
if (traceStorages?.Any() == true)
{
foreach (var name in traceStorages)
{
if (!Settings[$"Core.Trace.Storage.{name}.Enabled"].ParseTo(false))
{
continue;
}
Log.LibDebug("Loading trace storage: {0}", name);
var lTrace = Injector.New <ITraceStorage>(name);
if (lTrace == null)
{
Log.Warning("The Injection for \"{0}\" with name \"{1}\" is null.", typeof(ITraceStorage).Name, name);
continue;
}
Trace.Storage.Add(lTrace);
}
}
Trace.Enabled = GlobalSettings.TraceEnabled;
//Init Status
Log.LibDebug("Loading status engine configuration");
var statusTransports = Injector.GetNames <IStatusTransport>();
if (statusTransports?.Any() == true)
{
foreach (var name in statusTransports)
{
if (!Settings[$"Core.Status.Transport.{name}.Enabled"].ParseTo(false))
{
continue;
}
Log.LibDebug("Loading status transport: {0}", name);
var sTransport = Injector.New <IStatusTransport>(name);
if (sTransport == null)
{
Log.Warning("The Injection for \"{0}\" with name \"{1}\" is null.", typeof(IStatusTransport).Name, name);
continue;
}
Status.Transports.Add(sTransport);
}
}
Status.Enabled = GlobalSettings.StatusEnabled;
}
try
{
var allAssemblies = Factory.GetAllAssemblies();
var types = allAssemblies.SelectMany(a =>
{
try
{
return(a.DefinedTypes);
}
catch
{
// ignored
}
return(new TypeInfo[0]);
}).Where(t => !t.IsAbstract && t.IsClass && t.ImplementedInterfaces.Contains(typeof(ICoreStart))).ToArray();
if (types?.Any() == true)
{
foreach (var type in types)
{
try
{
var instance = (ICoreStart)Activator.CreateInstance(type.AsType());
Log.LibDebug("Loading CoreStart from: {0}", instance);
instance.CoreInit(factories);
}
catch (Exception ex)
{
Log.Write(ex);
}
}
}
}
catch (Exception ex)
{
Log.Write(ex);
}
Status.Attach(() =>
{
if (Settings == null)
{
return(null);
}
var sItem = new StatusItem
{
Name = "Application Information\\Settings"
};
Settings.OrderBy(i => i.Key).Each(i => sItem.Values.Add(i.Key, i.Value));
return(sItem);
});
var onError = false;
lock (OninitActions)
{
while (OninitActions.Count > 0)
{
try
{
OninitActions.Dequeue()();
}
catch (Exception ex)
{
Log.Write(ex);
onError = true;
}
}
}
Log.Start();
Task.Delay(25).WaitAsync();
var dlog = (Log as DefaultLogEngine);
dlog?.LogDoneTask.WaitAsync();
if (onError)
{
throw new Exception("Error initializing the application.");
}
Log.LibDebug("Core has been initialized.");
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="repositoryDirectory">Diretório base do respositório.</param>
/// <param name="assemblyFilesDirectories">Diretórios dos arquivos de assembly.</param>
/// <param name="assemblyResolverManager">Instancia responsável por resolver os assemblies.</param>
/// <param name="downloader">Instancia responsável pelo download dos assemblies.</param>
/// <param name="validator">Instancia do validador dos pacotes.</param>
public AssemblyRepository(string repositoryDirectory, string[] assemblyFilesDirectories, AssemblyResolverManager assemblyResolverManager, IAssemblyPackageDownloader downloader, IAssemblyPackageValidator validator) : this(repositoryDirectory, assemblyFilesDirectories, assemblyResolverManager, downloader, validator, null)
{
}
