private void AddModuleToGrid(ModuleWrapper module, GridEXRow row)
{
AssignNumberValueToCell <uint>(row.Cells[0], module.GetToken());
AssignNumberValueToCell <ulong>(row.Cells[1], module.GetBaseAddress());
AssignNumberValueToCell <uint>(row.Cells[2], module.GetSize());
row.Cells[3].Value = module.IsDynamic();
row.Cells[4].Value = module.IsInMemory();
string moduleName = module.GetName();
try
{
row.Cells[5].Value = Path.GetFileName(moduleName);
}
catch
{
}
row.Cells[6].Value = moduleName;
AssemblyWrapper assembly = module.GetAssembly();
row.Cells[7].Value = assembly.GetName();
AppDomainWrapper appDomain = assembly.GetAppDomain();
row.Cells[8].Value = appDomain.GetName();
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
Tools.Add(new Hammer());
var appSettings = new AppSettings();
var logger = PluginLoaderLogger.Factory(appSettings);
var appDomain = new AppDomainWrapper(AppDomain.CurrentDomain, logger);
var settings = new PluginLoaderSettings(appSettings);
var typeLoader = new TypeLoader <ITool>(PluginLoaderSettings.Default, logger);
var assemblyNameReader = new AssemblyNameReader();
var assemblyCache = new AssemblyCache(appDomain, assemblyNameReader, logger);
var assemblyLoader = new AssemblyLoader(appDomain, settings, assemblyCache, assemblyNameReader, logger);
var waiter = new Waiter(logger);
var assemblyResolveCache = new AssemblyResolveCache();
var pluginDependencyObjectCreator = new PluginDependencyResolverObjectCreator(appDomain, settings, assemblyLoader, waiter, assemblyResolveCache, logger);
var pluginDependencyResolverFactory = new PluginDependencyResolverCacheFactory(pluginDependencyObjectCreator, logger);
var pluginCacheFactory = new PluginCacheFactory <ITool>(typeLoader, pluginDependencyResolverFactory, assemblyLoader, logger);
var pluginPaths = new StaticPluginPaths(new[] { "Plugins" });
var pluginLoader = new PluginLoader <ITool>(pluginPaths, pluginCacheFactory);
var plugins = pluginLoader.LoadPlugins();
var objectCreator = new ObjectCreator <ITool>();
var toolPluginObjectCreator = new PluginObjectCreator <ITool>(settings, objectCreator, logger);
Tools.AddRange(plugins.CreatePluginObjects(toolPluginObjectCreator));
}
public static TestInfo GetConventionInfo(string testAssemblyPath)
{
var executingAssembly = Assembly.GetExecutingAssembly();
var executingAssemblyDirectory = Path.GetDirectoryName(executingAssembly.Location);
var previousDirectory = Directory.GetCurrentDirectory();
Directory.SetCurrentDirectory(executingAssemblyDirectory);
TestInfo info;
using (var appDomain = new AppDomainWrapper(executingAssemblyDirectory, "FixieTestFinder"))
{
var assemblyName = Assembly.GetExecutingAssembly().FullName;
var className = typeof(RemoteTestFinder).FullName;
var remoteFinder = appDomain.CreateObject <RemoteTestFinder>(
assemblyName,
className);
info = remoteFinder.FindTests(testAssemblyPath);
}
Directory.SetCurrentDirectory(previousDirectory);
return(info);
}
public static string[] LoadTestNames(AppDomainWrapper appDomainWrapper, string dllPath)
{
var o = appDomainWrapper.CreateObject <Marshalled.Executor.SpecEnumerator>("NJasmine.dll");
var result = o.GetTestNames(AssemblyName.GetAssemblyName(dllPath).FullName);
return(result);
}
public static string[] LoadTestNames(AppDomainWrapper appDomainWrapper, string dllPath)
{
var o = appDomainWrapper.CreateObject<Marshalled.Executor.SpecEnumerator>("NJasmine.dll");
var result = o.GetTestNames(AssemblyName.GetAssemblyName(dllPath).FullName);
return result;
}
public static void Cleanup()
{
var applicationDomain = new AppDomainWrapper(AppDomain.CurrentDomain);
var connectionSetting = ConnectionSettings["Delete-Database"];
var databaseNames = new List <string>();
var fileSystem = new FileSystem();
var providerFactories = new DbProviderFactoriesWrapper();
var connectionStringBuilderFactory = new ConnectionStringBuilderFactory(providerFactories);
var connectionStringBuilder = connectionStringBuilderFactory.Create(connectionSetting.ConnectionString, connectionSetting.ProviderName);
var databaseManagerFactory = new DatabaseManagerFactory(applicationDomain, connectionStringBuilderFactory, fileSystem, providerFactories);
var databaseManager = databaseManagerFactory.Create(connectionSetting.ProviderName);
var dbProviderFactory = providerFactories.Get(connectionSetting.ProviderName);
using (var connection = dbProviderFactory.CreateConnection())
{
// ReSharper disable PossibleNullReferenceException
connection.ConnectionString = connectionStringBuilder.ConnectionString;
// ReSharper restore PossibleNullReferenceException
connection.Open();
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT name FROM master.sys.databases;";
command.CommandType = CommandType.Text;
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
databaseNames.Add(reader.GetString(0));
}
}
}
}
foreach (var databaseName in databaseNames.Where(name => name.StartsWith(_testRootDirectoryPath, StringComparison.OrdinalIgnoreCase)))
{
connectionStringBuilder.DatabaseFilePath = databaseName;
// ReSharper disable EmptyGeneralCatchClause
try
{
databaseManager.DropDatabase(connectionStringBuilder.ConnectionString);
}
catch { }
// ReSharper restore EmptyGeneralCatchClause
}
Thread.Sleep(200);
if (Directory.Exists(_testRootDirectoryPath))
{
Directory.Delete(_testRootDirectoryPath, true);
}
}
static void Main()
{
var tools = new List <ITool>
{
new Hammer()
};
// Common objects
var appSettings = new AppSettings();
var logger = PluginLoaderLogger.Factory(appSettings);
var appDomain = new AppDomainWrapper(AppDomain.CurrentDomain, logger);
PluginLoaderSettings.Default = new MyPluginLoaderSettings(appSettings);
var settings = PluginLoaderSettings.Default;
var assemblyNameReader = new AssemblyNameReader();
var assemblyCache = new AssemblyCache(appDomain, assemblyNameReader, logger);
var assemblyLoader = new AssemblyLoader(appDomain, settings, assemblyCache, assemblyNameReader, logger);
var pluginPaths = new AppPluginPaths(settings.AppName, settings.PluginFolder, appDomain, logger);
var waiter = new Waiter(logger);
var assemblyResolveCache = new AssemblyResolveCache();
var pluginDependencyResolverObjectCreator = new PluginDependencyResolverObjectCreator(appDomain, settings, assemblyLoader, waiter, assemblyResolveCache, logger);
var pluginDependencyResolverFactory = new PluginDependencyResolverCacheFactory(pluginDependencyResolverObjectCreator, logger);
// ITool plugin loader objects
var typeLoader = new TypeLoader <ITool>(settings, logger);
var objectCreator = new ObjectCreator <ITool>();
var pluginCacheFactory = new PluginCacheFactory <ITool>(typeLoader, pluginDependencyResolverFactory, assemblyLoader, logger);
var pluginLoader = new PluginLoader <ITool>(pluginPaths, pluginCacheFactory);
var plugins = pluginLoader.LoadPlugins();
var toolPluginObjectCreator = new PluginObjectCreator <ITool>(settings, objectCreator, logger);
tools.AddRange(plugins.CreatePluginObjects(toolPluginObjectCreator));
// ICaveManTool<Hammer> plugin loader objects - using RuntimePluginLoader
var caveManHammerRuntimePluginLoader = RuntimePluginLoaderFactory.Instance.Create <CavemanHammerRuntimePluginLoader, ICaveManTool <Hammer> >();
var caveManObjectCreator = new ObjectCreator <ICaveManTool <Hammer> >();
var caveManToolPluginObjectCreator = new PluginObjectCreator <ICaveManTool <Hammer> >(settings, caveManObjectCreator, logger);
tools.AddRange(caveManHammerRuntimePluginLoader.PluginCollection.CreatePluginObjects(caveManToolPluginObjectCreator));
ShowPrompt(tools);
// Only 4 plugins will show as this doesn't support plugins with Constructor parameters
int input = ReadLine(tools);
while (input != 0)
{
if (input <= tools.Count)
{
Console.WriteLine(tools[input - 1].DoWork());
}
ShowPrompt(tools);
input = ReadLine(tools);
}
}
public static void VisitTests(IEnumerable <string> sources, Action <TestCase> visitor)
{
foreach (var source in sources.Where(s => IsAlongsideNJasmineDll(s)))
{
using (var appDomain = new AppDomainWrapper(source))
{
foreach (var result in UsingAppDomain.LoadTestNames(appDomain, source))
{
visitor(new TestCase(result, new Uri(VSExecutorUri), source));
}
}
}
}
public static void VisitTests(IEnumerable<string> sources, Action<TestCase> visitor)
{
foreach (var source in sources.Where(s => IsAlongsideNJasmineDll(s)))
{
using (var appDomain = new AppDomainWrapper(source))
{
foreach (var result in UsingAppDomain.LoadTestNames(appDomain, source))
{
visitor(new TestCase(result, new Uri(VSExecutorUri), source));
}
}
}
}
public void AppDomainWrapper_AppDomainWrapper_AssemblyResolve_Registration_NullLogger_Test()
{
// Arrange
var appDomainWrapper = new AppDomainWrapper(AppDomain.CurrentDomain, null)
{
Directory = _MockDirectory.Object
};
// Act
appDomainWrapper.AssemblyResolve += AppDomainWrapper_AssemblyResolve;
// Assert
_MockRepository.VerifyAll();
}
public SingletonObjects()
{
Settings = PluginLoaderSettings.Default;
AppSettings = new AppSettings();
Logger = PluginLoaderLogger.Factory(AppSettings);
AppDomain = new AppDomainWrapper(System.AppDomain.CurrentDomain, Logger);
AssemblyNameReader = new AssemblyNameReader();
AssemblyCache = new AssemblyCache(AppDomain, AssemblyNameReader, Logger);
AssemblyLoader = new AssemblyLoader(AppDomain, Settings, AssemblyCache, AssemblyNameReader, Logger);
PluginPaths = new AppPluginPaths(Settings.AppName, Settings.PluginFolder, AppDomain, Logger);
Waiter = new Waiter(Logger);
AssemblyResolveCache = new AssemblyResolveCache();
PluginDependencyResolverObjectCreator = new PluginDependencyResolverObjectCreator(AppDomain, Settings, AssemblyLoader, Waiter, AssemblyResolveCache, Logger);
PluginDependencyResolverFactory = new PluginDependencyResolverCacheFactory(PluginDependencyResolverObjectCreator, Logger);
}
private static void InternalRunTests(
IEnumerable<TestCase> tests,
IRunContext runContext,
IFrameworkHandle frameworkHandle,
string explicitlyIncluding)
{
var sink = new TestExecutorSinkAdapter(frameworkHandle, tests);
foreach (var group in tests.GroupBy(t => t.Source))
{
using (var appDomain = new AppDomainWrapper(@group.Key))
{
UsingAppDomain.RunTests(@group.Key, appDomain, tests.Select(t => t.FullyQualifiedName).ToArray(), explicitlyIncluding, sink);
}
}
}
private static void InternalRunTests(
IEnumerable <TestCase> tests,
IRunContext runContext,
IFrameworkHandle frameworkHandle,
string explicitlyIncluding)
{
var sink = new TestExecutorSinkAdapter(frameworkHandle, tests);
foreach (var group in tests.GroupBy(t => t.Source))
{
using (var appDomain = new AppDomainWrapper(@group.Key))
{
UsingAppDomain.RunTests(@group.Key, appDomain, tests.Select(t => t.FullyQualifiedName).ToArray(), explicitlyIncluding, sink);
}
}
}
public void AppDomainWrapper_TryLoad_RawAssembly_EmptyByteArray_NullLogger()
{
// Arrange
var appDomainWrapper = new AppDomainWrapper(AppDomain.CurrentDomain, null)
{
Directory = _MockDirectory.Object
};
byte[] rawAssembly = new byte[0];
// Act
var result = appDomainWrapper.TryLoad(rawAssembly);
// Assert
Assert.IsNull(result);
_MockRepository.VerifyAll();
}
public static Type FindType <TLoadType>(AssemblyInfo assemblyInfo, string debugDefault = "")
{
Type protocol = null;
var assemblyFile = FileSystem.Current.GetFileFromPathAsync(assemblyInfo.FilePath).Result;
if (assemblyFile != null)
{
using (var stream = assemblyFile.OpenAsync(FileAccess.Read).Result)
{
var asm = AppDomainWrapper.LoadAssembly(stream.ReadFully());
if (asm != null)
{
protocol = asm.DefinedTypes.Single(typeInfo => typeInfo.IsSubclassOf(typeof(TLoadType))).AsType();
}
}
}
/*
* var assemblyFolder = FileSystemWrapper.AssemblyFolder;
* if (assemblyFolder != null && assemblyFolder.CheckExistsAsync(assemblyInfo.FileName).Result == ExistenceCheckResult.FileExists)
* {
* using (var stream = assemblyFolder.GetFileAsync(assemblyInfo.FileName).Result.OpenAsync(FileAccess.Read).Result)
* {
* var asm = AppDomainWrapper.LoadAssembly(stream.ReadFully());
* if (asm != null)
* protocol = asm.DefinedTypes.Single(typeInfo => typeInfo.IsSubclassOf(typeof (TLoadType))).AsType();
* }
* }
*/
#region Debug
if (protocol == null)
{
var asm = Assembly.Load(new AssemblyName(debugDefault));
if (asm != null)
{
protocol = asm.DefinedTypes.Single(typeInfo => typeInfo.IsSubclassOf(typeof(TLoadType))).AsType();
}
}
#endregion Debug
return(protocol);
}
public static TestInfo GetConventionInfo(string testAssemblyPath)
{
var executingAssembly = Assembly.GetExecutingAssembly();
var executingAssemblyDirectory = Path.GetDirectoryName(executingAssembly.Location);
var previousDirectory = Directory.GetCurrentDirectory();
Directory.SetCurrentDirectory(executingAssemblyDirectory);
TestInfo info;
using (var appDomain = new AppDomainWrapper(executingAssemblyDirectory, "FixieTestFinder"))
{
var assemblyName = Assembly.GetExecutingAssembly().FullName;
var className = typeof(RemoteTestFinder).FullName;
var remoteFinder = appDomain.CreateObject<RemoteTestFinder>(
assemblyName,
className);
info = remoteFinder.FindTests(testAssemblyPath);
}
Directory.SetCurrentDirectory(previousDirectory);
return info;
}
static PlayPacketResponses()
{
new ServerPlayPacketTypes().CreatePacketInstancesOut(out Packets, AppDomainWrapper.GetAssembly(typeof(PlayPacketResponses)));
}
static StatusPacketResponses()
{
new ClientStatusPacketTypes().CreatePacketInstancesOut(out Packets, AppDomainWrapper.GetAssembly(typeof(StatusPacketResponses)));
}
static Messages()
{
new ForgeMessageTypes().CreatePacketInstancesOut(out Packets, AppDomainWrapper.GetAssembly(typeof(ForgeMessages)));
}
static StatusPacketResponses()
{
new ServerStatusPacketTypes().CreateHandlerInstancesOut(out Handlers, AppDomainWrapper.GetAssembly(typeof(StatusPacketResponses)));
}
public static void RunTests(string dllPath, AppDomainWrapper appDomainWrapper, string[] testNames, string explictlyIncluding, ITestResultListener sink)
{
var o = appDomainWrapper.CreateObject<Marshalled.Executor.SpecRunner>("NJasmine.dll");
o.RunTests(AssemblyName.GetAssemblyName(dllPath).FullName, testNames, explictlyIncluding, sink);
}
static PlayPacketResponses()
{
new ClientPlayPacketTypes().CreateHandlerInstancesOut(out Handlers, AppDomainWrapper.GetAssembly(typeof(PlayPacketResponses)));
}
static MessageHandlers()
{
new ForgeMessageTypes().CreateHandlerInstancesOut(out Handlers, AppDomainWrapper.GetAssembly(typeof(ForgeMessageHandlers)));
}
private void ShowThreads()
{
threadsGrid.BeginGridUpdate();
threadsGrid.ClearItems();
List <ThreadWrapper> threads = NuGenDebugEventHandler.Instance.EventObjects.Controller.EnumerateThreads();
foreach (ThreadWrapper thread in threads)
{
EvaluatedThreadName = "<no name>";
ValueWrapper threadObject = null;
ValueWrapper dereferencedObject = null;
if (!HasSearchedForNameMethod)
{
threadObject = thread.GetObject();
if (threadObject != null && !threadObject.IsNull())
{
dereferencedObject = threadObject.DereferenceValue();
if (dereferencedObject != null)
{
ClassWrapper threadClass = dereferencedObject.GetClassInformation();
uint threadTypeToken = threadClass.GetToken();
ModuleWrapper module = threadClass.GetModule();
FindGetThreadNameMethod(threadTypeToken, module);
}
}
}
if (HasSearchedForNameMethod)
{
if (GetThreadNameMethod == null)
{
EvaluatedThreadName = "<definition of the Thread class is not loaded>";
}
else
{
if (threadObject == null)
{
threadObject = thread.GetObject();
if (threadObject != null && !threadObject.IsNull())
{
dereferencedObject = threadObject.DereferenceValue();
}
}
if (dereferencedObject != null)
{
FrameWrapper threadActiveFrame = thread.GetActiveFrame();
if (threadActiveFrame != null)
{
NuGenFrameRefresher threadActiveFrameRefresher = new NuGenFrameRefresher(thread, threadActiveFrame.ChainIndex, threadActiveFrame.FrameIndex, threadActiveFrame.IsActiveFrame);
GetThreadName(thread, threadObject, threadActiveFrameRefresher);
}
}
}
}
GridEXRow row = threadsGrid.AddItem();
uint threadID = thread.GetID();
GridEXCell idCell = row.Cells[0];
NuGenHelperFunctions.TaggedObjects.Add((int)idCell.Value, threadID);
idCell.Value = NuGenHelperFunctions.FormatNumber(threadID);
row.Cells[1].Value = EvaluatedThreadName;
AppDomainWrapper appDomain = thread.GetAppDomain();
if (appDomain != null)
{
row.Cells[2].Value = appDomain.GetName();
}
NuGenHelperFunctions.TaggedObjects.Add((String)row.Cells[1].Value + (String)row.Cells[2].Value, thread);
}
threadsGrid.EndGridUpdate();
}
/// <summary>
/// Starts a runner instance
/// </summary>
/// <returns>The awaitable task.</returns>
/// <param name="domain">The AppDomain to use.</param>
/// <param name="config">The server configuration.</param>
/// <param name="usessl">If set to <c>true</c> use ssl.</param>
/// <param name="port">The port to listen on.</param>
private async Task StartRunnerAsync(System.AppDomain domain, ServerConfig config, bool usessl, string address, int port)
{
var enabled = !string.IsNullOrWhiteSpace(address);
// Ensure it parses
ParseUtil.ParseEndPoint(address, port);
var prev = m_handlers.Where(x => x.UseSSL == usessl).FirstOrDefault();
if (enabled)
{
var addcrashhandler = true;
var wrapper = new AppDomainWrapper(domain);
wrapper.SetupFromFile(usessl, m_path, config.Storage);
if (prev == null)
{
prev = new RunnerInstance(wrapper, address, port, usessl, config);
m_handlers.Add(prev);
}
else
{
if (prev.RunnerTask.IsFaulted || prev.RunnerTask.IsCanceled || prev.RunnerTask.IsCompleted)
{
var cur = new RunnerInstance(wrapper, address, port, usessl, config);
m_handlers.Remove(prev);
m_handlers.Add(cur);
prev = cur;
}
else if (prev.Port != port || !string.Equals(prev.Address, address, StringComparison.Ordinal))
{
// Address or port change, start new listener first
var cur = new RunnerInstance(wrapper, address, port, usessl, config);
if (!prev.RunnerTask.IsFaulted)
{
await prev.StopAsync();
}
m_handlers.Remove(prev);
m_handlers.Add(cur);
prev = cur;
}
else if (prev.Config.SocketBacklog != config.SocketBacklog)
{
await prev.RestartAsync(wrapper, address, port, usessl, config);
}
else
{
addcrashhandler = false; // We already have it
prev.Wrapper = wrapper; // Assign the new wrapper
}
}
if (addcrashhandler)
{
var dummy = prev.RunnerTask.ContinueWith(x =>
{
if (!prev.ShouldStop && InstanceCrashed != null)
{
InstanceCrashed(address, usessl, x.IsFaulted ? x.Exception : new Exception("Unexpected stop"));
}
});
}
}
else if (prev != null)
{
await prev.StopAsync();
m_handlers.Remove(prev);
}
}
/// <summary>Initializes a new instance of the <see cref="T:System.Object" /> class.</summary>
public MyAppDomain()
{
_appDomain = AppDomainWrapper.CurrentDomain;
}
public static void RunTests(string dllPath, AppDomainWrapper appDomainWrapper, string[] testNames, string explictlyIncluding, ITestResultListener sink)
{
var o = appDomainWrapper.CreateObject <Marshalled.Executor.SpecRunner>("NJasmine.dll");
o.RunTests(AssemblyName.GetAssemblyName(dllPath).FullName, testNames, explictlyIncluding, sink);
}
