public static int CreateDisposableTestProject(string runtimeHomeDir,
string targetDir,
string projectDir)
{
// Find the misc project to copy
var targetProjectDir = Path.Combine(targetDir, Path.GetFileName(projectDir));
CopyFolder(projectDir, targetProjectDir);
// Make sure package restore can be successful
var currentDnxSolutionRootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
File.Copy(Path.Combine(currentDnxSolutionRootDir, NuGet.Constants.SettingsFileName),
Path.Combine(targetProjectDir, NuGet.Constants.SettingsFileName));
// Use the newly built runtime to generate lock files for samples
string stdOut, stdErr;
return(DnuTestUtils.ExecDnu(
runtimeHomeDir,
subcommand: "restore",
arguments: targetProjectDir,
stdOut: out stdOut,
stdErr: out stdErr));
}
private void WriteGlobalJson()
{
var rootDirectory = ProjectResolver.ResolveRootDirectory(_project.ProjectDirectory);
var rootObject = default(JObject);
if (GlobalSettings.HasGlobalFile(rootDirectory))
{
rootObject = JObject.Parse(File.ReadAllText(Path.Combine(
rootDirectory,
GlobalSettings.GlobalFileName)));
}
else
{
rootObject = new JObject();
}
var applicationRoot = Path.Combine(OutputPath, PublishRoot.AppRootName);
// All dependency projects go to approot/src folder
// so we remove all other useless entries that might bring in ambiguity
rootObject["projects"] = new JArray(SourceFolderName);
rootObject["packages"] = PathUtility.GetRelativePath(
PathUtility.EnsureTrailingForwardSlash(applicationRoot),
TargetPackagesPath, separator: '/');
File.WriteAllText(Path.Combine(applicationRoot, GlobalSettings.GlobalFileName),
rootObject.ToString());
}
public static void Publish(
string root,
PublishOptions publishOptions,
ProjectPackSubSystem.PackOptions packOptions)
{
string src = Path.Combine(root, "build", "module.json");
ProjectPackSubSystem.Pack(root, packOptions);
if (!File.Exists(src))
{
EventManager <ErrorEvent> .SendEvent(new FileNotFoundEvent( src, false ));
return;
}
ProjectConfig t = ProjectConfig.Load(src);
Logger.LogMessage(LoggerSystems.ModuleSystem, "Publishing '{0}'", src);
ProjectResolver.GetManager(publishOptions.Repository).
AddPackage(
t,
Path.Combine(root, "build", "module.zip")
);
}
private static void HasNotChanged(Type type)
{
var projectResolver = new ProjectResolver();
var typeLoader = new ReflectionTypeLoader();
var projectInfo = projectResolver.GetProjectInfo(type);
var api = typeLoader.LoadApi(type);
Directory.CreateDirectory(projectInfo.TestFolderPath);
if (!projectResolver.ApiFileExists(projectInfo, type))
{
projectResolver.WriteApiToFile(projectInfo, type, api);
return;
}
var existingApi = projectResolver.ReadApiFromFile(projectInfo, type);
var compareStrategy = new BestGuessEndpointMatchingStrategy();
var comparer = new ApiComparer(compareStrategy);
comparer.Compare(existingApi, api);
// Nice to have:
// Fields / Events / Delegates
// Supporting constructor arguments on attributes
// Multiple public types per file
// custom struct as type
// Re-generate the output file if there are changes to the API that aren't breaking
}
public void BuildPackageAndCheckServiceability(string projectName, bool expectedServiceability)
{
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var projectSrcDir = Path.Combine(rootDir, "misc", "ServicingTestProjects", projectName);
const string configuration = "Debug";
var components = TestUtils.GetRuntimeComponentsCombinations().First();
var flavor = (string)components[0];
var os = (string)components[1];
var architecture = (string)components[2];
using (var runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor, os, architecture))
using (var tempDir = new DisposableDir())
{
var projectDir = Path.Combine(tempDir, projectName);
var buildOutpuDir = Path.Combine(tempDir, "output");
TestUtils.CopyFolder(projectSrcDir, projectDir);
var exitCode = DnuTestUtils.ExecDnu(runtimeHomeDir, "restore", projectDir);
Assert.Equal(0, exitCode);
exitCode = DnuTestUtils.ExecDnu(
runtimeHomeDir,
"pack",
$"{projectDir} --out {buildOutpuDir} --configuration {configuration}");
Assert.Equal(0, exitCode);
var assemblyPath = Path.Combine(buildOutpuDir, configuration, "dnx451", $"{projectName}.dll");
Assert.Equal(expectedServiceability, LockFileUtils.IsAssemblyServiceable(assemblyPath));
}
}
public override void Run(IEnumerable <string> args)
{
ArgumentSyntaxParser.Parse(args.Skip(1).ToArray(), this);
TcpProjectDatabaseServer server = new TcpProjectDatabaseServer(
ProjectResolver.GetManager(args.First()),
Port,
Path.Combine(
AppRootHelper.AppRoot,
"cache/upload_server"
)
);
Thread t = new Thread(server.ServerLoop);
t.Start();
while (true)
{
System.Console.WriteLine("'exit' to close server");
System.Console.Write(">");
string text = System.Console.ReadLine();
if (text.ToLower() == "exit")
{
break;
}
}
server.Stop();
}
private DefaultRazorProjectService CreateProjectService(
ProjectResolver projectResolver,
ProjectSnapshotManagerBase projectSnapshotManager,
DocumentResolver documentResolver = null,
DocumentVersionCache documentVersionCache = null)
{
documentVersionCache = documentVersionCache ?? Mock.Of <DocumentVersionCache>();
var filePathNormalizer = new FilePathNormalizer();
var accessor = Mock.Of <ProjectSnapshotManagerAccessor>(a => a.Instance == projectSnapshotManager);
documentResolver = documentResolver ?? Mock.Of <DocumentResolver>();
var hostDocumentFactory = new TestHostDocumentFactory();
var remoteTextLoaderFactory = Mock.Of <RemoteTextLoaderFactory>(factory => factory.Create(It.IsAny <string>()) == Mock.Of <TextLoader>());
var projectService = new DefaultRazorProjectService(
Dispatcher,
hostDocumentFactory,
remoteTextLoaderFactory,
documentResolver,
projectResolver,
documentVersionCache,
filePathNormalizer,
accessor,
LoggerFactory);
return(projectService);
}
public void ResolveNewNamedResxResources()
{
var expected = new[]
{
"testproject.OwnResources.resources",
"testproject.subfolder.nestedresource.resources",
"thisIs.New.Resource.resources"
};
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var testProjectFolder = Path.Combine(rootDir, "misc", "ResourcesTestProjects", "testproject");
Project project = ProjectUtilities.GetProject(@"
{
""namedResource"": {
""thisIs.New.Resource"": ""../someresources/OtherResources.resx""
}
}",
"testproject",
Path.Combine(testProjectFolder, "project.json"));
var resolver = new ResxResourceProvider();
var embeddedResources = resolver.GetResources(project).Select(resource => resource.Name).ToArray();
Assert.Equal(expected, embeddedResources);
}
public Project(Stream stream, ProjectResolver resolver)
{
_services = new ServiceContainer();
_levels = new NamedResourceCollection <Level>();
_levels.Modified += (s, e) => OnModified(EventArgs.Empty);
_libraryManager = new LibraryManager();
_libraryManager.Libraries.Modified += (s, e) => OnModified(EventArgs.Empty);
Extra = new List <XmlElement>();
XmlReaderSettings settings = new XmlReaderSettings()
{
CloseInput = true,
IgnoreComments = true,
IgnoreWhitespace = true,
};
using (XmlReader reader = XmlTextReader.Create(stream, settings)) {
XmlSerializer serializer = new XmlSerializer(typeof(ProjectX));
ProjectX proxy = serializer.Deserialize(reader) as ProjectX;
FromXProxy(proxy, resolver, this);
}
ResetModified();
}
private bool WrapAssembly()
{
if (string.IsNullOrEmpty(Framework))
{
Reports.Error.WriteLine("Please specify framework when wrapping an assembly", Framework.Red().Bold());
return(false);
}
var frameworkName = VersionUtility.ParseFrameworkName(Framework);
if (VersionUtility.UnsupportedFrameworkName.Equals(frameworkName))
{
Reports.Error.WriteLine("The framework '{0}' is not supported", Framework.Red().Bold());
return(false);
}
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var wrapRoot = Path.Combine(rootDir, WrapRootName);
EmitAssemblyWrapper(wrapRoot, frameworkName, InputFilePath);
AddWrapFolderToGlobalJson(rootDir);
return(true);
}
public Project(Stream stream, ProjectResolver resolver)
{
_services = new ServiceContainer();
_levels = new NamedResourceCollection<Level>();
_levels.Modified += (s, e) => OnModified(EventArgs.Empty);
_libraryManager = new LibraryManager();
_libraryManager.Libraries.Modified += (s, e) => OnModified(EventArgs.Empty);
Extra = new List<XmlElement>();
XmlReaderSettings settings = new XmlReaderSettings() {
CloseInput = true,
IgnoreComments = true,
IgnoreWhitespace = true,
};
using (XmlReader reader = XmlTextReader.Create(stream, settings)) {
XmlSerializer serializer = new XmlSerializer(typeof(ProjectX));
ProjectX proxy = serializer.Deserialize(reader) as ProjectX;
FromXProxy(proxy, resolver, this);
}
ResetModified();
}
private void WriteGlobalJson()
{
var rootDirectory = ProjectResolver.ResolveRootDirectory(_project.ProjectDirectory);
var rootObject = default(JObject);
if (GlobalSettings.HasGlobalFile(rootDirectory))
{
rootObject = JObject.Parse(File.ReadAllText(Path.Combine(
rootDirectory,
GlobalSettings.GlobalFileName)));
}
else
{
rootObject = new JObject();
}
var applicationRoot = Path.Combine(OutputPath, PublishRoot.AppRootName);
rootObject["packages"] = PathUtility.GetRelativePath(
PathUtility.EnsureTrailingForwardSlash(applicationRoot),
TargetPackagesPath, separator: '/');
File.WriteAllText(Path.Combine(applicationRoot, GlobalSettings.GlobalFileName),
rootObject.ToString());
}
public void Save(Stream stream, ProjectResolver resolver)
{
if (_project != null)
{
_project.Save(stream, resolver);
Modified = false;
}
}
public static void Restore(string projectRoot, string repo)
{
string src = Path.Combine(projectRoot, "project.json");
ProjectConfig t =
ProjectConfig.Load(src);
ProjectResolver.GetManager(repo).Restore(t, projectRoot);
}
public static Project FromXProxy(ProjectX proxy, ProjectResolver resolver)
{
if (proxy == null)
{
return(null);
}
return(FromXProxy(proxy, resolver, new Project()));
}
public static DisposableDir GetTempTestSolution(string name)
{
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var sourceSolutionPath = Path.Combine(rootDir, "misc", "KpmWrapTestSolutions", name);
var targetSolutionPath = CreateTempDir();
CopyFolder(sourceSolutionPath, targetSolutionPath);
return(targetSolutionPath);
}
public override void Restore(ProjectConfig target, string rootDir)
{
foreach (ProjectDependency targetDependency in target.Dependencies)
{
Get(
ProjectResolver.Resolve(this, targetDependency),
Path.Combine(rootDir, targetDependency.ProjectName)
);
}
}
public static Project FromXProxy(ProjectX proxy, ProjectResolver resolver, Project project)
{
if (proxy == null)
{
return(null);
}
if (proxy.PropertyGroup != null)
{
project.Uid = proxy.PropertyGroup.ProjectGuid;
project.Name = proxy.PropertyGroup.ProjectName;
project._defaultLibraryUid = proxy.PropertyGroup.DefaultLibrary;
project.Extra = new List <XmlElement>(proxy.PropertyGroup.Extra ?? new XmlElement[0]);
}
project._texturePool = new MetaTexturePool();
project._tilePools = new MetaTilePoolManager(project._texturePool);
project._objectPools = new MetaObjectPoolManager(project._texturePool);
project._tileBrushes = new MetaTileBrushManager();
foreach (var itemGroup in proxy.ItemGroups)
{
if (itemGroup.Libraries != null)
{
foreach (var libProxy in itemGroup.Libraries)
{
using (Stream stream = resolver.InputStream(libProxy.Include)) {
project.AddLibrary(new Library(stream)
{
FileName = libProxy.Include,
});
}
}
}
if (itemGroup.Levels != null)
{
foreach (var level in itemGroup.Levels)
{
using (Stream stream = resolver.InputStream(level.Include)) {
project.Levels.Add(new Level(stream, project)
{
FileName = level.Include,
});
}
}
}
}
//project._tilePools.Pools.PropertyChanged += project.TilePoolsModifiedHandler;
//project._objectPools.Pools.PropertyChanged += project.HandleObjectPoolManagerPropertyChanged;
return(project);
}
public void InversionOfControlContainerMustResolveProjectResolver()
{
IServiceCollection serviceCollection = new ServiceCollection();
serviceCollection.AddDbContext <PortfolioApplicationDbContext>(o => o.UseInMemoryDatabase(Guid.NewGuid().ToString()));
IContainer container = serviceCollection.AddApplicationModules();
ProjectResolver resolvedComponent = container.Resolve <ProjectResolver>();
Assert.IsType <ProjectResolver>(resolvedComponent);
}
public override void RunJob(
string projectRoot,
ProjectConfig project,
ProjectBuildTarget target,
ProjectBuildJob job)
{
foreach (KeyValuePair <string, string> keyValuePair in job.Arguments)
{
ProjectConfig info = ProjectResolver.Resolve(keyValuePair.Key, keyValuePair.Value);
info.Manager.Get(info, Path.Combine(projectRoot, info.ProjectName));
}
}
public void CanRoundtripDeserializeApi()
{
var resolver = new ProjectResolver();
var typeLoader = new ReflectionTypeLoader();
var api = typeLoader.LoadApi(typeof(TestApi));
var serializedApi = resolver.SerializeApi(api);
var deserializedApi = resolver.DeserializeApi(serializedApi);
Assert.Equal(api, deserializedApi);
api.NestedElements.ForEach(x => Assert.NotNull(x.Parent));
deserializedApi.NestedElements.ForEach(x => Assert.NotNull(x.Parent));
}
public void WatchProject(string projectPath)
{
if (string.IsNullOrEmpty(projectPath))
{
return;
}
// If any watchers already handle this path then noop
if (!IsAlreadyWatched(projectPath))
{
// To reduce the number of watchers we have we add a watcher to the root
// of this project so that we'll be notified if anything we care
// about changes
var rootPath = ProjectResolver.ResolveRootDirectory(projectPath);
AddWatcher(rootPath);
}
}
public void ResolveEmbeddedResources()
{
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var testProjectFolder = Path.Combine(rootDir, "misc", "ResourcesTestProjects", "testproject");
Project project;
bool projectFound = Project.TryGetProject(testProjectFolder, out project);
Assert.True(projectFound);
var resolver = new EmbeddedResourceProvider();
var embeddedResource = resolver.GetResources(project);
Assert.Equal("testproject.owntext.txt", embeddedResource[0].Name);
Assert.Equal("testproject.subfolder.nestedtext.txt", embeddedResource[1].Name);
Assert.Equal("testproject.OtherText.txt", embeddedResource[2].Name);
}
public bool ExecuteCommand()
{
var sw = new Stopwatch();
sw.Start();
var restoreDirectory = RestoreDirectory ?? Directory.GetCurrentDirectory();
var projectJsonFiles = Directory.GetFiles(restoreDirectory, "project.json", SearchOption.AllDirectories);
var rootDirectory = ProjectResolver.ResolveRootDirectory(restoreDirectory);
ReadSettings(rootDirectory);
string packagesDirectory = PackageFolder;
if (string.IsNullOrEmpty(PackageFolder))
{
packagesDirectory = NuGetDependencyResolver.ResolveRepositoryPath(rootDirectory);
}
var packagesFolderFileSystem = CreateFileSystem(packagesDirectory);
var pathResolver = new DefaultPackagePathResolver(packagesFolderFileSystem, useSideBySidePaths: true);
var localRepository = new LocalPackageRepository(pathResolver, packagesFolderFileSystem);
int restoreCount = 0;
int successCount = 0;
foreach (var projectJsonPath in projectJsonFiles)
{
restoreCount += 1;
var success = RestoreForProject(localRepository, projectJsonPath, rootDirectory, packagesDirectory).Result;
if (success)
{
successCount += 1;
}
}
if (restoreCount > 1)
{
Reports.Information.WriteLine(string.Format("Total time {0}ms", sw.ElapsedMilliseconds));
}
return(restoreCount == successCount);
}
private static void WriteLevel(ProjectResolver resolver, Level level, string levelPath)
{
using (Stream stream = resolver.OutputStream(levelPath)) {
XmlWriterSettings settings = new XmlWriterSettings()
{
CloseOutput = true,
Indent = true,
};
XmlWriter writer = XmlTextWriter.Create(stream, settings);
LevelX proxy = Level.ToXProxy(level);
XmlSerializer serializer = new XmlSerializer(typeof(LevelX));
serializer.Serialize(writer, proxy);
writer.Close();
}
}
private static string ResolvePackagesDirectory(string projectDir)
{
var rootDir = ProjectResolver.ResolveRootDirectory(projectDir);
var settings = SettingsUtils.ReadSettings(
solutionDir: rootDir,
nugetConfigFile: null,
fileSystem: new PhysicalFileSystem(projectDir),
machineWideSettings: new CommandLineMachineWideSettings());
var packagesDir = settings.GetRepositoryPath();
// If 'repositoryPath' is not specified in NuGet.config, use {SolutionRoot}/packages as default
if (string.IsNullOrEmpty(packagesDir))
{
packagesDir = Path.Combine(rootDir, "packages");
}
return(Path.GetFullPath(packagesDir));
}
public void ProjectResolverThrowsWhenResolvingAmbiguousName()
{
const string ambiguousName = "ProjectA";
var solutionStructure = @"{
'global.json': '',
'src1': {
'ProjectA': {
'project.json': '{}'
}
},
'src2': {
'ProjectA': {
'project.json': '{}'
}
}
}";
using (var solutionPath = new DisposableDir())
{
DirTree.CreateFromJson(solutionStructure)
.WithFileContents("global.json", @"{
""projects"": [""src1"", ""src2""]
}")
.WriteTo(solutionPath);
var src1ProjectPath = Path.Combine(solutionPath, "src1", ambiguousName);
var src2ProjectPath = Path.Combine(solutionPath, "src2", ambiguousName);
var expectedMessage = $@"The project name '{ambiguousName}' is ambiguous between the following projects:
{src1ProjectPath}
{src2ProjectPath}";
Runtime.Project project = null;
var resolver1 = new ProjectResolver(src1ProjectPath);
var exception = Assert.Throws <InvalidOperationException>(() => resolver1.TryResolveProject(ambiguousName, out project));
Assert.Contains(expectedMessage, exception.Message);
Assert.Null(project);
var resolver2 = new ProjectResolver(src2ProjectPath);
exception = Assert.Throws <InvalidOperationException>(() => resolver2.TryResolveProject(ambiguousName, out project));
Assert.Contains(expectedMessage, exception.Message);
Assert.Null(project);
}
}
public void ProjectResolverThrowsWhenResolvingAmbiguousName()
{
const string ambiguousName = "ProjectA";
var solutionStructure = @"{
'global.json': '',
'src1': {
'ProjectA': {
'project.json': '{}'
}
},
'src2': {
'ProjectA': {
'project.json': '{}'
}
}
}";
using (var solutionPath = new DisposableDir())
{
DirTree.CreateFromJson(solutionStructure)
.WithFileContents("global.json", @"{
""projects"": [""src1"", ""src2""]
}")
.WriteTo(solutionPath);
var src1ProjectPath = Path.Combine(solutionPath, "src1", ambiguousName);
var src2ProjectPath = Path.Combine(solutionPath, "src2", ambiguousName);
var expectedMessage = $@"The project name '{ambiguousName}' is ambiguous between the following projects:
{src1ProjectPath}
{src2ProjectPath}";
Runtime.Project project = null;
var resolver1 = new ProjectResolver(src1ProjectPath);
var exception = Assert.Throws<InvalidOperationException>(() => resolver1.TryResolveProject(ambiguousName, out project));
Assert.Contains(expectedMessage, exception.Message);
Assert.Null(project);
var resolver2 = new ProjectResolver(src2ProjectPath);
exception = Assert.Throws<InvalidOperationException>(() => resolver2.TryResolveProject(ambiguousName, out project));
Assert.Contains(expectedMessage, exception.Message);
Assert.Null(project);
}
}
public override void Get(ProjectConfig target, string targetDir)
{
if (Directory.Exists(targetDir))
{
Directory.Delete(targetDir, true);
}
string dataPath = GetTargetDataUri(target);
ZipFile.ExtractToDirectory(dataPath, targetDir);
foreach (ProjectDependency targetDependency in target.Dependencies)
{
Get(
ProjectResolver.Resolve(this, targetDependency),
Path.Combine(targetDir, targetDependency.ProjectName)
);
}
}
public ModuleLoaderContext(IServiceProvider serviceProvider,
string projectDirectory)
{
ProjectDirectory = projectDirectory;
RootDirectory = Microsoft.Dnx.Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory);
// A new project resolver is required. you cannot reuse the one from the
// parent service provider as that will be for the parent context.
ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(new FrameworkReferenceResolver());
// Need to pass through package directory incase you download a package from the gallary, this needs to know about it
var nuGetDependencyProvider = new NuGetDependencyResolver(new PackageRepository(
NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory)));
var gacDependencyResolver = new GacDependencyResolver();
var projectDepencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
var projectLockJsonPath = Path.Combine(ProjectDirectory, LockFileFormat.LockFileName);
if (File.Exists(projectLockJsonPath)) {
var lockFileFormat = new LockFileFormat();
var lockFile = lockFileFormat.Read(projectLockJsonPath);
nuGetDependencyProvider.ApplyLockFile(lockFile);
}
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
projectDepencyProvider,
nuGetDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
LibraryExportProvider = new CompositeLibraryExportProvider(new ILibraryExportProvider[] {
new ModuleProjectLibraryExportProvider(
ProjectResolver, serviceProvider),
referenceAssemblyDependencyResolver,
gacDependencyResolver,
nuGetDependencyProvider
});
}
public void BuildPackageAndCheckServiceability(string projectName, bool expectedServiceability)
{
var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var projectDir = Path.Combine(rootDir, "misc", "ServicingTestProjects", projectName);
const string configuration = "Debug";
using (var runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor: "clr", os: "win", architecture: "x86"))
using (var tempDir = new DisposableDir())
{
var buildOutpuDir = Path.Combine(tempDir, "output");
DnuTestUtils.ExecDnu(
runtimeHomeDir,
"pack",
$"{projectDir} --out {buildOutpuDir} --configuration {configuration}");
var assemblyPath = Path.Combine(buildOutpuDir, configuration, "dnx451", $"{projectName}.dll");
Assert.Equal(expectedServiceability, LockFileUtils.IsAssemblyServiceable(assemblyPath));
}
}
public static DisposableDir PrepareTemporarySamplesFolder(string runtimeHomeDir)
{
var tempDir = new DisposableDir();
TestUtils.CopyFolder(TestUtils.GetSamplesFolder(), tempDir);
// Make sure sample projects depend on runtime components from newly built dnx
var currentDnxSolutionRootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
var currentDnxSolutionSrcPath = Path.Combine(currentDnxSolutionRootDir, "src").Replace("\\", "\\\\");
var samplesGlobalJson = new JObject();
samplesGlobalJson["projects"] = new JArray(new[] { currentDnxSolutionSrcPath });
File.WriteAllText(Path.Combine(tempDir, GlobalSettings.GlobalFileName), samplesGlobalJson.ToString());
// Make sure package restore can be successful
const string nugetConfigName = "NuGet.Config";
File.Copy(Path.Combine(currentDnxSolutionRootDir, nugetConfigName), Path.Combine(tempDir, nugetConfigName));
// Use the newly built runtime to generate lock files for samples
string stdOut, stdErr;
int exitCode;
foreach (var projectDir in Directory.EnumerateDirectories(tempDir))
{
exitCode = DnuTestUtils.ExecDnu(
runtimeHomeDir,
subcommand: "restore",
arguments: projectDir,
stdOut: out stdOut,
stdErr: out stdErr);
if (exitCode != 0)
{
Console.WriteLine(stdOut);
Console.WriteLine(stdErr);
}
}
return(tempDir);
}
public override void Run(IEnumerable <string> args)
{
string[] a = args.ToArray();
ArgumentSyntaxParser.Parse(a, Logger.s_Settings);
ProjectResolver.Initialize();
CommonFiles.GenerateCommonFiles();
string root = a.Length != 0
? Path.GetFullPath(a[0])
: Directory.GetCurrentDirectory();
string src = Path.Combine(root, "project.json");
Logger.LogMessage(LoggerSystems.Console, "File: {0}", src);
ProjectConfig.AddRunner(new BuildJobBuild());
ProjectConfig.AddRunner(new BuildJobClean());
ProjectConfig.AddRunner(new BuildJobPublish());
ProjectConfig.AddRunner(new BuildJobRestore());
ProjectConfig.AddRunner(new BuildJobExternalBuild());
ProjectConfig.AddRunner(new BuildJobCombinedJobs());
ProjectConfig.AddRunner(new BuildJobMoveContent());
ProjectConfig.AddRunner(new BuildJobCopyContent());
ProjectConfig.AddRunner(new BuildJobRunJob());
ProjectConfig.AddRunner(new BuildJobGetDependency());
ProjectConfig.AddRunner(new BuildJobAddOrigin());
ProjectConfig.AddRunner(new BuildJobRemoveOrigin());
ProjectConfig.AddRunner(new BuildJobMergedJobs());
ProjectConfig.AddRunner(new BuildJobMakeHeader());
ProjectConfig config = ProjectConfig.Load(src);
string target = config.DefaultTarget;
if (a.Length > 1)
{
target = a[1];
}
config.RunTarget(root, target);
}
public static void Initialize(ApplicationHostContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
context.ProjectDirectory = context.Project?.ProjectDirectory ?? context.ProjectDirectory;
context.RootDirectory = context.RootDirectory ?? ProjectResolver.ResolveRootDirectory(context.ProjectDirectory);
var projectResolver = new ProjectResolver(context.ProjectDirectory, context.RootDirectory);
var frameworkReferenceResolver = context.FrameworkResolver ?? new FrameworkReferenceResolver();
context.PackagesDirectory = context.PackagesDirectory ?? PackageDependencyProvider.ResolveRepositoryPath(context.RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(frameworkReferenceResolver);
var gacDependencyResolver = new GacDependencyResolver();
var projectDependencyProvider = new ProjectReferenceDependencyProvider(projectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
IList<IDependencyProvider> dependencyProviders = null;
LockFileLookup lockFileLookup = null;
if (context.Project == null)
{
Project project;
if (Project.TryGetProject(context.ProjectDirectory, out project))
{
context.Project = project;
}
else
{
throw new InvalidOperationException($"Unable to resolve project from {context.ProjectDirectory}");
}
}
var projectLockJsonPath = Path.Combine(context.ProjectDirectory, LockFileReader.LockFileName);
var lockFileExists = File.Exists(projectLockJsonPath);
var validLockFile = false;
var skipLockFileValidation = context.SkipLockfileValidation;
string lockFileValidationMessage = null;
if (lockFileExists)
{
var lockFileReader = new LockFileReader();
var lockFile = lockFileReader.Read(projectLockJsonPath);
validLockFile = lockFile.IsValidForProject(context.Project, out lockFileValidationMessage);
// When the only invalid part of a lock file is version number,
// we shouldn't skip lock file validation because we want to leave all dependencies unresolved, so that
// VS can be aware of this version mismatch error and automatically do restore
skipLockFileValidation = context.SkipLockfileValidation && (lockFile.Version == Constants.LockFileVersion);
if (validLockFile || skipLockFileValidation)
{
lockFileLookup = new LockFileLookup(lockFile);
var packageDependencyProvider = new PackageDependencyProvider(context.PackagesDirectory, lockFileLookup);
dependencyProviders = new IDependencyProvider[] {
projectDependencyProvider,
packageDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
};
}
}
if ((!validLockFile && !skipLockFileValidation) || !lockFileExists)
{
// We don't add the PackageDependencyProvider to DependencyWalker
// It will leave all NuGet packages unresolved and give error message asking users to run "dnu restore"
dependencyProviders = new IDependencyProvider[] {
projectDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
};
}
var libraries = DependencyWalker.Walk(dependencyProviders, context.Project.Name, context.Project.Version, context.TargetFramework);
context.LibraryManager = new LibraryManager(context.Project.ProjectFilePath, context.TargetFramework, libraries);
if (!validLockFile)
{
context.LibraryManager.AddGlobalDiagnostics(new DiagnosticMessage(
$"{lockFileValidationMessage}. Please run \"dnu restore\" to generate a new lock file.",
Path.Combine(context.Project.ProjectDirectory, LockFileReader.LockFileName),
DiagnosticMessageSeverity.Error));
}
if (!lockFileExists)
{
context.LibraryManager.AddGlobalDiagnostics(new DiagnosticMessage(
$"The expected lock file doesn't exist. Please run \"dnu restore\" to generate a new lock file.",
Path.Combine(context.Project.ProjectDirectory, LockFileReader.LockFileName),
DiagnosticMessageSeverity.Error));
}
// Clear all the temporary memory aggressively here if we don't care about reuse
// e.g. runtime scenarios
lockFileLookup?.Clear();
projectResolver.Clear();
}
private static void WriteLevel(ProjectResolver resolver, Level level, string levelPath)
{
using (Stream stream = resolver.OutputStream(levelPath)) {
XmlWriterSettings settings = new XmlWriterSettings() {
CloseOutput = true,
Indent = true,
};
XmlWriter writer = XmlTextWriter.Create(stream, settings);
LevelX proxy = Level.ToXProxy(level);
XmlSerializer serializer = new XmlSerializer(typeof(LevelX));
serializer.Serialize(writer, proxy);
writer.Close();
}
}
public void Save(Stream stream, ProjectResolver resolver)
{
List<ProjectX.LibraryX> libraries = new List<ProjectX.LibraryX>();
List<ProjectX.LevelX> levels = new List<ProjectX.LevelX>();
foreach (Library library in _libraryManager.Libraries) {
if (library.FileName == null)
library.FileName = FormatSafeFileName(library.Name + ".tlbx");
using (Stream libStream = resolver.OutputStream(library.FileName)) {
library.Save(libStream);
}
libraries.Add(new ProjectX.LibraryX() {
Include = library.FileName,
});
}
foreach (Level level in Levels) {
if (level.FileName == null)
level.FileName = FormatSafeFileName(level.Name + ".tlvx");
using (Stream levStream = resolver.OutputStream(level.FileName)) {
level.Save(levStream);
}
levels.Add(new ProjectX.LevelX() {
Include = level.FileName,
});
}
XmlWriterSettings settings = new XmlWriterSettings() {
CloseOutput = true,
Indent = true,
};
XmlWriter writer = XmlTextWriter.Create(stream, settings);
ProjectX proxy = new ProjectX() {
ItemGroups = new List<ProjectX.ItemGroupX>(),
PropertyGroup = new ProjectX.PropertyGroupX() {
ProjectGuid = Uid,
ProjectName = Name,
DefaultLibrary = _defaultLibraryUid,
Extra = (Extra != null && Extra.Count > 0) ? Extra.ToArray() : null,
},
};
proxy.ItemGroups.Add(new ProjectX.ItemGroupX() {
Libraries = libraries,
});
proxy.ItemGroups.Add(new ProjectX.ItemGroupX() {
Levels = levels,
});
XmlSerializer serializer = new XmlSerializer(typeof(ProjectX));
serializer.Serialize(writer, proxy);
writer.Close();
ResetModified();
}
public static Project FromXProxy(ProjectX proxy, ProjectResolver resolver, Project project)
{
if (proxy == null)
return null;
if (proxy.PropertyGroup != null) {
project.Uid = proxy.PropertyGroup.ProjectGuid;
project.Name = proxy.PropertyGroup.ProjectName;
project._defaultLibraryUid = proxy.PropertyGroup.DefaultLibrary;
project.Extra = new List<XmlElement>(proxy.PropertyGroup.Extra ?? new XmlElement[0]);
}
project._texturePool = new MetaTexturePool();
project._tilePools = new MetaTilePoolManager(project._texturePool);
project._objectPools = new MetaObjectPoolManager(project._texturePool);
project._tileBrushes = new MetaTileBrushManager();
foreach (var itemGroup in proxy.ItemGroups) {
if (itemGroup.Libraries != null) {
foreach (var libProxy in itemGroup.Libraries) {
using (Stream stream = resolver.InputStream(libProxy.Include)) {
project.AddLibrary(new Library(stream) {
FileName = libProxy.Include,
});
}
}
}
if (itemGroup.Levels != null) {
foreach (var level in itemGroup.Levels) {
using (Stream stream = resolver.InputStream(level.Include)) {
project.Levels.Add(new Level(stream, project) {
FileName = level.Include,
});
}
}
}
}
//project._tilePools.Pools.PropertyChanged += project.TilePoolsModifiedHandler;
//project._objectPools.Pools.PropertyChanged += project.HandleObjectPoolManagerPropertyChanged;
return project;
}
private void EmitProjectWrapper(XElement projectElement)
{
var projectFile = Path.GetFullPath(projectElement.Attribute("projectFile").Value);
// Name of the wrapper project is output assembly name, instead of .csproj file name
var outputAssemblyPath = GetOutputAssemblyPath(projectElement);
outputAssemblyPath = GetConfigAgnosticAssemblyPath(outputAssemblyPath);
var projectName = Path.GetFileNameWithoutExtension(outputAssemblyPath);
var projectDir = Path.GetDirectoryName(projectFile);
var rootDir = ResolveRootDirectory(projectDir);
var wrapRoot = Path.Combine(rootDir, WrapRootName);
string targetProjectJson;
if (InPlace)
{
targetProjectJson = Path.Combine(projectDir, Runtime.Project.ProjectFileName);
}
else
{
var projectResolver = new ProjectResolver(projectDir, rootDir);
targetProjectJson = LocateExistingProject(projectResolver, projectName);
if (string.IsNullOrEmpty(targetProjectJson))
{
AddWrapFolderToGlobalJson(rootDir);
targetProjectJson = Path.Combine(wrapRoot, projectName, Runtime.Project.ProjectFileName);
}
}
var targetFramework = GetTargetFramework(projectElement);
Reports.Information.WriteLine("Wrapping project '{0}' for '{1}'", projectName, targetFramework);
Reports.Information.WriteLine(" Source {0}", projectFile.Bold());
Reports.Information.WriteLine(" Target {0}", targetProjectJson.Bold());
var projectJson = LoadOrCreateProjectJson(targetProjectJson);
var relativeCsProjectPath = PathUtility.GetRelativePath(targetProjectJson, projectFile, PathSeparator);
AddWrappedProjectPath(projectJson, relativeCsProjectPath, targetFramework);
// Add 'assembly' and 'pdb' to 'bin' section of the target framework
var relativeAssemblyPath = PathUtility.GetRelativePath(targetProjectJson, outputAssemblyPath, PathSeparator);
var relativePdbPath = Path.ChangeExtension(relativeAssemblyPath, ".pdb");
Reports.Information.WriteLine(" Adding bin paths for '{0}'", targetFramework);
Reports.Information.WriteLine(" Assembly: {0}", relativeAssemblyPath.Bold());
Reports.Information.WriteLine(" Pdb: {0}", relativePdbPath.Bold());
AddFrameworkBinPaths(projectJson, targetFramework, relativeAssemblyPath, relativePdbPath);
var nugetPackages = ResolveNuGetPackages(projectDir);
var nugetPackagePaths = nugetPackages.Select(x => x.Path);
// Add nuget dependency to 'dependencies' section of the target framework
foreach (var package in nugetPackages)
{
Reports.Information.WriteLine(" Adding package dependency '{0}.{1}'",
package.Identity, package.Version);
AddNuGetDependency(projectJson, package, targetFramework);
}
// Add dependency projects to 'dependencies' section of the target framework
foreach (var itemElement in GetItemsByType(projectElement, type: "ProjectReference"))
{
var referenceProjectName = GetMetadataValue(itemElement, "Name");
var outputName = GetReferenceProjectOutputName(projectElement, referenceProjectName);
Reports.Information.WriteLine(" Adding project dependency '{0}.{1}'",
outputName, WrapperProjectVersion);
AddProjectDependency(projectJson, outputName, targetFramework);
}
// Create wrapper projects for assembly references
// and add wrapper projects as project references
foreach (var itemElement in GetItemsByType(projectElement, type: "ReferencePath"))
{
if (IsAssemblyFromProjectReference(itemElement) ||
IsFrameworkAssembly(itemElement) ||
IsAssemblyFromNuGetPackage(itemElement, nugetPackagePaths))
{
continue;
}
// This assembly becomes a project reference
var assemblyPath = itemElement.Attribute("evaluated").Value;
var assemblyProjectName = Path.GetFileNameWithoutExtension(assemblyPath);
EmitAssemblyWrapper(wrapRoot, targetFramework, assemblyPath, isSubProcedure: true);
Reports.Information.WriteLine(" Adding project dependency '{0}.{1}'",
assemblyProjectName, WrapperProjectVersion);
AddProjectDependency(projectJson, assemblyProjectName, targetFramework);
AddWrapFolderToGlobalJson(rootDir);
}
PathUtility.EnsureParentDirectory(targetProjectJson);
File.WriteAllText(targetProjectJson, projectJson.ToString());
AddToGlobalJsonSources(rootDir, Path.GetDirectoryName(targetProjectJson));
Reports.Information.WriteLine();
}
public static Project FromXProxy(ProjectX proxy, ProjectResolver resolver)
{
if (proxy == null)
return null;
return FromXProxy(proxy, resolver, new Project());
}
