public void Test()
{
var version1Code = "[assembly: System.Reflection.AssemblyVersion(\"1.0.0.0\")]";
var version2Code = "[assembly: System.Reflection.AssemblyVersion(\"2.0.0.0\")]";
var appDomain1BasePath = Path.Combine(Path.GetTempPath(), "appdomain1");
var appDomain2BasePath = Path.Combine(Path.GetTempPath(), "appdomain2");
CompilationServices.EmitAssembly(Path.Combine(appDomain1BasePath, TestAssemblyName), BaseCode, version1Code);
CompilationServices.EmitAssembly(Path.Combine(appDomain2BasePath, TestAssemblyName), BaseCode, version2Code);
if (File.Exists(DataFile))
{
File.Delete(DataFile);
}
try
{
ExecuteTestMethodInAppDomain(appDomain1BasePath, "Store");
ExecuteTestMethodInAppDomain(appDomain2BasePath, "Load");
}
catch (Exception e)
{
while (e is TargetInvocationException)
{
e = e.InnerException;
}
Assert.Fail(e.Message);
}
}
private static Assembly EmitAssemblyAndLoad(string assemblyName, string code)
{
var assemblyFile = Path.Combine(Path.GetTempPath(), assemblyName);
CompilationServices.EmitAssembly(assemblyFile, code);
return(Assembly.LoadFrom(assemblyFile));
}
private static AppDomain PrepareTestEnvironment(string assemblyFileName, string code)
{
var targetAppDomain = CreateAppDomain();
var assemblyPath = Path.Combine(targetAppDomain.BaseDirectory, assemblyFileName + ".dll");
CompilationServices.EmitAssembly(assemblyPath, code);
return(targetAppDomain);
}
private string InstrumentResource()
{
string resourceName = ResourceServices.CompleteResourceName(GetType(), "TABytecodeChangesSubject");
string path = CompilationServices.EmitAssemblyFromResource(resourceName);
ShellUtilities.ProcessOutput output = InstrumentationServices.InstrumentAssembly("-ta", path);
Assert.AreEqual(0, output.ExitCode);
return(path);
}
public override async void Analyze(RepoProject project)
{
var logger = project.Repo.AnalysisServices.Logger;
try
{
var services = project.Repo.AnalysisServices;
logger.LogMessage("Loading project: " + project.ProjectId);
using (services.TaskDispatcher.TrackScope())
{
await services.TaskDispatcher.Invoke(async() =>
{
var solution = await lazySolution.Value;
Project = solution.GetProject(ProjectId);
if (Project == null)
{
logger.LogError($"Can't find project for {ProjectId} in {solution}");
}
else
{
Compilation = await Project.GetCompilationAsync();
CompilationServices = new CompilationServices(Compilation);
foreach (var reference in Compilation.ReferencedAssemblyNames)
{
var referencedProject = new ReferencedProject()
{
ProjectId = reference.Name,
DisplayName = reference.GetDisplayName(),
Properties = new Dictionary <string, string>()
{
{ "PublicKey", string.Concat(reference.PublicKey.Select(b => b.ToString("X2"))) }
}
};
ProjectContext.ReferencedProjects.TryAdd(referencedProject.ProjectId, referencedProject);
}
}
base.Analyze(project);
});
var documents = await Task.WhenAll(DocumentAnalysisTasks);
ProjectContext.Finish(project);
UploadProject(project, ProjectContext.Project);
project.Analyzer = RepoProjectAnalyzer.Null;
}
}
catch (Exception ex)
{
logger.LogExceptionError($"Loading project {project.ProjectId}", ex);
}
}
public static AssemblyDefinition AssemblyFromResource(string resourceName, Type simblingType, bool loadSymbols, Action <string> sourceHandler, params Assembly[] references)
{
string assemblyPath = CompilationServices.EmitAssemblyFromResource(
ResourceServices.CompleteResourceName(simblingType, resourceName),
sourceHandler,
references);
ReaderParameters parameters = new ReaderParameters();
parameters.ReadSymbols = loadSymbols;
return(AssemblyDefinition.ReadAssembly(assemblyPath, parameters));
}
public void TestCrossAssemblyActivateCallIsIgnored()
{
const string helperAssemblyCode = @"
using Db4objects.Db4o.TA;
using Db4objects.Db4o.Activation;
public class ActivatorUtil
{
public static void ActivateForRead(IActivatable item)
{
item.Activate(ActivationPurpose.Read);
}
}" ;
const string assemblyCode = @"
using Db4objects.Db4o.TA;
using Db4objects.Db4o.Activation;
public class ActivatableItem : IActivatable
{
public void Bind(IActivator activator) {}
public void Activate(ActivationPurpose purpose) {}
public string name;
}
public class Predicates
{
public bool ByName(ActivatableItem item)
{
ActivatorUtil.ActivateForRead(item);
return item.name.StartsWith(""foo"");
}
}" ;
CompilationServices.EmitAssembly(AssemblyPathFor("ActivatorHelper.dll"), new[] { Db4oAssemblyPath() },
helperAssemblyCode);
var crossNQAssemblyPath = AssemblyPathFor("CrossNQ.dll");
CompilationServices.EmitAssembly(crossNQAssemblyPath,
new[] { Db4oAssemblyPath(), AssemblyPathFor("ActivatorHelper.dll") }, assemblyCode);
var assembly = Assembly.LoadFrom(crossNQAssemblyPath);
var type = assembly.GetType("Predicates");
var expression =
new QueryExpressionBuilder().FromMethod(type.GetMethod("ByName",
BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.Public));
AssertSimpleComparisionAgainstConstant(expression, "foo");
}
protected override void Store()
{
var dynamicAssemblyPath = Path.GetTempFileName() + ".dll";
CompilationServices.EmitAssembly(dynamicAssemblyPath,
new string[0],
@"
namespace Test
{
public class Subject
{
public int value;
}
}
" );
_dynamicAssembly = Assembly.LoadFrom(dynamicAssemblyPath);
}
public void SetUp()
{
var dynamicAssemblyPath = Path.Combine(Path.GetTempPath(), "DynamicAssemblyTest.dll");
CompilationServices.EmitAssembly(dynamicAssemblyPath,
new string[0],
@"
namespace Test
{
public class Subject
{
public int value;
}
}
" );
var type = Assembly.LoadFrom(dynamicAssemblyPath).GetTypes()[0];
typeName = type.FullName + ", " + type.Assembly.GetName().Name;
}
private void Initialize(DefaultHostOptions options, IAssemblyLoadContextAccessor loadContextAccessor)
{
var applicationHostContext = new ApplicationHostContext
{
ProjectDirectory = _projectDirectory,
RuntimeIdentifiers = _runtimeEnvironment.GetAllRuntimeIdentifiers(),
TargetFramework = _targetFramework
};
var libraries = ApplicationHostContext.GetRuntimeLibraries(applicationHostContext, throwOnInvalidLockFile: true);
Logger.TraceInformation("[{0}]: Project path: {1}", GetType().Name, applicationHostContext.ProjectDirectory);
Logger.TraceInformation("[{0}]: Project root: {1}", GetType().Name, applicationHostContext.RootDirectory);
Logger.TraceInformation("[{0}]: Project configuration: {1}", GetType().Name, options.Configuration);
Logger.TraceInformation("[{0}]: Packages path: {1}", GetType().Name, applicationHostContext.PackagesDirectory);
_applicationHostContext = applicationHostContext;
_project = applicationHostContext.Project;
#if FEATURE_DNX_MIN_VERSION_CHECK
ValidateMinRuntimeVersion(libraries);
#endif
// Create a new Application Environment for running the app. It needs a reference to the Host's application environment
// (if any), which we can get from the service provider we were given.
// If this is null (i.e. there is no Host Application Environment), that's OK, the Application Environment we are creating
// will just have it's own independent set of global data.
var hostEnvironment = PlatformServices.Default.Application;
var applicationEnvironment = new ApplicationEnvironment(Project, _targetFramework, hostEnvironment);
var compilationContext = new CompilationEngineContext(
applicationEnvironment,
_runtimeEnvironment,
loadContextAccessor.Default,
new CompilationCache());
var compilationEngine = new CompilationEngine(compilationContext);
var runtimeLibraryExporter = new RuntimeLibraryExporter(() => compilationEngine.CreateProjectExporter(Project, _targetFramework, options.Configuration));
var runtimeLibraryManager = new RuntimeLibraryManager(applicationHostContext);
// Default services
_serviceProvider.Add(typeof(ILibraryExporter), runtimeLibraryExporter);
_serviceProvider.Add(typeof(IApplicationEnvironment), applicationEnvironment);
_serviceProvider.Add(typeof(IRuntimeEnvironment), PlatformServices.Default.Runtime);
_serviceProvider.Add(typeof(ILibraryManager), runtimeLibraryManager);
_serviceProvider.Add(typeof(IAssemblyLoadContextAccessor), PlatformServices.Default.AssemblyLoadContextAccessor);
_serviceProvider.Add(typeof(IAssemblyLoaderContainer), PlatformServices.Default.AssemblyLoaderContainer);
PlatformServices.SetDefault(new ApplicationHostPlatformServices(PlatformServices.Default, applicationEnvironment, runtimeLibraryManager));
if (options.CompilationServerPort.HasValue)
{
// Change the project reference provider
Project.DefaultCompiler = Project.DefaultDesignTimeCompiler;
Project.DesignTimeCompilerPort = options.CompilationServerPort.Value;
}
// TODO: Dedupe this logic in the RuntimeLoadContext
var projects = libraries.Where(p => p.Type == Runtime.LibraryTypes.Project)
.ToDictionary(p => p.Identity.Name, p => (ProjectDescription)p);
var assemblies = PackageDependencyProvider.ResolvePackageAssemblyPaths(libraries);
// Configure Assembly loaders
_loaders.Add(new ProjectAssemblyLoader(loadContextAccessor, compilationEngine, projects.Values, options.Configuration));
_loaders.Add(new PackageAssemblyLoader(loadContextAccessor, assemblies, libraries));
var compilerOptionsProvider = new CompilerOptionsProvider(projects);
_serviceProvider.Add(typeof(ICompilerOptionsProvider), compilerOptionsProvider);
CompilationServices.SetDefault(
CompilationServices.Create(
libraryExporter: runtimeLibraryExporter,
compilerOptionsProvider: compilerOptionsProvider
)
);
#if DNX451
PackageDependencyProvider.EnableLoadingNativeLibraries(libraries);
#endif
AddBreadcrumbs(libraries);
}
private void EmitAssembly(string assemblyFile)
{
string[] references = new string[] { Db4oAssemblyPath() };
CompilationServices.EmitAssembly(assemblyFile, references, DataGeneratorCode);
}
public void Emit(string fname)
{
CompilationServices.EmitAssembly(fname, new string[] { _legacyAssembly }, GetCode());
}
