internal StackFrame(Thread thread, ICorDebugILFrame corILFrame, uint chainIndex, uint frameIndex)
{
this.process = thread.Process;
this.thread = thread;
this.appDomain = process.AppDomains[corILFrame.GetFunction().GetClass().GetModule().GetAssembly().GetAppDomain()];
this.corILFrame = corILFrame;
this.corILFramePauseSession = process.PauseSession;
this.corFunction = corILFrame.GetFunction();
this.chainIndex = chainIndex;
this.frameIndex = frameIndex;
MetaDataImport metaData = thread.Process.Modules[corFunction.GetClass().GetModule()].MetaData;
int methodGenArgs = metaData.EnumGenericParams(corFunction.GetToken()).Length;
// Class parameters are first, then the method ones
List<ICorDebugType> corGenArgs = ((ICorDebugILFrame2)corILFrame).EnumerateTypeParameters().ToList();
// Remove method parametrs at the end
corGenArgs.RemoveRange(corGenArgs.Count - methodGenArgs, methodGenArgs);
List<DebugType> genArgs = new List<DebugType>(corGenArgs.Count);
foreach(ICorDebugType corGenArg in corGenArgs) {
genArgs.Add(DebugType.CreateFromCorType(this.AppDomain, corGenArg));
}
DebugType debugType = DebugType.CreateFromCorClass(
this.AppDomain,
null,
corFunction.GetClass(),
genArgs.ToArray()
);
this.methodInfo = (DebugMethodInfo)debugType.GetMember(corFunction.GetToken());
}
void ExecuteInOwnAppDomain()
{
if (WeaversHistory.HasChanged(Weavers.Select(x => x.AssemblyPath)) || appDomain == null)
{
if (appDomain != null)
{
AppDomain.Unload(appDomain);
}
var appDomainSetup = new AppDomainSetup
{
ApplicationBase = AssemblyLocation.CurrentDirectory(),
};
appDomain = AppDomain.CreateDomain("Fody", null, appDomainSetup);
}
var innerWeaver = (IInnerWeaver) appDomain.CreateInstanceAndUnwrap("FodyIsolated", "InnerWeaver");
innerWeaver.AssemblyPath = AssemblyPath;
innerWeaver.References = References;
innerWeaver.KeyFilePath = KeyFilePath;
innerWeaver.Logger = Logger;
innerWeaver.AssemblyPath = AssemblyPath;
innerWeaver.Weavers = Weavers;
innerWeaver.IntermediateDir = IntermediateDir;
innerWeaver.Execute();
}
private static AppDomain BuildChildDomain(AppDomain parentDomain)
{
var evidence = new Evidence(parentDomain.Evidence);
AppDomainSetup setup = parentDomain.SetupInformation;
return AppDomain.CreateDomain("DiscoveryRegion",
evidence, setup);
}
public static Foo GetRemote (AppDomain domain)
{
Foo test = (Foo) domain.CreateInstanceAndUnwrap (
typeof (Foo).Assembly.FullName,
typeof (Foo).FullName, new object [0]);
return test;
}
static void DisplayDADStats(AppDomain domain)
{
// Get access to the AppDomain for the current thread
Console.WriteLine("Name of this domain: {0}", domain.FriendlyName);
Console.WriteLine("ID of domain in this process: {0}", domain.Id);
Console.WriteLine("Is this the default domain?: {0}", domain.IsDefaultAppDomain());
Console.WriteLine("Base Directory of this domain: {0}", domain.BaseDirectory);
}
internal SecurityFrame (RuntimeSecurityFrame frame)
{
_domain = null;
_method = null;
_assert = null;
_deny = null;
_permitonly = null;
InitFromRuntimeFrame (frame);
}
static CrossDomainTester CreateCrossDomainTester (AppDomain domain)
{
Type testerType = typeof (CrossDomainTester);
return (CrossDomainTester) domain.CreateInstanceAndUnwrap (
testerType.Assembly.FullName, testerType.FullName, false,
BindingFlags.Public | BindingFlags.Instance, null, new object [0],
CultureInfo.InvariantCulture, new object [0], domain.Evidence);
}
private static void Main()
{
Class32.appDomain_0 = AppDomain.CreateDomain("NovoFatum R3", null);
Class1.smethod_0();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Class0.main_0 = new Main();
Application.Run(Class0.main_0);
}
static void ListAllAssembliesInAppDomain(AppDomain domain)
{
Assembly[] loadedAssemblies = domain.GetAssemblies();
Console.WriteLine("**** Here are the assemblies loaded in {0} ******\n",
domain.FriendlyName);
foreach (Assembly a in loadedAssemblies) {
Console.WriteLine("-> Name: {0}", a.GetName().Name);
Console.WriteLine("-> Version: {0}", a.GetName().Version);
}
}
internal SecurityFrame (int skip)
{
_domain = null;
_method = null;
_assert = null;
_deny = null;
_permitonly = null;
InitFromRuntimeFrame (_GetSecurityFrame (skip + 2));
// TODO - add the imperative informations into the frame
}
static int Main ()
{
AppDomain.Unload (AppDomain.CreateDomain ("Warmup unload code"));
Console.WriteLine (".");
ad = AppDomain.CreateDomain ("NewDomain");
ad.DoCallBack (Bla);
var t = new Thread (UnloadIt);
t.IsBackground = true;
t.Start ();
evt.WaitOne ();
return 0;
}
static void ListAllAssembliesInAppDomain2(AppDomain domain)
{
var loadedAssemblies = from a in domain.GetAssemblies()
orderby a.GetName().Name select a;
Console.WriteLine("**** Here are the assemblies loaded in {0} ******\n",
domain.FriendlyName);
foreach (var a in loadedAssemblies) {
Console.WriteLine("-> Name: {0}", a.GetName().Name);
Console.WriteLine("-> Version: {0}", a.GetName().Version);
}
}
static Assembly DefineDynamicAssembly (AppDomain domain)
{
AssemblyName assemblyName = new AssemblyName ();
assemblyName.Name = "MyDynamicAssembly";
AssemblyBuilder assemblyBuilder = domain.DefineDynamicAssembly (assemblyName, AssemblyBuilderAccess.Run);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule ("MyDynamicModule");
TypeBuilder typeBuilder = moduleBuilder.DefineType ("MyDynamicType", TypeAttributes.Public);
ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard, null);
ILGenerator ilGenerator = constructorBuilder.GetILGenerator ();
ilGenerator.EmitWriteLine ("MyDynamicType instantiated!");
ilGenerator.Emit (OpCodes.Ret);
typeBuilder.CreateType ();
return assemblyBuilder;
}
static void InitDAD(AppDomain domain)
{
// this prints out the name of any assembly
// loaded into the domain, after it has been
// created.
domain.AssemblyLoad += (o, s) =>
{
Console.WriteLine("\n{0} has just now been loaded!!\n", s.LoadedAssembly.GetName().Name);
};
domain.ProcessExit += (o, s) =>
{
Console.WriteLine("\nAD has just been unloaded!!\n");
};
}
internal ManifestRunner (AppDomain domain, ActivationContext activationContext) {
m_domain = domain;
string file, parameters;
CmsUtils.GetEntryPoint(activationContext, out file, out parameters);
if (parameters == null || parameters.Length == 0)
m_args = new string[0];
else
m_args = parameters.Split(' ');
m_apt = ApartmentState.Unknown;
// get the 'merged' application directory path.
string directoryName = activationContext.ApplicationDirectory;
m_path = Path.Combine(directoryName, file);
}
Eval(AppDomain appDomain, string description, EvalStarter evalStarter)
{
this.appDomain = appDomain;
this.process = appDomain.Process;
this.description = description;
this.state = EvalState.Evaluating;
this.thread = GetEvaluationThread(appDomain);
this.corEval = thread.CorThread.CreateEval();
try {
evalStarter(this);
} catch (COMException e) {
if ((uint)e.ErrorCode == 0x80131C26) {
throw new GetValueException("Can not evaluate in optimized code");
} else if ((uint)e.ErrorCode == 0x80131C28) {
throw new GetValueException("Object is in wrong AppDomain");
} else if ((uint)e.ErrorCode == 0x8013130A) {
// Happens on getting of Sytem.Threading.Thread.ManagedThreadId; See SD2-1116
throw new GetValueException("Function does not have IL code");
} else if ((uint)e.ErrorCode == 0x80131C23) {
// The operation failed because it is a GC unsafe point. (Exception from HRESULT: 0x80131C23)
// This can probably happen when we break and the thread is in native code
throw new GetValueException("Thread is in GC unsafe point");
} else if ((uint)e.ErrorCode == 0x80131C22) {
// The operation is illegal because of a stack overflow.
throw new GetValueException("Can not evaluate after stack overflow");
} else if ((uint)e.ErrorCode == 0x80131313) {
// Func eval cannot work. Bad starting point.
// Reproduction circumstancess are unknown
throw new GetValueException("Func eval cannot work. Bad starting point.");
} else {
#if DEBUG
throw; // Expose for more diagnostics
#else
throw new GetValueException(e.Message);
#endif
}
}
appDomain.Process.ActiveEvals.Add(this);
if (appDomain.Process.Options.SuspendOtherThreads) {
appDomain.Process.AsyncContinue(DebuggeeStateAction.Keep, new Thread[] { thread }, CorDebugThreadState.THREAD_SUSPEND);
} else {
appDomain.Process.AsyncContinue(DebuggeeStateAction.Keep, this.Process.UnsuspendedThreads, CorDebugThreadState.THREAD_RUN);
}
}
internal ManifestRunner (AppDomain domain, ActivationContext activationContext) {
m_domain = domain;
string file, parameters;
CmsUtils.GetEntryPoint(activationContext, out file, out parameters);
if (String.IsNullOrEmpty(file))
throw new ArgumentException(Environment.GetResourceString("Argument_NoMain"));
if (String.IsNullOrEmpty(parameters))
m_args = new string[0];
else
m_args = parameters.Split(' ');
m_apt = ApartmentState.Unknown;
// get the 'merged' application directory path.
string directoryName = activationContext.ApplicationDirectory;
m_path = Path.Combine(directoryName, file);
}
internal Module(AppDomain appDomain, ICorDebugModule corModule)
{
this.appDomain = appDomain;
this.process = appDomain.Process;
this.corModule = corModule;
metaData = new MetaDataImport(corModule);
if (IsDynamic || IsInMemory) {
name = corModule.GetName();
} else {
fullPath = corModule.GetName();
name = System.IO.Path.GetFileName(FullPath);
}
asmFilename = corModule.GetAssembly().GetName();
SetJITCompilerFlags();
LoadSymbolsFromDisk(process.Options.SymbolsSearchPaths);
ResetJustMyCodeStatus();
}
private static Type MyCreateCallee(AppDomain domain)
{
AssemblyName myAssemblyName = new AssemblyName();
myAssemblyName.Name = "EmittedAssembly";
// Define a dynamic assembly in the current application domain.
AssemblyBuilder myAssembly =
domain.DefineDynamicAssembly(myAssemblyName,AssemblyBuilderAccess.Run);
// Define a dynamic module in this assembly.
ModuleBuilder myModuleBuilder = myAssembly.DefineDynamicModule("EmittedModule");
// Construct a 'TypeBuilder' given the name and attributes.
TypeBuilder myTypeBuilder = myModuleBuilder.DefineType("HelloWorld",
TypeAttributes.Public);
// Define a constructor of the dynamic class.
ConstructorBuilder myConstructor = myTypeBuilder.DefineConstructor(
MethodAttributes.Public, CallingConventions.Standard, new Type[]{typeof(String)});
ILGenerator myILGenerator = myConstructor.GetILGenerator();
myILGenerator.Emit(OpCodes.Ldstr, "Constructor is invoked");
myILGenerator.Emit(OpCodes.Ldarg_1);
MethodInfo myMethodInfo =
typeof(Console).GetMethod("WriteLine",new Type[]{typeof(string)});
myILGenerator.Emit(OpCodes.Call, myMethodInfo);
myILGenerator.Emit(OpCodes.Ret);
Type myType = typeof(MyAttribute);
ConstructorInfo myConstructorInfo = myType.GetConstructor(new Type[]{typeof(object)});
try
{
CustomAttributeBuilder methodCABuilder = new CustomAttributeBuilder (myConstructorInfo, new object [] { TypeCode.Double } );
myConstructor.SetCustomAttribute(methodCABuilder);
}
catch(ArgumentNullException ex)
{
Console.WriteLine("The following exception has occured : "+ex.Message);
}
catch(Exception ex)
{
Console.WriteLine("The following exception has occured : "+ex.Message);
}
return myTypeBuilder.CreateType();
}
internal Value(AppDomain appDomain, ICorDebugValue corValue)
{
if (corValue == null)
throw new ArgumentNullException("corValue");
this.appDomain = appDomain;
this.corValue = corValue;
this.corValue_pauseSession = this.Process.PauseSession;
this.isNull = corValue is ICorDebugReferenceValue && ((ICorDebugReferenceValue)corValue).IsNull() != 0;
if (corValue is ICorDebugReferenceValue &&
((ICorDebugReferenceValue)corValue).GetValue() == 0 &&
((ICorDebugValue2)corValue).GetExactType() == null)
{
// We were passed null reference and no metadata description
// (happens during CreateThread callback for the thread object)
this.type = appDomain.ObjectType;
} else {
ICorDebugType exactType = ((ICorDebugValue2)this.CorValue).GetExactType();
this.type = DebugType.CreateFromCorType(appDomain, exactType);
}
}
private static void InstallAssemblyLoader(AppDomain domain)
{
domain.ReflectionOnlyAssemblyResolve += (sender, args) => Assembly.ReflectionOnlyLoadFrom(
Path.Combine(ProgramDirectory, args.Name.Substring(0, args.Name.IndexOf(',')) + ".dll"));
}
//multiple app domains
private static void Example2()
{
//create instance for running threads in the current AppDomain
AppDomain domain1 = AppDomain.CreateDomain("Domain-1");
AppDomain domain2 = AppDomain.CreateDomain("Domain-2");
Program p1 = (Program)domain1.CreateInstanceFromAndUnwrap("2_TLSContext.exe", "_2_TLSContext.Program");
Program p2 = (Program)domain2.CreateInstanceFromAndUnwrap("2_TLSContext.exe", "_2_TLSContext.Program");
//start on same domain...
ThreadPool.QueueUserWorkItem((x) => p1.SomeMethod(1));
ThreadPool.QueueUserWorkItem((x) => p1.SomeMethod(2));
ThreadPool.QueueUserWorkItem((x) => p1.SomeMethod(3));
ThreadPool.QueueUserWorkItem((x) => p1.SomeMethod(4));
ThreadPool.QueueUserWorkItem((x) => p1.SomeMethod(5));
ThreadPool.QueueUserWorkItem((x) => p1.SomeMethod(6));
ThreadPool.QueueUserWorkItem((x) => p1.SomeMethod(7));
ThreadPool.QueueUserWorkItem((x) => p1.SomeMethod(8));
ThreadPool.QueueUserWorkItem((x) => p1.SomeMethod(9));
ThreadPool.QueueUserWorkItem((x) => p1.SomeMethod(10));
//now demonstrate 2nd AppDomain uniqueness
ThreadPool.QueueUserWorkItem((x) => p2.SomeMethod(10));
ThreadPool.QueueUserWorkItem((x) => p2.SomeMethod(11));
ThreadPool.QueueUserWorkItem((x) => p2.SomeMethod(12));
ThreadPool.QueueUserWorkItem((x) => p2.SomeMethod(13));
ThreadPool.QueueUserWorkItem((x) => p2.SomeMethod(14));
ThreadPool.QueueUserWorkItem((x) => p2.SomeMethod(15));
ThreadPool.QueueUserWorkItem((x) => p2.SomeMethod(16));
ThreadPool.QueueUserWorkItem((x) => p2.SomeMethod(17));
ThreadPool.QueueUserWorkItem((x) => p2.SomeMethod(18));
ThreadPool.QueueUserWorkItem((x) => p1.SomeMethod(19));
ThreadPool.QueueUserWorkItem((x) => p1.SomeMethod(20));
/* Output
* Creating new context. Thread: 12 AppDomain: Domain-1
* Creating new context. Thread: 14 AppDomain: Domain-1
* Creating new context. Thread: 13 AppDomain: Domain-1
* Thread 14 AppDomain: Domain-1 Prev Value: 0 New Value: 4
* Thread 12 AppDomain: Domain-1 Prev Value: 0 New Value: 3
* Thread 14 AppDomain: Domain-1 Prev Value: 4 New Value: 5
* Thread 13 AppDomain: Domain-1 Prev Value: 0 New Value: 1
* Creating new context. Thread: 11 AppDomain: Domain-1
* Thread 11 AppDomain: Domain-1 Prev Value: 0 New Value: 2
* Thread 12 AppDomain: Domain-1 Prev Value: 3 New Value: 6
* Thread 14 AppDomain: Domain-1 Prev Value: 5 New Value: 7
* Thread 13 AppDomain: Domain-1 Prev Value: 1 New Value: 8
* Thread 11 AppDomain: Domain-1 Prev Value: 2 New Value: 9
* Thread 12 AppDomain: Domain-1 Prev Value: 6 New Value: 10
* Creating new context. Thread: 12 AppDomain: Domain-2
* Creating new context. Thread: 14 AppDomain: Domain-2
* Creating new context. Thread: 11 AppDomain: Domain-2
* Thread 14 AppDomain: Domain-2 Prev Value: 0 New Value: 10
* Creating new context. Thread: 13 AppDomain: Domain-2
* Thread 11 AppDomain: Domain-2 Prev Value: 0 New Value: 12
* Thread 14 AppDomain: Domain-2 Prev Value: 10 New Value: 14
* Thread 11 AppDomain: Domain-2 Prev Value: 12 New Value: 15
* Thread 13 AppDomain: Domain-2 Prev Value: 0 New Value: 11
* Thread 12 AppDomain: Domain-2 Prev Value: 0 New Value: 13
* Thread 14 AppDomain: Domain-2 Prev Value: 14 New Value: 16
* Thread 13 AppDomain: Domain-2 Prev Value: 11 New Value: 18
* Thread 11 AppDomain: Domain-2 Prev Value: 15 New Value: 17
* Thread 12 AppDomain: Domain-1 Prev Value: 10 New Value: 19
* Thread 14 AppDomain: Domain-1 Prev Value: 7 New Value: 20 */
}
static AppDomain()
{
CurrentDomain = new AppDomain();
}
public static EmbeddedAssemblyLoader Register(string resourceNamespace, Assembly assembly = null, AppDomain domain = null)
{
assembly = assembly ?? Assembly.GetCallingAssembly();
var loader = new EmbeddedAssemblyLoader(resourceNamespace, assembly);
loader.Register(domain);
return(loader);
}
private void LoadPlugin(PluginInfo info, string[] excludedPlugins)
{
lock (SyncObject)
{
var domainSetup = new AppDomainSetup();
domainSetup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
domainSetup.PrivateBinPath = "plugins;bin";
var permissions = new PermissionSet(PermissionState.None);
permissions.AddPermission(new UIPermission(PermissionState.Unrestricted));
permissions.AddPermission(new SecurityPermission(
SecurityPermissionFlag.Execution |
SecurityPermissionFlag.SerializationFormatter |
SecurityPermissionFlag.UnmanagedCode)); // TODO: wpf need it :(
permissions.AddPermission(new FileIOPermission(
FileIOPermissionAccess.PathDiscovery |
FileIOPermissionAccess.Write |
FileIOPermissionAccess.Read,
AppDomain.CurrentDomain.BaseDirectory));
var engineStrongName = typeof(TPlugin).Assembly.Evidence.GetHostEvidence <StrongName>();
if (engineStrongName == null)
{
OnError("Can't load plugins. Engine library without strong name.", null);
return;
}
var pluginName = string.Empty;
var domainName = string.Format("Plugin Domain [{0}]", Path.GetFileNameWithoutExtension(info.AssemblyPath));
var domain = AppDomain.CreateDomain(domainName, null, domainSetup, permissions, engineStrongName);
try
{
var plugin = (TPlugin)domain.CreateInstanceFromAndUnwrap(info.AssemblyPath, info.TypeName);
info.Name = plugin.Name;
pluginName = plugin.Name;
if (Plugins.ContainsKey(pluginName) || (excludedPlugins != null && excludedPlugins.Contains(pluginName)))
{
AppDomain.Unload(domain);
return;
}
var model = new TModel();
plugin.Initialize(model);
var container = new PluginContainer(domain, plugin, model);
Plugins.Add(pluginName, container);
OnPluginLoaded(container);
}
catch (Exception e)
{
OnError(string.Format("Plugin failed: {0}", pluginName), e);
if (UnloadPlugin(pluginName))
{
return;
}
AppDomain.Unload(domain);
}
}
}
public ToolingFacade(
string migrationsAssemblyName,
string contextAssemblyName,
string configurationTypeName,
string workingDirectory,
string configurationFilePath,
string dataDirectory,
DbConnectionInfo connectionStringInfo)
{
Check.NotEmpty(migrationsAssemblyName, "migrationsAssemblyName");
_migrationsAssemblyName = migrationsAssemblyName;
_contextAssemblyName = contextAssemblyName;
_configurationTypeName = configurationTypeName;
_connectionStringInfo = connectionStringInfo;
var info = new AppDomainSetup
{
ShadowCopyFiles = "true"
};
if (!string.IsNullOrWhiteSpace(workingDirectory))
{
info.ApplicationBase = workingDirectory;
}
_configurationFile = new ConfigurationFileUpdater().Update(configurationFilePath);
info.ConfigurationFile = _configurationFile;
var friendlyName = "MigrationsToolingFacade" + Convert.ToBase64String(Guid.NewGuid().ToByteArray());
_appDomain = AppDomain.CreateDomain(friendlyName, null, info);
if (!string.IsNullOrWhiteSpace(dataDirectory))
{
_appDomain.SetData("DataDirectory", dataDirectory);
}
}
public void GetCurrentThreadId()
{
Assert.Equal(AppDomain.GetCurrentThreadId(), Environment.CurrentManagedThreadId);
}
public static Type BuildMyType()
{
AppDomain myDomain = Thread.GetDomain();
AssemblyName myAsmName = new AssemblyName();
myAsmName.Name = "MyDynamicAssembly";
AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(
myAsmName,
AssemblyBuilderAccess.Run);
ModuleBuilder myModBuilder = myAsmBuilder.DefineDynamicModule(
"MyJumpTableDemo");
TypeBuilder myTypeBuilder = myModBuilder.DefineType("JumpTableDemo",
TypeAttributes.Public);
MethodBuilder myMthdBuilder = myTypeBuilder.DefineMethod("SwitchMe",
MethodAttributes.Public |
MethodAttributes.Static,
typeof(string),
new Type[] { typeof(int) });
ILGenerator myIL = myMthdBuilder.GetILGenerator();
Label defaultCase = myIL.DefineLabel();
Label endOfMethod = myIL.DefineLabel();
// We are initializing our jump table. Note that the labels
// will be placed later using the MarkLabel method.
Label[] jumpTable = new Label[] { myIL.DefineLabel(),
myIL.DefineLabel(),
myIL.DefineLabel(),
myIL.DefineLabel(),
myIL.DefineLabel() };
// arg0, the number we passed, is pushed onto the stack.
// In this case, due to the design of the code sample,
// the value pushed onto the stack happens to match the
// index of the label (in IL terms, the index of the offset
// in the jump table). If this is not the case, such as
// when switching based on non-integer values, rules for the correspondence
// between the possible case values and each index of the offsets
// must be established outside of the ILGenerator.Emit calls,
// much as a compiler would.
myIL.Emit(OpCodes.Ldarg_0);
myIL.Emit(OpCodes.Switch, jumpTable);
// Branch on default case
myIL.Emit(OpCodes.Br_S, defaultCase);
// Case arg0 = 0
myIL.MarkLabel(jumpTable[0]);
myIL.Emit(OpCodes.Ldstr, "are no bananas");
myIL.Emit(OpCodes.Br_S, endOfMethod);
// Case arg0 = 1
myIL.MarkLabel(jumpTable[1]);
myIL.Emit(OpCodes.Ldstr, "is one banana");
myIL.Emit(OpCodes.Br_S, endOfMethod);
// Case arg0 = 2
myIL.MarkLabel(jumpTable[2]);
myIL.Emit(OpCodes.Ldstr, "are two bananas");
myIL.Emit(OpCodes.Br_S, endOfMethod);
// Case arg0 = 3
myIL.MarkLabel(jumpTable[3]);
myIL.Emit(OpCodes.Ldstr, "are three bananas");
myIL.Emit(OpCodes.Br_S, endOfMethod);
// Case arg0 = 4
myIL.MarkLabel(jumpTable[4]);
myIL.Emit(OpCodes.Ldstr, "are four bananas");
myIL.Emit(OpCodes.Br_S, endOfMethod);
// Default case
myIL.MarkLabel(defaultCase);
myIL.Emit(OpCodes.Ldstr, "are many bananas");
myIL.MarkLabel(endOfMethod);
myIL.Emit(OpCodes.Ret);
return(myTypeBuilder.CreateType());
}
private SiloHandle StartOrleansSilo(Silo.SiloType type, TestingSiloOptions options, int instanceCount, AppDomain shared = null)
{
return(StartOrleansSilo(this, type, options, instanceCount, shared));
}
public static int RunFromMostRecent(System.Reflection.MethodInfo method, string[] cmdargs, AutoUpdateStrategy defaultstrategy = AutoUpdateStrategy.CheckDuring)
{
// If the update is disabled, go straight in
if (DISABLE_UPDATE_DOMAIN)
{
return(RunMethod(method, cmdargs));
}
// If we are not the primary domain, just execute
if (!AppDomain.CurrentDomain.IsDefaultAppDomain())
{
int r = 0;
WrapWithUpdater(defaultstrategy, () => {
r = RunMethod(method, cmdargs);
});
return(r);
}
// If we are a re-launch, wait briefly for the other process to exit
var sleepmarker = System.Environment.GetEnvironmentVariable(string.Format(SLEEP_ENVNAME_TEMPLATE, APPNAME));
if (!string.IsNullOrWhiteSpace(sleepmarker))
{
System.Environment.SetEnvironmentVariable(string.Format(SLEEP_ENVNAME_TEMPLATE, APPNAME), null);
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10));
}
// Check if there are updates installed, otherwise use current
KeyValuePair <string, UpdateInfo> best = new KeyValuePair <string, UpdateInfo>(AppDomain.CurrentDomain.SetupInformation.ApplicationBase, SelfVersion);
if (HasUpdateInstalled)
{
best = m_hasUpdateInstalled.Value;
}
if (INSTALLDIR != null && System.IO.File.Exists(System.IO.Path.Combine(INSTALLDIR, CURRENT_FILE)))
{
try
{
var current = System.IO.File.ReadAllText(System.IO.Path.Combine(INSTALLDIR, CURRENT_FILE)).Trim();
if (!string.IsNullOrWhiteSpace(current))
{
var targetfolder = System.IO.Path.Combine(INSTALLDIR, current);
var currentmanifest = ReadInstalledManifest(targetfolder);
if (currentmanifest != null && VerifyUnpackedFolder(targetfolder, currentmanifest))
{
best = new KeyValuePair <string, UpdateInfo>(targetfolder, currentmanifest);
}
}
}
catch (Exception ex)
{
if (OnError != null)
{
OnError(ex);
}
}
}
Environment.SetEnvironmentVariable(string.Format(INSTALLDIR_ENVNAME_TEMPLATE, APPNAME), InstalledBaseDir);
var folder = best.Key;
// Basic idea with the loop is that the running AppDomain can use
// RUN_UPDATED_ENVNAME_TEMPLATE to signal that a new version is ready
// when the caller exits, the new update is executed
//
// This allows more or less seamless updates
//
int result = 0;
while (!string.IsNullOrWhiteSpace(folder) && System.IO.Directory.Exists(folder))
{
var prevfolder = folder;
// Create the new domain
var domain = AppDomain.CreateDomain(
"UpdateDomain",
null,
folder,
"",
false
);
result = domain.ExecuteAssemblyByName(method.DeclaringType.Assembly.GetName().Name, cmdargs);
folder = (string)domain.GetData(RUN_UPDATED_FOLDER_PATH);
try { AppDomain.Unload(domain); }
catch (Exception ex)
{
Console.WriteLine("Appdomain unload error: {0}", ex);
}
if (!string.IsNullOrWhiteSpace(folder))
{
if (!VerifyUnpackedFolder(folder))
{
folder = prevfolder; //Go back and run the previous version
}
else if (RequiresRespawn)
{
// We have a valid update, and the current instance is terminated.
// But due to external libraries, we need to re-spawn the original process
try
{
var args = Environment.CommandLine;
var app = Environment.GetCommandLineArgs().First();
args = args.Substring(app.Length);
if (!System.IO.Path.IsPathRooted(app))
{
app = System.IO.Path.Combine(InstalledBaseDir, app);
}
// Re-launch but give the OS a little time to fully unload all open handles, etc.
var si = new System.Diagnostics.ProcessStartInfo(app, args);
si.UseShellExecute = false;
si.EnvironmentVariables.Add(string.Format(SLEEP_ENVNAME_TEMPLATE, APPNAME), "1");
System.Diagnostics.Process.Start(si);
return(0);
}
catch (Exception ex)
{
if (OnError != null)
{
OnError(ex);
}
folder = prevfolder;
}
}
}
}
return(result);
}
/// <summary>
/// This closes the scrpit, removes it from any known spots, and disposes of itself.
/// </summary>
/// <param name="Silent">Should we back up this script and fire state_exit?</param>
public void CloseAndDispose(bool Silent)
{
// this is still broken ?
m_ScriptEngine.MaintenanceThread.RemoveFromEventSchQueue(this, true);
if (!Silent)
{
if (Script != null)
{
/*
* //Fire this directly so its not closed before its fired
* SetEventParams("state_exit", new DetectParams[0]);
*
* m_ScriptEngine.MaintenanceThread.ProcessQIS(new QueueItemStruct()
* {
* ID = this,
* CurrentlyAt = null,
* functionName = "state_exit",
* param = new object[0],
* llDetectParams = new DetectParams[0],
* VersionID = VersionID
* });
*/
// dont think we should fire state_exit here
// m_ScriptEngine.MaintenanceThread.DoAndWaitEventSch(this, "state_exit",
// new DetectParams[0], VersionID, EventPriority.FirstStart, new object[0]);
m_ScriptEngine.StateSave.SaveStateTo(this);
}
}
VersionID += 5;
m_ScriptEngine.MaintenanceThread.SetEventSchSetIgnoreNew(this, false);
//Give the user back any controls we took
ReleaseControls();
// Tell script not to accept new requests
//These are fine to set as the state wont be saved again
if (!Silent)
{
Running = false;
Disabled = true;
}
// Remove from internal structure
ScriptEngine.ScriptProtection.RemoveScript(this);
// if (!Silent) //Don't remove on a recompile because we'll make it under a different assembly
// ScriptEngine.ScriptProtection.RemovePreviouslyCompiled(Source);
//Remove any errors that might be sitting around
m_ScriptEngine.ScriptErrorReporter.RemoveError(ItemID);
#region Clean out script parts
//Only if this script changed target omega do we reset it
if (TargetOmegaWasSet)
{
Part.AngularVelocity = Vector3.Zero; // Removed in SL
Part.ScheduleUpdate(PrimUpdateFlags.AngularVelocity); // Send changes to client.
}
#endregion
if (Script != null)
{
// Stop long command on script
m_ScriptEngine.RemoveScript(Part.UUID, ItemID);
//Release the script and destroy it
ILease lease = (ILease)RemotingServices.GetLifetimeService(Script as MarshalByRefObject);
if (lease != null)
{
lease.Unregister(Script.Sponsor);
}
Script.Close();
Script = null;
}
if (AppDomain == null)
{
return;
}
// Tell AppDomain that we have stopped script
m_ScriptEngine.AppDomainManager.UnloadScriptAppDomain(AppDomain);
AppDomain = null;
m_log.Debug("[" + m_ScriptEngine.ScriptEngineName + "]: Closed Script " + InventoryItem.Name + " in " + Part.Name);
}
public static PluginLifetimeStatus CheckPluginLifetimeStatus(Exception ex)
{
Boolean pluginDisconnected =
(ex is RemotingException) && (ex.Message.EndsWith(LifetimeExpiredMsgEnd));
if (!pluginDisconnected)
{
return(PluginLifetimeStatus.Active);
}
string pluginWrapperFile = Assembly.GetCallingAssembly().Location;
TcPluginLoadingInfo loadingInfo = FindPluginLoadingInfoByWrapperFileName(pluginWrapperFile);
if (loadingInfo == null)
{
return(PluginLifetimeStatus.NotLoaded);
}
StackTrace stackTrace = new StackTrace(true);
#if TRACE
string category = loadingInfo.PluginNumber.ToString(CultureInfo.InvariantCulture);
string text;
#endif
var stackFrames = stackTrace.GetFrames();
if (stackFrames != null)
{
foreach (StackFrame sf in stackFrames)
{
Type declaringType = sf.GetMethod().DeclaringType;
if (declaringType != null &&
(declaringType.FullName.StartsWith("OY.TotalCommander.WfxWrapper") &&
!sf.GetMethod().Name.Equals("ProcessException")))
{
#if TRACE
text = String.Format(TraceMsg15, declaringType.FullName.Substring(29), sf.GetMethod().Name);
TraceError(text, category);
#endif
break;
}
}
}
// Plugin remote object has expired, try to unload plugin AppDomain
loadingInfo.LifetimeStatus = PluginLifetimeStatus.Expired;
if (loadingInfo.UnloadExpired)
{
AppDomain pluginDomain = loadingInfo.Domain;
try {
AppDomain.Unload(pluginDomain);
#if TRACE
text = "Plugin Lifetime Expired - Plugin \"" + pluginWrapperFile + "\" was disconnected from TC.";
TraceError(text, category);
#endif
MessageBox.Show(
"Plugin " + Path.GetFileNameWithoutExtension(pluginWrapperFile)
+ " has expired and was disconnected From TC.",
"Plugin disconnected", MessageBoxButtons.OK, MessageBoxIcon.Information);
OpenTcPluginHome();
loadingInfo.LifetimeStatus = PluginLifetimeStatus.PluginUnloaded;
} catch (Exception e) {
#if TRACE
text = "Unload ERROR: " + e.Message;
TraceError(text, category);
#endif
}
}
else
{
MessageBox.Show(
"Plugin " + Path.GetFileNameWithoutExtension(pluginWrapperFile) + " has expired.",
"Plugin expired", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return(loadingInfo.LifetimeStatus);
}
public static void HandledAllExceptions()
{
AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.UnhandledException += new UnhandledExceptionEventHandler(MyHandler);
}
public Step7ProjectV15_1(string projectfile, CultureInfo culture = null, Credentials credentials = null)
{
_credentials = credentials;
if (culture == null)
{
Culture = CultureInfo.CurrentCulture;
}
else
{
Culture = culture;
}
AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.AssemblyResolve += currentDomain_AssemblyResolve;
ProjectFile = projectfile;
if (ProjectFile.ToLower().EndsWith("zip") || ProjectFile.ToLower().EndsWith("zap15_1"))
{
if (string.IsNullOrEmpty(ProjectFile))
{
ProjectFile = ZipHelper.GetFirstZipEntryWithEnding(ProjectFile, ".ap15_1");
}
if (string.IsNullOrEmpty(ProjectFile))
{
ProjectFile = ZipHelper.GetFirstZipEntryWithEnding(ProjectFile, ".al15_1");
}
if (string.IsNullOrEmpty(projectfile))
{
throw new Exception("Zip-File contains no valid TIA Project !");
}
this._ziphelper = new ZipHelper(projectfile);
}
try
{
using (var stream = _ziphelper.GetReadStream(projectfile))
{
var xmlDoc = new XmlDocument();
xmlDoc.Load(stream);
XmlNamespaceManager nsmgr = new XmlNamespaceManager(xmlDoc.NameTable);
nsmgr.AddNamespace("x", "http://www.siemens.com/2007/07/Automation/CommonServices/DataInfoValueData");
var nd = xmlDoc.SelectSingleNode("x:Data", nsmgr);
this.ProjectName = nd.Attributes["Name"].Value;
}
}
catch (Exception)
{ }
DataFile = Path.GetDirectoryName(projectfile) + "\\System\\PEData.plf";
ProjectFolder = projectfile.Substring(0, projectfile.LastIndexOf(Path.DirectorySeparatorChar)) + Path.DirectorySeparatorChar;
//BinaryParseTIAFile();
//LoadProject();
OpenViaOpennessDlls(credentials);
currentDomain.AssemblyResolve -= currentDomain_AssemblyResolve;
}
public void CreateAppDomain(ICorDebugProcess pProcess, ICorDebugAppDomain pAppDomain)
{
EnterCallback("CreateAppDomain", pAppDomain);
pAppDomain.Attach();
AppDomain appDomain = new AppDomain(process, pAppDomain);
process.appDomains.Add(appDomain);
process.OnAppDomainCreated(appDomain);
ExitCallback();
}
/// <summary>
/// Start a new silo in the target cluster
/// </summary>
/// <param name="host">The target cluster</param>
/// <param name="type">The type of the silo to deploy</param>
/// <param name="options">The options to use for the silo</param>
/// <param name="instanceCount">The instance count of the silo</param>
/// <param name="shared">The shared AppDomain to use</param>
/// <returns>A handle to the deployed silo</returns>
public static SiloHandle StartOrleansSilo(TestingSiloHost host, Silo.SiloType type, TestingSiloOptions options, int instanceCount, AppDomain shared = null)
{
if (host == null)
{
throw new ArgumentNullException("host");
}
// Load initial config settings, then apply some overrides below.
ClusterConfiguration config = new ClusterConfiguration();
try
{
if (options.SiloConfigFile == null)
{
config.StandardLoad();
}
else
{
config.LoadFromFile(options.SiloConfigFile.FullName);
}
}
catch (FileNotFoundException)
{
if (options.SiloConfigFile != null &&
!string.Equals(options.SiloConfigFile.Name, TestingSiloOptions.DEFAULT_SILO_CONFIG_FILE, StringComparison.InvariantCultureIgnoreCase))
{
// if the user is not using the defaults, then throw because the file was legitimally not found
throw;
}
config = ClusterConfiguration.LocalhostPrimarySilo();
config.AddMemoryStorageProvider("Default");
config.AddMemoryStorageProvider("MemoryStore");
}
int basePort = options.BasePort < 0 ? BasePort : options.BasePort;
if (config.Globals.SeedNodes.Count > 0 && options.BasePort < 0)
{
config.PrimaryNode = config.Globals.SeedNodes[0];
}
else
{
config.PrimaryNode = new IPEndPoint(IPAddress.Loopback, basePort);
}
config.Globals.SeedNodes.Clear();
config.Globals.SeedNodes.Add(config.PrimaryNode);
if (!String.IsNullOrEmpty(host.DeploymentId))
{
config.Globals.DeploymentId = host.DeploymentId;
}
config.Defaults.PropagateActivityId = options.PropagateActivityId;
if (options.LargeMessageWarningThreshold > 0)
{
config.Defaults.LargeMessageWarningThreshold = options.LargeMessageWarningThreshold;
}
config.Globals.LivenessType = options.LivenessType;
config.Globals.ReminderServiceType = options.ReminderServiceType;
if (!String.IsNullOrEmpty(options.DataConnectionString))
{
config.Globals.DataConnectionString = options.DataConnectionString;
}
host.Globals = config.Globals;
string siloName;
switch (type)
{
case Silo.SiloType.Primary:
siloName = "Primary";
break;
default:
siloName = "Secondary_" + instanceCount.ToString(CultureInfo.InvariantCulture);
break;
}
NodeConfiguration nodeConfig = config.GetOrCreateNodeConfigurationForSilo(siloName);
nodeConfig.HostNameOrIPAddress = "loopback";
nodeConfig.Port = basePort + instanceCount;
nodeConfig.DefaultTraceLevel = config.Defaults.DefaultTraceLevel;
nodeConfig.PropagateActivityId = config.Defaults.PropagateActivityId;
nodeConfig.BulkMessageLimit = config.Defaults.BulkMessageLimit;
int?gatewayport = null;
if (nodeConfig.ProxyGatewayEndpoint != null && nodeConfig.ProxyGatewayEndpoint.Address != null)
{
gatewayport = (options.ProxyBasePort < 0 ? ProxyBasePort : options.ProxyBasePort) + instanceCount;
nodeConfig.ProxyGatewayEndpoint = new IPEndPoint(nodeConfig.ProxyGatewayEndpoint.Address, gatewayport.Value);
}
config.Globals.ExpectedClusterSize = 2;
config.Overrides[siloName] = nodeConfig;
AdjustForTest(config, options);
WriteLog("Starting a new silo in app domain {0} with config {1}", siloName, config.ToString(siloName));
return(AppDomainSiloHandle.Create(siloName, type, config, nodeConfig, host.additionalAssemblies));
}
internal BlogBodyViewModel(Blog blog)
{
SettingManager = SettingManager.Current;
AppDomain = AppDomain.Current;
Blog = blog;
}
private static ProxyBuilder CreateProxyBuilder(string proxyName, Type interfaceType, Type channelType, Type ctorArgType)
{
AppDomain domain = Thread.GetDomain();
// create a new assembly for the proxy
AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(PROXY_ASSEMBLY), AssemblyBuilderAccess.Run);
// create a new module for the proxy
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(PROXY_MODULE);
// Set the class to be public and sealed
TypeAttributes typeAttributes = TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Sealed;
// Construct the type builder
TypeBuilder typeBuilder = moduleBuilder.DefineType(interfaceType.Name + PROXY, typeAttributes, channelType);
List <Type> allInterfaces = new List <Type>(interfaceType.GetInterfaces());
allInterfaces.Add(interfaceType);
//add the interface
typeBuilder.AddInterfaceImplementation(interfaceType);
//construct the constructor
Type[] ctorArgTypes = new Type[] { typeof(Type), ctorArgType };
CreateConstructor(channelType, typeBuilder, ctorArgTypes);
//construct the type maps
Dictionary <Type, OpCode> ldindOpCodeTypeMap = new Dictionary <Type, OpCode>();
ldindOpCodeTypeMap.Add(typeof(Boolean), OpCodes.Ldind_I1);
ldindOpCodeTypeMap.Add(typeof(Byte), OpCodes.Ldind_U1);
ldindOpCodeTypeMap.Add(typeof(SByte), OpCodes.Ldind_I1);
ldindOpCodeTypeMap.Add(typeof(Int16), OpCodes.Ldind_I2);
ldindOpCodeTypeMap.Add(typeof(UInt16), OpCodes.Ldind_U2);
ldindOpCodeTypeMap.Add(typeof(Int32), OpCodes.Ldind_I4);
ldindOpCodeTypeMap.Add(typeof(UInt32), OpCodes.Ldind_U4);
ldindOpCodeTypeMap.Add(typeof(Int64), OpCodes.Ldind_I8);
ldindOpCodeTypeMap.Add(typeof(UInt64), OpCodes.Ldind_I8);
ldindOpCodeTypeMap.Add(typeof(Char), OpCodes.Ldind_U2);
ldindOpCodeTypeMap.Add(typeof(Double), OpCodes.Ldind_R8);
ldindOpCodeTypeMap.Add(typeof(Single), OpCodes.Ldind_R4);
Dictionary <Type, OpCode> stindOpCodeTypeMap = new Dictionary <Type, OpCode>();
stindOpCodeTypeMap.Add(typeof(Boolean), OpCodes.Stind_I1);
stindOpCodeTypeMap.Add(typeof(Byte), OpCodes.Stind_I1);
stindOpCodeTypeMap.Add(typeof(SByte), OpCodes.Stind_I1);
stindOpCodeTypeMap.Add(typeof(Int16), OpCodes.Stind_I2);
stindOpCodeTypeMap.Add(typeof(UInt16), OpCodes.Stind_I2);
stindOpCodeTypeMap.Add(typeof(Int32), OpCodes.Stind_I4);
stindOpCodeTypeMap.Add(typeof(UInt32), OpCodes.Stind_I4);
stindOpCodeTypeMap.Add(typeof(Int64), OpCodes.Stind_I8);
stindOpCodeTypeMap.Add(typeof(UInt64), OpCodes.Stind_I8);
stindOpCodeTypeMap.Add(typeof(Char), OpCodes.Stind_I2);
stindOpCodeTypeMap.Add(typeof(Double), OpCodes.Stind_R8);
stindOpCodeTypeMap.Add(typeof(Single), OpCodes.Stind_R4);
//construct the method builders from the method infos defined in the interface
List <MethodInfo> methods = GetAllMethods(allInterfaces);
foreach (MethodInfo methodInfo in methods)
{
MethodBuilder methodBuilder = ConstructMethod(channelType, methodInfo, typeBuilder, ldindOpCodeTypeMap, stindOpCodeTypeMap);
typeBuilder.DefineMethodOverride(methodBuilder, methodInfo);
}
//create proxy builder
var result = new ProxyBuilder
{
ProxyName = proxyName,
InterfaceType = interfaceType,
CtorType = ctorArgType,
AssemblyBuilder = assemblyBuilder,
ModuleBuilder = moduleBuilder,
TypeBuilder = typeBuilder
};
return(result);
}
// internal - get called by the class loader
// Called when
// - class inheritance
// - method overrides
private unsafe static bool InheritanceDemand (AppDomain ad, Assembly a, RuntimeDeclSecurityActions *actions)
{
try {
PermissionSet ps = null;
bool result = true;
if (actions->cas.size > 0) {
ps = Decode (actions->cas.blob, actions->cas.size);
result = (SecurityManager.CheckPermissionSet (a, ps, false) == null);
if (result) {
// also check appdomain
result = (SecurityManager.CheckPermissionSet (ad, ps) == null);
}
}
if (actions->noncas.size > 0) {
ps = Decode (actions->noncas.blob, actions->noncas.size);
result = (SecurityManager.CheckPermissionSet (a, ps, true) == null);
if (result) {
// also check appdomain
result = (SecurityManager.CheckPermissionSet (ad, ps) == null);
}
}
return result;
}
catch (SecurityException) {
return false;
}
}
static void TestCAS(string connectString1, string connectString2)
{
// Create permission set for sandbox AppDomain.
// This example only allows execution.
PermissionSet permissions = new PermissionSet(PermissionState.None);
permissions.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));
// Create sandbox AppDomain with permission set that only allows execution,
// and has no SqlClientPermissions.
AppDomainSetup appDomainSetup = new AppDomainSetup();
appDomainSetup.ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
AppDomain firstDomain = AppDomain.CreateDomain("NoSqlPermissions", null, appDomainSetup, permissions);
// Create helper object in sandbox AppDomain so that code can be executed in that AppDomain.
Type helperType = typeof(PartialTrustHelper);
PartialTrustHelper firstHelper = (PartialTrustHelper)firstDomain.CreateInstanceAndUnwrap(helperType.Assembly.FullName, helperType.FullName);
try {
// Attempt to open a connection in the sandbox AppDomain.
// This is expected to fail.
firstHelper.TestConnectionOpen(connectString1);
Console.WriteLine("Connection opened, unexpected.");
}
catch (System.Security.SecurityException ex) {
Console.WriteLine("Failed, as expected: {0}",
ex.FirstPermissionThatFailed);
// Uncomment the following line to see Exception details.
// Console.WriteLine("BaseException: " + ex.GetBaseException());
}
// Add permission for a specific connection string.
SqlClientPermission sqlPermission = new SqlClientPermission(PermissionState.None);
sqlPermission.Add(connectString1, "", KeyRestrictionBehavior.AllowOnly);
permissions.AddPermission(sqlPermission);
AppDomain secondDomain = AppDomain.CreateDomain("OneSqlPermission", null, appDomainSetup, permissions);
PartialTrustHelper secondHelper = (PartialTrustHelper)secondDomain.CreateInstanceAndUnwrap(helperType.Assembly.FullName, helperType.FullName);
// Try connection open again, it should succeed now.
try {
secondHelper.TestConnectionOpen(connectString1);
Console.WriteLine("Connection opened, as expected.");
}
catch (System.Security.SecurityException ex) {
Console.WriteLine("Unexpected failure: {0}", ex.Message);
}
// Try a different connection string. This should fail.
try {
secondHelper.TestConnectionOpen(connectString2);
Console.WriteLine("Connection opened, unexpected.");
}
catch (System.Security.SecurityException ex) {
Console.WriteLine("Failed, as expected: {0}", ex.Message);
}
}
/// <summary>
/// Construct an application domain for running a test package
/// </summary>
/// <param name="package">The TestPackage to be run</param>
public AppDomain CreateDomain(TestPackage package)
{
AppDomainSetup setup = new AppDomainSetup();
//For paralell tests, we need to use distinct application name
setup.ApplicationName = "Tests" + "_" + Environment.TickCount;
FileInfo testFile = package.FullName != null && package.FullName != string.Empty
? new FileInfo(package.FullName)
: null;
string appBase = package.BasePath;
string configFile = package.ConfigurationFile;
string binPath = package.PrivateBinPath;
if (testFile != null)
{
if (appBase == null || appBase == string.Empty)
{
appBase = testFile.DirectoryName;
}
if (configFile == null || configFile == string.Empty)
{
configFile = Services.ProjectService.CanLoadProject(testFile.Name)
? Path.GetFileNameWithoutExtension(testFile.Name) + ".config"
: testFile.Name + ".config";
}
}
else if (appBase == null || appBase == string.Empty)
{
appBase = GetCommonAppBase(package.Assemblies);
}
char lastChar = appBase[appBase.Length - 1];
if (lastChar != Path.DirectorySeparatorChar && lastChar != Path.AltDirectorySeparatorChar)
{
appBase += Path.DirectorySeparatorChar;
}
setup.ApplicationBase = appBase;
// TODO: Check whether Mono still needs full path to config file...
setup.ConfigurationFile = appBase != null && configFile != null
? Path.Combine(appBase, configFile)
: configFile;
if (package.AutoBinPath)
{
binPath = GetPrivateBinPath(appBase, package.Assemblies);
}
setup.PrivateBinPath = binPath;
if (package.GetSetting("ShadowCopyFiles", true))
{
setup.ShadowCopyFiles = "true";
setup.ShadowCopyDirectories = appBase;
setup.CachePath = GetCachePath();
}
else
{
setup.ShadowCopyFiles = "false";
}
string domainName = "test-domain-" + package.Name;
// Setup the Evidence
Evidence evidence = new Evidence(AppDomain.CurrentDomain.Evidence);
if (evidence.Count == 0)
{
Zone zone = new Zone(SecurityZone.MyComputer);
evidence.AddHost(zone);
Assembly assembly = Assembly.GetExecutingAssembly();
Url url = new Url(assembly.CodeBase);
evidence.AddHost(url);
Hash hash = new Hash(assembly);
evidence.AddHost(hash);
}
log.Info("Creating AppDomain " + domainName);
AppDomain runnerDomain;
// TODO: Try to eliminate this test. Currently, running on
// Linux with the permission set specified causes an
// unexplained crash when unloading the domain.
#if CLR_2_0 || CLR_4_0
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
PermissionSet permissionSet = new PermissionSet(PermissionState.Unrestricted);
runnerDomain = AppDomain.CreateDomain(domainName, evidence, setup, permissionSet, null);
}
else
#endif
runnerDomain = AppDomain.CreateDomain(domainName, evidence, setup);
// Set PrincipalPolicy for the domain if called for in the settings
if (Services.UserSettings.GetSetting("Options.TestLoader.SetPrincipalPolicy", false))
{
runnerDomain.SetPrincipalPolicy((PrincipalPolicy)Services.UserSettings.GetSetting(
"Options.TestLoader.PrincipalPolicy", PrincipalPolicy.UnauthenticatedPrincipal));
}
// HACK: Only pass down our AddinRegistry one level so that tests of NUnit
// itself start without any addins defined.
if (!IsTestDomain(AppDomain.CurrentDomain))
{
runnerDomain.SetData("AddinRegistry", Services.AddinRegistry);
}
// Inject DomainInitializer into the remote domain - there are other
// approaches, but this works for all CLR versions.
DomainInitializer initializer = DomainInitializer.CreateInstance(runnerDomain);
// HACK: Under nunit-console, direct use of the enum fails
int traceLevel = IsTestDomain(AppDomain.CurrentDomain)
? (int)InternalTraceLevel.Off : (int)InternalTrace.Level;
initializer.InitializeDomain(traceLevel);
return(runnerDomain);
}
internal RuntimeData(RuntimeAssemblyManager manager, AppDomain appDomain)
{
Manager = manager;
AppDomain = appDomain;
}
public PluginContainer(AppDomain domain, TPlugin plugin, TModel model)
{
Domain = domain;
Plugin = plugin;
Model = model;
}
/// <summary>
/// Init the repository from a given path
/// </summary>
public void Init(string path)
{
RepositoryPath = path;
RepositoryServer.ViewsFolder = ViewsFolder;
RepositoryServer.TableTemplatesFolder = TableTemplatesFolder;
CheckFolders();
//Data sources
if (Sources.Count == 0)
{
foreach (var file in Directory.GetFiles(SourcesFolder, "*." + SealConfigurationFileExtension))
{
try
{
var source = MetaSource.LoadFromFile(file, this);
Sources.Add(source);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
}
if (Devices.Count == 0)
{
//Devices, add a default folder device, then the other devices
Devices.Add(OutputFolderDevice.Create());
foreach (var file in Directory.GetFiles(DevicesEmailFolder, "*." + SealConfigurationFileExtension))
{
try
{
Devices.Add(OutputEmailDevice.LoadFromFile(file, true));
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
foreach (var file in Directory.GetFiles(DevicesFileServerFolder, "*." + SealConfigurationFileExtension))
{
try
{
Devices.Add(OutputFileServerDevice.LoadFromFile(file, true));
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
}
if (!_assembliesLoaded)
{
//Load extra assemblies defined in Repository
var assemblies = Directory.GetFiles(AssembliesFolder, "*.dll");
foreach (var assembly in assemblies)
{
try
{
Assembly.LoadFrom(assembly);
}
catch (Exception Exception)
{
Debug.WriteLine(Exception.Message);
}
}
//Add this assembly resolve necessary when executing Razor scripts
AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.AssemblyResolve += new ResolveEventHandler(AssemblyResolve);
_assembliesLoaded = true;
}
}
/// <summary>
/// Returns true if this is a clickonce deployed app.
/// </summary>
internal static bool IsClickOnceDeployed(AppDomain appDomain)
{
// Never ClickOnce app in CoreFX
return(false);
}
/// <summary>
/// Method initiates the startup of the application.
/// The MainWindow entity is retrieved from the services provider and rendered to the user
/// </summary>
/// <param name="sender">The caller of the method</param>
/// <param name="e">Any startup arguments provided</param>
private void OnStartup(object sender, StartupEventArgs e)
{
// global exception handler for unhandled exceptions
AppDomain domain = AppDomain.CurrentDomain;
domain.UnhandledException += DomainOnUnhandledException;
string env = null;
for (int i = 0; i < e.Args.Length; i++)
{
if (e.Args[i].Equals("-config"))
{
_enviromentTag = e.Args[i + 1];
switch (e.Args[i + 1])
{
case "Development":
env = "appsettings.Development.json";
break;
case "Live":
env = "appsettings.json";
break;
default:
env = null;
break;
}
}
else if (e.Args[i].Equals("-clear"))
{
clearList.Clear = true;
clearList.ClearValue = int.Parse(e.Args[i + 1]);
}
}
// add in the app settings file
var builder = new ConfigurationBuilder()
.SetBasePath(Environment.CurrentDirectory)
.AddJsonFile(env, optional: false, reloadOnChange: false);
_configuration = builder.Build();
ServiceCollection serviceCollection = new ServiceCollection();
// Add NLog
serviceCollection.AddLogging(loggingProvider =>
{
// configure Logging with NLog
loggingProvider.ClearProviders();
loggingProvider.SetMinimumLevel(LogLevel.Debug);
loggingProvider.AddConfiguration(_configuration.GetSection("Logging"));
loggingProvider.AddNLog(_configuration);
});
// configure all classes that need to be injected
ConfigureServices(serviceCollection);
ConfigureViews(serviceCollection);
ConfigureViewModels(serviceCollection);
ConfigDatabase(serviceCollection); // Database
_serviceProvider = serviceCollection.BuildServiceProvider();
Services = serviceCollection;
MigrateDatabase();
SeedDatabase();
MainWindow mainWindow = _serviceProvider.GetService <MainWindow>();
mainWindow.Show();
}
public Event.ExecutionOrigin ExecutionOriginHere()
{
return(new Event.ExecutionOrigin(process.MainModule.ModuleName, (uint)process.Id, (uint)AppDomain.GetCurrentThreadId()));
}
private void SetupExceptionHandling()
{
AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.UnhandledException += CurrentDomain_UnhandledException;
}
public void LoadAssemblies()
{
if (ad != null)
{
System.Console.Error.WriteLine("Unloading domain");
AppDomain.Unload(ad);
}
ad = AppDomain.CreateDomain("MyAppDomain");
object o = ad.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, "CompleteSharp+MyAppDomain+Hack");
Hack h = o as Hack;
h.ad = this;
int idx = 0;
foreach (string a in assemblies)
{
try
{
FileInfo fi = new FileInfo(a);
times[idx] = fi.LastWriteTime;
idx++;
System.Console.Error.WriteLine("Loading: " + a);
h.Load(a);
}
catch (Exception e)
{
reportError(e);
}
}
}
void EnableAlternativeAssemblyResolvers()
{
AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.AssemblyResolve += CurrentDomainOnAssemblyResolve;
}
public UnloadThread (AppDomain domain) {
this.domain = domain;
}
public void Dispose()
{
AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.AssemblyResolve -= CurrentDomainOnAssemblyResolve;
}
/// <summary>
/// Handles unloads for assemblyLoad and domainUnload events
/// </summary>
/// <param name="ad">The appdomain to potentially unload</param>
/// <param name="eReasonForUnload">reason for unload</param>
public void UnloadOnEvent(AppDomain ad, eReasonForUnload reason)
{
int percent = 0;
switch (reason)
{
case eReasonForUnload.AssemblyLoad:
percent = curTestSet.ULAssemblyLoadPercent;
break;
case eReasonForUnload.AppDomainUnload:
percent = curTestSet.ULAppDomainUnloadPercent;
break;
case eReasonForUnload.Replay:
percent = 100;
break;
}
if (randNum.Next(100) < percent)
{
for (int i = 0; i < curTestSet.Tests.Length; i++)
{
lock (curTestSet.Tests[i])
{
if ((curTestSet.Tests[i].AppDomain != null) && (curTestSet.Tests[i].AppDomain.FriendlyName == ad.FriendlyName))
{
//update testsRanCount to reflect missing tests
this.testsRanCount += curTestSet.Tests[i].ConcurrentCopies * curTestSet.MaximumLoops - curTestSet.Tests[i].RunCount;
//print unload message to log
//WriteToLog(String.Format("UNLOAD {0} AppDomain Unloaded: {1}{2}", DateTime.Now, curTestSet.Tests[i].RefOrID, Environment.NewLine));
if (reason == eReasonForUnload.AssemblyLoad)
{
//The test isn't going to load, so don't count it
Interlocked.Decrement(ref LoadingCount);
}
Console.WriteLine("\nReliabilityFramework: Unload on{0}-{1}-{2}", reason.ToString(), curTestSet.Tests[i].RefOrID, System.DateTime.Now);
// unload domain
AppDomainUnloadDelegate adu = new AppDomainUnloadDelegate(AppDomain.Unload);
adu.BeginInvoke(curTestSet.Tests[i].AppDomain, null, null);
curTestSet.Tests[i].AppDomain = null;
curTestSet.Tests[i].ConcurrentCopies = 0;
}
}
}
}
}
public void Unload(AppDomain domain)
{
new DomainUnloader(domain).Unload();
}
/// <summary>
/// Releases all resources used by the facade.
/// </summary>
/// <param name="disposing">
/// <c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.
/// </param>
protected virtual void Dispose(bool disposing)
{
if (disposing && _appDomain != null)
{
AppDomain.Unload(_appDomain);
_appDomain = null;
}
if (_configurationFile != null)
{
File.Delete(_configurationFile);
}
}
public DomainUnloader(AppDomain domain)
{
this.domain = domain;
}
internal static IPermission CheckPermissionSet (AppDomain ad, PermissionSet ps)
{
if ((ps == null) || ps.IsEmpty ())
return null;
PermissionSet granted = ad.GrantedPermissionSet;
if (granted == null)
return null;
if (granted.IsUnrestricted ())
return null;
if (ps.IsUnrestricted ())
return new SecurityPermission (SecurityPermissionFlag.NoFlags);
foreach (IPermission p in ps) {
if (p is CodeAccessPermission) {
CodeAccessPermission grant = (CodeAccessPermission) granted.GetPermission (p.GetType ());
if (grant == null) {
if (!granted.IsUnrestricted () || !(p is IUnrestrictedPermission)) {
if (!p.IsSubsetOf (null))
return p;
}
} else if (!p.IsSubsetOf (grant)) {
return p;
}
} else {
// but non-CAS will throw on failure...
try {
p.Demand ();
}
catch (SecurityException) {
// ... so we catch
return p;
}
}
}
return null;
}
private bool IsTestDomain(AppDomain domain)
{
return(domain.FriendlyName.StartsWith("test-domain-"));
}
// Arguments: Codebase, flags, zone, srcurl
// If the flags indicate zone then a zone must be provided.
// If the flags indicate a site then a srcurl must be provided, codebase must be a filepath
public int Execute(string codebase, Int32 flags, Int32 evidenceZone, string evidenceSrcUrl, string stringArg)
{
string file = codebase;
if ((file.Length == 0) || (file[0] == '\0'))
{
throw new ArgumentException("Invalid codebase");
}
Console.WriteLine("Codebase- {0}", file);
// Find the appbase of the executable. For now we assume the
// form to be http://blah/... with forward slashes. This
// need to be update.
// Note: aso works with '\' as in file paths
string appbase = null;
string ConfigurationFile = null;
int k = file.LastIndexOf('/');
if (k <= 0)
{
k = file.LastIndexOf('\\');
if (k == 0)
{
appbase = file;
ConfigurationFile = file;
}
}
if (k != 0)
{
// if k is still < 0 at this point, appbase should be an empty string
appbase = file.Substring(0, k + 1);
if (k + 1 < file.Length)
{
ConfigurationFile = file.Substring(k + 1);
}
}
// Check 1: disallow non-fully qualified path/codebase
if ((appbase.Length == 0) || (appbase[0] == '.'))
{
throw new ArgumentException("Codebase must be fully qualified");
}
// BUGBUG: should appbase be the source of the code, not local?
Console.WriteLine("AppBase- {0}", appbase);
// Build up the configuration File name
if (ConfigurationFile != null)
{
StringBuilder bld = new StringBuilder();
bld.Append(ConfigurationFile);
bld.Append(".config");
ConfigurationFile = bld.ToString();
}
Console.WriteLine("Config- {0}", ConfigurationFile);
// Get the flags
// 0x1 we have Zone
// 0x2 we have a unique id.
int dwFlag = flags;
Evidence documentSecurity = null;
// Check 2: disallow called with no evidence
if (dwFlag == SECURITY_NONE)
{
// BUGBUG?: disallow executing with no evidence
throw new ArgumentException("Flag set at no evidence");
}
if ((dwFlag & SECURITY_SITE) != 0 ||
(dwFlag & SECURITY_ZONE) != 0)
{
documentSecurity = new Evidence();
}
// BUGBUG: check other invalid cases for dwFlag
if ((dwFlag & SECURITY_ZONE) != 0)
{
int zone = evidenceZone;
documentSecurity.AddHost(new Zone((System.Security.SecurityZone)zone));
Console.WriteLine("Evidence Zone- {0}", zone);
}
if ((dwFlag & SECURITY_SITE) != 0)
{
if (file.Length < 7 || String.Compare(file.Substring(0, 7), "file://", true) != 0)
{
documentSecurity.AddHost(System.Security.Policy.Site.CreateFromUrl(evidenceSrcUrl));
Console.WriteLine("Evidence SiteFromUrl- {0}", evidenceSrcUrl);
// if srcUrl is given, assume file/appbase is a local file path
StringBuilder bld = new StringBuilder();
bld.Append("file://");
bld.Append(appbase);
documentSecurity.AddHost(new ApplicationDirectory(bld.ToString()));
Console.WriteLine("Evidence AppDir- {0}", bld);
}
// URLs may be matched exactly or by a wildcard in the final position,
// for example: http://www.fourthcoffee.com/process/*
StringBuilder bld2 = new StringBuilder();
if (evidenceSrcUrl[evidenceSrcUrl.Length - 1] == '/')
{
bld2.Append(evidenceSrcUrl);
}
else
{
int j = evidenceSrcUrl.LastIndexOf('/');
if (j > 0)
{
if (j > 7) // evidenceSrcUrl == "http://a/file.exe"
{
bld2.Append(evidenceSrcUrl.Substring(0, j + 1));
}
else
{
// evidenceSrcUrl == "http://foo.com" -> but why?
bld2.Append(evidenceSrcUrl);
bld2.Append('/');
}
}
else
{
throw new ArgumentException("Invalid Url format");
}
}
bld2.Append('*');
documentSecurity.AddHost(new Url(bld2.ToString()));
Console.WriteLine("Evidence Url- {0}", bld2);
}
// other evidence: Hash, Publisher, StrongName
// Set domain name to site name if possible
string friendlyName = null;
if ((dwFlag & SECURITY_SITE) != 0)
{
friendlyName = GetSiteName(evidenceSrcUrl);
}
else
{
friendlyName = GetSiteName(file);
}
Console.WriteLine("AppDomain friendlyName- {0}", friendlyName);
// set up arguments
// only allow 1 for now
string[] args;
if (stringArg != null)
{
args = new string[1];
args[0] = stringArg;
}
else
{
args = new string[0];
}
AppDomainSetup properties = new AppDomainSetup();
properties.ApplicationBase = appbase;
properties.PrivateBinPath = "bin";
if (ConfigurationFile != null)
{
properties.ConfigurationFile = ConfigurationFile;
}
AppDomain proxy = AppDomain.CreateDomain(friendlyName, documentSecurity, properties);
if (proxy != null)
{
AssemblyName asmname = Assembly.GetExecutingAssembly().GetName();
Console.WriteLine("AsmExecute name- {0}", asmname);
try
{
// Use remoting. Otherwise asm will be loaded both in current and the new AppDomain
// ... as explained by URT dev
// asmexec.dll must be found on path (CorPath?) or in the GAC for this to work.
ObjectHandle handle = proxy.CreateInstance(asmname.FullName, "FusionCLRHost.AsmExecute");
if (handle != null)
{
AsmExecute execproxy = (AsmExecute)handle.Unwrap();
int retVal = -1;
Console.WriteLine("\n========");
if (execproxy != null)
{
retVal = execproxy.ExecuteAsAssembly(file, documentSecurity, args);
}
Console.WriteLine("\n========");
return(retVal);
}
}
catch (Exception e)
{
Console.WriteLine("AsmExecute CreateInstance(AsmExecute) failed: {0}", e.Message);
throw e;
}
}
else
{
Console.WriteLine("AsmExecute CreateDomain failed");
}
// BUGBUG: throw Exception?
return(-1);
}
public void CreateDomainNonNetfx()
{
AssertExtensions.Throws <ArgumentNullException>("friendlyName", () => { AppDomain.CreateDomain(null); });
Assert.Throws <PlatformNotSupportedException>(() => { AppDomain.CreateDomain("test"); });
}
