| public Load ( AssemblyName assemblyRef ) : Assembly | ||
| assemblyRef | AssemblyName | |
| return | Assembly | |
static void Main()
{
//включаем визуальные стили для прилжения, поскольку оно является оконным
Application.EnableVisualStyles();
/*создаём необходимые домены приложений с дружественными именами и
* сохраняем ссылки на них в соответствующие переменные*/
Drawer = AppDomain.CreateDomain("Drawer");
TextWindow = AppDomain.CreateDomain("TextWindow");
/*загружаем сборки с оконными приложениями в соответствующие домены приложений*/
DrawerAsm = Drawer.Load(AssemblyName.GetAssemblyName("TextDrawer.exe"));
TextWindowAsm = Drawer.Load(AssemblyName.GetAssemblyName("TextWindow.exe"));
/*создаём объекты окон на сонове оконных типов данных из загруженных сборок*/
DrawerWindow = Activator.CreateInstance(DrawerAsm.GetType("TextDrawer.Form1")) as Form;
TextWindowWnd = Activator.CreateInstance(
TextWindowAsm.GetType("TextWindow.Form1"),
new object[]
{
DrawerAsm.GetModule("TextDrawer.exe"),
DrawerWindow
}) as Form;
/*запускаем потоки*/
(new Thread(new ThreadStart(RunVisualizer))).Start();
(new Thread(new ThreadStart(RunDrawer))).Start();
/*добавляем обработчик события DomainUnload*/
Drawer.DomainUnload += new EventHandler(Drawer_DomainUnload);
}
public DynamicAssemblyProxy(string luceneIndexFolder)
{
_currentDomain = AppDomain.CurrentDomain;
const string asemblyName = "dynamicProcessLib";
const string systemAsemblyName = "dynamicProcessLibSys";
//const string asemblyName = "dynamicProcessLib, Version=1.1.166.5, Culture=neutral, PublicKeyToken=null";
//const string systemAsemblyName = "dynamicProcessLibSys, Version=1.1.166.5, Culture=neutral, PublicKeyToken=null";
try
{
systemAssembly = _currentDomain.Load(systemAsemblyName);
userAssembly = _currentDomain.Load(asemblyName);
}
catch (Exception ex)
{
throw new ApplicationException(
string.Format(CultureInfo.InvariantCulture,
"Global Search Exception : AppDomain/ problem on loading (AssemblyName : {1}) /{0}/",
luceneIndexFolder,
asemblyName),
ex);
}
_luceneIndexFolder = luceneIndexFolder;
InitializeService();
}
/// <summary>
/// Initializes a new instance of the NamespaceDeclaration class.
/// </summary>
/// <param name="nsdecl">The namespace being compiled.</param>
public DomTester(NamespaceDeclaration nsdecl)
{
_nsdecl = nsdecl;
_appDomain = AppDomain.CreateDomain("testdomain");
this.Compile();
_appDomain.Load("System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
_appDomain.Load(_compiled.GetName());
}
/// <summary>
/// Starts this instance.
/// </summary>
/// <exception cref="System.InvalidOperationException">Job already started.</exception>
public static void Start()
{
if (_job != null)
throw new InvalidOperationException("Job already started.");
var evidence = new Evidence(AppDomain.CurrentDomain.Evidence);
var setup = new AppDomainSetup
{
ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase,
ShadowCopyFiles = "false"
};
_appDomain = AppDomain.CreateDomain("eSync-" + Guid.NewGuid(), evidence, setup);
try
{
var assembly = _appDomain.Load(typeof(SyncServiceJob).Assembly.GetName());
var jobTypeName = typeof(SyncServiceJob).FullName;
_job = (IJob)_appDomain.CreateInstanceAndUnwrap(assembly.FullName, jobTypeName);
_job.Start();
}
catch
{
_job = null;
AppDomain.Unload(_appDomain);
_appDomain = null;
throw;
}
}
public static void RegisterWithBuilderFromPath(ContainerBuilder builder, AppDomain currentDomain, EnumRegistrationType enumRegistrationType)
{
List<Assembly> vuelingAssembliesList = new List<Assembly>();
Assembly[] vuelingAssembliesArray;
customRegistration(builder);
List<Assembly> assemblies = currentDomain.GetAssemblies().ToList<Assembly>();
var loadedAssemblies = currentDomain.GetAssemblies().ToList();
var loadedPaths = loadedAssemblies.Select(a => a.Location).ToArray();
var referencedPaths = Directory.GetFiles(currentDomain.BaseDirectory, "*.dll");
var toLoad = referencedPaths.Where(r => !loadedPaths.Contains(r, StringComparer.InvariantCultureIgnoreCase)).ToList();
toLoad.ForEach(path => loadedAssemblies.Add(currentDomain.Load(AssemblyName.GetAssemblyName(path))));
foreach (var referencedAssembly in toLoad)
{
assemblies.Add(Assembly.LoadFrom(referencedAssembly));
}
foreach (var assembly in assemblies.Distinct())
{
if (assembly.GetName().Name.ToLower().Contains("vueling")) vuelingAssembliesList.Add(Assembly.Load(assembly.GetName().Name));
}
vuelingAssembliesArray = vuelingAssembliesList.ToArray<Assembly>();
if (enumRegistrationType == EnumRegistrationType.justWithDecoratedClasses) RegisterAssemblyTypesWithDecoratedClasses(builder, vuelingAssembliesArray);
else RegisterAssemblyTypes(builder, vuelingAssembliesArray);
}
public void SetUp()
{
string path = new Uri(Assembly.GetExecutingAssembly().EscapedCodeBase).LocalPath;
_localDomain = AppDomain.CreateDomain("NewDomain");
_localDomain.Load(typeof(DataAccessor).Assembly.GetName());
_localTest = (DataAccessorBuilderTest)_localDomain.CreateInstanceFromAndUnwrap(path, GetType().FullName);
}
private static void LoadAssembly(AppDomain newAppDomain, string assemblyName)
{
try
{
newAppDomain.Load(assemblyName);
}
catch (FileNotFoundException ex)
{
Console.WriteLine(ex.Message);
}
}
public void Init()
{
AppDomainSetup testDomainSetup = new AppDomainSetup()
{
ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase
};
_TestDomain = AppDomain.CreateDomain("SampleServiceDomain",
null,
testDomainSetup);
_TestDomain.Load("SampleService");
}
public void Init()
{
_EmptyDomain = AppDomain.CreateDomain("EmptyDomain");
//_EmptyDomain = AppDomain.CurrentDomain;
//this doesn't seem to work as expected - if this is run concurrently with the EmptyResourceList test using CurrentDomain, things break
AppDomainSetup testDomainSetup = new AppDomainSetup();
testDomainSetup.ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
_TestDomain = AppDomain.CreateDomain("SampleServiceDomain",
null,
testDomainSetup);
_TestDomain.Load("SampleService");
}
public void CreateAppdomain()
{
var appdomainSetup = new AppDomainSetup();
//string appBase = Environment.CurrentDirectory;
//string appBase = HttpContext.Current.Request.ApplicationPath;
appdomainSetup.ApplicationBase = CodeTemplateProjectInfo.BLASSEMBLYLOCATIONPATHONLY;
//System.Diagnostics.Debug.WriteLine(AppDomain.CurrentDomain.SetupInformation.ApplicationBase);
appdomainSetup.DisallowBindingRedirects = false;
appdomainSetup.DisallowCodeDownload = true;
appdomainSetup.ConfigurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
appDomain = AppDomain.CreateDomain("compilerAppdomain", null, appdomainSetup);
appDomain.Load(AssemblyName.GetAssemblyName(CodeTemplateProjectInfo.BLASSEMBLYLOCATION));
}
private void LoadAssembliesForVersion()
{
_appDomain = AppDomain.CreateDomain("NHibernateContext");
var nhibernatePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, string.Format(@"DataContext\{0}", _version));
var assembliesToLoad = Directory.GetFiles(nhibernatePath, "*.dll");
foreach (var assemblyFile in assembliesToLoad)
{
var assemblyFileName = new FileInfo(assemblyFile).Name;
var assemblyFileToCreate = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, assemblyFileName);
File.Copy(assemblyFile, assemblyFileToCreate, true);
_appDomain.Load(AssemblyName.GetAssemblyName(assemblyFileToCreate));
}
}
public void Launch(string pluginPath, AppDomain appDomain, Uri pluginApiUri, int clientPort, string tokenValue)
{
var token = Token.With(tokenValue);
var assembly = appDomain.Load(AssemblyName.GetAssemblyName(pluginPath));
var pluginDirectory = Path.GetDirectoryName(pluginPath);
appDomain.AssemblyResolve += (sender, args) =>
{
var ad = sender as AppDomain;
var path = Path.Combine(pluginDirectory, args.Name.Split(',')[0] + ".dll");
return ad.Load(path);
};
var pluginBootstrapperType = assembly.GetTypes().Single(t => typeof (IPluginBootstrapper).IsAssignableFrom(t));
var pluginBootstrapper = (IPluginBootstrapper) Activator.CreateInstance(pluginBootstrapperType);
var uri = new Uri($"http://127.0.0.1:{clientPort}");
var pluginRegistration = new PluginRegistration(
uri,
token,
new CommandApi(pluginApiUri, token),
new MessageApi(pluginApiUri, token),
new HttpApi(),
new Apis.PluginApi(pluginApiUri, token),
new ConfigApi(pluginApiUri, token),
new SettingApi(pluginApiUri, token));
pluginBootstrapper.Start(r =>
{
r(pluginRegistration);
if (pluginRegistration.PluginInformation == null)
{
throw new InvalidOperationException("You must call SetPluginInformation(...)");
}
using (var a = AsyncHelper.Wait)
{
a.Run(pluginRegistration.CommandApi.RegisterAsync(
pluginRegistration.CommandDescriptions,
CancellationToken.None));
}
});
_apiHost = new ApiHost();
_apiHost.Start(uri, pluginRegistration);
}
public static void StartServers(TestContext ctx)
{
#region TCP Duplex
// Setup TCP Duplex Server AppDomain
AppDomainSetup tcpDuplexAppDomainSetup = new AppDomainSetup() { ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) };
_tcpDuplexServerAppDomain = AppDomain.CreateDomain("RecreateClientConnectionTests_Server", null, tcpDuplexAppDomainSetup);
_tcpDuplexServerAppDomain.Load(typeof(ZyanConnection).Assembly.GetName());
// Start Zyan host inside the TCP Duplex Server AppDomain
var tcpDuplexServerWork = new CrossAppDomainDelegate(() =>
{
var server = TcpDuplexServerHostEnvironment.Instance;
if (server != null)
{
Console.WriteLine("TCP Duplex Server running.");
}
});
_tcpDuplexServerAppDomain.DoCallBack(tcpDuplexServerWork);
#endregion
#region TCP Simplex
// Setup TCP Simplex Server AppDomain
AppDomainSetup tcpSimplexAppDomainSetup = new AppDomainSetup() { ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) };
_tcpSimplexServerAppDomain = AppDomain.CreateDomain("RecreateClientConnectionTests_Server", null, tcpSimplexAppDomainSetup);
_tcpSimplexServerAppDomain.Load(typeof(ZyanConnection).Assembly.GetName());
// Start Zyan host inside the TCP Simplex Server AppDomain
var tcpSimplexServerWork = new CrossAppDomainDelegate(() =>
{
var server = TcpSimplexServerHostEnvironment.Instance;
if (server != null)
{
Console.WriteLine("TCP Simplex Server running.");
}
});
_tcpSimplexServerAppDomain.DoCallBack(tcpSimplexServerWork);
#endregion
}
public Assembly Inject(Guid checksum, object arg, Stream rawStream = null)
{
Contract.Requires(checksum != Guid.Empty);
if (rawStream != null)
{
var raw = new MemoryStream();
rawStream.FixedCopyTo(raw);
raw.Position = 0L;
Guid checksumNew = CryptoManaged.MD5Hash(raw);
if (checksum != checksumNew)
{
throw new InvalidOperationException("checksum");
}
return(this.Mapper.GetOrAdd(checksum, k => _Domain.Load(raw.ToArray())));
}
Assembly assembly;
if (!this.Mapper.TryGetValue(checksum, out assembly))
{
throw new InvalidOperationException("checksum");
}
var eType = typeof(IAppEntry);
var q = from t in assembly.GetTypes()
where t.IsSubclassOf(eType)
select t;
var entryType = q.FirstOrDefault();
if (entryType != null)
{
var creator = entryType.GetConstructor(Type.EmptyTypes);
if (creator != null)
{
var entry = (IAppEntry)creator.Invoke(null);
entry.DoEntry(arg);
}
}
return(assembly);
}
public static SR.Assembly CreateReflectionAssembly (AssemblyDefinition asm, AppDomain domain)
{
using (MemoryBinaryWriter writer = new MemoryBinaryWriter ()) {
WriteAssembly (asm, writer);
return domain.Load (writer.ToArray ());
}
}
private void Initialize()
{
string szAssm = typeof( AppDomainTest ).Assembly.FullName;
m_appDomain = AppDomain.CreateDomain( this.GetType().FullName );
m_appDomain.Load( szAssm );
m_mbroProxy = (MyMarshalByRefObject)m_appDomain.CreateInstanceAndUnwrap( szAssm, typeof( MyMarshalByRefObject ).FullName );
m_mbro = new MyMarshalByRefObject();
}
public static int Main(string[] args)
{
AppDomainSetup setup = new AppDomainSetup();
setup.ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
_serverAppDomain = AppDomain.CreateDomain("Server", null, setup);
_serverAppDomain.Load(typeof(ZyanConnection).Assembly.GetName());
CrossAppDomainDelegate serverWork = new CrossAppDomainDelegate(() =>
{
var server = EventServer.Instance;
if (server != null)
{
Console.WriteLine("Event server started.");
}
});
_serverAppDomain.DoCallBack(serverWork);
// Test IPC Binary
int ipcBinaryTestResult = IpcBinaryTest.RunTest();
Console.WriteLine("Passed: {0}", ipcBinaryTestResult == 0);
// Test TCP Binary
int tcpBinaryTestResult = TcpBinaryTest.RunTest();
Console.WriteLine("Passed: {0}", tcpBinaryTestResult == 0);
// Test TCP Custom
int tcpCustomTestResult = TcpCustomTest.RunTest();
Console.WriteLine("Passed: {0}", tcpCustomTestResult == 0);
// Test TCP Duplex
int tcpDuplexTestResult = TcpDuplexTest.RunTest();
Console.WriteLine("Passed: {0}", tcpDuplexTestResult == 0);
// Test HTTP Custom
int httpCustomTestResult = HttpCustomTest.RunTest();
Console.WriteLine("Passed: {0}", httpCustomTestResult == 0);
// Test NULL Channel
const string nullChannelResultSlot = "NullChannelResult";
_serverAppDomain.DoCallBack(new CrossAppDomainDelegate(() =>
{
int result = NullChannelTest.RunTest();
AppDomain.CurrentDomain.SetData(nullChannelResultSlot, result);
}));
var nullChannelTestResult = Convert.ToInt32(_serverAppDomain.GetData(nullChannelResultSlot));
Console.WriteLine("Passed: {0}", nullChannelTestResult == 0);
// Stop the event server
EventServerLocator locator = _serverAppDomain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, "IntegrationTest_DistributedEvents.EventServerLocator") as EventServerLocator;
locator.GetEventServer().Dispose();
Console.WriteLine("Event server stopped.");
if (!MonoCheck.IsRunningOnMono || MonoCheck.IsUnixOS)
{
// Mono/Windows bug:
// AppDomain.Unload freezes in Mono under Windows if tests for
// System.Runtime.Remoting.Channels.Tcp.TcpChannel were executed.
AppDomain.Unload(_serverAppDomain);
Console.WriteLine("Server AppDomain unloaded.");
}
if (ipcBinaryTestResult + tcpBinaryTestResult + tcpCustomTestResult + tcpDuplexTestResult + httpCustomTestResult + nullChannelTestResult == 0)
{
Console.WriteLine("All tests passed.");
return 0;
}
return 1;
}
public void OnServiceStart(string[] args)
{
banManagers = new Dictionary<string, FWBanTimeManager>();
instances = new Dictionary<string, object[]>();
moduleDomain = AppDomain.CreateDomain("Modules");
// Read Modules
string ModulePath = System.IO.Path.Combine(DataPath, "modules.json");
if (System.IO.File.Exists(ModulePath))
{
Newtonsoft.Json.Linq.JArray modules = (Newtonsoft.Json.Linq.JArray)JsonConvert.DeserializeObject(System.IO.File.ReadAllText(ModulePath));
foreach (var item in modules)
{
string assemblyName = ((string)item).ToLower();
string assemblyPath = System.IO.Path.Combine(DataPath, assemblyName, assemblyName + ".dll");
if (System.IO.File.Exists(assemblyPath))
{
banManagers.Add(assemblyName, new FWBanTimeManager("WinBan." + assemblyName));
LoadBanList(assemblyName);
System.Reflection.AssemblyName assemblyName2 = new System.Reflection.AssemblyName();
assemblyName2.CodeBase = assemblyPath;
System.Reflection.Assembly assembly = moduleDomain.Load(assemblyName2);
Type t = assembly.GetType("WinBanModule." + assemblyName);
System.Reflection.MethodInfo mod_OnStart = t.GetMethod("OnStart");
System.Reflection.MethodInfo mod_OnStop = t.GetMethod("OnStop");
object instance = assembly.CreateInstance("WinBanModule." + assemblyName);
instances.Add(assemblyName, new object[] { instance, mod_OnStart, mod_OnStop });
mod_OnStart.Invoke(instance, new object[] { this, typeof(WinBanService) });
}
}
}
}
/// <summary>
/// Creates a test worker in another domain
/// </summary>
/// <param name="domain">
/// The domain.
/// </param>
/// <returns>
/// A StaticXamlTestWorker
/// </returns>
private static StaticXamlTestWorker CreateTestWorker(AppDomain domain)
{
domain.Load(Assembly.GetExecutingAssembly().GetName().FullName);
var worker =
(StaticXamlTestWorker)
domain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().GetName().FullName, "Microsoft.Activities.Extensions.Tests.StaticXamlTestWorker");
return worker;
}
public PluginResponse LoadAssembly(AppDomain domain, FileInfo resolvePlugin)
{
var asmBin = File.ReadAllBytes(resolvePlugin.FullName);
assembly = domain.Load(asmBin);
return LoadAssembly(domain, assembly);
}
private void CheckNamespace(AppDomain appDomain, string ns)
{
foreach (var assembly in assemblies)
foreach (var type in appDomain.Load(assembly).GetTypes())
if (type.Namespace == ns)
return;
// todo: error message
throw new EdgeAnalyzerException();
}
/// <summary>
/// Creates an ITask instance and returns it.
/// </summary>
internal static ITask CreateTask(LoadedType loadedType, string taskName, string taskLocation, int taskLine, int taskColumn, LogError logError, AppDomainSetup appDomainSetup, bool isOutOfProc, out AppDomain taskAppDomain)
{
bool separateAppDomain = loadedType.HasLoadInSeparateAppDomainAttribute();
s_resolverLoadedType = null;
taskAppDomain = null;
ITask taskInstanceInOtherAppDomain = null;
try
{
if (separateAppDomain)
{
if (!loadedType.Type.IsMarshalByRef)
{
logError
(
taskLocation,
taskLine,
taskColumn,
"TaskNotMarshalByRef",
taskName
);
return null;
}
else
{
// Our task depend on this name to be precisely that, so if you change it make sure
// you also change the checks in the tasks run in separate AppDomains. Better yet, just don't change it.
// Make sure we copy the appdomain configuration and send it to the appdomain we create so that if the creator of the current appdomain
// has done the binding redirection in code, that we will get those settings as well.
AppDomainSetup appDomainInfo = new AppDomainSetup();
// Get the current app domain setup settings
byte[] currentAppdomainBytes = appDomainSetup.GetConfigurationBytes();
// Apply the appdomain settings to the new appdomain before creating it
appDomainInfo.SetConfigurationBytes(currentAppdomainBytes);
AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolver;
s_resolverLoadedType = loadedType;
taskAppDomain = AppDomain.CreateDomain(isOutOfProc ? "taskAppDomain (out-of-proc)" : "taskAppDomain (in-proc)", null, appDomainInfo);
if (loadedType.LoadedAssembly != null)
{
taskAppDomain.Load(loadedType.LoadedAssembly.GetName());
}
// Hook up last minute dumping of any exceptions
taskAppDomain.UnhandledException += new UnhandledExceptionEventHandler(ExceptionHandling.UnhandledExceptionHandler);
}
}
else
{
// perf improvement for the same appdomain case - we already have the type object
// and don't want to go through reflection to recreate it from the name.
return (ITask)Activator.CreateInstance(loadedType.Type);
}
if (loadedType.Assembly.AssemblyFile != null)
{
taskInstanceInOtherAppDomain = (ITask)taskAppDomain.CreateInstanceFromAndUnwrap(loadedType.Assembly.AssemblyFile, loadedType.Type.FullName);
// this will force evaluation of the task class type and try to load the task assembly
Type taskType = taskInstanceInOtherAppDomain.GetType();
// If the types don't match, we have a problem. It means that our AppDomain was able to load
// a task assembly using Load, and loaded a different one. I don't see any other choice than
// to fail here.
if (taskType != loadedType.Type)
{
logError
(
taskLocation,
taskLine,
taskColumn,
"ConflictingTaskAssembly",
loadedType.Assembly.AssemblyFile,
loadedType.Type.Assembly.Location
);
taskInstanceInOtherAppDomain = null;
}
}
else
{
taskInstanceInOtherAppDomain = (ITask)taskAppDomain.CreateInstanceAndUnwrap(loadedType.Type.Assembly.FullName, loadedType.Type.FullName);
}
return taskInstanceInOtherAppDomain;
}
finally
{
// Don't leave appdomains open
if (taskAppDomain != null && taskInstanceInOtherAppDomain == null)
{
AppDomain.Unload(taskAppDomain);
RemoveAssemblyResolver();
}
}
}
private static Assembly LoadAssambly(AppDomain domain, string assambly)
{
Assembly assemble;
try
{
if (Logger.IsTraceEnabled && Log.IsDebugEnabled)
{
Log.DebugFormat("loadAssambly('{0}') called...", assambly);
}
string assambly1 = assambly;
if(assambly1.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) ||
assambly1.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
{
assambly1 = assambly1.Substring(0, assambly1.Length - 4);
}
var assembles = domain.GetAssemblies();
foreach (var assembleLoaded in assembles)
{
var an = assembleLoaded.GetName();
if (String.Compare(an.Name, assambly1, StringComparison.OrdinalIgnoreCase) == 0)
{
return assembleLoaded;
}
}
// Load the requested assembly from file
if (string.IsNullOrEmpty(domain.SetupInformation.CachePath))
{
/*if (logger.IsDebugEnabled)
{
logger.DebugFormat(@"App ApplicationBase '{0}', CachePath is {1}, PrivateBinPath is {2} ShadowCopyDirectories: {3} ",
domain.SetupInformation.ApplicationBase,
domain.SetupInformation.CachePath,
domain.SetupInformation.PrivateBinPath,
domain.SetupInformation.ShadowCopyDirectories);
}*/
}
if(File.Exists(assambly))
{
//assambly = IOUtil.GetFullPath(assambly);
//assemble = Assembly.LoadFile(assambly);
assemble = Assembly.LoadFrom(assambly);
//byte[] buf = IOUtil.binReadFile(assambly);
//assemble = domain.Load(buf);
}
else
{
if (!Path.IsPathRooted(assambly))
{
if (AssemblyPathes.Select(t => t + Path.DirectorySeparatorChar + assambly).Any(File.Exists))
{
var buf = IOUtil.BinReadFile(assambly);
assemble = domain.Load(buf);
return assemble;
}
}
assemble = domain.Load(assambly);
}
}
catch (FileNotFoundException e)
{
if (Logger.IsTraceEnabled) Log.ErrorFormat("Could not load Assembly '{0}', error: {1}", assambly, e.Message);
throw;
}
return assemble;
}
public AppInvokeEntryPointResult FindForm(AppDomain ad, string assemblyFile, string configFile)
{
//IAppInvokeEntryPoint result = null;
AppInvokeEntryPointResult result = new AppInvokeEntryPointResult();
try
{
// Load the primary assembly here
Assembly asmEntryPoint = Assembly.LoadFrom(assemblyFile);
// other assemblies
Assembly[] asms = AppDomain.CurrentDomain.GetAssemblies();
// entry point
if (asmEntryPoint.EntryPoint == null)
{
// find the entry point assembly
foreach (Assembly asm in asms)
{
if (asm.EntryPoint != null)
{
asmEntryPoint = asm;
break;
}
}
}
// Load all the assemblies
IDictionary<string, string> loadedAssemblies = result.LoadedAssemblies;
foreach (Assembly asm in asms)
{
string fullName = asm.FullName;
if (!loadedAssemblies.ContainsKey(fullName))
{
loadedAssemblies.Add(fullName, asm.Location);
}
foreach (var asmRef in asm.GetReferencedAssemblies())
{
fullName = asmRef.FullName;
if (!loadedAssemblies.ContainsKey(fullName))
{
Assembly asm2 = ad.Load(asmRef);
loadedAssemblies.Add(fullName, asm2.Location);
}
}
}
// find the entry point class implements our interface
Type typeEntryPoint = asmEntryPoint.EntryPoint.DeclaringType;
if (typeof(IAppInvokeEntryPoint).IsAssignableFrom(typeEntryPoint))
{
AssemblyName asm = AssemblyName.GetAssemblyName(assemblyFile);
//result = ad.CreateInstanceAndUnwrap(asm.FullName, typeEntryPoint.FullName) as IAppInvokeEntryPoint;
result.AssemblyName = asm.FullName;
result.TypeName = typeEntryPoint.FullName;
result.Instance = ad.CreateInstance(asm.FullName, typeEntryPoint.FullName);
}
}
catch (Exception ex)
{
ExceptionManagement.ExceptionManager.Publish(ex);
}
return result;
}
public void LoadDllViaNewAppDomain()
{
AppDomainSetup domainInfo = new AppDomainSetup();
domainInfo.ApplicationBase = @"file:///c:/Projects/oa-public/src/OrbisAccess.PublicSite.Specs/bin";
domainInfo.PrivateBinPath = "c:/Projects/oa-public/src/OrbisAccess.PublicSite.Specs/bin";
domainInfo.ShadowCopyFiles = true.ToString();
domainInfo.ShadowCopyDirectories = "Debug";
domainInfo.PrivateBinPathProbe = "c:/Projects/oa-public/src/OrbisAccess.PublicSite.Specs/bin/Debug";
// domainInfo.ApplicationBase = @"file:///" + System.Environment.SystemDirectory;
Evidence evidence = AppDomain.CurrentDomain.Evidence;
domain = AppDomain.CreateDomain("GetRefs", evidence, domainInfo);
domain.AssemblyResolve +=new ResolveEventHandler(domain_AssemblyResolve);
Console.WriteLine(domainInfo.ApplicationBase);
var bytes = File.ReadAllBytes(@"C:\\Projects\\oa-public\src\\OrbisAccess.PublicSite.Specs\\bin\\debug\\OrbisAccess.PublicSite.Specs.dll");
var assembly = domain.Load("OrbisAccess.PublicSite.Specs");
Assert.IsNotNull(assembly);
}
public PluginResponse LoadAssembly(AppDomain domain, AssemblyName resolveName)
{
assembly = domain.Load(resolveName);
return LoadAssembly(domain, assembly);
}
/// <summary>
/// Load the script from an assembly into an AppDomain.
/// </summary>
/// <param name='dom'></param>
/// <param name='assembly'></param>
/// <param name='stateSource'></param>
/// <returns>false if load failed, true if suceeded</returns>
public bool Load(AppDomain dom, string assembly, StateSource stateSource)
{
m_Assembly = assembly;
m_stateSource = stateSource;
ApiManager am = new ApiManager();
foreach (string api in am.GetApis())
{
m_Apis[api] = am.CreateApi(api);
m_Apis[api].Initialize(Engine, Part, ScriptTask, m_coopSleepHandle);
}
try
{
object[] constructorParams;
Assembly scriptAssembly = dom.Load(Path.GetFileNameWithoutExtension(assembly));
Type scriptType = scriptAssembly.GetType("SecondLife.XEngineScript");
if (scriptType != null)
{
constructorParams = new object[] { m_coopSleepHandle };
}
else if (!m_coopTermination)
{
scriptType = scriptAssembly.GetType("SecondLife.Script");
constructorParams = null;
}
else
{
m_log.ErrorFormat(
"[SCRIPT INSTANCE]: Not starting script {0} (id {1}) in part {2} (id {3}) in object {4} in {5}. You must remove all existing {6}* script DLL files before using enabling co-op termination"
+ ", either by setting DeleteScriptsOnStartup = true in [XEngine] for one run"
+ " or by deleting these files manually.",
ScriptTask.Name, ScriptTask.ItemID, Part.Name, Part.UUID, Part.ParentGroup.Name, Engine.World.Name, assembly);
return false;
}
// m_log.DebugFormat(
// "[SCRIPT INSTANCE]: Looking to load {0} from assembly {1} in {2}",
// scriptType.FullName, Path.GetFileNameWithoutExtension(assembly), Engine.World.Name);
if (dom != System.AppDomain.CurrentDomain)
m_Script
= (IScript)dom.CreateInstanceAndUnwrap(
Path.GetFileNameWithoutExtension(assembly),
scriptType.FullName,
false,
BindingFlags.Default,
null,
constructorParams,
null,
null,
null);
else
m_Script
= (IScript)scriptAssembly.CreateInstance(
scriptType.FullName,
false,
BindingFlags.Default,
null,
constructorParams,
null,
null);
//ILease lease = (ILease)RemotingServices.GetLifetimeService(m_Script as ScriptBaseClass);
//RemotingServices.GetLifetimeService(m_Script as ScriptBaseClass);
// lease.Register(this);
}
catch (Exception e)
{
m_log.ErrorFormat(
"[SCRIPT INSTANCE]: Not starting script {0} (id {1}) in part {2} (id {3}) in object {4} in {5}. Error loading assembly {6}. Exception {7}{8}",
ScriptTask.Name, ScriptTask.ItemID, Part.Name, Part.UUID, Part.ParentGroup.Name, Engine.World.Name, assembly, e.Message, e.StackTrace);
return false;
}
try
{
foreach (KeyValuePair<string,IScriptApi> kv in m_Apis)
{
m_Script.InitApi(kv.Key, kv.Value);
}
// // m_log.Debug("[Script] Script instance created");
Part.SetScriptEvents(ItemID,
(int)m_Script.GetStateEventFlags(State));
}
catch (Exception e)
{
m_log.ErrorFormat(
"[SCRIPT INSTANCE]: Not starting script {0} (id {1}) in part {2} (id {3}) in object {4} in {5}. Error initializing script instance. Exception {6}{7}",
ScriptTask.Name, ScriptTask.ItemID, Part.Name, Part.UUID, Part.ParentGroup.Name, Engine.World.Name, e.Message, e.StackTrace);
return false;
}
m_SaveState = true;
string savedState = Path.Combine(Path.GetDirectoryName(assembly),
ItemID.ToString() + ".state");
if (File.Exists(savedState))
{
string xml = String.Empty;
try
{
FileInfo fi = new FileInfo(savedState);
int size = (int)fi.Length;
if (size < 512000)
{
using (FileStream fs = File.Open(savedState,
FileMode.Open, FileAccess.Read, FileShare.None))
{
Byte[] data = new Byte[size];
fs.Read(data, 0, size);
xml = Encoding.UTF8.GetString(data);
ScriptSerializer.Deserialize(xml, this);
AsyncCommandManager.CreateFromData(Engine,
LocalID, ItemID, ObjectID,
PluginData);
// m_log.DebugFormat("[Script] Successfully retrieved state for script {0}.{1}", PrimName, m_ScriptName);
Part.SetScriptEvents(ItemID,
(int)m_Script.GetStateEventFlags(State));
if (!Running)
m_startOnInit = false;
Running = false;
// we get new rez events on sim restart, too
// but if there is state, then we fire the change
// event
// We loaded state, don't force a re-save
m_SaveState = false;
m_startedFromSavedState = true;
}
}
else
{
m_log.WarnFormat(
"[SCRIPT INSTANCE]: Not starting script {0} (id {1}) in part {2} (id {3}) in object {4} in {5}. Unable to load script state file {6}. Memory limit exceeded.",
ScriptTask.Name, ScriptTask.ItemID, Part.Name, Part.UUID, Part.ParentGroup.Name, Engine.World.Name, savedState);
}
}
catch (Exception e)
{
m_log.ErrorFormat(
"[SCRIPT INSTANCE]: Not starting script {0} (id {1}) in part {2} (id {3}) in object {4} in {5}. Unable to load script state file {6}. XML is {7}. Exception {8}{9}",
ScriptTask.Name, ScriptTask.ItemID, Part.Name, Part.UUID, Part.ParentGroup.Name, Engine.World.Name, savedState, xml, e.Message, e.StackTrace);
}
}
// else
// {
// ScenePresence presence = Engine.World.GetScenePresence(part.OwnerID);
// if (presence != null && (!postOnRez))
// presence.ControllingClient.SendAgentAlertMessage("Compile successful", false);
// }
return true;
}
private void CreateSandbox()
{
Contract.Requires(engineType != null);
using (Perfomance.Trace("SandboxEngine::CreateSandbox()").BindToConsole())
{
sandboxDomain = AppDomain.CreateDomain(SandboxDomainName);
//sandboxDomain.AssemblyLoad += (_, e) =>
//{
// Debug.Print("SANDBOX: Loaded rawAssembly {0}", e.LoadedAssembly.FullName);
//};
//sandboxDomain.AssemblyResolve += (_, e) =>
//{
// Debug.Print("SANDBOX: Resolving rawAssembly {0}", e.Name);
//};
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
sandboxDomain.Load(assembly.GetName());
}
var sandBoxAssembly = sandboxDomain.Load(engineType.Assembly.FullName);
sandbox = sandboxDomain.CreateInstanceAndUnwrap(sandBoxAssembly.FullName, engineType.FullName)
as IExecutionEngine;
sandbox.Repository = Repository;
sandbox.SystemResources = SystemResources;
}
}
private dynamic CreateAppDomainExecutor(AppDomain VSRunnerDomain)
{
// until the vsrunner is included with mspec we will need to ship it with the adapter and copy it into the target mspec directory
// get the location of the adpter so we know where to copy the vsrunner from
Assembly mspecVsTestAdapterAssembly = AppDomain.CurrentDomain.GetAssemblies().Where(x => x.FullName.StartsWith(adapterName)).SingleOrDefault();
if (mspecVsTestAdapterAssembly == null)
{
throw new Exception();
}
// we will copy it to the vsrunner app domains base directory
string vsRunnerDestinationFileName = Path.Combine(VSRunnerDomain.BaseDirectory, runnerDllName);
// from the current mstestadapter domain location
string vsRunnerSourceFileName = Path.Combine(Path.GetDirectoryName(mspecVsTestAdapterAssembly.Location), runnerDllName);
if (File.Exists(vsRunnerDestinationFileName))
{
File.Delete(vsRunnerDestinationFileName);
}
File.Copy(vsRunnerSourceFileName, vsRunnerDestinationFileName);
// load the vs runner assembly into the appdomain
VSRunnerDomain.Load(runnerName);
return VSRunnerDomain.CreateInstanceAndUnwrap(runnerName, runnerClassName, false, BindingFlags.Default, (Binder)null, new object[0], (CultureInfo)null, (object[])null);
}
void DetectResharperLoading(AppDomain vsAppDomain)
{
while (_retries <= MAX_RETRIES)
{
Assembly resharperAssembly;
try
{
resharperAssembly = vsAppDomain.Load("JetBrains.Platform.ReSharper.Shell");
}
catch
{
resharperAssembly = null;
}
if (resharperAssembly == null && _retries++ <= MAX_RETRIES)
{
_output.Write("ReSharper not found, try {0}/{1}, sleeping for 2 seconds.", _retries, MAX_RETRIES);
Thread.Sleep(TimeSpan.FromSeconds(2));
continue;
}
var resharperVersion = resharperAssembly.GetName().Version;
var pluginManagerType = LoadTypeFromVersion(resharperVersion);
if (pluginManagerType == null) return;
var assemblyLocation = pluginManagerType.Assembly.Location;
var destinationAssemblyFile = CopyAndSign(assemblyLocation);
_pluginManager = vsAppDomain.CreateInstanceFromAndUnwrap(destinationAssemblyFile.Path, pluginManagerType.FullName);
return;
}
}
/// <summary>
/// Gets the documentation domain.
/// </summary>
/// <returns></returns>
private AppDomain GetDocumentationDomain()
{
if(DocumentationDomain == null) {
// create a new app domain for processing.
DocumentationDomain = AppDomain.CreateDomain("Documentation");
var dir = new DirectoryInfo(HostingEnvironment.MapPath("~/app_data/"));
dir.GetFiles("*.dll").ForEach(a => {
DocumentationDomain.Load(AssemblyName.GetAssemblyName(a.FullName));
});
}
return DocumentationDomain;
}