Livar
GitHub
commit
9f2bb66198
60 changed files with 5816 additions and 17 deletions
|
|
@ -115,6 +115,12 @@ Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "Microsoft.DotNet.ProjectMod
|
|||
EndProject
|
||||
Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "Microsoft.DotNet.ProjectModel.Loader.Tests", "test\Microsoft.DotNet.ProjectModel.Loader.Tests\Microsoft.DotNet.ProjectModel.Loader.Tests.xproj", "{5DF6C9DA-6909-4EC0-909E-6913580BB4A4}"
|
||||
EndProject
|
||||
Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "Microsoft.DotNet.Configurer", "src\Microsoft.DotNet.Configurer\Microsoft.DotNet.Configurer.xproj", "{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}"
|
||||
EndProject
|
||||
Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "Microsoft.DotNet.Configurer.UnitTests", "test\Microsoft.DotNet.Configurer.UnitTests\Microsoft.DotNet.Configurer.UnitTests.xproj", "{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}"
|
||||
EndProject
|
||||
Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "Microsoft.DotNet.Archive", "src\Microsoft.DotNet.Archive\Microsoft.DotNet.Archive.xproj", "{35B19F22-B8C0-4849-9C35-3F809B7588B8}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
Debug|Any CPU = Debug|Any CPU
|
||||
|
|
@ -847,6 +853,54 @@ Global
|
|||
{5DF6C9DA-6909-4EC0-909E-6913580BB4A4}.RelWithDebInfo|Any CPU.Build.0 = Release|Any CPU
|
||||
{5DF6C9DA-6909-4EC0-909E-6913580BB4A4}.RelWithDebInfo|x64.ActiveCfg = Release|Any CPU
|
||||
{5DF6C9DA-6909-4EC0-909E-6913580BB4A4}.RelWithDebInfo|x64.Build.0 = Release|Any CPU
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}.Debug|Any CPU.Build.0 = Debug|Any CPU
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}.Debug|x64.ActiveCfg = Debug|Any CPU
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}.Debug|x64.Build.0 = Debug|Any CPU
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}.MinSizeRel|Any CPU.ActiveCfg = Debug|Any CPU
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}.MinSizeRel|Any CPU.Build.0 = Debug|Any CPU
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}.MinSizeRel|x64.ActiveCfg = Debug|Any CPU
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}.MinSizeRel|x64.Build.0 = Debug|Any CPU
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}.Release|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}.Release|Any CPU.Build.0 = Release|Any CPU
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}.Release|x64.ActiveCfg = Release|Any CPU
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}.Release|x64.Build.0 = Release|Any CPU
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}.RelWithDebInfo|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}.RelWithDebInfo|Any CPU.Build.0 = Release|Any CPU
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}.RelWithDebInfo|x64.ActiveCfg = Release|Any CPU
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F}.RelWithDebInfo|x64.Build.0 = Release|Any CPU
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}.Debug|Any CPU.Build.0 = Debug|Any CPU
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}.Debug|x64.ActiveCfg = Debug|Any CPU
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}.Debug|x64.Build.0 = Debug|Any CPU
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}.MinSizeRel|Any CPU.ActiveCfg = Debug|Any CPU
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}.MinSizeRel|Any CPU.Build.0 = Debug|Any CPU
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}.MinSizeRel|x64.ActiveCfg = Debug|Any CPU
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}.MinSizeRel|x64.Build.0 = Debug|Any CPU
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}.Release|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}.Release|Any CPU.Build.0 = Release|Any CPU
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}.Release|x64.ActiveCfg = Release|Any CPU
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}.Release|x64.Build.0 = Release|Any CPU
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}.RelWithDebInfo|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}.RelWithDebInfo|Any CPU.Build.0 = Release|Any CPU
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}.RelWithDebInfo|x64.ActiveCfg = Release|Any CPU
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759}.RelWithDebInfo|x64.Build.0 = Release|Any CPU
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8}.Debug|Any CPU.Build.0 = Debug|Any CPU
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8}.Debug|x64.ActiveCfg = Debug|Any CPU
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8}.Debug|x64.Build.0 = Debug|Any CPU
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8}.MinSizeRel|Any CPU.ActiveCfg = Debug|Any CPU
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8}.MinSizeRel|Any CPU.Build.0 = Debug|Any CPU
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8}.MinSizeRel|x64.ActiveCfg = Debug|Any CPU
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8}.MinSizeRel|x64.Build.0 = Debug|Any CPU
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8}.Release|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8}.Release|Any CPU.Build.0 = Release|Any CPU
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8}.Release|x64.ActiveCfg = Release|Any CPU
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8}.Release|x64.Build.0 = Release|Any CPU
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8}.RelWithDebInfo|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8}.RelWithDebInfo|Any CPU.Build.0 = Release|Any CPU
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8}.RelWithDebInfo|x64.ActiveCfg = Release|Any CPU
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8}.RelWithDebInfo|x64.Build.0 = Release|Any CPU
|
||||
EndGlobalSection
|
||||
GlobalSection(SolutionProperties) = preSolution
|
||||
HideSolutionNode = FALSE
|
||||
|
|
@ -902,5 +956,8 @@ Global
|
|||
{1DBB7542-0345-4F4B-A84B-3B00B185D416} = {88278B81-7649-45DC-8A6A-D3A645C5AFC3}
|
||||
{1C599FFD-FB52-4279-A8E5-465D3EC499E1} = {ED2FE3E2-F7E7-4389-8231-B65123F2076F}
|
||||
{5DF6C9DA-6909-4EC0-909E-6913580BB4A4} = {17735A9D-BFD9-4585-A7CB-3208CA6EA8A7}
|
||||
{E5ED47EF-BF25-4DA9-A7FE-290C642CBF0F} = {ED2FE3E2-F7E7-4389-8231-B65123F2076F}
|
||||
{4C3B06D5-B6D5-4E5B-A44F-3EBE52A1C759} = {17735A9D-BFD9-4585-A7CB-3208CA6EA8A7}
|
||||
{35B19F22-B8C0-4849-9C35-3F809B7588B8} = {ED2FE3E2-F7E7-4389-8231-B65123F2076F}
|
||||
EndGlobalSection
|
||||
EndGlobal
|
||||
|
|
|
|||
|
|
@ -109,7 +109,8 @@ namespace Microsoft.DotNet.Cli.Build
|
|||
|
||||
var result = CompileCliSdk(c,
|
||||
dotnet: DotNetCli.Stage1,
|
||||
rootOutputDirectory: Dirs.Stage2);
|
||||
rootOutputDirectory: Dirs.Stage2,
|
||||
generateNugetPackagesArchive: true);
|
||||
|
||||
if (!result.Success)
|
||||
{
|
||||
|
|
@ -157,7 +158,11 @@ namespace Microsoft.DotNet.Cli.Build
|
|||
FS.RmFilesInDirRecursive(directory, "*.pdb");
|
||||
}
|
||||
|
||||
private static BuildTargetResult CompileCliSdk(BuildTargetContext c, DotNetCli dotnet, string rootOutputDirectory)
|
||||
private static BuildTargetResult CompileCliSdk(
|
||||
BuildTargetContext c,
|
||||
DotNetCli dotnet,
|
||||
string rootOutputDirectory,
|
||||
bool generateNugetPackagesArchive = false)
|
||||
{
|
||||
var configuration = c.BuildContext.Get<string>("Configuration");
|
||||
var buildVersion = c.BuildContext.Get<BuildVersion>("BuildVersion");
|
||||
|
|
@ -236,7 +241,7 @@ namespace Microsoft.DotNet.Cli.Build
|
|||
var sharedFrameworkNameVersionPath = SharedFrameworkPublisher.GetSharedFrameworkPublishPath(
|
||||
rootOutputDirectory,
|
||||
sharedFrameworkNugetVersion);
|
||||
|
||||
|
||||
// Copy Host to SDK Directory
|
||||
File.Copy(
|
||||
Path.Combine(sharedFrameworkNameVersionPath, HostArtifactNames.DotnetHostBaseName),
|
||||
|
|
@ -250,7 +255,7 @@ namespace Microsoft.DotNet.Cli.Build
|
|||
Path.Combine(sharedFrameworkNameVersionPath, HostArtifactNames.HostPolicyBaseName),
|
||||
Path.Combine(sdkOutputDirectory, HostArtifactNames.HostPolicyBaseName),
|
||||
overwrite: true);
|
||||
|
||||
|
||||
CrossgenUtil.CrossgenDirectory(
|
||||
sharedFrameworkNameVersionPath,
|
||||
sdkOutputDirectory);
|
||||
|
|
@ -260,9 +265,77 @@ namespace Microsoft.DotNet.Cli.Build
|
|||
var content = $@"{c.BuildContext["CommitHash"]}{Environment.NewLine}{version}{Environment.NewLine}";
|
||||
File.WriteAllText(Path.Combine(sdkOutputDirectory, ".version"), content);
|
||||
|
||||
if(generateNugetPackagesArchive)
|
||||
{
|
||||
GenerateNuGetPackagesArchive(c, dotnet, sdkOutputDirectory);
|
||||
}
|
||||
|
||||
return c.Success();
|
||||
}
|
||||
|
||||
private static void GenerateNuGetPackagesArchive(
|
||||
BuildTargetContext c,
|
||||
DotNetCli dotnet,
|
||||
string sdkOutputDirectory)
|
||||
{
|
||||
var nuGetPackagesArchiveProject = Path.Combine(Dirs.Intermediate, "NuGetPackagesArchiveProject");
|
||||
var nuGetPackagesArchiveFolder = Path.Combine(Dirs.Intermediate, "nuGetPackagesArchiveFolder");
|
||||
|
||||
RestoreNuGetPackagesArchive(dotnet, nuGetPackagesArchiveProject, nuGetPackagesArchiveFolder);
|
||||
|
||||
CompressNuGetPackagesArchive(c, dotnet, nuGetPackagesArchiveFolder, sdkOutputDirectory);
|
||||
}
|
||||
|
||||
private static void RestoreNuGetPackagesArchive(
|
||||
DotNetCli dotnet,
|
||||
string nuGetPackagesArchiveProject,
|
||||
string nuGetPackagesArchiveFolder)
|
||||
{
|
||||
Rmdir(nuGetPackagesArchiveProject);
|
||||
Mkdirp(nuGetPackagesArchiveProject);
|
||||
|
||||
Rmdir(nuGetPackagesArchiveFolder);
|
||||
Mkdirp(nuGetPackagesArchiveFolder);
|
||||
|
||||
dotnet.New()
|
||||
.WorkingDirectory(nuGetPackagesArchiveProject)
|
||||
.Execute()
|
||||
.EnsureSuccessful();
|
||||
|
||||
dotnet.Restore("--packages", nuGetPackagesArchiveFolder)
|
||||
.WorkingDirectory(nuGetPackagesArchiveProject)
|
||||
.Execute()
|
||||
.EnsureSuccessful();
|
||||
}
|
||||
|
||||
private static void CompressNuGetPackagesArchive(
|
||||
BuildTargetContext c,
|
||||
DotNetCli dotnet,
|
||||
string nuGetPackagesArchiveFolder,
|
||||
string sdkOutputDirectory)
|
||||
{
|
||||
var configuration = c.BuildContext.Get<string>("Configuration");
|
||||
var archiverExe = Path.Combine(Dirs.Output, "tools", $"Archiver{Constants.ExeSuffix}");
|
||||
var intermediateArchive = Path.Combine(Dirs.Intermediate, "nuGetPackagesArchive.lzma");
|
||||
var finalArchive = Path.Combine(sdkOutputDirectory, "nuGetPackagesArchive.lzma");
|
||||
|
||||
Rm(intermediateArchive);
|
||||
Rm($"{intermediateArchive}.zip");
|
||||
|
||||
c.Info("Publishing Archiver");
|
||||
dotnet.Publish("--output", Path.Combine(Dirs.Output, "tools"), "--configuration", configuration)
|
||||
.WorkingDirectory(Path.Combine(Dirs.RepoRoot, "tools", "Archiver"))
|
||||
.Execute()
|
||||
.EnsureSuccessful();
|
||||
|
||||
Cmd(archiverExe,
|
||||
"-a", intermediateArchive,
|
||||
nuGetPackagesArchiveFolder)
|
||||
.Execute();
|
||||
|
||||
File.Copy(intermediateArchive, finalArchive);
|
||||
}
|
||||
|
||||
private static void RemoveAssetFromDepsPackages(string depsFile, string sectionName, string assetPath)
|
||||
{
|
||||
JToken deps;
|
||||
|
|
|
|||
|
|
@ -41,6 +41,7 @@ namespace Microsoft.DotNet.Cli.Build
|
|||
"Microsoft.DotNet.ProjectModel.Tests",
|
||||
"Microsoft.DotNet.ProjectModel.Loader.Tests",
|
||||
"Microsoft.Extensions.DependencyModel.Tests",
|
||||
"Microsoft.DotNet.Configurer.UnitTests",
|
||||
"Performance"
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -38,6 +38,7 @@ namespace Microsoft.DotNet.Cli.Build
|
|||
public Command Pack(params string[] args) => Exec("pack", args);
|
||||
public Command Test(params string[] args) => Exec("test", args);
|
||||
public Command Publish(params string[] args) => Exec("publish", args);
|
||||
public Command New(params string[] args) => Exec("new", args);
|
||||
|
||||
public string GetRuntimeId()
|
||||
{
|
||||
|
|
|
|||
107
src/Microsoft.DotNet.Archive/CompressionUtility.cs
Normal file
107
src/Microsoft.DotNet.Archive/CompressionUtility.cs
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using SevenZip;
|
||||
using System;
|
||||
using System.IO;
|
||||
|
||||
namespace Microsoft.DotNet.Archive
|
||||
{
|
||||
internal static class CompressionUtility
|
||||
{
|
||||
enum MeasureBy
|
||||
{
|
||||
Input,
|
||||
Output
|
||||
}
|
||||
|
||||
private class LzmaProgress : ICodeProgress
|
||||
{
|
||||
private IProgress<ProgressReport> progress;
|
||||
private long totalSize;
|
||||
private string phase;
|
||||
private MeasureBy measureBy;
|
||||
|
||||
public LzmaProgress(IProgress<ProgressReport> progress, string phase, long totalSize, MeasureBy measureBy)
|
||||
{
|
||||
this.progress = progress;
|
||||
this.totalSize = totalSize;
|
||||
this.phase = phase;
|
||||
this.measureBy = measureBy;
|
||||
}
|
||||
|
||||
public void SetProgress(long inSize, long outSize)
|
||||
{
|
||||
progress.Report(phase, measureBy == MeasureBy.Input ? inSize : outSize, totalSize);
|
||||
}
|
||||
}
|
||||
|
||||
public static void Compress(Stream inStream, Stream outStream, IProgress<ProgressReport> progress)
|
||||
{
|
||||
SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
|
||||
|
||||
CoderPropID[] propIDs =
|
||||
{
|
||||
CoderPropID.DictionarySize,
|
||||
CoderPropID.PosStateBits,
|
||||
CoderPropID.LitContextBits,
|
||||
CoderPropID.LitPosBits,
|
||||
CoderPropID.Algorithm,
|
||||
CoderPropID.NumFastBytes,
|
||||
CoderPropID.MatchFinder,
|
||||
CoderPropID.EndMarker
|
||||
};
|
||||
object[] properties =
|
||||
{
|
||||
(Int32)(1 << 26),
|
||||
(Int32)(1),
|
||||
(Int32)(8),
|
||||
(Int32)(0),
|
||||
(Int32)(2),
|
||||
(Int32)(96),
|
||||
"bt4",
|
||||
false
|
||||
};
|
||||
|
||||
encoder.SetCoderProperties(propIDs, properties);
|
||||
encoder.WriteCoderProperties(outStream);
|
||||
|
||||
Int64 inSize = inStream.Length;
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
outStream.WriteByte((Byte)(inSize >> (8 * i)));
|
||||
}
|
||||
|
||||
var lzmaProgress = new LzmaProgress(progress, "Compressing", inSize, MeasureBy.Input);
|
||||
lzmaProgress.SetProgress(0, 0);
|
||||
encoder.Code(inStream, outStream, -1, -1, lzmaProgress);
|
||||
lzmaProgress.SetProgress(inSize, outStream.Length);
|
||||
}
|
||||
|
||||
public static void Decompress(Stream inStream, Stream outStream, IProgress<ProgressReport> progress)
|
||||
{
|
||||
byte[] properties = new byte[5];
|
||||
|
||||
if (inStream.Read(properties, 0, 5) != 5)
|
||||
throw (new Exception("input .lzma is too short"));
|
||||
|
||||
SevenZip.Compression.LZMA.Decoder decoder = new SevenZip.Compression.LZMA.Decoder();
|
||||
decoder.SetDecoderProperties(properties);
|
||||
|
||||
long outSize = 0;
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
int v = inStream.ReadByte();
|
||||
if (v < 0)
|
||||
throw (new Exception("Can't Read 1"));
|
||||
outSize |= ((long)(byte)v) << (8 * i);
|
||||
}
|
||||
|
||||
long compressedSize = inStream.Length - inStream.Position;
|
||||
var lzmaProgress = new LzmaProgress(progress, "Decompressing", outSize, MeasureBy.Output);
|
||||
lzmaProgress.SetProgress(0, 0);
|
||||
decoder.Code(inStream, outStream, compressedSize, outSize, lzmaProgress);
|
||||
lzmaProgress.SetProgress(inStream.Length, outSize);
|
||||
}
|
||||
}
|
||||
}
|
||||
52
src/Microsoft.DotNet.Archive/ConsoleProgressReport.cs
Normal file
52
src/Microsoft.DotNet.Archive/ConsoleProgressReport.cs
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System;
|
||||
using System.Diagnostics;
|
||||
|
||||
namespace Microsoft.DotNet.Archive
|
||||
{
|
||||
public class ConsoleProgressReport : IProgress<ProgressReport>
|
||||
{
|
||||
private string _currentPhase;
|
||||
private int _lastLineLength = 0;
|
||||
private double _lastProgress = -1;
|
||||
private Stopwatch _stopwatch;
|
||||
private object _stateLock = new object();
|
||||
|
||||
public void Report(ProgressReport value)
|
||||
{
|
||||
long progress = (long)(100 * ((double)value.Ticks / value.Total));
|
||||
|
||||
if (progress == _lastProgress && value.Phase == _currentPhase)
|
||||
{
|
||||
return;
|
||||
}
|
||||
_lastProgress = progress;
|
||||
|
||||
lock (_stateLock)
|
||||
{
|
||||
string line = $"{value.Phase} {progress}%";
|
||||
if (value.Phase == _currentPhase)
|
||||
{
|
||||
Console.Write(new string('\b', _lastLineLength));
|
||||
|
||||
Console.Write(line);
|
||||
_lastLineLength = line.Length;
|
||||
|
||||
if (progress == 100)
|
||||
{
|
||||
Console.WriteLine($" {_stopwatch.ElapsedMilliseconds} ms");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Console.Write(line);
|
||||
_currentPhase = value.Phase;
|
||||
_lastLineLength = line.Length;
|
||||
_stopwatch = Stopwatch.StartNew();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
551
src/Microsoft.DotNet.Archive/IndexedArchive.cs
Normal file
551
src/Microsoft.DotNet.Archive/IndexedArchive.cs
Normal file
|
|
@ -0,0 +1,551 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.IO.Compression;
|
||||
using System.Linq;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
|
||||
namespace Microsoft.DotNet.Archive
|
||||
{
|
||||
public class IndexedArchive : IDisposable
|
||||
{
|
||||
private class DestinationFileInfo
|
||||
{
|
||||
public DestinationFileInfo(string destinationPath, string hash)
|
||||
{
|
||||
DestinationPath = destinationPath;
|
||||
Hash = hash;
|
||||
}
|
||||
|
||||
public string DestinationPath { get; }
|
||||
public string Hash { get; }
|
||||
}
|
||||
|
||||
private class ArchiveFileInfo
|
||||
{
|
||||
public ArchiveFileInfo(Stream stream, string archivePath, string hash)
|
||||
{
|
||||
Stream = stream;
|
||||
ArchivePath = archivePath;
|
||||
Hash = hash;
|
||||
}
|
||||
|
||||
public Stream Stream { get; set; }
|
||||
public string ArchivePath { get; }
|
||||
public string Hash { get; }
|
||||
public string FileName { get { return Path.GetFileNameWithoutExtension(ArchivePath); } }
|
||||
public string Extension { get { return Path.GetExtension(ArchivePath); } }
|
||||
|
||||
public long Size { get { return Stream.Length; } }
|
||||
|
||||
}
|
||||
|
||||
static string[] ZipExtensions = new[] { ".zip", ".nupkg" };
|
||||
static string IndexFileName = "index.txt";
|
||||
|
||||
// maps file hash to archve path
|
||||
// $ prefix indicates that the file is not in the archive and path is a hash
|
||||
private Dictionary<string, ArchiveFileInfo> _archiveFiles = new Dictionary<string, ArchiveFileInfo>();
|
||||
// maps file hash to external path
|
||||
private Dictionary<string, string> _externalFiles = new Dictionary<string, string>();
|
||||
// lists all extracted files & hashes
|
||||
private List<DestinationFileInfo> _destFiles = new List<DestinationFileInfo>();
|
||||
private bool _disposed = false;
|
||||
private ThreadLocal<SHA256> _sha = new ThreadLocal<SHA256>(() => SHA256.Create());
|
||||
|
||||
public IndexedArchive()
|
||||
{ }
|
||||
|
||||
private static Stream CreateTemporaryStream()
|
||||
{
|
||||
string temp = Path.GetTempPath();
|
||||
string tempFile = Path.Combine(temp, Guid.NewGuid().ToString());
|
||||
return File.Create(tempFile, 4096, FileOptions.DeleteOnClose);
|
||||
}
|
||||
|
||||
private static FileStream CreateTemporaryFileStream()
|
||||
{
|
||||
string temp = Path.GetTempPath();
|
||||
string tempFile = Path.Combine(temp, Guid.NewGuid().ToString());
|
||||
return new FileStream(tempFile, FileMode.Create, FileAccess.ReadWrite, FileShare.Read | FileShare.Delete, 4096, FileOptions.DeleteOnClose);
|
||||
}
|
||||
|
||||
public void Save(string archivePath, IProgress<ProgressReport> progress)
|
||||
{
|
||||
CheckDisposed();
|
||||
|
||||
using (var archiveStream = CreateTemporaryStream())
|
||||
{
|
||||
using (var archive = new ZipArchive(archiveStream, ZipArchiveMode.Create, true))
|
||||
{
|
||||
BuildArchive(archive, progress);
|
||||
} // close archive
|
||||
|
||||
archiveStream.Seek(0, SeekOrigin.Begin);
|
||||
|
||||
using (var lzmaStream = File.Create(archivePath))
|
||||
{
|
||||
CompressionUtility.Compress(archiveStream, lzmaStream, progress);
|
||||
}
|
||||
} // close archiveStream
|
||||
}
|
||||
|
||||
private void BuildArchive(ZipArchive archive, IProgress<ProgressReport> progress)
|
||||
{
|
||||
// write the file index
|
||||
var indexEntry = archive.CreateEntry(IndexFileName, CompressionLevel.NoCompression);
|
||||
|
||||
using (var stream = indexEntry.Open())
|
||||
using (var textWriter = new StreamWriter(stream))
|
||||
{
|
||||
foreach (var entry in _destFiles)
|
||||
{
|
||||
var archiveFile = _archiveFiles[entry.Hash];
|
||||
string archivePath = _archiveFiles[entry.Hash].ArchivePath;
|
||||
if (archiveFile.Stream == null)
|
||||
{
|
||||
archivePath = "$" + archivePath;
|
||||
}
|
||||
|
||||
textWriter.WriteLine($"{entry.DestinationPath}|{archivePath}");
|
||||
}
|
||||
}
|
||||
|
||||
// sort the files so that similar files are close together
|
||||
var filesToArchive = _archiveFiles.Values.ToList();
|
||||
filesToArchive.Sort((f1, f2) =>
|
||||
{
|
||||
// first sort by extension
|
||||
var comp = String.Compare(f1.Extension, f2.Extension, StringComparison.OrdinalIgnoreCase);
|
||||
|
||||
if (comp == 0)
|
||||
{
|
||||
// then sort by filename
|
||||
comp = String.Compare(f1.FileName, f2.FileName, StringComparison.OrdinalIgnoreCase);
|
||||
}
|
||||
|
||||
if (comp == 0)
|
||||
{
|
||||
// sort by file size (helps differentiate ref/lib/facade)
|
||||
comp = f1.Size.CompareTo(f2.Size);
|
||||
}
|
||||
|
||||
if (comp == 0)
|
||||
{
|
||||
// finally sort by full archive path so we have stable output
|
||||
comp = String.Compare(f1.ArchivePath, f2.ArchivePath, StringComparison.OrdinalIgnoreCase);
|
||||
}
|
||||
|
||||
return comp;
|
||||
});
|
||||
|
||||
int filesAdded = 0;
|
||||
// add all the files
|
||||
foreach (var fileToArchive in filesToArchive)
|
||||
{
|
||||
var entry = archive.CreateEntry(fileToArchive.ArchivePath, CompressionLevel.NoCompression);
|
||||
using (var entryStream = entry.Open())
|
||||
{
|
||||
fileToArchive.Stream.CopyTo(entryStream);
|
||||
fileToArchive.Stream.Dispose();
|
||||
fileToArchive.Stream = null;
|
||||
}
|
||||
|
||||
progress.Report("Archiving files", ++filesAdded, filesToArchive.Count);
|
||||
}
|
||||
}
|
||||
|
||||
private abstract class ExtractOperation
|
||||
{
|
||||
public ExtractOperation(string destinationPath)
|
||||
{
|
||||
DestinationPath = destinationPath;
|
||||
}
|
||||
|
||||
public string DestinationPath { get; }
|
||||
public virtual void DoOperation()
|
||||
{
|
||||
string directory = Path.GetDirectoryName(DestinationPath);
|
||||
|
||||
if (!Directory.Exists(directory))
|
||||
{
|
||||
Directory.CreateDirectory(directory);
|
||||
}
|
||||
|
||||
Execute();
|
||||
}
|
||||
protected abstract void Execute();
|
||||
}
|
||||
|
||||
private class CopyOperation : ExtractOperation
|
||||
{
|
||||
public CopyOperation(ExtractSource source, string destinationPath) : base(destinationPath)
|
||||
{
|
||||
Source = source;
|
||||
}
|
||||
public ExtractSource Source { get; }
|
||||
protected override void Execute()
|
||||
{
|
||||
if (Source.LocalPath != null)
|
||||
{
|
||||
File.Copy(Source.LocalPath, DestinationPath, true);
|
||||
}
|
||||
else
|
||||
{
|
||||
using (var destinationStream = File.Create(DestinationPath))
|
||||
{
|
||||
Source.CopyToStream(destinationStream);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class ZipOperation : ExtractOperation
|
||||
{
|
||||
public ZipOperation(string destinationPath) : base(destinationPath)
|
||||
{
|
||||
}
|
||||
|
||||
private List<Tuple<string, ExtractSource>> entries = new List<Tuple<string, ExtractSource>>();
|
||||
|
||||
public void AddEntry(string entryName, ExtractSource source)
|
||||
{
|
||||
entries.Add(Tuple.Create(entryName, source));
|
||||
}
|
||||
|
||||
protected override void Execute()
|
||||
{
|
||||
using (var archiveStream = File.Create(DestinationPath))
|
||||
using (var archive = new ZipArchive(archiveStream, ZipArchiveMode.Create))
|
||||
{
|
||||
foreach(var zipSource in entries)
|
||||
{
|
||||
var entry = archive.CreateEntry(zipSource.Item1, CompressionLevel.Optimal);
|
||||
using (var entryStream = entry.Open())
|
||||
{
|
||||
zipSource.Item2.CopyToStream(entryStream);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class ExtractSource
|
||||
{
|
||||
private string _entryName;
|
||||
private string _localPath;
|
||||
private ThreadLocalZipArchive _archive;
|
||||
|
||||
public ExtractSource(string sourceString, Dictionary<string, string> externalFiles, ThreadLocalZipArchive archive)
|
||||
{
|
||||
if (sourceString[0] == '$')
|
||||
{
|
||||
var externalHash = sourceString.Substring(1);
|
||||
if (!externalFiles.TryGetValue(externalHash, out _localPath))
|
||||
{
|
||||
throw new Exception("Could not find external file with hash {externalHash}.");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_entryName = sourceString;
|
||||
_archive = archive;
|
||||
}
|
||||
}
|
||||
|
||||
public string LocalPath { get { return _localPath; } }
|
||||
|
||||
public void CopyToStream(Stream destinationStream)
|
||||
{
|
||||
if (_localPath != null)
|
||||
{
|
||||
using (var sourceStream = File.OpenRead(_localPath))
|
||||
{
|
||||
sourceStream.CopyTo(destinationStream);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// we open the archive each time since ZipArchive is not thread safe and we want to be able
|
||||
// to extract from many threads
|
||||
//using (var archive = new ZipArchive(File.Open(_archivePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete)))
|
||||
using (var sourceStream = _archive.Archive.GetEntry(_entryName).Open())
|
||||
{
|
||||
sourceStream.CopyTo(destinationStream);
|
||||
|
||||
var destinationFileStream = destinationStream as FileStream;
|
||||
if (destinationFileStream != null)
|
||||
{
|
||||
// Set Local path so that the next copy operation using the same source will
|
||||
// do a copy instead of a write.
|
||||
_localPath = destinationFileStream.Name;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
private static char[] pipeSeperator = new[] { '|' };
|
||||
public void Extract(string compressedArchivePath, string outputDirectory, IProgress<ProgressReport> progress)
|
||||
{
|
||||
using (var archiveStream = CreateTemporaryFileStream())
|
||||
{
|
||||
// decompress the LZMA stream
|
||||
using (var lzmaStream = File.OpenRead(compressedArchivePath))
|
||||
{
|
||||
CompressionUtility.Decompress(lzmaStream, archiveStream, progress);
|
||||
}
|
||||
|
||||
var archivePath = ((FileStream)archiveStream).Name;
|
||||
|
||||
// reset the uncompressed stream
|
||||
archiveStream.Seek(0, SeekOrigin.Begin);
|
||||
|
||||
// read as a zip archive
|
||||
using (var archive = new ZipArchive(archiveStream, ZipArchiveMode.Read))
|
||||
using (var tlArchive = new ThreadLocalZipArchive(archivePath, archive))
|
||||
{
|
||||
List<ExtractOperation> extractOperations = new List<ExtractOperation>();
|
||||
Dictionary<string, ExtractSource> sourceCache = new Dictionary<string, ExtractSource>();
|
||||
|
||||
// process the index to determine all extraction operations
|
||||
var indexEntry = archive.GetEntry(IndexFileName);
|
||||
using (var indexReader = new StreamReader(indexEntry.Open()))
|
||||
{
|
||||
Dictionary<string, ZipOperation> zipOperations = new Dictionary<string, ZipOperation>(StringComparer.OrdinalIgnoreCase);
|
||||
for (var line = indexReader.ReadLine(); line != null; line = indexReader.ReadLine())
|
||||
{
|
||||
var lineParts = line.Split(pipeSeperator);
|
||||
if (lineParts.Length != 2)
|
||||
{
|
||||
throw new Exception("Unexpected index line format, too many '|'s.");
|
||||
}
|
||||
|
||||
string target = lineParts[0];
|
||||
string source = lineParts[1];
|
||||
|
||||
ExtractSource extractSource;
|
||||
if (!sourceCache.TryGetValue(source, out extractSource))
|
||||
{
|
||||
sourceCache[source] = extractSource = new ExtractSource(source, _externalFiles, tlArchive);
|
||||
}
|
||||
|
||||
var zipSeperatorIndex = target.IndexOf("::", StringComparison.OrdinalIgnoreCase);
|
||||
|
||||
if (zipSeperatorIndex != -1)
|
||||
{
|
||||
string zipRelativePath = target.Substring(0, zipSeperatorIndex);
|
||||
string zipEntryName = target.Substring(zipSeperatorIndex + 2);
|
||||
string destinationPath = Path.Combine(outputDirectory, zipRelativePath);
|
||||
|
||||
// operations on a zip file will be sequential
|
||||
ZipOperation currentZipOperation;
|
||||
|
||||
if (!zipOperations.TryGetValue(destinationPath, out currentZipOperation))
|
||||
{
|
||||
extractOperations.Add(currentZipOperation = new ZipOperation(destinationPath));
|
||||
zipOperations.Add(destinationPath, currentZipOperation);
|
||||
}
|
||||
currentZipOperation.AddEntry(zipEntryName, extractSource);
|
||||
}
|
||||
else
|
||||
{
|
||||
string destinationPath = Path.Combine(outputDirectory, target);
|
||||
extractOperations.Add(new CopyOperation(extractSource, destinationPath));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int opsExecuted = 0;
|
||||
// execute all operations
|
||||
//foreach(var extractOperation in extractOperations)
|
||||
extractOperations.AsParallel().ForAll(extractOperation =>
|
||||
{
|
||||
extractOperation.DoOperation();
|
||||
progress.Report("Expanding", Interlocked.Increment(ref opsExecuted), extractOperations.Count);
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void AddExternalDirectory(string externalDirectory)
|
||||
{
|
||||
CheckDisposed();
|
||||
foreach (var externalFile in Directory.EnumerateFiles(externalDirectory, "*", SearchOption.AllDirectories))
|
||||
{
|
||||
AddExternalFile(externalFile);
|
||||
}
|
||||
}
|
||||
|
||||
public void AddExternalFile(string externalFile)
|
||||
{
|
||||
CheckDisposed();
|
||||
using (var fs = File.OpenRead(externalFile))
|
||||
{
|
||||
string hash = GetHash(fs);
|
||||
// $ prefix indicates that the file is not in the archive and path is relative to an external directory
|
||||
_archiveFiles[hash] = new ArchiveFileInfo(null, "$" + hash , hash);
|
||||
_externalFiles[hash] = externalFile;
|
||||
}
|
||||
}
|
||||
public void AddDirectory(string sourceDirectory, IProgress<ProgressReport> progress, string destinationDirectory = null)
|
||||
{
|
||||
var sourceFiles = Directory.EnumerateFiles(sourceDirectory, "*", SearchOption.AllDirectories).ToArray();
|
||||
int filesAdded = 0;
|
||||
sourceFiles.AsParallel().ForAll(sourceFile =>
|
||||
{
|
||||
// path relative to the destination/extracted directory to write the file
|
||||
string destinationRelativePath = sourceFile.Substring(sourceDirectory.Length + 1);
|
||||
|
||||
if (destinationDirectory != null)
|
||||
{
|
||||
destinationRelativePath = Path.Combine(destinationDirectory, destinationRelativePath);
|
||||
}
|
||||
|
||||
string extension = Path.GetExtension(sourceFile);
|
||||
|
||||
if (ZipExtensions.Any(ze => ze.Equals(extension, StringComparison.OrdinalIgnoreCase)))
|
||||
{
|
||||
AddZip(sourceFile, destinationRelativePath);
|
||||
}
|
||||
else
|
||||
{
|
||||
AddFile(sourceFile, destinationRelativePath);
|
||||
}
|
||||
|
||||
progress.Report($"Adding {sourceDirectory}", Interlocked.Increment(ref filesAdded), sourceFiles.Length);
|
||||
});
|
||||
}
|
||||
|
||||
public void AddZip(string sourceZipFile, string destinationZipFile)
|
||||
{
|
||||
using (var sourceArchive = new ZipArchive(File.OpenRead(sourceZipFile), ZipArchiveMode.Read))
|
||||
{
|
||||
foreach(var entry in sourceArchive.Entries)
|
||||
{
|
||||
// we can dispose this stream, if AddStream uses it, it will make a copy.
|
||||
using (var stream = entry.Open())
|
||||
{
|
||||
string destinationPath = $"{destinationZipFile}::{entry.FullName}";
|
||||
AddStream(stream, destinationPath);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void AddFile(string sourceFilePath, string destinationPath)
|
||||
{
|
||||
// lifetime of this stream is managed by AddStream
|
||||
var stream = File.Open(sourceFilePath, FileMode.Open);
|
||||
AddStream(stream, destinationPath);
|
||||
}
|
||||
|
||||
public void AddStream(Stream stream, string destinationPath)
|
||||
{
|
||||
CheckDisposed();
|
||||
|
||||
string hash = null;
|
||||
|
||||
if (stream.CanSeek)
|
||||
{
|
||||
hash = GetHash(stream);
|
||||
}
|
||||
else
|
||||
{
|
||||
var copy = CreateTemporaryStream();
|
||||
stream.CopyTo(copy);
|
||||
copy.Seek(0, SeekOrigin.Begin);
|
||||
hash = GetHash(copy);
|
||||
stream.Dispose();
|
||||
stream = copy;
|
||||
}
|
||||
|
||||
lock (_archiveFiles)
|
||||
{
|
||||
_destFiles.Add(new DestinationFileInfo(destinationPath, hash));
|
||||
|
||||
// see if we already have this file in the archive/external
|
||||
ArchiveFileInfo existing = null;
|
||||
if (_archiveFiles.TryGetValue(hash, out existing))
|
||||
{
|
||||
// reduce memory pressure
|
||||
if (!(stream is MemoryStream) && (existing.Stream is MemoryStream))
|
||||
{
|
||||
// dispose memory stream
|
||||
existing.Stream.Dispose();
|
||||
stream.Seek(0, SeekOrigin.Begin);
|
||||
existing.Stream = stream;
|
||||
}
|
||||
else
|
||||
{
|
||||
// we already have a good stream, free this one.
|
||||
stream.Dispose();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// add a new entry;
|
||||
stream.Seek(0, SeekOrigin.Begin);
|
||||
var archivePath = Path.Combine(hash, Path.GetFileName(destinationPath));
|
||||
|
||||
_archiveFiles.Add(hash, new ArchiveFileInfo(stream, archivePath, hash));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public string GetHash(Stream stream)
|
||||
{
|
||||
var hashBytes = _sha.Value.ComputeHash(stream);
|
||||
|
||||
return GetHashString(hashBytes);
|
||||
}
|
||||
|
||||
private static string GetHashString(byte[] hashBytes)
|
||||
{
|
||||
StringBuilder builder = new StringBuilder(hashBytes.Length * 2);
|
||||
foreach (var b in hashBytes)
|
||||
{
|
||||
builder.AppendFormat("{0:x2}", b);
|
||||
}
|
||||
return builder.ToString();
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
if (!_disposed)
|
||||
{
|
||||
if (_archiveFiles != null)
|
||||
{
|
||||
foreach(var archiveFile in _archiveFiles.Values)
|
||||
{
|
||||
if (archiveFile.Stream != null)
|
||||
{
|
||||
archiveFile.Stream.Dispose();
|
||||
archiveFile.Stream = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (_sha != null)
|
||||
{
|
||||
_sha.Dispose();
|
||||
_sha = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void CheckDisposed()
|
||||
{
|
||||
if (_disposed)
|
||||
{
|
||||
throw new ObjectDisposedException(nameof(IndexedArchive));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
55
src/Microsoft.DotNet.Archive/LZMA/Common/CRC.cs
Normal file
55
src/Microsoft.DotNet.Archive/LZMA/Common/CRC.cs
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
// Common/CRC.cs
|
||||
|
||||
namespace SevenZip
|
||||
{
|
||||
class CRC
|
||||
{
|
||||
public static readonly uint[] Table;
|
||||
|
||||
static CRC()
|
||||
{
|
||||
Table = new uint[256];
|
||||
const uint kPoly = 0xEDB88320;
|
||||
for (uint i = 0; i < 256; i++)
|
||||
{
|
||||
uint r = i;
|
||||
for (int j = 0; j < 8; j++)
|
||||
if ((r & 1) != 0)
|
||||
r = (r >> 1) ^ kPoly;
|
||||
else
|
||||
r >>= 1;
|
||||
Table[i] = r;
|
||||
}
|
||||
}
|
||||
|
||||
uint _value = 0xFFFFFFFF;
|
||||
|
||||
public void Init() { _value = 0xFFFFFFFF; }
|
||||
|
||||
public void UpdateByte(byte b)
|
||||
{
|
||||
_value = Table[(((byte)(_value)) ^ b)] ^ (_value >> 8);
|
||||
}
|
||||
|
||||
public void Update(byte[] data, uint offset, uint size)
|
||||
{
|
||||
for (uint i = 0; i < size; i++)
|
||||
_value = Table[(((byte)(_value)) ^ data[offset + i])] ^ (_value >> 8);
|
||||
}
|
||||
|
||||
public uint GetDigest() { return _value ^ 0xFFFFFFFF; }
|
||||
|
||||
static uint CalculateDigest(byte[] data, uint offset, uint size)
|
||||
{
|
||||
CRC crc = new CRC();
|
||||
// crc.Init();
|
||||
crc.Update(data, offset, size);
|
||||
return crc.GetDigest();
|
||||
}
|
||||
|
||||
static bool VerifyDigest(uint digest, byte[] data, uint offset, uint size)
|
||||
{
|
||||
return (CalculateDigest(data, offset, size) == digest);
|
||||
}
|
||||
}
|
||||
}
|
||||
72
src/Microsoft.DotNet.Archive/LZMA/Common/InBuffer.cs
Normal file
72
src/Microsoft.DotNet.Archive/LZMA/Common/InBuffer.cs
Normal file
|
|
@ -0,0 +1,72 @@
|
|||
// InBuffer.cs
|
||||
|
||||
namespace SevenZip.Buffer
|
||||
{
|
||||
public class InBuffer
|
||||
{
|
||||
byte[] m_Buffer;
|
||||
uint m_Pos;
|
||||
uint m_Limit;
|
||||
uint m_BufferSize;
|
||||
System.IO.Stream m_Stream;
|
||||
bool m_StreamWasExhausted;
|
||||
ulong m_ProcessedSize;
|
||||
|
||||
public InBuffer(uint bufferSize)
|
||||
{
|
||||
m_Buffer = new byte[bufferSize];
|
||||
m_BufferSize = bufferSize;
|
||||
}
|
||||
|
||||
public void Init(System.IO.Stream stream)
|
||||
{
|
||||
m_Stream = stream;
|
||||
m_ProcessedSize = 0;
|
||||
m_Limit = 0;
|
||||
m_Pos = 0;
|
||||
m_StreamWasExhausted = false;
|
||||
}
|
||||
|
||||
public bool ReadBlock()
|
||||
{
|
||||
if (m_StreamWasExhausted)
|
||||
return false;
|
||||
m_ProcessedSize += m_Pos;
|
||||
int aNumProcessedBytes = m_Stream.Read(m_Buffer, 0, (int)m_BufferSize);
|
||||
m_Pos = 0;
|
||||
m_Limit = (uint)aNumProcessedBytes;
|
||||
m_StreamWasExhausted = (aNumProcessedBytes == 0);
|
||||
return (!m_StreamWasExhausted);
|
||||
}
|
||||
|
||||
|
||||
public void ReleaseStream()
|
||||
{
|
||||
// m_Stream.Close();
|
||||
m_Stream = null;
|
||||
}
|
||||
|
||||
public bool ReadByte(byte b) // check it
|
||||
{
|
||||
if (m_Pos >= m_Limit)
|
||||
if (!ReadBlock())
|
||||
return false;
|
||||
b = m_Buffer[m_Pos++];
|
||||
return true;
|
||||
}
|
||||
|
||||
public byte ReadByte()
|
||||
{
|
||||
// return (byte)m_Stream.ReadByte();
|
||||
if (m_Pos >= m_Limit)
|
||||
if (!ReadBlock())
|
||||
return 0xFF;
|
||||
return m_Buffer[m_Pos++];
|
||||
}
|
||||
|
||||
public ulong GetProcessedSize()
|
||||
{
|
||||
return m_ProcessedSize + m_Pos;
|
||||
}
|
||||
}
|
||||
}
|
||||
47
src/Microsoft.DotNet.Archive/LZMA/Common/OutBuffer.cs
Normal file
47
src/Microsoft.DotNet.Archive/LZMA/Common/OutBuffer.cs
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
// OutBuffer.cs
|
||||
|
||||
namespace SevenZip.Buffer
|
||||
{
|
||||
public class OutBuffer
|
||||
{
|
||||
byte[] m_Buffer;
|
||||
uint m_Pos;
|
||||
uint m_BufferSize;
|
||||
System.IO.Stream m_Stream;
|
||||
ulong m_ProcessedSize;
|
||||
|
||||
public OutBuffer(uint bufferSize)
|
||||
{
|
||||
m_Buffer = new byte[bufferSize];
|
||||
m_BufferSize = bufferSize;
|
||||
}
|
||||
|
||||
public void SetStream(System.IO.Stream stream) { m_Stream = stream; }
|
||||
public void FlushStream() { m_Stream.Flush(); }
|
||||
public void CloseStream() { m_Stream.Dispose(); }
|
||||
public void ReleaseStream() { m_Stream = null; }
|
||||
|
||||
public void Init()
|
||||
{
|
||||
m_ProcessedSize = 0;
|
||||
m_Pos = 0;
|
||||
}
|
||||
|
||||
public void WriteByte(byte b)
|
||||
{
|
||||
m_Buffer[m_Pos++] = b;
|
||||
if (m_Pos >= m_BufferSize)
|
||||
FlushData();
|
||||
}
|
||||
|
||||
public void FlushData()
|
||||
{
|
||||
if (m_Pos == 0)
|
||||
return;
|
||||
m_Stream.Write(m_Buffer, 0, (int)m_Pos);
|
||||
m_Pos = 0;
|
||||
}
|
||||
|
||||
public ulong GetProcessedSize() { return m_ProcessedSize + m_Pos; }
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
// IMatchFinder.cs
|
||||
|
||||
using System;
|
||||
|
||||
namespace SevenZip.Compression.LZ
|
||||
{
|
||||
interface IInWindowStream
|
||||
{
|
||||
void SetStream(System.IO.Stream inStream);
|
||||
void Init();
|
||||
void ReleaseStream();
|
||||
Byte GetIndexByte(Int32 index);
|
||||
UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit);
|
||||
UInt32 GetNumAvailableBytes();
|
||||
}
|
||||
|
||||
interface IMatchFinder : IInWindowStream
|
||||
{
|
||||
void Create(UInt32 historySize, UInt32 keepAddBufferBefore,
|
||||
UInt32 matchMaxLen, UInt32 keepAddBufferAfter);
|
||||
UInt32 GetMatches(UInt32[] distances);
|
||||
void Skip(UInt32 num);
|
||||
}
|
||||
}
|
||||
367
src/Microsoft.DotNet.Archive/LZMA/Compress/LZ/LzBinTree.cs
Normal file
367
src/Microsoft.DotNet.Archive/LZMA/Compress/LZ/LzBinTree.cs
Normal file
|
|
@ -0,0 +1,367 @@
|
|||
// LzBinTree.cs
|
||||
|
||||
using System;
|
||||
|
||||
namespace SevenZip.Compression.LZ
|
||||
{
|
||||
public class BinTree : InWindow, IMatchFinder
|
||||
{
|
||||
UInt32 _cyclicBufferPos;
|
||||
UInt32 _cyclicBufferSize = 0;
|
||||
UInt32 _matchMaxLen;
|
||||
|
||||
UInt32[] _son;
|
||||
UInt32[] _hash;
|
||||
|
||||
UInt32 _cutValue = 0xFF;
|
||||
UInt32 _hashMask;
|
||||
UInt32 _hashSizeSum = 0;
|
||||
|
||||
bool HASH_ARRAY = true;
|
||||
|
||||
const UInt32 kHash2Size = 1 << 10;
|
||||
const UInt32 kHash3Size = 1 << 16;
|
||||
const UInt32 kBT2HashSize = 1 << 16;
|
||||
const UInt32 kStartMaxLen = 1;
|
||||
const UInt32 kHash3Offset = kHash2Size;
|
||||
const UInt32 kEmptyHashValue = 0;
|
||||
const UInt32 kMaxValForNormalize = ((UInt32)1 << 31) - 1;
|
||||
|
||||
UInt32 kNumHashDirectBytes = 0;
|
||||
UInt32 kMinMatchCheck = 4;
|
||||
UInt32 kFixHashSize = kHash2Size + kHash3Size;
|
||||
|
||||
public void SetType(int numHashBytes)
|
||||
{
|
||||
HASH_ARRAY = (numHashBytes > 2);
|
||||
if (HASH_ARRAY)
|
||||
{
|
||||
kNumHashDirectBytes = 0;
|
||||
kMinMatchCheck = 4;
|
||||
kFixHashSize = kHash2Size + kHash3Size;
|
||||
}
|
||||
else
|
||||
{
|
||||
kNumHashDirectBytes = 2;
|
||||
kMinMatchCheck = 2 + 1;
|
||||
kFixHashSize = 0;
|
||||
}
|
||||
}
|
||||
|
||||
public new void SetStream(System.IO.Stream stream) { base.SetStream(stream); }
|
||||
public new void ReleaseStream() { base.ReleaseStream(); }
|
||||
|
||||
public new void Init()
|
||||
{
|
||||
base.Init();
|
||||
for (UInt32 i = 0; i < _hashSizeSum; i++)
|
||||
_hash[i] = kEmptyHashValue;
|
||||
_cyclicBufferPos = 0;
|
||||
ReduceOffsets(-1);
|
||||
}
|
||||
|
||||
public new void MovePos()
|
||||
{
|
||||
if (++_cyclicBufferPos >= _cyclicBufferSize)
|
||||
_cyclicBufferPos = 0;
|
||||
base.MovePos();
|
||||
if (_pos == kMaxValForNormalize)
|
||||
Normalize();
|
||||
}
|
||||
|
||||
public new Byte GetIndexByte(Int32 index) { return base.GetIndexByte(index); }
|
||||
|
||||
public new UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit)
|
||||
{ return base.GetMatchLen(index, distance, limit); }
|
||||
|
||||
public new UInt32 GetNumAvailableBytes() { return base.GetNumAvailableBytes(); }
|
||||
|
||||
public void Create(UInt32 historySize, UInt32 keepAddBufferBefore,
|
||||
UInt32 matchMaxLen, UInt32 keepAddBufferAfter)
|
||||
{
|
||||
if (historySize > kMaxValForNormalize - 256)
|
||||
throw new Exception();
|
||||
_cutValue = 16 + (matchMaxLen >> 1);
|
||||
|
||||
UInt32 windowReservSize = (historySize + keepAddBufferBefore +
|
||||
matchMaxLen + keepAddBufferAfter) / 2 + 256;
|
||||
|
||||
base.Create(historySize + keepAddBufferBefore, matchMaxLen + keepAddBufferAfter, windowReservSize);
|
||||
|
||||
_matchMaxLen = matchMaxLen;
|
||||
|
||||
UInt32 cyclicBufferSize = historySize + 1;
|
||||
if (_cyclicBufferSize != cyclicBufferSize)
|
||||
_son = new UInt32[(_cyclicBufferSize = cyclicBufferSize) * 2];
|
||||
|
||||
UInt32 hs = kBT2HashSize;
|
||||
|
||||
if (HASH_ARRAY)
|
||||
{
|
||||
hs = historySize - 1;
|
||||
hs |= (hs >> 1);
|
||||
hs |= (hs >> 2);
|
||||
hs |= (hs >> 4);
|
||||
hs |= (hs >> 8);
|
||||
hs >>= 1;
|
||||
hs |= 0xFFFF;
|
||||
if (hs > (1 << 24))
|
||||
hs >>= 1;
|
||||
_hashMask = hs;
|
||||
hs++;
|
||||
hs += kFixHashSize;
|
||||
}
|
||||
if (hs != _hashSizeSum)
|
||||
_hash = new UInt32[_hashSizeSum = hs];
|
||||
}
|
||||
|
||||
public UInt32 GetMatches(UInt32[] distances)
|
||||
{
|
||||
UInt32 lenLimit;
|
||||
if (_pos + _matchMaxLen <= _streamPos)
|
||||
lenLimit = _matchMaxLen;
|
||||
else
|
||||
{
|
||||
lenLimit = _streamPos - _pos;
|
||||
if (lenLimit < kMinMatchCheck)
|
||||
{
|
||||
MovePos();
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
UInt32 offset = 0;
|
||||
UInt32 matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;
|
||||
UInt32 cur = _bufferOffset + _pos;
|
||||
UInt32 maxLen = kStartMaxLen; // to avoid items for len < hashSize;
|
||||
UInt32 hashValue, hash2Value = 0, hash3Value = 0;
|
||||
|
||||
if (HASH_ARRAY)
|
||||
{
|
||||
UInt32 temp = CRC.Table[_bufferBase[cur]] ^ _bufferBase[cur + 1];
|
||||
hash2Value = temp & (kHash2Size - 1);
|
||||
temp ^= ((UInt32)(_bufferBase[cur + 2]) << 8);
|
||||
hash3Value = temp & (kHash3Size - 1);
|
||||
hashValue = (temp ^ (CRC.Table[_bufferBase[cur + 3]] << 5)) & _hashMask;
|
||||
}
|
||||
else
|
||||
hashValue = _bufferBase[cur] ^ ((UInt32)(_bufferBase[cur + 1]) << 8);
|
||||
|
||||
UInt32 curMatch = _hash[kFixHashSize + hashValue];
|
||||
if (HASH_ARRAY)
|
||||
{
|
||||
UInt32 curMatch2 = _hash[hash2Value];
|
||||
UInt32 curMatch3 = _hash[kHash3Offset + hash3Value];
|
||||
_hash[hash2Value] = _pos;
|
||||
_hash[kHash3Offset + hash3Value] = _pos;
|
||||
if (curMatch2 > matchMinPos)
|
||||
if (_bufferBase[_bufferOffset + curMatch2] == _bufferBase[cur])
|
||||
{
|
||||
distances[offset++] = maxLen = 2;
|
||||
distances[offset++] = _pos - curMatch2 - 1;
|
||||
}
|
||||
if (curMatch3 > matchMinPos)
|
||||
if (_bufferBase[_bufferOffset + curMatch3] == _bufferBase[cur])
|
||||
{
|
||||
if (curMatch3 == curMatch2)
|
||||
offset -= 2;
|
||||
distances[offset++] = maxLen = 3;
|
||||
distances[offset++] = _pos - curMatch3 - 1;
|
||||
curMatch2 = curMatch3;
|
||||
}
|
||||
if (offset != 0 && curMatch2 == curMatch)
|
||||
{
|
||||
offset -= 2;
|
||||
maxLen = kStartMaxLen;
|
||||
}
|
||||
}
|
||||
|
||||
_hash[kFixHashSize + hashValue] = _pos;
|
||||
|
||||
UInt32 ptr0 = (_cyclicBufferPos << 1) + 1;
|
||||
UInt32 ptr1 = (_cyclicBufferPos << 1);
|
||||
|
||||
UInt32 len0, len1;
|
||||
len0 = len1 = kNumHashDirectBytes;
|
||||
|
||||
if (kNumHashDirectBytes != 0)
|
||||
{
|
||||
if (curMatch > matchMinPos)
|
||||
{
|
||||
if (_bufferBase[_bufferOffset + curMatch + kNumHashDirectBytes] !=
|
||||
_bufferBase[cur + kNumHashDirectBytes])
|
||||
{
|
||||
distances[offset++] = maxLen = kNumHashDirectBytes;
|
||||
distances[offset++] = _pos - curMatch - 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
UInt32 count = _cutValue;
|
||||
|
||||
while(true)
|
||||
{
|
||||
if(curMatch <= matchMinPos || count-- == 0)
|
||||
{
|
||||
_son[ptr0] = _son[ptr1] = kEmptyHashValue;
|
||||
break;
|
||||
}
|
||||
UInt32 delta = _pos - curMatch;
|
||||
UInt32 cyclicPos = ((delta <= _cyclicBufferPos) ?
|
||||
(_cyclicBufferPos - delta) :
|
||||
(_cyclicBufferPos - delta + _cyclicBufferSize)) << 1;
|
||||
|
||||
UInt32 pby1 = _bufferOffset + curMatch;
|
||||
UInt32 len = Math.Min(len0, len1);
|
||||
if (_bufferBase[pby1 + len] == _bufferBase[cur + len])
|
||||
{
|
||||
while(++len != lenLimit)
|
||||
if (_bufferBase[pby1 + len] != _bufferBase[cur + len])
|
||||
break;
|
||||
if (maxLen < len)
|
||||
{
|
||||
distances[offset++] = maxLen = len;
|
||||
distances[offset++] = delta - 1;
|
||||
if (len == lenLimit)
|
||||
{
|
||||
_son[ptr1] = _son[cyclicPos];
|
||||
_son[ptr0] = _son[cyclicPos + 1];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (_bufferBase[pby1 + len] < _bufferBase[cur + len])
|
||||
{
|
||||
_son[ptr1] = curMatch;
|
||||
ptr1 = cyclicPos + 1;
|
||||
curMatch = _son[ptr1];
|
||||
len1 = len;
|
||||
}
|
||||
else
|
||||
{
|
||||
_son[ptr0] = curMatch;
|
||||
ptr0 = cyclicPos;
|
||||
curMatch = _son[ptr0];
|
||||
len0 = len;
|
||||
}
|
||||
}
|
||||
MovePos();
|
||||
return offset;
|
||||
}
|
||||
|
||||
public void Skip(UInt32 num)
|
||||
{
|
||||
do
|
||||
{
|
||||
UInt32 lenLimit;
|
||||
if (_pos + _matchMaxLen <= _streamPos)
|
||||
lenLimit = _matchMaxLen;
|
||||
else
|
||||
{
|
||||
lenLimit = _streamPos - _pos;
|
||||
if (lenLimit < kMinMatchCheck)
|
||||
{
|
||||
MovePos();
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
UInt32 matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;
|
||||
UInt32 cur = _bufferOffset + _pos;
|
||||
|
||||
UInt32 hashValue;
|
||||
|
||||
if (HASH_ARRAY)
|
||||
{
|
||||
UInt32 temp = CRC.Table[_bufferBase[cur]] ^ _bufferBase[cur + 1];
|
||||
UInt32 hash2Value = temp & (kHash2Size - 1);
|
||||
_hash[hash2Value] = _pos;
|
||||
temp ^= ((UInt32)(_bufferBase[cur + 2]) << 8);
|
||||
UInt32 hash3Value = temp & (kHash3Size - 1);
|
||||
_hash[kHash3Offset + hash3Value] = _pos;
|
||||
hashValue = (temp ^ (CRC.Table[_bufferBase[cur + 3]] << 5)) & _hashMask;
|
||||
}
|
||||
else
|
||||
hashValue = _bufferBase[cur] ^ ((UInt32)(_bufferBase[cur + 1]) << 8);
|
||||
|
||||
UInt32 curMatch = _hash[kFixHashSize + hashValue];
|
||||
_hash[kFixHashSize + hashValue] = _pos;
|
||||
|
||||
UInt32 ptr0 = (_cyclicBufferPos << 1) + 1;
|
||||
UInt32 ptr1 = (_cyclicBufferPos << 1);
|
||||
|
||||
UInt32 len0, len1;
|
||||
len0 = len1 = kNumHashDirectBytes;
|
||||
|
||||
UInt32 count = _cutValue;
|
||||
while (true)
|
||||
{
|
||||
if (curMatch <= matchMinPos || count-- == 0)
|
||||
{
|
||||
_son[ptr0] = _son[ptr1] = kEmptyHashValue;
|
||||
break;
|
||||
}
|
||||
|
||||
UInt32 delta = _pos - curMatch;
|
||||
UInt32 cyclicPos = ((delta <= _cyclicBufferPos) ?
|
||||
(_cyclicBufferPos - delta) :
|
||||
(_cyclicBufferPos - delta + _cyclicBufferSize)) << 1;
|
||||
|
||||
UInt32 pby1 = _bufferOffset + curMatch;
|
||||
UInt32 len = Math.Min(len0, len1);
|
||||
if (_bufferBase[pby1 + len] == _bufferBase[cur + len])
|
||||
{
|
||||
while (++len != lenLimit)
|
||||
if (_bufferBase[pby1 + len] != _bufferBase[cur + len])
|
||||
break;
|
||||
if (len == lenLimit)
|
||||
{
|
||||
_son[ptr1] = _son[cyclicPos];
|
||||
_son[ptr0] = _son[cyclicPos + 1];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (_bufferBase[pby1 + len] < _bufferBase[cur + len])
|
||||
{
|
||||
_son[ptr1] = curMatch;
|
||||
ptr1 = cyclicPos + 1;
|
||||
curMatch = _son[ptr1];
|
||||
len1 = len;
|
||||
}
|
||||
else
|
||||
{
|
||||
_son[ptr0] = curMatch;
|
||||
ptr0 = cyclicPos;
|
||||
curMatch = _son[ptr0];
|
||||
len0 = len;
|
||||
}
|
||||
}
|
||||
MovePos();
|
||||
}
|
||||
while (--num != 0);
|
||||
}
|
||||
|
||||
void NormalizeLinks(UInt32[] items, UInt32 numItems, UInt32 subValue)
|
||||
{
|
||||
for (UInt32 i = 0; i < numItems; i++)
|
||||
{
|
||||
UInt32 value = items[i];
|
||||
if (value <= subValue)
|
||||
value = kEmptyHashValue;
|
||||
else
|
||||
value -= subValue;
|
||||
items[i] = value;
|
||||
}
|
||||
}
|
||||
|
||||
void Normalize()
|
||||
{
|
||||
UInt32 subValue = _pos - _cyclicBufferSize;
|
||||
NormalizeLinks(_son, _cyclicBufferSize * 2, subValue);
|
||||
NormalizeLinks(_hash, _hashSizeSum, subValue);
|
||||
ReduceOffsets((Int32)subValue);
|
||||
}
|
||||
|
||||
public void SetCutValue(UInt32 cutValue) { _cutValue = cutValue; }
|
||||
}
|
||||
}
|
||||
132
src/Microsoft.DotNet.Archive/LZMA/Compress/LZ/LzInWindow.cs
Normal file
132
src/Microsoft.DotNet.Archive/LZMA/Compress/LZ/LzInWindow.cs
Normal file
|
|
@ -0,0 +1,132 @@
|
|||
// LzInWindow.cs
|
||||
|
||||
using System;
|
||||
|
||||
namespace SevenZip.Compression.LZ
|
||||
{
|
||||
public class InWindow
|
||||
{
|
||||
public Byte[] _bufferBase = null; // pointer to buffer with data
|
||||
System.IO.Stream _stream;
|
||||
UInt32 _posLimit; // offset (from _buffer) of first byte when new block reading must be done
|
||||
bool _streamEndWasReached; // if (true) then _streamPos shows real end of stream
|
||||
|
||||
UInt32 _pointerToLastSafePosition;
|
||||
|
||||
public UInt32 _bufferOffset;
|
||||
|
||||
public UInt32 _blockSize; // Size of Allocated memory block
|
||||
public UInt32 _pos; // offset (from _buffer) of curent byte
|
||||
UInt32 _keepSizeBefore; // how many BYTEs must be kept in buffer before _pos
|
||||
UInt32 _keepSizeAfter; // how many BYTEs must be kept buffer after _pos
|
||||
public UInt32 _streamPos; // offset (from _buffer) of first not read byte from Stream
|
||||
|
||||
public void MoveBlock()
|
||||
{
|
||||
UInt32 offset = (UInt32)(_bufferOffset) + _pos - _keepSizeBefore;
|
||||
// we need one additional byte, since MovePos moves on 1 byte.
|
||||
if (offset > 0)
|
||||
offset--;
|
||||
|
||||
UInt32 numBytes = (UInt32)(_bufferOffset) + _streamPos - offset;
|
||||
|
||||
// check negative offset ????
|
||||
for (UInt32 i = 0; i < numBytes; i++)
|
||||
_bufferBase[i] = _bufferBase[offset + i];
|
||||
_bufferOffset -= offset;
|
||||
}
|
||||
|
||||
public virtual void ReadBlock()
|
||||
{
|
||||
if (_streamEndWasReached)
|
||||
return;
|
||||
while (true)
|
||||
{
|
||||
int size = (int)((0 - _bufferOffset) + _blockSize - _streamPos);
|
||||
if (size == 0)
|
||||
return;
|
||||
int numReadBytes = _stream.Read(_bufferBase, (int)(_bufferOffset + _streamPos), size);
|
||||
if (numReadBytes == 0)
|
||||
{
|
||||
_posLimit = _streamPos;
|
||||
UInt32 pointerToPostion = _bufferOffset + _posLimit;
|
||||
if (pointerToPostion > _pointerToLastSafePosition)
|
||||
_posLimit = (UInt32)(_pointerToLastSafePosition - _bufferOffset);
|
||||
|
||||
_streamEndWasReached = true;
|
||||
return;
|
||||
}
|
||||
_streamPos += (UInt32)numReadBytes;
|
||||
if (_streamPos >= _pos + _keepSizeAfter)
|
||||
_posLimit = _streamPos - _keepSizeAfter;
|
||||
}
|
||||
}
|
||||
|
||||
void Free() { _bufferBase = null; }
|
||||
|
||||
public void Create(UInt32 keepSizeBefore, UInt32 keepSizeAfter, UInt32 keepSizeReserv)
|
||||
{
|
||||
_keepSizeBefore = keepSizeBefore;
|
||||
_keepSizeAfter = keepSizeAfter;
|
||||
UInt32 blockSize = keepSizeBefore + keepSizeAfter + keepSizeReserv;
|
||||
if (_bufferBase == null || _blockSize != blockSize)
|
||||
{
|
||||
Free();
|
||||
_blockSize = blockSize;
|
||||
_bufferBase = new Byte[_blockSize];
|
||||
}
|
||||
_pointerToLastSafePosition = _blockSize - keepSizeAfter;
|
||||
}
|
||||
|
||||
public void SetStream(System.IO.Stream stream) { _stream = stream; }
|
||||
public void ReleaseStream() { _stream = null; }
|
||||
|
||||
public void Init()
|
||||
{
|
||||
_bufferOffset = 0;
|
||||
_pos = 0;
|
||||
_streamPos = 0;
|
||||
_streamEndWasReached = false;
|
||||
ReadBlock();
|
||||
}
|
||||
|
||||
public void MovePos()
|
||||
{
|
||||
_pos++;
|
||||
if (_pos > _posLimit)
|
||||
{
|
||||
UInt32 pointerToPostion = _bufferOffset + _pos;
|
||||
if (pointerToPostion > _pointerToLastSafePosition)
|
||||
MoveBlock();
|
||||
ReadBlock();
|
||||
}
|
||||
}
|
||||
|
||||
public Byte GetIndexByte(Int32 index) { return _bufferBase[_bufferOffset + _pos + index]; }
|
||||
|
||||
// index + limit have not to exceed _keepSizeAfter;
|
||||
public UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit)
|
||||
{
|
||||
if (_streamEndWasReached)
|
||||
if ((_pos + index) + limit > _streamPos)
|
||||
limit = _streamPos - (UInt32)(_pos + index);
|
||||
distance++;
|
||||
// Byte *pby = _buffer + (size_t)_pos + index;
|
||||
UInt32 pby = _bufferOffset + _pos + (UInt32)index;
|
||||
|
||||
UInt32 i;
|
||||
for (i = 0; i < limit && _bufferBase[pby + i] == _bufferBase[pby + i - distance]; i++);
|
||||
return i;
|
||||
}
|
||||
|
||||
public UInt32 GetNumAvailableBytes() { return _streamPos - _pos; }
|
||||
|
||||
public void ReduceOffsets(Int32 subValue)
|
||||
{
|
||||
_bufferOffset += (UInt32)subValue;
|
||||
_posLimit -= (UInt32)subValue;
|
||||
_pos -= (UInt32)subValue;
|
||||
_streamPos -= (UInt32)subValue;
|
||||
}
|
||||
}
|
||||
}
|
||||
110
src/Microsoft.DotNet.Archive/LZMA/Compress/LZ/LzOutWindow.cs
Normal file
110
src/Microsoft.DotNet.Archive/LZMA/Compress/LZ/LzOutWindow.cs
Normal file
|
|
@ -0,0 +1,110 @@
|
|||
// LzOutWindow.cs
|
||||
|
||||
namespace SevenZip.Compression.LZ
|
||||
{
|
||||
public class OutWindow
|
||||
{
|
||||
byte[] _buffer = null;
|
||||
uint _pos;
|
||||
uint _windowSize = 0;
|
||||
uint _streamPos;
|
||||
System.IO.Stream _stream;
|
||||
|
||||
public uint TrainSize = 0;
|
||||
|
||||
public void Create(uint windowSize)
|
||||
{
|
||||
if (_windowSize != windowSize)
|
||||
{
|
||||
// System.GC.Collect();
|
||||
_buffer = new byte[windowSize];
|
||||
}
|
||||
_windowSize = windowSize;
|
||||
_pos = 0;
|
||||
_streamPos = 0;
|
||||
}
|
||||
|
||||
public void Init(System.IO.Stream stream, bool solid)
|
||||
{
|
||||
ReleaseStream();
|
||||
_stream = stream;
|
||||
if (!solid)
|
||||
{
|
||||
_streamPos = 0;
|
||||
_pos = 0;
|
||||
TrainSize = 0;
|
||||
}
|
||||
}
|
||||
|
||||
public bool Train(System.IO.Stream stream)
|
||||
{
|
||||
long len = stream.Length;
|
||||
uint size = (len < _windowSize) ? (uint)len : _windowSize;
|
||||
TrainSize = size;
|
||||
stream.Position = len - size;
|
||||
_streamPos = _pos = 0;
|
||||
while (size > 0)
|
||||
{
|
||||
uint curSize = _windowSize - _pos;
|
||||
if (size < curSize)
|
||||
curSize = size;
|
||||
int numReadBytes = stream.Read(_buffer, (int)_pos, (int)curSize);
|
||||
if (numReadBytes == 0)
|
||||
return false;
|
||||
size -= (uint)numReadBytes;
|
||||
_pos += (uint)numReadBytes;
|
||||
_streamPos += (uint)numReadBytes;
|
||||
if (_pos == _windowSize)
|
||||
_streamPos = _pos = 0;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public void ReleaseStream()
|
||||
{
|
||||
Flush();
|
||||
_stream = null;
|
||||
}
|
||||
|
||||
public void Flush()
|
||||
{
|
||||
uint size = _pos - _streamPos;
|
||||
if (size == 0)
|
||||
return;
|
||||
_stream.Write(_buffer, (int)_streamPos, (int)size);
|
||||
if (_pos >= _windowSize)
|
||||
_pos = 0;
|
||||
_streamPos = _pos;
|
||||
}
|
||||
|
||||
public void CopyBlock(uint distance, uint len)
|
||||
{
|
||||
uint pos = _pos - distance - 1;
|
||||
if (pos >= _windowSize)
|
||||
pos += _windowSize;
|
||||
for (; len > 0; len--)
|
||||
{
|
||||
if (pos >= _windowSize)
|
||||
pos = 0;
|
||||
_buffer[_pos++] = _buffer[pos++];
|
||||
if (_pos >= _windowSize)
|
||||
Flush();
|
||||
}
|
||||
}
|
||||
|
||||
public void PutByte(byte b)
|
||||
{
|
||||
_buffer[_pos++] = b;
|
||||
if (_pos >= _windowSize)
|
||||
Flush();
|
||||
}
|
||||
|
||||
public byte GetByte(uint distance)
|
||||
{
|
||||
uint pos = _pos - distance - 1;
|
||||
if (pos >= _windowSize)
|
||||
pos += _windowSize;
|
||||
return _buffer[pos];
|
||||
}
|
||||
}
|
||||
}
|
||||
76
src/Microsoft.DotNet.Archive/LZMA/Compress/LZMA/LzmaBase.cs
Normal file
76
src/Microsoft.DotNet.Archive/LZMA/Compress/LZMA/LzmaBase.cs
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
// LzmaBase.cs
|
||||
|
||||
namespace SevenZip.Compression.LZMA
|
||||
{
|
||||
internal abstract class Base
|
||||
{
|
||||
public const uint kNumRepDistances = 4;
|
||||
public const uint kNumStates = 12;
|
||||
|
||||
// static byte []kLiteralNextStates = {0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 4, 5};
|
||||
// static byte []kMatchNextStates = {7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10};
|
||||
// static byte []kRepNextStates = {8, 8, 8, 8, 8, 8, 8, 11, 11, 11, 11, 11};
|
||||
// static byte []kShortRepNextStates = {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11};
|
||||
|
||||
public struct State
|
||||
{
|
||||
public uint Index;
|
||||
public void Init() { Index = 0; }
|
||||
public void UpdateChar()
|
||||
{
|
||||
if (Index < 4) Index = 0;
|
||||
else if (Index < 10) Index -= 3;
|
||||
else Index -= 6;
|
||||
}
|
||||
public void UpdateMatch() { Index = (uint)(Index < 7 ? 7 : 10); }
|
||||
public void UpdateRep() { Index = (uint)(Index < 7 ? 8 : 11); }
|
||||
public void UpdateShortRep() { Index = (uint)(Index < 7 ? 9 : 11); }
|
||||
public bool IsCharState() { return Index < 7; }
|
||||
}
|
||||
|
||||
public const int kNumPosSlotBits = 6;
|
||||
public const int kDicLogSizeMin = 0;
|
||||
// public const int kDicLogSizeMax = 30;
|
||||
// public const uint kDistTableSizeMax = kDicLogSizeMax * 2;
|
||||
|
||||
public const int kNumLenToPosStatesBits = 2; // it's for speed optimization
|
||||
public const uint kNumLenToPosStates = 1 << kNumLenToPosStatesBits;
|
||||
|
||||
public const uint kMatchMinLen = 2;
|
||||
|
||||
public static uint GetLenToPosState(uint len)
|
||||
{
|
||||
len -= kMatchMinLen;
|
||||
if (len < kNumLenToPosStates)
|
||||
return len;
|
||||
return (uint)(kNumLenToPosStates - 1);
|
||||
}
|
||||
|
||||
public const int kNumAlignBits = 4;
|
||||
public const uint kAlignTableSize = 1 << kNumAlignBits;
|
||||
public const uint kAlignMask = (kAlignTableSize - 1);
|
||||
|
||||
public const uint kStartPosModelIndex = 4;
|
||||
public const uint kEndPosModelIndex = 14;
|
||||
public const uint kNumPosModels = kEndPosModelIndex - kStartPosModelIndex;
|
||||
|
||||
public const uint kNumFullDistances = 1 << ((int)kEndPosModelIndex / 2);
|
||||
|
||||
public const uint kNumLitPosStatesBitsEncodingMax = 4;
|
||||
public const uint kNumLitContextBitsMax = 8;
|
||||
|
||||
public const int kNumPosStatesBitsMax = 4;
|
||||
public const uint kNumPosStatesMax = (1 << kNumPosStatesBitsMax);
|
||||
public const int kNumPosStatesBitsEncodingMax = 4;
|
||||
public const uint kNumPosStatesEncodingMax = (1 << kNumPosStatesBitsEncodingMax);
|
||||
|
||||
public const int kNumLowLenBits = 3;
|
||||
public const int kNumMidLenBits = 3;
|
||||
public const int kNumHighLenBits = 8;
|
||||
public const uint kNumLowLenSymbols = 1 << kNumLowLenBits;
|
||||
public const uint kNumMidLenSymbols = 1 << kNumMidLenBits;
|
||||
public const uint kNumLenSymbols = kNumLowLenSymbols + kNumMidLenSymbols +
|
||||
(1 << kNumHighLenBits);
|
||||
public const uint kMatchMaxLen = kMatchMinLen + kNumLenSymbols - 1;
|
||||
}
|
||||
}
|
||||
399
src/Microsoft.DotNet.Archive/LZMA/Compress/LZMA/LzmaDecoder.cs
Normal file
399
src/Microsoft.DotNet.Archive/LZMA/Compress/LZMA/LzmaDecoder.cs
Normal file
|
|
@ -0,0 +1,399 @@
|
|||
// LzmaDecoder.cs
|
||||
|
||||
using System;
|
||||
|
||||
namespace SevenZip.Compression.LZMA
|
||||
{
|
||||
using RangeCoder;
|
||||
|
||||
public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream
|
||||
{
|
||||
class LenDecoder
|
||||
{
|
||||
BitDecoder m_Choice = new BitDecoder();
|
||||
BitDecoder m_Choice2 = new BitDecoder();
|
||||
BitTreeDecoder[] m_LowCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
|
||||
BitTreeDecoder[] m_MidCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
|
||||
BitTreeDecoder m_HighCoder = new BitTreeDecoder(Base.kNumHighLenBits);
|
||||
uint m_NumPosStates = 0;
|
||||
|
||||
public void Create(uint numPosStates)
|
||||
{
|
||||
for (uint posState = m_NumPosStates; posState < numPosStates; posState++)
|
||||
{
|
||||
m_LowCoder[posState] = new BitTreeDecoder(Base.kNumLowLenBits);
|
||||
m_MidCoder[posState] = new BitTreeDecoder(Base.kNumMidLenBits);
|
||||
}
|
||||
m_NumPosStates = numPosStates;
|
||||
}
|
||||
|
||||
public void Init()
|
||||
{
|
||||
m_Choice.Init();
|
||||
for (uint posState = 0; posState < m_NumPosStates; posState++)
|
||||
{
|
||||
m_LowCoder[posState].Init();
|
||||
m_MidCoder[posState].Init();
|
||||
}
|
||||
m_Choice2.Init();
|
||||
m_HighCoder.Init();
|
||||
}
|
||||
|
||||
public uint Decode(RangeCoder.Decoder rangeDecoder, uint posState)
|
||||
{
|
||||
if (m_Choice.Decode(rangeDecoder) == 0)
|
||||
return m_LowCoder[posState].Decode(rangeDecoder);
|
||||
else
|
||||
{
|
||||
uint symbol = Base.kNumLowLenSymbols;
|
||||
if (m_Choice2.Decode(rangeDecoder) == 0)
|
||||
symbol += m_MidCoder[posState].Decode(rangeDecoder);
|
||||
else
|
||||
{
|
||||
symbol += Base.kNumMidLenSymbols;
|
||||
symbol += m_HighCoder.Decode(rangeDecoder);
|
||||
}
|
||||
return symbol;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class LiteralDecoder
|
||||
{
|
||||
struct Decoder2
|
||||
{
|
||||
BitDecoder[] m_Decoders;
|
||||
public void Create() { m_Decoders = new BitDecoder[0x300]; }
|
||||
public void Init() { for (int i = 0; i < 0x300; i++) m_Decoders[i].Init(); }
|
||||
|
||||
public byte DecodeNormal(RangeCoder.Decoder rangeDecoder)
|
||||
{
|
||||
uint symbol = 1;
|
||||
do
|
||||
symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);
|
||||
while (symbol < 0x100);
|
||||
return (byte)symbol;
|
||||
}
|
||||
|
||||
public byte DecodeWithMatchByte(RangeCoder.Decoder rangeDecoder, byte matchByte)
|
||||
{
|
||||
uint symbol = 1;
|
||||
do
|
||||
{
|
||||
uint matchBit = (uint)(matchByte >> 7) & 1;
|
||||
matchByte <<= 1;
|
||||
uint bit = m_Decoders[((1 + matchBit) << 8) + symbol].Decode(rangeDecoder);
|
||||
symbol = (symbol << 1) | bit;
|
||||
if (matchBit != bit)
|
||||
{
|
||||
while (symbol < 0x100)
|
||||
symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);
|
||||
break;
|
||||
}
|
||||
}
|
||||
while (symbol < 0x100);
|
||||
return (byte)symbol;
|
||||
}
|
||||
}
|
||||
|
||||
Decoder2[] m_Coders;
|
||||
int m_NumPrevBits;
|
||||
int m_NumPosBits;
|
||||
uint m_PosMask;
|
||||
|
||||
public void Create(int numPosBits, int numPrevBits)
|
||||
{
|
||||
if (m_Coders != null && m_NumPrevBits == numPrevBits &&
|
||||
m_NumPosBits == numPosBits)
|
||||
return;
|
||||
m_NumPosBits = numPosBits;
|
||||
m_PosMask = ((uint)1 << numPosBits) - 1;
|
||||
m_NumPrevBits = numPrevBits;
|
||||
uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);
|
||||
m_Coders = new Decoder2[numStates];
|
||||
for (uint i = 0; i < numStates; i++)
|
||||
m_Coders[i].Create();
|
||||
}
|
||||
|
||||
public void Init()
|
||||
{
|
||||
uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);
|
||||
for (uint i = 0; i < numStates; i++)
|
||||
m_Coders[i].Init();
|
||||
}
|
||||
|
||||
uint GetState(uint pos, byte prevByte)
|
||||
{ return ((pos & m_PosMask) << m_NumPrevBits) + (uint)(prevByte >> (8 - m_NumPrevBits)); }
|
||||
|
||||
public byte DecodeNormal(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte)
|
||||
{ return m_Coders[GetState(pos, prevByte)].DecodeNormal(rangeDecoder); }
|
||||
|
||||
public byte DecodeWithMatchByte(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte, byte matchByte)
|
||||
{ return m_Coders[GetState(pos, prevByte)].DecodeWithMatchByte(rangeDecoder, matchByte); }
|
||||
};
|
||||
|
||||
LZ.OutWindow m_OutWindow = new LZ.OutWindow();
|
||||
RangeCoder.Decoder m_RangeDecoder = new RangeCoder.Decoder();
|
||||
|
||||
BitDecoder[] m_IsMatchDecoders = new BitDecoder[Base.kNumStates << Base.kNumPosStatesBitsMax];
|
||||
BitDecoder[] m_IsRepDecoders = new BitDecoder[Base.kNumStates];
|
||||
BitDecoder[] m_IsRepG0Decoders = new BitDecoder[Base.kNumStates];
|
||||
BitDecoder[] m_IsRepG1Decoders = new BitDecoder[Base.kNumStates];
|
||||
BitDecoder[] m_IsRepG2Decoders = new BitDecoder[Base.kNumStates];
|
||||
BitDecoder[] m_IsRep0LongDecoders = new BitDecoder[Base.kNumStates << Base.kNumPosStatesBitsMax];
|
||||
|
||||
BitTreeDecoder[] m_PosSlotDecoder = new BitTreeDecoder[Base.kNumLenToPosStates];
|
||||
BitDecoder[] m_PosDecoders = new BitDecoder[Base.kNumFullDistances - Base.kEndPosModelIndex];
|
||||
|
||||
BitTreeDecoder m_PosAlignDecoder = new BitTreeDecoder(Base.kNumAlignBits);
|
||||
|
||||
LenDecoder m_LenDecoder = new LenDecoder();
|
||||
LenDecoder m_RepLenDecoder = new LenDecoder();
|
||||
|
||||
LiteralDecoder m_LiteralDecoder = new LiteralDecoder();
|
||||
|
||||
uint m_DictionarySize;
|
||||
uint m_DictionarySizeCheck;
|
||||
|
||||
uint m_PosStateMask;
|
||||
|
||||
public Decoder()
|
||||
{
|
||||
m_DictionarySize = 0xFFFFFFFF;
|
||||
for (int i = 0; i < Base.kNumLenToPosStates; i++)
|
||||
m_PosSlotDecoder[i] = new BitTreeDecoder(Base.kNumPosSlotBits);
|
||||
}
|
||||
|
||||
void SetDictionarySize(uint dictionarySize)
|
||||
{
|
||||
if (m_DictionarySize != dictionarySize)
|
||||
{
|
||||
m_DictionarySize = dictionarySize;
|
||||
m_DictionarySizeCheck = Math.Max(m_DictionarySize, 1);
|
||||
uint blockSize = Math.Max(m_DictionarySizeCheck, (1 << 12));
|
||||
m_OutWindow.Create(blockSize);
|
||||
}
|
||||
}
|
||||
|
||||
void SetLiteralProperties(int lp, int lc)
|
||||
{
|
||||
if (lp > 8)
|
||||
throw new InvalidParamException();
|
||||
if (lc > 8)
|
||||
throw new InvalidParamException();
|
||||
m_LiteralDecoder.Create(lp, lc);
|
||||
}
|
||||
|
||||
void SetPosBitsProperties(int pb)
|
||||
{
|
||||
if (pb > Base.kNumPosStatesBitsMax)
|
||||
throw new InvalidParamException();
|
||||
uint numPosStates = (uint)1 << pb;
|
||||
m_LenDecoder.Create(numPosStates);
|
||||
m_RepLenDecoder.Create(numPosStates);
|
||||
m_PosStateMask = numPosStates - 1;
|
||||
}
|
||||
|
||||
bool _solid = false;
|
||||
void Init(System.IO.Stream inStream, System.IO.Stream outStream)
|
||||
{
|
||||
m_RangeDecoder.Init(inStream);
|
||||
m_OutWindow.Init(outStream, _solid);
|
||||
|
||||
uint i;
|
||||
for (i = 0; i < Base.kNumStates; i++)
|
||||
{
|
||||
for (uint j = 0; j <= m_PosStateMask; j++)
|
||||
{
|
||||
uint index = (i << Base.kNumPosStatesBitsMax) + j;
|
||||
m_IsMatchDecoders[index].Init();
|
||||
m_IsRep0LongDecoders[index].Init();
|
||||
}
|
||||
m_IsRepDecoders[i].Init();
|
||||
m_IsRepG0Decoders[i].Init();
|
||||
m_IsRepG1Decoders[i].Init();
|
||||
m_IsRepG2Decoders[i].Init();
|
||||
}
|
||||
|
||||
m_LiteralDecoder.Init();
|
||||
for (i = 0; i < Base.kNumLenToPosStates; i++)
|
||||
m_PosSlotDecoder[i].Init();
|
||||
// m_PosSpecDecoder.Init();
|
||||
for (i = 0; i < Base.kNumFullDistances - Base.kEndPosModelIndex; i++)
|
||||
m_PosDecoders[i].Init();
|
||||
|
||||
m_LenDecoder.Init();
|
||||
m_RepLenDecoder.Init();
|
||||
m_PosAlignDecoder.Init();
|
||||
}
|
||||
|
||||
public void Code(System.IO.Stream inStream, System.IO.Stream outStream,
|
||||
Int64 inSize, Int64 outSize, ICodeProgress progress)
|
||||
{
|
||||
Init(inStream, outStream);
|
||||
|
||||
Base.State state = new Base.State();
|
||||
state.Init();
|
||||
uint rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0;
|
||||
|
||||
UInt64 nowPos64 = 0;
|
||||
UInt64 outSize64 = (UInt64)outSize;
|
||||
if (nowPos64 < outSize64)
|
||||
{
|
||||
if (m_IsMatchDecoders[state.Index << Base.kNumPosStatesBitsMax].Decode(m_RangeDecoder) != 0)
|
||||
throw new DataErrorException();
|
||||
state.UpdateChar();
|
||||
byte b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, 0, 0);
|
||||
m_OutWindow.PutByte(b);
|
||||
nowPos64++;
|
||||
}
|
||||
while (nowPos64 < outSize64)
|
||||
{
|
||||
progress.SetProgress(inStream.Position, (long)nowPos64);
|
||||
// UInt64 next = Math.Min(nowPos64 + (1 << 18), outSize64);
|
||||
// while(nowPos64 < next)
|
||||
{
|
||||
uint posState = (uint)nowPos64 & m_PosStateMask;
|
||||
if (m_IsMatchDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState].Decode(m_RangeDecoder) == 0)
|
||||
{
|
||||
byte b;
|
||||
byte prevByte = m_OutWindow.GetByte(0);
|
||||
if (!state.IsCharState())
|
||||
b = m_LiteralDecoder.DecodeWithMatchByte(m_RangeDecoder,
|
||||
(uint)nowPos64, prevByte, m_OutWindow.GetByte(rep0));
|
||||
else
|
||||
b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, (uint)nowPos64, prevByte);
|
||||
m_OutWindow.PutByte(b);
|
||||
state.UpdateChar();
|
||||
nowPos64++;
|
||||
}
|
||||
else
|
||||
{
|
||||
uint len;
|
||||
if (m_IsRepDecoders[state.Index].Decode(m_RangeDecoder) == 1)
|
||||
{
|
||||
if (m_IsRepG0Decoders[state.Index].Decode(m_RangeDecoder) == 0)
|
||||
{
|
||||
if (m_IsRep0LongDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState].Decode(m_RangeDecoder) == 0)
|
||||
{
|
||||
state.UpdateShortRep();
|
||||
m_OutWindow.PutByte(m_OutWindow.GetByte(rep0));
|
||||
nowPos64++;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
UInt32 distance;
|
||||
if (m_IsRepG1Decoders[state.Index].Decode(m_RangeDecoder) == 0)
|
||||
{
|
||||
distance = rep1;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (m_IsRepG2Decoders[state.Index].Decode(m_RangeDecoder) == 0)
|
||||
distance = rep2;
|
||||
else
|
||||
{
|
||||
distance = rep3;
|
||||
rep3 = rep2;
|
||||
}
|
||||
rep2 = rep1;
|
||||
}
|
||||
rep1 = rep0;
|
||||
rep0 = distance;
|
||||
}
|
||||
len = m_RepLenDecoder.Decode(m_RangeDecoder, posState) + Base.kMatchMinLen;
|
||||
state.UpdateRep();
|
||||
}
|
||||
else
|
||||
{
|
||||
rep3 = rep2;
|
||||
rep2 = rep1;
|
||||
rep1 = rep0;
|
||||
len = Base.kMatchMinLen + m_LenDecoder.Decode(m_RangeDecoder, posState);
|
||||
state.UpdateMatch();
|
||||
uint posSlot = m_PosSlotDecoder[Base.GetLenToPosState(len)].Decode(m_RangeDecoder);
|
||||
if (posSlot >= Base.kStartPosModelIndex)
|
||||
{
|
||||
int numDirectBits = (int)((posSlot >> 1) - 1);
|
||||
rep0 = ((2 | (posSlot & 1)) << numDirectBits);
|
||||
if (posSlot < Base.kEndPosModelIndex)
|
||||
rep0 += BitTreeDecoder.ReverseDecode(m_PosDecoders,
|
||||
rep0 - posSlot - 1, m_RangeDecoder, numDirectBits);
|
||||
else
|
||||
{
|
||||
rep0 += (m_RangeDecoder.DecodeDirectBits(
|
||||
numDirectBits - Base.kNumAlignBits) << Base.kNumAlignBits);
|
||||
rep0 += m_PosAlignDecoder.ReverseDecode(m_RangeDecoder);
|
||||
}
|
||||
}
|
||||
else
|
||||
rep0 = posSlot;
|
||||
}
|
||||
if (rep0 >= m_OutWindow.TrainSize + nowPos64 || rep0 >= m_DictionarySizeCheck)
|
||||
{
|
||||
if (rep0 == 0xFFFFFFFF)
|
||||
break;
|
||||
throw new DataErrorException();
|
||||
}
|
||||
m_OutWindow.CopyBlock(rep0, len);
|
||||
nowPos64 += len;
|
||||
}
|
||||
}
|
||||
}
|
||||
m_OutWindow.Flush();
|
||||
m_OutWindow.ReleaseStream();
|
||||
m_RangeDecoder.ReleaseStream();
|
||||
}
|
||||
|
||||
public void SetDecoderProperties(byte[] properties)
|
||||
{
|
||||
if (properties.Length < 5)
|
||||
throw new InvalidParamException();
|
||||
int lc = properties[0] % 9;
|
||||
int remainder = properties[0] / 9;
|
||||
int lp = remainder % 5;
|
||||
int pb = remainder / 5;
|
||||
if (pb > Base.kNumPosStatesBitsMax)
|
||||
throw new InvalidParamException();
|
||||
UInt32 dictionarySize = 0;
|
||||
for (int i = 0; i < 4; i++)
|
||||
dictionarySize += ((UInt32)(properties[1 + i])) << (i * 8);
|
||||
SetDictionarySize(dictionarySize);
|
||||
SetLiteralProperties(lp, lc);
|
||||
SetPosBitsProperties(pb);
|
||||
}
|
||||
|
||||
public bool Train(System.IO.Stream stream)
|
||||
{
|
||||
_solid = true;
|
||||
return m_OutWindow.Train(stream);
|
||||
}
|
||||
|
||||
/*
|
||||
public override bool CanRead { get { return true; }}
|
||||
public override bool CanWrite { get { return true; }}
|
||||
public override bool CanSeek { get { return true; }}
|
||||
public override long Length { get { return 0; }}
|
||||
public override long Position
|
||||
{
|
||||
get { return 0; }
|
||||
set { }
|
||||
}
|
||||
public override void Flush() { }
|
||||
public override int Read(byte[] buffer, int offset, int count)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
public override void Write(byte[] buffer, int offset, int count)
|
||||
{
|
||||
}
|
||||
public override long Seek(long offset, System.IO.SeekOrigin origin)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
public override void SetLength(long value) {}
|
||||
*/
|
||||
}
|
||||
}
|
||||
1480
src/Microsoft.DotNet.Archive/LZMA/Compress/LZMA/LzmaEncoder.cs
Normal file
1480
src/Microsoft.DotNet.Archive/LZMA/Compress/LZMA/LzmaEncoder.cs
Normal file
File diff suppressed because it is too large
Load diff
|
|
@ -0,0 +1,234 @@
|
|||
using System;
|
||||
|
||||
namespace SevenZip.Compression.RangeCoder
|
||||
{
|
||||
class Encoder
|
||||
{
|
||||
public const uint kTopValue = (1 << 24);
|
||||
|
||||
System.IO.Stream Stream;
|
||||
|
||||
public UInt64 Low;
|
||||
public uint Range;
|
||||
uint _cacheSize;
|
||||
byte _cache;
|
||||
|
||||
long StartPosition;
|
||||
|
||||
public void SetStream(System.IO.Stream stream)
|
||||
{
|
||||
Stream = stream;
|
||||
}
|
||||
|
||||
public void ReleaseStream()
|
||||
{
|
||||
Stream = null;
|
||||
}
|
||||
|
||||
public void Init()
|
||||
{
|
||||
StartPosition = Stream.Position;
|
||||
|
||||
Low = 0;
|
||||
Range = 0xFFFFFFFF;
|
||||
_cacheSize = 1;
|
||||
_cache = 0;
|
||||
}
|
||||
|
||||
public void FlushData()
|
||||
{
|
||||
for (int i = 0; i < 5; i++)
|
||||
ShiftLow();
|
||||
}
|
||||
|
||||
public void FlushStream()
|
||||
{
|
||||
Stream.Flush();
|
||||
}
|
||||
|
||||
public void CloseStream()
|
||||
{
|
||||
Stream.Dispose();
|
||||
}
|
||||
|
||||
public void Encode(uint start, uint size, uint total)
|
||||
{
|
||||
Low += start * (Range /= total);
|
||||
Range *= size;
|
||||
while (Range < kTopValue)
|
||||
{
|
||||
Range <<= 8;
|
||||
ShiftLow();
|
||||
}
|
||||
}
|
||||
|
||||
public void ShiftLow()
|
||||
{
|
||||
if ((uint)Low < (uint)0xFF000000 || (uint)(Low >> 32) == 1)
|
||||
{
|
||||
byte temp = _cache;
|
||||
do
|
||||
{
|
||||
Stream.WriteByte((byte)(temp + (Low >> 32)));
|
||||
temp = 0xFF;
|
||||
}
|
||||
while (--_cacheSize != 0);
|
||||
_cache = (byte)(((uint)Low) >> 24);
|
||||
}
|
||||
_cacheSize++;
|
||||
Low = ((uint)Low) << 8;
|
||||
}
|
||||
|
||||
public void EncodeDirectBits(uint v, int numTotalBits)
|
||||
{
|
||||
for (int i = numTotalBits - 1; i >= 0; i--)
|
||||
{
|
||||
Range >>= 1;
|
||||
if (((v >> i) & 1) == 1)
|
||||
Low += Range;
|
||||
if (Range < kTopValue)
|
||||
{
|
||||
Range <<= 8;
|
||||
ShiftLow();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void EncodeBit(uint size0, int numTotalBits, uint symbol)
|
||||
{
|
||||
uint newBound = (Range >> numTotalBits) * size0;
|
||||
if (symbol == 0)
|
||||
Range = newBound;
|
||||
else
|
||||
{
|
||||
Low += newBound;
|
||||
Range -= newBound;
|
||||
}
|
||||
while (Range < kTopValue)
|
||||
{
|
||||
Range <<= 8;
|
||||
ShiftLow();
|
||||
}
|
||||
}
|
||||
|
||||
public long GetProcessedSizeAdd()
|
||||
{
|
||||
return _cacheSize +
|
||||
Stream.Position - StartPosition + 4;
|
||||
// (long)Stream.GetProcessedSize();
|
||||
}
|
||||
}
|
||||
|
||||
class Decoder
|
||||
{
|
||||
public const uint kTopValue = (1 << 24);
|
||||
public uint Range;
|
||||
public uint Code;
|
||||
// public Buffer.InBuffer Stream = new Buffer.InBuffer(1 << 16);
|
||||
public System.IO.Stream Stream;
|
||||
|
||||
public void Init(System.IO.Stream stream)
|
||||
{
|
||||
// Stream.Init(stream);
|
||||
Stream = stream;
|
||||
|
||||
Code = 0;
|
||||
Range = 0xFFFFFFFF;
|
||||
for (int i = 0; i < 5; i++)
|
||||
Code = (Code << 8) | (byte)Stream.ReadByte();
|
||||
}
|
||||
|
||||
public void ReleaseStream()
|
||||
{
|
||||
// Stream.ReleaseStream();
|
||||
Stream = null;
|
||||
}
|
||||
|
||||
public void CloseStream()
|
||||
{
|
||||
Stream.Dispose();
|
||||
}
|
||||
|
||||
public void Normalize()
|
||||
{
|
||||
while (Range < kTopValue)
|
||||
{
|
||||
Code = (Code << 8) | (byte)Stream.ReadByte();
|
||||
Range <<= 8;
|
||||
}
|
||||
}
|
||||
|
||||
public void Normalize2()
|
||||
{
|
||||
if (Range < kTopValue)
|
||||
{
|
||||
Code = (Code << 8) | (byte)Stream.ReadByte();
|
||||
Range <<= 8;
|
||||
}
|
||||
}
|
||||
|
||||
public uint GetThreshold(uint total)
|
||||
{
|
||||
return Code / (Range /= total);
|
||||
}
|
||||
|
||||
public void Decode(uint start, uint size, uint total)
|
||||
{
|
||||
Code -= start * Range;
|
||||
Range *= size;
|
||||
Normalize();
|
||||
}
|
||||
|
||||
public uint DecodeDirectBits(int numTotalBits)
|
||||
{
|
||||
uint range = Range;
|
||||
uint code = Code;
|
||||
uint result = 0;
|
||||
for (int i = numTotalBits; i > 0; i--)
|
||||
{
|
||||
range >>= 1;
|
||||
/*
|
||||
result <<= 1;
|
||||
if (code >= range)
|
||||
{
|
||||
code -= range;
|
||||
result |= 1;
|
||||
}
|
||||
*/
|
||||
uint t = (code - range) >> 31;
|
||||
code -= range & (t - 1);
|
||||
result = (result << 1) | (1 - t);
|
||||
|
||||
if (range < kTopValue)
|
||||
{
|
||||
code = (code << 8) | (byte)Stream.ReadByte();
|
||||
range <<= 8;
|
||||
}
|
||||
}
|
||||
Range = range;
|
||||
Code = code;
|
||||
return result;
|
||||
}
|
||||
|
||||
public uint DecodeBit(uint size0, int numTotalBits)
|
||||
{
|
||||
uint newBound = (Range >> numTotalBits) * size0;
|
||||
uint symbol;
|
||||
if (Code < newBound)
|
||||
{
|
||||
symbol = 0;
|
||||
Range = newBound;
|
||||
}
|
||||
else
|
||||
{
|
||||
symbol = 1;
|
||||
Code -= newBound;
|
||||
Range -= newBound;
|
||||
}
|
||||
Normalize();
|
||||
return symbol;
|
||||
}
|
||||
|
||||
// ulong GetProcessedSize() {return Stream.GetProcessedSize(); }
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,117 @@
|
|||
using System;
|
||||
|
||||
namespace SevenZip.Compression.RangeCoder
|
||||
{
|
||||
struct BitEncoder
|
||||
{
|
||||
public const int kNumBitModelTotalBits = 11;
|
||||
public const uint kBitModelTotal = (1 << kNumBitModelTotalBits);
|
||||
const int kNumMoveBits = 5;
|
||||
const int kNumMoveReducingBits = 2;
|
||||
public const int kNumBitPriceShiftBits = 6;
|
||||
|
||||
uint Prob;
|
||||
|
||||
public void Init() { Prob = kBitModelTotal >> 1; }
|
||||
|
||||
public void UpdateModel(uint symbol)
|
||||
{
|
||||
if (symbol == 0)
|
||||
Prob += (kBitModelTotal - Prob) >> kNumMoveBits;
|
||||
else
|
||||
Prob -= (Prob) >> kNumMoveBits;
|
||||
}
|
||||
|
||||
public void Encode(Encoder encoder, uint symbol)
|
||||
{
|
||||
// encoder.EncodeBit(Prob, kNumBitModelTotalBits, symbol);
|
||||
// UpdateModel(symbol);
|
||||
uint newBound = (encoder.Range >> kNumBitModelTotalBits) * Prob;
|
||||
if (symbol == 0)
|
||||
{
|
||||
encoder.Range = newBound;
|
||||
Prob += (kBitModelTotal - Prob) >> kNumMoveBits;
|
||||
}
|
||||
else
|
||||
{
|
||||
encoder.Low += newBound;
|
||||
encoder.Range -= newBound;
|
||||
Prob -= (Prob) >> kNumMoveBits;
|
||||
}
|
||||
if (encoder.Range < Encoder.kTopValue)
|
||||
{
|
||||
encoder.Range <<= 8;
|
||||
encoder.ShiftLow();
|
||||
}
|
||||
}
|
||||
|
||||
private static UInt32[] ProbPrices = new UInt32[kBitModelTotal >> kNumMoveReducingBits];
|
||||
|
||||
static BitEncoder()
|
||||
{
|
||||
const int kNumBits = (kNumBitModelTotalBits - kNumMoveReducingBits);
|
||||
for (int i = kNumBits - 1; i >= 0; i--)
|
||||
{
|
||||
UInt32 start = (UInt32)1 << (kNumBits - i - 1);
|
||||
UInt32 end = (UInt32)1 << (kNumBits - i);
|
||||
for (UInt32 j = start; j < end; j++)
|
||||
ProbPrices[j] = ((UInt32)i << kNumBitPriceShiftBits) +
|
||||
(((end - j) << kNumBitPriceShiftBits) >> (kNumBits - i - 1));
|
||||
}
|
||||
}
|
||||
|
||||
public uint GetPrice(uint symbol)
|
||||
{
|
||||
return ProbPrices[(((Prob - symbol) ^ ((-(int)symbol))) & (kBitModelTotal - 1)) >> kNumMoveReducingBits];
|
||||
}
|
||||
public uint GetPrice0() { return ProbPrices[Prob >> kNumMoveReducingBits]; }
|
||||
public uint GetPrice1() { return ProbPrices[(kBitModelTotal - Prob) >> kNumMoveReducingBits]; }
|
||||
}
|
||||
|
||||
struct BitDecoder
|
||||
{
|
||||
public const int kNumBitModelTotalBits = 11;
|
||||
public const uint kBitModelTotal = (1 << kNumBitModelTotalBits);
|
||||
const int kNumMoveBits = 5;
|
||||
|
||||
uint Prob;
|
||||
|
||||
public void UpdateModel(int numMoveBits, uint symbol)
|
||||
{
|
||||
if (symbol == 0)
|
||||
Prob += (kBitModelTotal - Prob) >> numMoveBits;
|
||||
else
|
||||
Prob -= (Prob) >> numMoveBits;
|
||||
}
|
||||
|
||||
public void Init() { Prob = kBitModelTotal >> 1; }
|
||||
|
||||
public uint Decode(RangeCoder.Decoder rangeDecoder)
|
||||
{
|
||||
uint newBound = (uint)(rangeDecoder.Range >> kNumBitModelTotalBits) * (uint)Prob;
|
||||
if (rangeDecoder.Code < newBound)
|
||||
{
|
||||
rangeDecoder.Range = newBound;
|
||||
Prob += (kBitModelTotal - Prob) >> kNumMoveBits;
|
||||
if (rangeDecoder.Range < Decoder.kTopValue)
|
||||
{
|
||||
rangeDecoder.Code = (rangeDecoder.Code << 8) | (byte)rangeDecoder.Stream.ReadByte();
|
||||
rangeDecoder.Range <<= 8;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
rangeDecoder.Range -= newBound;
|
||||
rangeDecoder.Code -= newBound;
|
||||
Prob -= (Prob) >> kNumMoveBits;
|
||||
if (rangeDecoder.Range < Decoder.kTopValue)
|
||||
{
|
||||
rangeDecoder.Code = (rangeDecoder.Code << 8) | (byte)rangeDecoder.Stream.ReadByte();
|
||||
rangeDecoder.Range <<= 8;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,157 @@
|
|||
using System;
|
||||
|
||||
namespace SevenZip.Compression.RangeCoder
|
||||
{
|
||||
struct BitTreeEncoder
|
||||
{
|
||||
BitEncoder[] Models;
|
||||
int NumBitLevels;
|
||||
|
||||
public BitTreeEncoder(int numBitLevels)
|
||||
{
|
||||
NumBitLevels = numBitLevels;
|
||||
Models = new BitEncoder[1 << numBitLevels];
|
||||
}
|
||||
|
||||
public void Init()
|
||||
{
|
||||
for (uint i = 1; i < (1 << NumBitLevels); i++)
|
||||
Models[i].Init();
|
||||
}
|
||||
|
||||
public void Encode(Encoder rangeEncoder, UInt32 symbol)
|
||||
{
|
||||
UInt32 m = 1;
|
||||
for (int bitIndex = NumBitLevels; bitIndex > 0; )
|
||||
{
|
||||
bitIndex--;
|
||||
UInt32 bit = (symbol >> bitIndex) & 1;
|
||||
Models[m].Encode(rangeEncoder, bit);
|
||||
m = (m << 1) | bit;
|
||||
}
|
||||
}
|
||||
|
||||
public void ReverseEncode(Encoder rangeEncoder, UInt32 symbol)
|
||||
{
|
||||
UInt32 m = 1;
|
||||
for (UInt32 i = 0; i < NumBitLevels; i++)
|
||||
{
|
||||
UInt32 bit = symbol & 1;
|
||||
Models[m].Encode(rangeEncoder, bit);
|
||||
m = (m << 1) | bit;
|
||||
symbol >>= 1;
|
||||
}
|
||||
}
|
||||
|
||||
public UInt32 GetPrice(UInt32 symbol)
|
||||
{
|
||||
UInt32 price = 0;
|
||||
UInt32 m = 1;
|
||||
for (int bitIndex = NumBitLevels; bitIndex > 0; )
|
||||
{
|
||||
bitIndex--;
|
||||
UInt32 bit = (symbol >> bitIndex) & 1;
|
||||
price += Models[m].GetPrice(bit);
|
||||
m = (m << 1) + bit;
|
||||
}
|
||||
return price;
|
||||
}
|
||||
|
||||
public UInt32 ReverseGetPrice(UInt32 symbol)
|
||||
{
|
||||
UInt32 price = 0;
|
||||
UInt32 m = 1;
|
||||
for (int i = NumBitLevels; i > 0; i--)
|
||||
{
|
||||
UInt32 bit = symbol & 1;
|
||||
symbol >>= 1;
|
||||
price += Models[m].GetPrice(bit);
|
||||
m = (m << 1) | bit;
|
||||
}
|
||||
return price;
|
||||
}
|
||||
|
||||
public static UInt32 ReverseGetPrice(BitEncoder[] Models, UInt32 startIndex,
|
||||
int NumBitLevels, UInt32 symbol)
|
||||
{
|
||||
UInt32 price = 0;
|
||||
UInt32 m = 1;
|
||||
for (int i = NumBitLevels; i > 0; i--)
|
||||
{
|
||||
UInt32 bit = symbol & 1;
|
||||
symbol >>= 1;
|
||||
price += Models[startIndex + m].GetPrice(bit);
|
||||
m = (m << 1) | bit;
|
||||
}
|
||||
return price;
|
||||
}
|
||||
|
||||
public static void ReverseEncode(BitEncoder[] Models, UInt32 startIndex,
|
||||
Encoder rangeEncoder, int NumBitLevels, UInt32 symbol)
|
||||
{
|
||||
UInt32 m = 1;
|
||||
for (int i = 0; i < NumBitLevels; i++)
|
||||
{
|
||||
UInt32 bit = symbol & 1;
|
||||
Models[startIndex + m].Encode(rangeEncoder, bit);
|
||||
m = (m << 1) | bit;
|
||||
symbol >>= 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct BitTreeDecoder
|
||||
{
|
||||
BitDecoder[] Models;
|
||||
int NumBitLevels;
|
||||
|
||||
public BitTreeDecoder(int numBitLevels)
|
||||
{
|
||||
NumBitLevels = numBitLevels;
|
||||
Models = new BitDecoder[1 << numBitLevels];
|
||||
}
|
||||
|
||||
public void Init()
|
||||
{
|
||||
for (uint i = 1; i < (1 << NumBitLevels); i++)
|
||||
Models[i].Init();
|
||||
}
|
||||
|
||||
public uint Decode(RangeCoder.Decoder rangeDecoder)
|
||||
{
|
||||
uint m = 1;
|
||||
for (int bitIndex = NumBitLevels; bitIndex > 0; bitIndex--)
|
||||
m = (m << 1) + Models[m].Decode(rangeDecoder);
|
||||
return m - ((uint)1 << NumBitLevels);
|
||||
}
|
||||
|
||||
public uint ReverseDecode(RangeCoder.Decoder rangeDecoder)
|
||||
{
|
||||
uint m = 1;
|
||||
uint symbol = 0;
|
||||
for (int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)
|
||||
{
|
||||
uint bit = Models[m].Decode(rangeDecoder);
|
||||
m <<= 1;
|
||||
m += bit;
|
||||
symbol |= (bit << bitIndex);
|
||||
}
|
||||
return symbol;
|
||||
}
|
||||
|
||||
public static uint ReverseDecode(BitDecoder[] Models, UInt32 startIndex,
|
||||
RangeCoder.Decoder rangeDecoder, int NumBitLevels)
|
||||
{
|
||||
uint m = 1;
|
||||
uint symbol = 0;
|
||||
for (int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)
|
||||
{
|
||||
uint bit = Models[startIndex + m].Decode(rangeDecoder);
|
||||
m <<= 1;
|
||||
m += bit;
|
||||
symbol |= (bit << bitIndex);
|
||||
}
|
||||
return symbol;
|
||||
}
|
||||
}
|
||||
}
|
||||
157
src/Microsoft.DotNet.Archive/LZMA/ICoder.cs
Normal file
157
src/Microsoft.DotNet.Archive/LZMA/ICoder.cs
Normal file
|
|
@ -0,0 +1,157 @@
|
|||
// ICoder.h
|
||||
|
||||
using System;
|
||||
|
||||
namespace SevenZip
|
||||
{
|
||||
/// <summary>
|
||||
/// The exception that is thrown when an error in input stream occurs during decoding.
|
||||
/// </summary>
|
||||
class DataErrorException : Exception
|
||||
{
|
||||
public DataErrorException(): base("Data Error") { }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The exception that is thrown when the value of an argument is outside the allowable range.
|
||||
/// </summary>
|
||||
class InvalidParamException : Exception
|
||||
{
|
||||
public InvalidParamException(): base("Invalid Parameter") { }
|
||||
}
|
||||
|
||||
public interface ICodeProgress
|
||||
{
|
||||
/// <summary>
|
||||
/// Callback progress.
|
||||
/// </summary>
|
||||
/// <param name="inSize">
|
||||
/// input size. -1 if unknown.
|
||||
/// </param>
|
||||
/// <param name="outSize">
|
||||
/// output size. -1 if unknown.
|
||||
/// </param>
|
||||
void SetProgress(Int64 inSize, Int64 outSize);
|
||||
};
|
||||
|
||||
public interface ICoder
|
||||
{
|
||||
/// <summary>
|
||||
/// Codes streams.
|
||||
/// </summary>
|
||||
/// <param name="inStream">
|
||||
/// input Stream.
|
||||
/// </param>
|
||||
/// <param name="outStream">
|
||||
/// output Stream.
|
||||
/// </param>
|
||||
/// <param name="inSize">
|
||||
/// input Size. -1 if unknown.
|
||||
/// </param>
|
||||
/// <param name="outSize">
|
||||
/// output Size. -1 if unknown.
|
||||
/// </param>
|
||||
/// <param name="progress">
|
||||
/// callback progress reference.
|
||||
/// </param>
|
||||
/// <exception cref="SevenZip.DataErrorException">
|
||||
/// if input stream is not valid
|
||||
/// </exception>
|
||||
void Code(System.IO.Stream inStream, System.IO.Stream outStream,
|
||||
Int64 inSize, Int64 outSize, ICodeProgress progress);
|
||||
};
|
||||
|
||||
/*
|
||||
public interface ICoder2
|
||||
{
|
||||
void Code(ISequentialInStream []inStreams,
|
||||
const UInt64 []inSizes,
|
||||
ISequentialOutStream []outStreams,
|
||||
UInt64 []outSizes,
|
||||
ICodeProgress progress);
|
||||
};
|
||||
*/
|
||||
|
||||
/// <summary>
|
||||
/// Provides the fields that represent properties idenitifiers for compressing.
|
||||
/// </summary>
|
||||
public enum CoderPropID
|
||||
{
|
||||
/// <summary>
|
||||
/// Specifies default property.
|
||||
/// </summary>
|
||||
DefaultProp = 0,
|
||||
/// <summary>
|
||||
/// Specifies size of dictionary.
|
||||
/// </summary>
|
||||
DictionarySize,
|
||||
/// <summary>
|
||||
/// Specifies size of memory for PPM*.
|
||||
/// </summary>
|
||||
UsedMemorySize,
|
||||
/// <summary>
|
||||
/// Specifies order for PPM methods.
|
||||
/// </summary>
|
||||
Order,
|
||||
/// <summary>
|
||||
/// Specifies Block Size.
|
||||
/// </summary>
|
||||
BlockSize,
|
||||
/// <summary>
|
||||
/// Specifies number of postion state bits for LZMA (0 <= x <= 4).
|
||||
/// </summary>
|
||||
PosStateBits,
|
||||
/// <summary>
|
||||
/// Specifies number of literal context bits for LZMA (0 <= x <= 8).
|
||||
/// </summary>
|
||||
LitContextBits,
|
||||
/// <summary>
|
||||
/// Specifies number of literal position bits for LZMA (0 <= x <= 4).
|
||||
/// </summary>
|
||||
LitPosBits,
|
||||
/// <summary>
|
||||
/// Specifies number of fast bytes for LZ*.
|
||||
/// </summary>
|
||||
NumFastBytes,
|
||||
/// <summary>
|
||||
/// Specifies match finder. LZMA: "BT2", "BT4" or "BT4B".
|
||||
/// </summary>
|
||||
MatchFinder,
|
||||
/// <summary>
|
||||
/// Specifies the number of match finder cyckes.
|
||||
/// </summary>
|
||||
MatchFinderCycles,
|
||||
/// <summary>
|
||||
/// Specifies number of passes.
|
||||
/// </summary>
|
||||
NumPasses,
|
||||
/// <summary>
|
||||
/// Specifies number of algorithm.
|
||||
/// </summary>
|
||||
Algorithm,
|
||||
/// <summary>
|
||||
/// Specifies the number of threads.
|
||||
/// </summary>
|
||||
NumThreads,
|
||||
/// <summary>
|
||||
/// Specifies mode with end marker.
|
||||
/// </summary>
|
||||
EndMarker
|
||||
};
|
||||
|
||||
|
||||
public interface ISetCoderProperties
|
||||
{
|
||||
void SetCoderProperties(CoderPropID[] propIDs, object[] properties);
|
||||
};
|
||||
|
||||
public interface IWriteCoderProperties
|
||||
{
|
||||
void WriteCoderProperties(System.IO.Stream outStream);
|
||||
}
|
||||
|
||||
public interface ISetDecoderProperties
|
||||
{
|
||||
void SetDecoderProperties(byte[] properties);
|
||||
}
|
||||
}
|
||||
5
src/Microsoft.DotNet.Archive/LZMA/README.md
Normal file
5
src/Microsoft.DotNet.Archive/LZMA/README.md
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
## LZMA SDK
|
||||
This source came from the C# implementation of LZMA from the LZMA SDK, version 16.02, from http://www.7-zip.org/sdk.html.
|
||||
|
||||
## License
|
||||
The LZMA SDK is public domain. Thanks goes to Igor Pavlov for making this available.
|
||||
18
src/Microsoft.DotNet.Archive/Microsoft.DotNet.Archive.xproj
Normal file
18
src/Microsoft.DotNet.Archive/Microsoft.DotNet.Archive.xproj
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<PropertyGroup>
|
||||
<VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0</VisualStudioVersion>
|
||||
<VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VSToolsPath)\DNX\Microsoft.DNX.Props" Condition="'$(VSToolsPath)' != ''" />
|
||||
<PropertyGroup Label="Globals">
|
||||
<ProjectGuid>35b19f22-b8c0-4849-9c35-3f809b7588b8</ProjectGuid>
|
||||
<RootNamespace>Microsoft.DotNet.Archive</RootNamespace>
|
||||
<BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)'=='' ">..\..\artifacts\obj\$(MSBuildProjectName)</BaseIntermediateOutputPath>
|
||||
<OutputPath Condition="'$(OutputPath)'=='' ">..\..\artifacts\bin</OutputPath>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup>
|
||||
<SchemaVersion>2.0</SchemaVersion>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VSToolsPath)\DNX\Microsoft.DNX.targets" Condition="'$(VSToolsPath)' != ''" />
|
||||
</Project>
|
||||
29
src/Microsoft.DotNet.Archive/ProgressReport.cs
Normal file
29
src/Microsoft.DotNet.Archive/ProgressReport.cs
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System;
|
||||
|
||||
namespace Microsoft.DotNet.Archive
|
||||
{
|
||||
public struct ProgressReport
|
||||
{
|
||||
public ProgressReport(string phase, long ticks, long total)
|
||||
{
|
||||
Phase = phase;
|
||||
Ticks = ticks;
|
||||
Total = total;
|
||||
}
|
||||
public string Phase { get; }
|
||||
public long Ticks { get; }
|
||||
public long Total { get; }
|
||||
}
|
||||
|
||||
public static class ProgressReportExtensions
|
||||
{
|
||||
public static void Report(this IProgress<ProgressReport> progress, string phase, long ticks, long total)
|
||||
{
|
||||
progress.Report(new ProgressReport(phase, ticks, total));
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
59
src/Microsoft.DotNet.Archive/ThreadLocalZipArchive.cs
Normal file
59
src/Microsoft.DotNet.Archive/ThreadLocalZipArchive.cs
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.IO.Compression;
|
||||
using System.Threading;
|
||||
|
||||
namespace Microsoft.DotNet.Archive
|
||||
{
|
||||
/// <summary>
|
||||
/// Wraps ThreadLocal<ZipArchive> and exposes Dispose semantics that dispose all archives
|
||||
/// </summary>
|
||||
internal class ThreadLocalZipArchive : IDisposable
|
||||
{
|
||||
private ThreadLocal<ZipArchive> _archive;
|
||||
private bool _disposed = false;
|
||||
|
||||
public ThreadLocalZipArchive(string archivePath, ZipArchive local = null)
|
||||
{
|
||||
_archive = new ThreadLocal<ZipArchive>(() =>
|
||||
new ZipArchive(File.Open(archivePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete), ZipArchiveMode.Read),
|
||||
trackAllValues:true);
|
||||
|
||||
if (local != null)
|
||||
{
|
||||
// reuse provided one for current thread
|
||||
_archive.Value = local;
|
||||
}
|
||||
}
|
||||
|
||||
public ZipArchive Archive { get { return _archive.Value; } }
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
if (!_disposed)
|
||||
{
|
||||
if (_archive != null)
|
||||
{
|
||||
// dispose all archives
|
||||
if (_archive.Values != null)
|
||||
{
|
||||
foreach (var value in _archive.Values)
|
||||
{
|
||||
if (value != null)
|
||||
{
|
||||
value.Dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// dispose ThreadLocal
|
||||
_archive.Dispose();
|
||||
_archive = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
15
src/Microsoft.DotNet.Archive/project.json
Normal file
15
src/Microsoft.DotNet.Archive/project.json
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
{
|
||||
"version": "1.0.0-preview3-*",
|
||||
"buildOptions": {
|
||||
"keyFile": "../../tools/Key.snk"
|
||||
},
|
||||
"description": "Archive and compression types.",
|
||||
"dependencies": {
|
||||
"NETStandard.Library": "1.6.0-rc3-24201-00",
|
||||
"System.Linq.Parallel": "4.0.1-rc3-24201-00"
|
||||
},
|
||||
"frameworks": {
|
||||
"netstandard1.3": {}
|
||||
},
|
||||
"scripts": {}
|
||||
}
|
||||
|
|
@ -165,12 +165,14 @@ namespace Microsoft.DotNet.Cli.Utils
|
|||
|
||||
public ICommand CaptureStdErr()
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
_stdErr.Capture();
|
||||
return this;
|
||||
}
|
||||
|
||||
public ICommand CaptureStdOut()
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
_stdOut.Capture();
|
||||
return this;
|
||||
}
|
||||
|
||||
public ICommand EnvironmentVariable(string name, string value)
|
||||
|
|
|
|||
|
|
@ -10,10 +10,15 @@ namespace Microsoft.DotNet.Cli.Utils
|
|||
{
|
||||
public static class DotnetFiles
|
||||
{
|
||||
private static string SdkRootFolder => Path.Combine(typeof(DotnetFiles).GetTypeInfo().Assembly.Location, "..");
|
||||
|
||||
/// <summary>
|
||||
/// The CLI ships with a .version file that stores the commit information and CLI version
|
||||
/// </summary>
|
||||
public static string VersionFile => Path.GetFullPath(Path.Combine(typeof(DotnetFiles).GetTypeInfo().Assembly.Location, "..", ".version"));
|
||||
public static string VersionFile => Path.GetFullPath(Path.Combine(SdkRootFolder, ".version"));
|
||||
|
||||
public static string NuGetPackagesArchive =>
|
||||
Path.GetFullPath(Path.Combine(SdkRootFolder, "nuGetPackagesArchive.lzma"));
|
||||
|
||||
/// <summary>
|
||||
/// Reads the version file and adds runtime specific information
|
||||
|
|
|
|||
|
|
@ -0,0 +1,64 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System.IO;
|
||||
using Microsoft.DotNet.Cli.Utils;
|
||||
using Microsoft.Extensions.EnvironmentAbstractions;
|
||||
|
||||
namespace Microsoft.DotNet.Configurer
|
||||
{
|
||||
public class DotnetFirstTimeUseConfigurer
|
||||
{
|
||||
private IEnvironmentProvider _environmentProvider;
|
||||
private INuGetCachePrimer _nugetCachePrimer;
|
||||
private INuGetCacheSentinel _nugetCacheSentinel;
|
||||
|
||||
public DotnetFirstTimeUseConfigurer(
|
||||
INuGetCachePrimer nugetCachePrimer,
|
||||
INuGetCacheSentinel nugetCacheSentinel,
|
||||
IEnvironmentProvider environmentProvider)
|
||||
{
|
||||
_nugetCachePrimer = nugetCachePrimer;
|
||||
_nugetCacheSentinel = nugetCacheSentinel;
|
||||
_environmentProvider = environmentProvider;
|
||||
}
|
||||
|
||||
public void Configure()
|
||||
{
|
||||
if(ShouldPrimeNugetCache())
|
||||
{
|
||||
PrintFirstTimeUseNotice();
|
||||
|
||||
_nugetCachePrimer.PrimeCache();
|
||||
}
|
||||
}
|
||||
|
||||
private void PrintFirstTimeUseNotice()
|
||||
{
|
||||
const string firstTimeUseWelcomeMessage = @"Welcome to .NET Core!
|
||||
---------------------
|
||||
Learn more about .NET Core @ https://aka.ms/dotnet-docs. Use dotnet --help to see available commands or go to https://aka.ms/dotnet-cli-docs.
|
||||
Telemetry
|
||||
--------------
|
||||
The .NET Core tools collect usage data in order to improve your experience. The data is anonymous and does not include commandline arguments. The data is collected by Microsoft and shared with the community.
|
||||
You can opt out of telemetry by setting a DOTNET_CLI_TELEMETRY_OPTOUT environment variable to 1 using your favorite shell.
|
||||
You can read more about .NET Core tools telemetry @ https://aka.ms/dotnet-cli-telemetry.
|
||||
Configuring...
|
||||
-------------------
|
||||
A command is running to initially populate your local package cache, to improve restore speed and enable offline access. This command will take up to a minute to complete and will only happen once.";
|
||||
|
||||
Reporter.Output.WriteLine();
|
||||
Reporter.Output.WriteLine(firstTimeUseWelcomeMessage);
|
||||
}
|
||||
|
||||
private bool ShouldPrimeNugetCache()
|
||||
{
|
||||
var skipFirstTimeExperience =
|
||||
_environmentProvider.GetEnvironmentVariableAsBool("DOTNET_SKIP_FIRST_TIME_EXPERIENCE", false);
|
||||
|
||||
return !skipFirstTimeExperience &&
|
||||
!_nugetCacheSentinel.Exists() &&
|
||||
!_nugetCacheSentinel.InProgressSentinelAlreadyExists();
|
||||
}
|
||||
}
|
||||
}
|
||||
10
src/Microsoft.DotNet.Configurer/INuGetCachePrimer.cs
Normal file
10
src/Microsoft.DotNet.Configurer/INuGetCachePrimer.cs
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
namespace Microsoft.DotNet.Configurer
|
||||
{
|
||||
public interface INuGetCachePrimer
|
||||
{
|
||||
void PrimeCache();
|
||||
}
|
||||
}
|
||||
16
src/Microsoft.DotNet.Configurer/INuGetCacheSentinel.cs
Normal file
16
src/Microsoft.DotNet.Configurer/INuGetCacheSentinel.cs
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System;
|
||||
|
||||
namespace Microsoft.DotNet.Configurer
|
||||
{
|
||||
public interface INuGetCacheSentinel : IDisposable
|
||||
{
|
||||
bool InProgressSentinelAlreadyExists();
|
||||
|
||||
bool Exists();
|
||||
|
||||
void CreateIfNotExists();
|
||||
}
|
||||
}
|
||||
14
src/Microsoft.DotNet.Configurer/INuGetPackagesArchiver.cs
Normal file
14
src/Microsoft.DotNet.Configurer/INuGetPackagesArchiver.cs
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System;
|
||||
|
||||
namespace Microsoft.DotNet.Configurer
|
||||
{
|
||||
public interface INuGetPackagesArchiver : IDisposable
|
||||
{
|
||||
string NuGetPackagesArchive { get; }
|
||||
|
||||
string ExtractArchive();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="14.0.25123" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<PropertyGroup>
|
||||
<VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0.25123</VisualStudioVersion>
|
||||
<VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.Props" Condition="'$(VSToolsPath)' != ''" />
|
||||
<PropertyGroup Label="Globals">
|
||||
<ProjectGuid>e5ed47ef-bf25-4da9-a7fe-290c642cbf0f</ProjectGuid>
|
||||
<RootNamespace>Microsoft.DotNet.Configurer</RootNamespace>
|
||||
<BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)'=='' ">.\obj</BaseIntermediateOutputPath>
|
||||
<OutputPath Condition="'$(OutputPath)'=='' ">.\bin\</OutputPath>
|
||||
</PropertyGroup>
|
||||
|
||||
<PropertyGroup>
|
||||
<SchemaVersion>2.0</SchemaVersion>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.targets" Condition="'$(VSToolsPath)' != ''" />
|
||||
</Project>
|
||||
114
src/Microsoft.DotNet.Configurer/NuGetCachePrimer.cs
Normal file
114
src/Microsoft.DotNet.Configurer/NuGetCachePrimer.cs
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Microsoft.DotNet.Cli.Utils;
|
||||
using Microsoft.Extensions.EnvironmentAbstractions;
|
||||
|
||||
namespace Microsoft.DotNet.Configurer
|
||||
{
|
||||
public class NuGetCachePrimer : INuGetCachePrimer
|
||||
{
|
||||
private readonly ICommandFactory _commandFactory;
|
||||
private readonly IDirectory _directory;
|
||||
private readonly IFile _file;
|
||||
private readonly INuGetPackagesArchiver _nugetPackagesArchiver;
|
||||
private readonly INuGetCacheSentinel _nuGetCacheSentinel;
|
||||
|
||||
public NuGetCachePrimer(
|
||||
ICommandFactory commandFactory,
|
||||
INuGetPackagesArchiver nugetPackagesArchiver,
|
||||
INuGetCacheSentinel nuGetCacheSentinel)
|
||||
: this(commandFactory,
|
||||
nugetPackagesArchiver,
|
||||
nuGetCacheSentinel,
|
||||
FileSystemWrapper.Default.Directory,
|
||||
FileSystemWrapper.Default.File)
|
||||
{
|
||||
}
|
||||
|
||||
internal NuGetCachePrimer(
|
||||
ICommandFactory commandFactory,
|
||||
INuGetPackagesArchiver nugetPackagesArchiver,
|
||||
INuGetCacheSentinel nuGetCacheSentinel,
|
||||
IDirectory directory,
|
||||
IFile file)
|
||||
{
|
||||
_commandFactory = commandFactory;
|
||||
_directory = directory;
|
||||
_nugetPackagesArchiver = nugetPackagesArchiver;
|
||||
_nuGetCacheSentinel = nuGetCacheSentinel;
|
||||
_file = file;
|
||||
}
|
||||
|
||||
public void PrimeCache()
|
||||
{
|
||||
if(SkipPrimingTheCache())
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var extractedPackagesArchiveDirectory = _nugetPackagesArchiver.ExtractArchive();
|
||||
|
||||
PrimeCacheUsingArchive(extractedPackagesArchiveDirectory);
|
||||
}
|
||||
|
||||
private bool SkipPrimingTheCache()
|
||||
{
|
||||
return !_file.Exists(_nugetPackagesArchiver.NuGetPackagesArchive);
|
||||
}
|
||||
|
||||
private void PrimeCacheUsingArchive(string extractedPackagesArchiveDirectory)
|
||||
{
|
||||
using (var temporaryDotnetNewDirectory = _directory.CreateTemporaryDirectory())
|
||||
{
|
||||
var workingDirectory = temporaryDotnetNewDirectory.DirectoryPath;
|
||||
var createProjectSucceeded = CreateTemporaryProject(workingDirectory);
|
||||
|
||||
if (createProjectSucceeded)
|
||||
{
|
||||
var restoreProjectSucceeded =
|
||||
RestoreTemporaryProject(extractedPackagesArchiveDirectory, workingDirectory);
|
||||
if (restoreProjectSucceeded)
|
||||
{
|
||||
_nuGetCacheSentinel.CreateIfNotExists();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private bool CreateTemporaryProject(string workingDirectory)
|
||||
{
|
||||
return RunCommand("new", Enumerable.Empty<string>(), workingDirectory);
|
||||
}
|
||||
|
||||
private bool RestoreTemporaryProject(string extractedPackagesArchiveDirectory, string workingDirectory)
|
||||
{
|
||||
return RunCommand(
|
||||
"restore",
|
||||
new[] {"-s", $"{extractedPackagesArchiveDirectory}"},
|
||||
workingDirectory);
|
||||
}
|
||||
|
||||
private bool RunCommand(string commandToExecute, IEnumerable<string> args, string workingDirectory)
|
||||
{
|
||||
var command = _commandFactory
|
||||
.Create(commandToExecute, args)
|
||||
.WorkingDirectory(workingDirectory)
|
||||
.CaptureStdOut()
|
||||
.CaptureStdErr();
|
||||
|
||||
var commandResult = command.Execute();
|
||||
|
||||
if (commandResult.ExitCode != 0)
|
||||
{
|
||||
Reporter.Verbose.WriteLine(commandResult.StdErr);
|
||||
Reporter.Error.WriteLine(
|
||||
$"Failed to create prime the NuGet cache. {commandToExecute} failed with: {commandResult.ExitCode}");
|
||||
}
|
||||
|
||||
return commandResult.ExitCode == 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
106
src/Microsoft.DotNet.Configurer/NuGetCacheSentinel.cs
Normal file
106
src/Microsoft.DotNet.Configurer/NuGetCacheSentinel.cs
Normal file
|
|
@ -0,0 +1,106 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System.IO;
|
||||
using Microsoft.DotNet.Cli.Utils;
|
||||
using Microsoft.Extensions.EnvironmentAbstractions;
|
||||
using Microsoft.DotNet.ProjectModel.Resolution;
|
||||
|
||||
namespace Microsoft.DotNet.Configurer
|
||||
{
|
||||
public class NuGetCacheSentinel : INuGetCacheSentinel
|
||||
{
|
||||
public static readonly string SENTINEL = $"{Product.Version}.dotnetSentinel";
|
||||
public static readonly string INPROGRESS_SENTINEL = $"{Product.Version}.inprogress.dotnetSentinel";
|
||||
|
||||
private readonly IFile _file;
|
||||
|
||||
private string _nugetCachePath;
|
||||
|
||||
private string NuGetCachePath
|
||||
{
|
||||
get
|
||||
{
|
||||
if (string.IsNullOrEmpty(_nugetCachePath))
|
||||
{
|
||||
_nugetCachePath = PackageDependencyProvider.ResolvePackagesPath(null, null);
|
||||
}
|
||||
|
||||
return _nugetCachePath;
|
||||
}
|
||||
}
|
||||
|
||||
private string SentinelPath => Path.Combine(NuGetCachePath, SENTINEL);
|
||||
private string InProgressSentinelPath => Path.Combine(NuGetCachePath, INPROGRESS_SENTINEL);
|
||||
|
||||
private Stream InProgressSentinel { get; set; }
|
||||
|
||||
public NuGetCacheSentinel() : this(string.Empty, FileSystemWrapper.Default.File)
|
||||
{
|
||||
}
|
||||
|
||||
internal NuGetCacheSentinel(string nugetCachePath, IFile file)
|
||||
{
|
||||
_file = file;
|
||||
_nugetCachePath = nugetCachePath;
|
||||
|
||||
SetInProgressSentinel();
|
||||
}
|
||||
|
||||
public bool InProgressSentinelAlreadyExists()
|
||||
{
|
||||
return CouldNotGetAHandleToTheInProgressSentinel();
|
||||
}
|
||||
|
||||
public bool Exists()
|
||||
{
|
||||
return _file.Exists(SentinelPath);
|
||||
}
|
||||
|
||||
public void CreateIfNotExists()
|
||||
{
|
||||
if (!Exists())
|
||||
{
|
||||
_file.CreateEmptyFile(SentinelPath);
|
||||
}
|
||||
}
|
||||
|
||||
private bool CouldNotGetAHandleToTheInProgressSentinel()
|
||||
{
|
||||
return InProgressSentinel == null;
|
||||
}
|
||||
|
||||
private void SetInProgressSentinel()
|
||||
{
|
||||
try
|
||||
{
|
||||
if(!Directory.Exists(NuGetCachePath))
|
||||
{
|
||||
Directory.CreateDirectory(NuGetCachePath);
|
||||
}
|
||||
|
||||
// open an exclusive handle to the in-progress sentinel and mark it for delete on close.
|
||||
// we open with exclusive FileShare.None access to indicate that the operation is in progress.
|
||||
// buffer size is minimum since we won't be reading or writing from the file.
|
||||
// delete on close is to indicate that the operation is no longer in progress when we dispose
|
||||
// this.
|
||||
InProgressSentinel = _file.OpenFile(
|
||||
InProgressSentinelPath,
|
||||
FileMode.OpenOrCreate,
|
||||
FileAccess.ReadWrite,
|
||||
FileShare.None,
|
||||
1,
|
||||
FileOptions.DeleteOnClose);
|
||||
}
|
||||
catch { }
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
if (InProgressSentinel != null)
|
||||
{
|
||||
InProgressSentinel.Dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
40
src/Microsoft.DotNet.Configurer/NuGetPackagesArchiver.cs
Normal file
40
src/Microsoft.DotNet.Configurer/NuGetPackagesArchiver.cs
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using Microsoft.DotNet.Cli.Utils;
|
||||
using Microsoft.DotNet.Archive;
|
||||
using Microsoft.Extensions.EnvironmentAbstractions;
|
||||
|
||||
namespace Microsoft.DotNet.Configurer
|
||||
{
|
||||
public class NuGetPackagesArchiver : INuGetPackagesArchiver
|
||||
{
|
||||
private ITemporaryDirectory _temporaryDirectory;
|
||||
|
||||
public string NuGetPackagesArchive => DotnetFiles.NuGetPackagesArchive;
|
||||
|
||||
public NuGetPackagesArchiver() : this(FileSystemWrapper.Default.Directory)
|
||||
{
|
||||
}
|
||||
|
||||
internal NuGetPackagesArchiver(IDirectory directory)
|
||||
{
|
||||
_temporaryDirectory = directory.CreateTemporaryDirectory();
|
||||
}
|
||||
|
||||
public string ExtractArchive()
|
||||
{
|
||||
var progress = new ConsoleProgressReport();
|
||||
var archive = new IndexedArchive();
|
||||
|
||||
archive.Extract(NuGetPackagesArchive, _temporaryDirectory.DirectoryPath, progress);
|
||||
|
||||
return _temporaryDirectory.DirectoryPath;
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
_temporaryDirectory.Dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
3
src/Microsoft.DotNet.Configurer/Properties/Properties.cs
Normal file
3
src/Microsoft.DotNet.Configurer/Properties/Properties.cs
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
using System.Runtime.CompilerServices;
|
||||
|
||||
[assembly: InternalsVisibleTo("Microsoft.DotNet.Configurer.UnitTests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
|
||||
34
src/Microsoft.DotNet.Configurer/project.json
Normal file
34
src/Microsoft.DotNet.Configurer/project.json
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
{
|
||||
"version": "1.0.0-rc3-*",
|
||||
"buildOptions": {
|
||||
"warningsAsErrors": true,
|
||||
"keyFile": "../../tools/Key.snk",
|
||||
},
|
||||
"dependencies": {
|
||||
"Microsoft.DotNet.InternalAbstractions": {
|
||||
"target": "project"
|
||||
},
|
||||
"Microsoft.DotNet.Cli.Utils": {
|
||||
"target": "project"
|
||||
},
|
||||
"Microsoft.DotNet.ProjectModel": {
|
||||
"target": "project"
|
||||
},
|
||||
"Microsoft.DotNet.Archive": {
|
||||
"target": "project"
|
||||
}
|
||||
},
|
||||
"frameworks": {
|
||||
"netstandard1.6": {
|
||||
"imports": [
|
||||
"portable-net45+wp80+win8+wpa81+dnxcore50"
|
||||
]
|
||||
}
|
||||
},
|
||||
"packOptions": {
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/dotnet/cli"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -2,6 +2,7 @@
|
|||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System.IO;
|
||||
using Microsoft.DotNet.InternalAbstractions;
|
||||
|
||||
namespace Microsoft.Extensions.EnvironmentAbstractions
|
||||
{
|
||||
|
|
@ -11,5 +12,10 @@ namespace Microsoft.Extensions.EnvironmentAbstractions
|
|||
{
|
||||
return Directory.Exists(path);
|
||||
}
|
||||
|
||||
public ITemporaryDirectory CreateTemporaryDirectory()
|
||||
{
|
||||
return new TemporaryDirectory();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,6 +1,7 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System;
|
||||
using System.IO;
|
||||
|
||||
namespace Microsoft.Extensions.EnvironmentAbstractions
|
||||
|
|
@ -21,5 +22,29 @@ namespace Microsoft.Extensions.EnvironmentAbstractions
|
|||
{
|
||||
return File.OpenRead(path);
|
||||
}
|
||||
|
||||
public Stream OpenFile(
|
||||
string path,
|
||||
FileMode fileMode,
|
||||
FileAccess fileAccess,
|
||||
FileShare fileShare,
|
||||
int bufferSize,
|
||||
FileOptions fileOptions)
|
||||
{
|
||||
return new FileStream(path, fileMode, fileAccess, fileShare, bufferSize, fileOptions);
|
||||
}
|
||||
|
||||
public void CreateEmptyFile(string path)
|
||||
{
|
||||
try
|
||||
{
|
||||
var emptyFile = File.Create(path);
|
||||
if (emptyFile != null)
|
||||
{
|
||||
emptyFile.Dispose();
|
||||
}
|
||||
}
|
||||
catch { }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -6,5 +6,7 @@ namespace Microsoft.Extensions.EnvironmentAbstractions
|
|||
internal interface IDirectory
|
||||
{
|
||||
bool Exists(string path);
|
||||
|
||||
ITemporaryDirectory CreateTemporaryDirectory();
|
||||
}
|
||||
}
|
||||
|
|
@ -12,5 +12,15 @@ namespace Microsoft.Extensions.EnvironmentAbstractions
|
|||
string ReadAllText(string path);
|
||||
|
||||
Stream OpenRead(string path);
|
||||
|
||||
Stream OpenFile(
|
||||
string path,
|
||||
FileMode fileMode,
|
||||
FileAccess fileAccess,
|
||||
FileShare fileShare,
|
||||
int bufferSize,
|
||||
FileOptions fileOptions);
|
||||
|
||||
void CreateEmptyFile(string path);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System;
|
||||
|
||||
namespace Microsoft.Extensions.EnvironmentAbstractions
|
||||
{
|
||||
internal interface ITemporaryDirectory : IDisposable
|
||||
{
|
||||
string DirectoryPath { get; }
|
||||
}
|
||||
}
|
||||
|
|
@ -2,4 +2,7 @@
|
|||
|
||||
[assembly: InternalsVisibleTo("Microsoft.Extensions.DependencyModel, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
|
||||
[assembly: InternalsVisibleTo("Microsoft.DotNet.Tools.Tests.Utilities, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
|
||||
[assembly: InternalsVisibleTo("Microsoft.Extensions.DependencyModel.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
|
||||
[assembly: InternalsVisibleTo("Microsoft.Extensions.DependencyModel.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
|
||||
[assembly: InternalsVisibleTo("Microsoft.DotNet.Configurer, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
|
||||
[assembly: InternalsVisibleTo("Microsoft.DotNet.Configurer.UnitTests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
|
||||
[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7")]
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using Microsoft.Extensions.EnvironmentAbstractions;
|
||||
using System.IO;
|
||||
|
||||
namespace Microsoft.DotNet.InternalAbstractions
|
||||
{
|
||||
internal class TemporaryDirectory : ITemporaryDirectory
|
||||
{
|
||||
public string DirectoryPath { get; }
|
||||
|
||||
public TemporaryDirectory()
|
||||
{
|
||||
DirectoryPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
|
||||
Directory.CreateDirectory(DirectoryPath);
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
try
|
||||
{
|
||||
Directory.Delete(DirectoryPath, true);
|
||||
}
|
||||
catch
|
||||
{
|
||||
// Ignore failures here.
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
110
src/dotnet-archive/Program.cs
Normal file
110
src/dotnet-archive/Program.cs
Normal file
|
|
@ -0,0 +1,110 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using Microsoft.DotNet.Cli.CommandLine;
|
||||
//using Microsoft.DotNet.Cli.Utils;
|
||||
using Microsoft.DotNet.Archive;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Reflection;
|
||||
|
||||
namespace Microsoft.DotNet.Tools.Archive
|
||||
{
|
||||
|
||||
public partial class ArchiveCommand
|
||||
{
|
||||
public static int Main(string[] args)
|
||||
{
|
||||
//DebugHelper.HandleDebugSwitch(ref args);
|
||||
|
||||
var app = new CommandLineApplication();
|
||||
app.Name = "archive";
|
||||
app.FullName = ".NET archiver";
|
||||
app.Description = "Archives and expands sets of files";
|
||||
app.HelpOption("-h|--help");
|
||||
|
||||
var extract = app.Option("-x|--extract <outputDirectory>", "Directory to extract to", CommandOptionType.SingleValue);
|
||||
var archiveFile = app.Option("-a|--archive <file>", "Archive to operate on", CommandOptionType.SingleValue);
|
||||
var externals = app.Option("--external <external>...", "External files and directories to consider for extraction", CommandOptionType.MultipleValue);
|
||||
var sources = app.Argument("<sources>...", "Files & directory to include in the archive", multipleValues:true);
|
||||
|
||||
app.OnExecute(() => {
|
||||
|
||||
if (extract.HasValue() && sources.Values.Any())
|
||||
{
|
||||
Console.WriteLine("Extract '-x' can only be specified when no '<sources>' are specified to add to the archive.");
|
||||
return 1;
|
||||
}
|
||||
else if (!extract.HasValue() && !sources.Values.Any())
|
||||
{
|
||||
Console.WriteLine("Either extract '-x' or '<sources>' must be specified.");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (!archiveFile.HasValue())
|
||||
{
|
||||
Console.WriteLine("Archive '-a' must be specified.");
|
||||
return 1;
|
||||
}
|
||||
|
||||
var progress = new ConsoleProgressReport();
|
||||
|
||||
var archive = new IndexedArchive();
|
||||
foreach (var external in externals.Values)
|
||||
{
|
||||
if (Directory.Exists(external))
|
||||
{
|
||||
archive.AddExternalDirectory(external);
|
||||
}
|
||||
else
|
||||
{
|
||||
archive.AddExternalFile(external);
|
||||
}
|
||||
}
|
||||
|
||||
if (sources.Values.Any())
|
||||
{
|
||||
foreach(var source in sources.Values)
|
||||
{
|
||||
if (Directory.Exists(source))
|
||||
{
|
||||
archive.AddDirectory(source, progress);
|
||||
}
|
||||
else
|
||||
{
|
||||
archive.AddFile(source, Path.GetFileName(source));
|
||||
}
|
||||
}
|
||||
|
||||
archive.Save(archiveFile.Value(), progress);
|
||||
}
|
||||
else // sources not specified, extract must have been specified
|
||||
{
|
||||
archive.Extract(archiveFile.Value(), extract.Value(), progress);
|
||||
|
||||
}
|
||||
|
||||
return 0;
|
||||
});
|
||||
|
||||
try
|
||||
{
|
||||
return app.Execute(args);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
#if DEBUG
|
||||
//Reporter.Error.WriteLine(ex.ToString());
|
||||
Console.WriteLine(ex.ToString());
|
||||
#else
|
||||
// Reporter.Error.WriteLine(ex.Message);
|
||||
Console.WriteLine(ex.Message);
|
||||
#endif
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
23
src/dotnet-archive/project.json
Normal file
23
src/dotnet-archive/project.json
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
{
|
||||
"buildOptions": {
|
||||
"emitEntryPoint": true,
|
||||
"compile": {
|
||||
"include": [
|
||||
"**/*.cs",
|
||||
"../dotnet/CommandLine/*.cs"
|
||||
]
|
||||
}
|
||||
},
|
||||
"dependencies": {
|
||||
"Microsoft.DotNet.Archive": {
|
||||
"target": "project"
|
||||
},
|
||||
"Microsoft.NETCore.App": {
|
||||
"type": "platform",
|
||||
"version": "1.0.0-rc3-004449-00"
|
||||
}
|
||||
},
|
||||
"frameworks": {
|
||||
"netcoreapp1.0": {}
|
||||
}
|
||||
}
|
||||
|
|
@ -8,6 +8,7 @@ using System.Linq;
|
|||
using System.Runtime.Loader;
|
||||
using System.Text;
|
||||
using Microsoft.DotNet.Cli.Utils;
|
||||
using Microsoft.DotNet.Configurer;
|
||||
using Microsoft.DotNet.InternalAbstractions;
|
||||
using Microsoft.DotNet.ProjectModel.Server;
|
||||
using Microsoft.DotNet.Tools.Build;
|
||||
|
|
@ -54,6 +55,8 @@ namespace Microsoft.DotNet.Cli
|
|||
|
||||
try
|
||||
{
|
||||
ConfigureDotNetForFirstTimeUse();
|
||||
|
||||
using (PerfTrace.Current.CaptureTiming())
|
||||
{
|
||||
return ProcessArgs(args, new Telemetry());
|
||||
|
|
@ -157,6 +160,28 @@ namespace Microsoft.DotNet.Cli
|
|||
|
||||
}
|
||||
|
||||
private static void ConfigureDotNetForFirstTimeUse()
|
||||
{
|
||||
using (PerfTrace.Current.CaptureTiming())
|
||||
{
|
||||
using (var nugetPackagesArchiver = new NuGetPackagesArchiver())
|
||||
{
|
||||
using (var nugetCacheSentinel = new NuGetCacheSentinel())
|
||||
{
|
||||
var environmentProvider = new EnvironmentProvider();
|
||||
var commandFactory = new DotNetCommandFactory();
|
||||
var nugetCachePrimer =
|
||||
new NuGetCachePrimer(commandFactory, nugetPackagesArchiver, nugetCacheSentinel);
|
||||
var dotnetConfigurer = new DotnetFirstTimeUseConfigurer(
|
||||
nugetCachePrimer,
|
||||
nugetCacheSentinel,
|
||||
environmentProvider);
|
||||
|
||||
dotnetConfigurer.Configure();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static void InitializeProcess()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -43,6 +43,9 @@
|
|||
"Microsoft.Extensions.Testing.Abstractions": {
|
||||
"target": "project"
|
||||
},
|
||||
"Microsoft.DotNet.Configurer": {
|
||||
"target": "project"
|
||||
},
|
||||
"Microsoft.NETCore.App": {
|
||||
"type": "platform",
|
||||
"version": "1.0.0-rc3-004459-00"
|
||||
|
|
|
|||
|
|
@ -0,0 +1,94 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using FluentAssertions;
|
||||
using Microsoft.DotNet.Cli.Utils;
|
||||
using Microsoft.DotNet.Configurer;
|
||||
using Microsoft.DotNet.Tools.Test;
|
||||
using Microsoft.Extensions.DependencyModel.Tests;
|
||||
using Moq;
|
||||
using Xunit;
|
||||
|
||||
namespace Microsoft.DotNet.Configurer.UnitTests
|
||||
{
|
||||
public class GivenADotnetFirstTimeUseConfigurer
|
||||
{
|
||||
private Mock<INuGetCachePrimer> _nugetCachePrimerMock;
|
||||
private Mock<INuGetCacheSentinel> _nugetCacheSentinelMock;
|
||||
private Mock<IEnvironmentProvider> _environmentProviderMock;
|
||||
|
||||
public GivenADotnetFirstTimeUseConfigurer()
|
||||
{
|
||||
_nugetCachePrimerMock = new Mock<INuGetCachePrimer>();
|
||||
_nugetCacheSentinelMock = new Mock<INuGetCacheSentinel>();
|
||||
_environmentProviderMock = new Mock<IEnvironmentProvider>();
|
||||
|
||||
_environmentProviderMock
|
||||
.Setup(e => e.GetEnvironmentVariableAsBool("DOTNET_SKIP_FIRST_TIME_EXPERIENCE", false))
|
||||
.Returns(false);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_does_not_prime_the_cache_if_the_sentinel_exists()
|
||||
{
|
||||
_nugetCacheSentinelMock.Setup(n => n.Exists()).Returns(true);
|
||||
|
||||
var dotnetFirstTimeUseConfigurer = new DotnetFirstTimeUseConfigurer(
|
||||
_nugetCachePrimerMock.Object,
|
||||
_nugetCacheSentinelMock.Object,
|
||||
_environmentProviderMock.Object);
|
||||
|
||||
dotnetFirstTimeUseConfigurer.Configure();
|
||||
|
||||
_nugetCachePrimerMock.Verify(r => r.PrimeCache(), Times.Never);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_does_not_prime_the_cache_if_first_run_experience_is_already_happening()
|
||||
{
|
||||
_nugetCacheSentinelMock.Setup(n => n.InProgressSentinelAlreadyExists()).Returns(true);
|
||||
|
||||
var dotnetFirstTimeUseConfigurer = new DotnetFirstTimeUseConfigurer(
|
||||
_nugetCachePrimerMock.Object,
|
||||
_nugetCacheSentinelMock.Object,
|
||||
_environmentProviderMock.Object);
|
||||
|
||||
dotnetFirstTimeUseConfigurer.Configure();
|
||||
|
||||
_nugetCachePrimerMock.Verify(r => r.PrimeCache(), Times.Never);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_does_not_prime_the_cache_if_the_sentinel_exists_but_the_user_has_set_the_DOTNET_SKIP_FIRST_TIME_EXPERIENCE_environemnt_variable()
|
||||
{
|
||||
_nugetCacheSentinelMock.Setup(n => n.Exists()).Returns(false);
|
||||
_environmentProviderMock
|
||||
.Setup(e => e.GetEnvironmentVariableAsBool("DOTNET_SKIP_FIRST_TIME_EXPERIENCE", false))
|
||||
.Returns(true);
|
||||
|
||||
var dotnetFirstTimeUseConfigurer = new DotnetFirstTimeUseConfigurer(
|
||||
_nugetCachePrimerMock.Object,
|
||||
_nugetCacheSentinelMock.Object,
|
||||
_environmentProviderMock.Object);
|
||||
|
||||
dotnetFirstTimeUseConfigurer.Configure();
|
||||
|
||||
_nugetCachePrimerMock.Verify(r => r.PrimeCache(), Times.Never);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_primes_the_cache_if_the_sentinel_does_not_exist()
|
||||
{
|
||||
_nugetCacheSentinelMock.Setup(n => n.Exists()).Returns(false);
|
||||
|
||||
var dotnetFirstTimeUseConfigurer = new DotnetFirstTimeUseConfigurer(
|
||||
_nugetCachePrimerMock.Object,
|
||||
_nugetCacheSentinelMock.Object,
|
||||
_environmentProviderMock.Object);
|
||||
|
||||
dotnetFirstTimeUseConfigurer.Configure();
|
||||
|
||||
_nugetCachePrimerMock.Verify(r => r.PrimeCache(), Times.Once);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,232 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using FluentAssertions;
|
||||
using Microsoft.DotNet.Cli.Utils;
|
||||
using Microsoft.DotNet.Tools.Test.Utilities.Mock;
|
||||
using Microsoft.Extensions.DependencyModel.Tests;
|
||||
using Microsoft.Extensions.EnvironmentAbstractions;
|
||||
using Moq;
|
||||
using NuGet.Frameworks;
|
||||
using Xunit;
|
||||
|
||||
namespace Microsoft.DotNet.Configurer.UnitTests
|
||||
{
|
||||
public class GivenANuGetCachePrimer
|
||||
{
|
||||
private const string COMPRESSED_ARCHIVE_PATH = "a path to somewhere";
|
||||
private const string TEMPORARY_FOLDER_PATH = "some path";
|
||||
private const string PACKAGES_ARCHIVE_PATH = "some other path";
|
||||
|
||||
private IFileSystem _fileSystemMock;
|
||||
private ITemporaryDirectoryMock _temporaryDirectoryMock;
|
||||
|
||||
private Mock<ICommandFactory> _commandFactoryMock;
|
||||
private Mock<ICommand> _dotnetNewCommandMock;
|
||||
private Mock<ICommand> _dotnetRestoreCommandMock;
|
||||
private Mock<INuGetPackagesArchiver> _nugetPackagesArchiverMock;
|
||||
private Mock<INuGetCacheSentinel> _nugetCacheSentinel;
|
||||
|
||||
public GivenANuGetCachePrimer()
|
||||
{
|
||||
var fileSystemMockBuilder = FileSystemMockBuilder.Create();
|
||||
fileSystemMockBuilder.TemporaryFolder = TEMPORARY_FOLDER_PATH;
|
||||
fileSystemMockBuilder.AddFile(COMPRESSED_ARCHIVE_PATH);
|
||||
_fileSystemMock = fileSystemMockBuilder.Build();
|
||||
_temporaryDirectoryMock = (ITemporaryDirectoryMock)_fileSystemMock.Directory.CreateTemporaryDirectory();
|
||||
|
||||
_commandFactoryMock = SetupCommandFactoryMock();
|
||||
|
||||
_nugetPackagesArchiverMock = new Mock<INuGetPackagesArchiver>();
|
||||
_nugetPackagesArchiverMock.Setup(n => n.ExtractArchive()).Returns(PACKAGES_ARCHIVE_PATH);
|
||||
_nugetPackagesArchiverMock.Setup(n => n.NuGetPackagesArchive).Returns(COMPRESSED_ARCHIVE_PATH);
|
||||
|
||||
_nugetCacheSentinel = new Mock<INuGetCacheSentinel>();
|
||||
|
||||
var nugetCachePrimer = new NuGetCachePrimer(
|
||||
_commandFactoryMock.Object,
|
||||
_nugetPackagesArchiverMock.Object,
|
||||
_nugetCacheSentinel.Object,
|
||||
_fileSystemMock.Directory,
|
||||
_fileSystemMock.File);
|
||||
|
||||
nugetCachePrimer.PrimeCache();
|
||||
}
|
||||
|
||||
private Mock<ICommandFactory> SetupCommandFactoryMock()
|
||||
{
|
||||
var commandFactoryMock = new Mock<ICommandFactory>();
|
||||
|
||||
_dotnetNewCommandMock = new Mock<ICommand>();
|
||||
SetupCommandMock(_dotnetNewCommandMock);
|
||||
commandFactoryMock
|
||||
.Setup(c => c.Create("new", Enumerable.Empty<string>(), null, Constants.DefaultConfiguration))
|
||||
.Returns(_dotnetNewCommandMock.Object);
|
||||
|
||||
_dotnetRestoreCommandMock = new Mock<ICommand>();
|
||||
SetupCommandMock(_dotnetRestoreCommandMock);
|
||||
commandFactoryMock
|
||||
.Setup(c => c.Create(
|
||||
"restore",
|
||||
It.IsAny<IEnumerable<string>>(),
|
||||
null,
|
||||
Constants.DefaultConfiguration))
|
||||
.Returns(_dotnetRestoreCommandMock.Object);
|
||||
|
||||
return commandFactoryMock;
|
||||
}
|
||||
|
||||
private void SetupCommandMock(Mock<ICommand> commandMock)
|
||||
{
|
||||
commandMock
|
||||
.Setup(c => c.WorkingDirectory(TEMPORARY_FOLDER_PATH))
|
||||
.Returns(commandMock.Object);
|
||||
commandMock.Setup(c => c.CaptureStdOut()).Returns(commandMock.Object);
|
||||
commandMock.Setup(c => c.CaptureStdErr()).Returns(commandMock.Object);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_does_not_prime_the_NuGet_cache_if_the_archive_is_not_found_so_that_we_do_not_need_to_generate_the_archive_for_stage1()
|
||||
{
|
||||
var fileSystemMockBuilder = FileSystemMockBuilder.Create();
|
||||
var fileSystemMock = fileSystemMockBuilder.Build();
|
||||
|
||||
var commandFactoryMock = SetupCommandFactoryMock();
|
||||
|
||||
var nugetPackagesArchiverMock = new Mock<INuGetPackagesArchiver>();
|
||||
nugetPackagesArchiverMock.Setup(n => n.NuGetPackagesArchive).Returns(COMPRESSED_ARCHIVE_PATH);
|
||||
|
||||
var nugetCachePrimer = new NuGetCachePrimer(
|
||||
commandFactoryMock.Object,
|
||||
nugetPackagesArchiverMock.Object,
|
||||
_nugetCacheSentinel.Object,
|
||||
fileSystemMock.Directory,
|
||||
fileSystemMock.File);
|
||||
|
||||
nugetCachePrimer.PrimeCache();
|
||||
|
||||
nugetPackagesArchiverMock.Verify(n => n.ExtractArchive(), Times.Never);
|
||||
commandFactoryMock.Verify(c => c.Create(
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<IEnumerable<string>>(),
|
||||
null,
|
||||
Constants.DefaultConfiguration), Times.Never);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_disposes_the_temporary_directory_created_for_the_temporary_project_used_to_prime_the_cache()
|
||||
{
|
||||
_temporaryDirectoryMock.DisposedTemporaryDirectory.Should().BeTrue();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_runs_dotnet_new_using_the_temporary_folder()
|
||||
{
|
||||
_dotnetNewCommandMock.Verify(c => c.WorkingDirectory(TEMPORARY_FOLDER_PATH), Times.Once);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_runs_dotnet_new_capturing_stdout()
|
||||
{
|
||||
_dotnetNewCommandMock.Verify(c => c.CaptureStdOut(), Times.Once);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_runs_dotnet_new_capturing_stderr()
|
||||
{
|
||||
_dotnetNewCommandMock.Verify(c => c.CaptureStdErr(), Times.Once);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_actually_runs_dotnet_new()
|
||||
{
|
||||
_dotnetNewCommandMock.Verify(c => c.Execute(), Times.Once);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_uses_the_packages_archive_with_dotnet_restore()
|
||||
{
|
||||
_commandFactoryMock.Verify(
|
||||
c => c.Create(
|
||||
"restore",
|
||||
new [] {"-s", $"{PACKAGES_ARCHIVE_PATH}"},
|
||||
null,
|
||||
Constants.DefaultConfiguration),
|
||||
Times.Once);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_does_not_run_restore_if_dotnet_new_fails()
|
||||
{
|
||||
var commandFactoryMock = SetupCommandFactoryMock();
|
||||
_dotnetNewCommandMock.Setup(c => c.Execute()).Returns(new CommandResult(null, -1, null, null));
|
||||
|
||||
var nugetCachePrimer = new NuGetCachePrimer(
|
||||
commandFactoryMock.Object,
|
||||
_nugetPackagesArchiverMock.Object,
|
||||
_nugetCacheSentinel.Object,
|
||||
_fileSystemMock.Directory,
|
||||
_fileSystemMock.File);
|
||||
|
||||
nugetCachePrimer.PrimeCache();
|
||||
|
||||
commandFactoryMock.Verify(
|
||||
c => c.Create(
|
||||
"restore",
|
||||
It.IsAny<IEnumerable<string>>(),
|
||||
It.IsAny<NuGetFramework>(),
|
||||
It.IsAny<string>()),
|
||||
Times.Never);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_runs_dotnet_restore_using_the_temporary_folder()
|
||||
{
|
||||
_dotnetRestoreCommandMock.Verify(c => c.WorkingDirectory(TEMPORARY_FOLDER_PATH), Times.Once);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_runs_dotnet_restore_capturing_stdout()
|
||||
{
|
||||
_dotnetRestoreCommandMock.Verify(c => c.CaptureStdOut(), Times.Once);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_runs_dotnet_restore_capturing_stderr()
|
||||
{
|
||||
_dotnetRestoreCommandMock.Verify(c => c.CaptureStdErr(), Times.Once);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_actually_runs_dotnet_restore()
|
||||
{
|
||||
_dotnetRestoreCommandMock.Verify(c => c.Execute(), Times.Once);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_creates_a_sentinel_when_restore_succeeds()
|
||||
{
|
||||
_nugetCacheSentinel.Verify(n => n.CreateIfNotExists(), Times.Once);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_does_not_create_a_sentinel_when_restore_fails()
|
||||
{
|
||||
var nugetCacheSentinel = new Mock<INuGetCacheSentinel>();
|
||||
_dotnetRestoreCommandMock.Setup(c => c.Execute()).Returns(new CommandResult(null, -1, null, null));
|
||||
|
||||
var nugetCachePrimer = new NuGetCachePrimer(
|
||||
_commandFactoryMock.Object,
|
||||
_nugetPackagesArchiverMock.Object,
|
||||
nugetCacheSentinel.Object,
|
||||
_fileSystemMock.Directory,
|
||||
_fileSystemMock.File);
|
||||
|
||||
nugetCachePrimer.PrimeCache();
|
||||
|
||||
nugetCacheSentinel.Verify(n => n.CreateIfNotExists(), Times.Never);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,191 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System;
|
||||
using System.IO;
|
||||
using FluentAssertions;
|
||||
using Microsoft.DotNet.Cli.Utils;
|
||||
using Microsoft.DotNet.Configurer;
|
||||
using Microsoft.Extensions.DependencyModel.Tests;
|
||||
using Microsoft.Extensions.EnvironmentAbstractions;
|
||||
using Xunit;
|
||||
|
||||
namespace Microsoft.DotNet.Configurer.UnitTests
|
||||
{
|
||||
public class GivenANuGetCacheSentinel
|
||||
{
|
||||
private const string NUGET_CACHE_PATH = "some path";
|
||||
|
||||
private FileSystemMockBuilder _fileSystemMockBuilder;
|
||||
|
||||
public GivenANuGetCacheSentinel()
|
||||
{
|
||||
_fileSystemMockBuilder = FileSystemMockBuilder.Create();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void As_soon_as_it_gets_created_it_tries_to_get_handle_of_the_InProgress_sentinel()
|
||||
{
|
||||
var fileMock = new FileMock();
|
||||
var nugetCacheSentinel = new NuGetCacheSentinel(NUGET_CACHE_PATH, fileMock);
|
||||
|
||||
fileMock.OpenFileWithRightParamsCalled.Should().BeTrue();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_returns_true_to_the_in_progress_sentinel_already_exists_when_it_fails_to_get_a_handle_to_it()
|
||||
{
|
||||
var fileMock = new FileMock();
|
||||
fileMock.InProgressSentinel = null;
|
||||
var nugetCacheSentinel = new NuGetCacheSentinel(NUGET_CACHE_PATH, fileMock);
|
||||
|
||||
nugetCacheSentinel.InProgressSentinelAlreadyExists().Should().BeTrue();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_returns_false_to_the_in_progress_sentinel_already_exists_when_it_succeeds_in_getting_a_handle_to_it()
|
||||
{
|
||||
var fileMock = new FileMock();
|
||||
fileMock.InProgressSentinel = new MemoryStream();
|
||||
var nugetCacheSentinel = new NuGetCacheSentinel(NUGET_CACHE_PATH, fileMock);
|
||||
|
||||
nugetCacheSentinel.InProgressSentinelAlreadyExists().Should().BeFalse();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_disposes_of_the_handle_to_the_InProgressSentinel_when_NuGetCacheSentinel_is_disposed()
|
||||
{
|
||||
var mockStream = new MockStream();
|
||||
var fileMock = new FileMock();
|
||||
fileMock.InProgressSentinel = mockStream;
|
||||
using (var nugetCacheSentinel = new NuGetCacheSentinel(NUGET_CACHE_PATH, fileMock))
|
||||
{}
|
||||
|
||||
mockStream.IsDisposed.Should().BeTrue();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void The_sentinel_has_the_current_version_in_its_name()
|
||||
{
|
||||
NuGetCacheSentinel.SENTINEL.Should().Contain($"{Product.Version}");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_returns_true_if_the_sentinel_exists()
|
||||
{
|
||||
_fileSystemMockBuilder.AddFiles(NUGET_CACHE_PATH, NuGetCacheSentinel.SENTINEL);
|
||||
|
||||
var fileSystemMock = _fileSystemMockBuilder.Build();
|
||||
|
||||
var nugetCacheSentinel = new NuGetCacheSentinel(NUGET_CACHE_PATH, fileSystemMock.File);
|
||||
|
||||
nugetCacheSentinel.Exists().Should().BeTrue();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_returns_false_if_the_sentinel_does_not_exist()
|
||||
{
|
||||
var fileSystemMock = _fileSystemMockBuilder.Build();
|
||||
|
||||
var nugetCacheSentinel = new NuGetCacheSentinel(NUGET_CACHE_PATH, fileSystemMock.File);
|
||||
|
||||
nugetCacheSentinel.Exists().Should().BeFalse();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_creates_the_sentinel_in_the_nuget_cache_path_if_it_does_not_exist_already()
|
||||
{
|
||||
var fileSystemMock = _fileSystemMockBuilder.Build();
|
||||
var nugetCacheSentinel = new NuGetCacheSentinel(NUGET_CACHE_PATH, fileSystemMock.File);
|
||||
|
||||
nugetCacheSentinel.Exists().Should().BeFalse();
|
||||
|
||||
nugetCacheSentinel.CreateIfNotExists();
|
||||
|
||||
nugetCacheSentinel.Exists().Should().BeTrue();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_does_not_create_the_sentinel_again_if_it_already_exists_in_the_nuget_cache_path()
|
||||
{
|
||||
const string contentToValidateSentinalWasNotReplaced = "some string";
|
||||
var sentinel = Path.Combine(NUGET_CACHE_PATH, NuGetCacheSentinel.SENTINEL);
|
||||
_fileSystemMockBuilder.AddFile(sentinel, contentToValidateSentinalWasNotReplaced);
|
||||
|
||||
var fileSystemMock = _fileSystemMockBuilder.Build();
|
||||
|
||||
var nugetCacheSentinel = new NuGetCacheSentinel(NUGET_CACHE_PATH, fileSystemMock.File);
|
||||
|
||||
nugetCacheSentinel.Exists().Should().BeTrue();
|
||||
|
||||
nugetCacheSentinel.CreateIfNotExists();
|
||||
|
||||
fileSystemMock.File.ReadAllText(sentinel).Should().Be(contentToValidateSentinalWasNotReplaced);
|
||||
}
|
||||
|
||||
private class FileMock : IFile
|
||||
{
|
||||
public bool OpenFileWithRightParamsCalled { get; private set; }
|
||||
|
||||
public Stream InProgressSentinel { get; set;}
|
||||
|
||||
public bool Exists(string path)
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public string ReadAllText(string path)
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public Stream OpenRead(string path)
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public Stream OpenFile(
|
||||
string path,
|
||||
FileMode fileMode,
|
||||
FileAccess fileAccess,
|
||||
FileShare fileShare,
|
||||
int bufferSize,
|
||||
FileOptions fileOptions)
|
||||
{
|
||||
Stream fileStream = null;
|
||||
|
||||
var inProgressSentinel =
|
||||
Path.Combine(GivenANuGetCacheSentinel.NUGET_CACHE_PATH, NuGetCacheSentinel.INPROGRESS_SENTINEL);
|
||||
|
||||
if (path.Equals(inProgressSentinel) &&
|
||||
fileMode == FileMode.OpenOrCreate &&
|
||||
fileAccess == FileAccess.ReadWrite &&
|
||||
fileShare == FileShare.None &&
|
||||
bufferSize == 1 &&
|
||||
fileOptions == FileOptions.DeleteOnClose)
|
||||
{
|
||||
OpenFileWithRightParamsCalled = true;
|
||||
fileStream = InProgressSentinel;
|
||||
}
|
||||
|
||||
return fileStream;
|
||||
}
|
||||
|
||||
public void CreateEmptyFile(string path)
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
}
|
||||
|
||||
private class MockStream : MemoryStream
|
||||
{
|
||||
public bool IsDisposed { get; private set;}
|
||||
|
||||
protected override void Dispose(bool disposing)
|
||||
{
|
||||
base.Dispose(disposing);
|
||||
IsDisposed = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project ToolsVersion="14.0.23107" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<PropertyGroup>
|
||||
<VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0.23107</VisualStudioVersion>
|
||||
<VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VSToolsPath)\DNX\Microsoft.DNX.Props" Condition="'$(VSToolsPath)' != ''" />
|
||||
<PropertyGroup Label="Globals">
|
||||
<ProjectGuid>4c3b06d5-b6d5-4e5b-a44f-3ebe52a1c759</ProjectGuid>
|
||||
<RootNamespace>Microsoft.DotNet.Configurer.UnitTests</RootNamespace>
|
||||
<BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)'=='' ">..\..\artifacts\obj\$(MSBuildProjectName)</BaseIntermediateOutputPath>
|
||||
<OutputPath Condition="'$(OutputPath)'=='' ">..\..\artifacts\bin</OutputPath>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup>
|
||||
<SchemaVersion>2.0</SchemaVersion>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VSToolsPath)\DNX\Microsoft.DNX.targets" Condition="'$(VSToolsPath)' != ''" />
|
||||
</Project>
|
||||
35
test/Microsoft.DotNet.Configurer.UnitTests/project.json
Normal file
35
test/Microsoft.DotNet.Configurer.UnitTests/project.json
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
{
|
||||
"version": "1.0.0-*",
|
||||
"buildOptions": {
|
||||
"keyFile": "../../tools/Key.snk"
|
||||
},
|
||||
"dependencies": {
|
||||
"Microsoft.NETCore.App": {
|
||||
"type": "platform",
|
||||
"version": "1.0.0-rc3-004442-00"
|
||||
},
|
||||
"System.Diagnostics.TraceSource": "4.0.0-rc3-24131-00",
|
||||
"Microsoft.DotNet.Configurer": {
|
||||
"target": "project"
|
||||
},
|
||||
"Microsoft.DotNet.Tools.Tests.Utilities": {
|
||||
"target": "project"
|
||||
},
|
||||
"Microsoft.DotNet.Cli.Utils": {
|
||||
"target": "project"
|
||||
},
|
||||
"FluentAssertions": "4.0.0",
|
||||
"moq.netcore": "4.4.0-beta8",
|
||||
"xunit": "2.1.0",
|
||||
"dotnet-test-xunit": "1.0.0-rc2-192208-24"
|
||||
},
|
||||
"frameworks": {
|
||||
"netcoreapp1.0": {
|
||||
"imports": [
|
||||
"dotnet5.4",
|
||||
"portable-net451+win8"
|
||||
]
|
||||
}
|
||||
},
|
||||
"testRunner": "xunit"
|
||||
}
|
||||
|
|
@ -1,10 +1,12 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using Microsoft.DotNet.Tools.Test.Utilities.Mock;
|
||||
using Microsoft.Extensions.EnvironmentAbstractions;
|
||||
|
||||
namespace Microsoft.Extensions.DependencyModel.Tests
|
||||
|
|
@ -13,6 +15,8 @@ namespace Microsoft.Extensions.DependencyModel.Tests
|
|||
{
|
||||
private Dictionary<string, string> _files = new Dictionary<string, string>();
|
||||
|
||||
public string TemporaryFolder { get; set; }
|
||||
|
||||
internal static IFileSystem Empty { get; } = Create().Build();
|
||||
|
||||
public static FileSystemMockBuilder Create()
|
||||
|
|
@ -37,15 +41,15 @@ namespace Microsoft.Extensions.DependencyModel.Tests
|
|||
|
||||
internal IFileSystem Build()
|
||||
{
|
||||
return new FileSystemMock(_files);
|
||||
return new FileSystemMock(_files, TemporaryFolder);
|
||||
}
|
||||
|
||||
private class FileSystemMock : IFileSystem
|
||||
{
|
||||
public FileSystemMock(Dictionary<string, string> files)
|
||||
public FileSystemMock(Dictionary<string, string> files, string temporaryFolder)
|
||||
{
|
||||
File = new FileMock(files);
|
||||
Directory = new DirectoryMock(files);
|
||||
Directory = new DirectoryMock(files, temporaryFolder);
|
||||
}
|
||||
|
||||
public IFile File { get; }
|
||||
|
|
@ -80,14 +84,38 @@ namespace Microsoft.Extensions.DependencyModel.Tests
|
|||
{
|
||||
return new MemoryStream(Encoding.UTF8.GetBytes(ReadAllText(path)));
|
||||
}
|
||||
|
||||
public Stream OpenFile(
|
||||
string path,
|
||||
FileMode fileMode,
|
||||
FileAccess fileAccess,
|
||||
FileShare fileShare,
|
||||
int bufferSize,
|
||||
FileOptions fileOptions)
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public void CreateEmptyFile(string path)
|
||||
{
|
||||
_files.Add(path, string.Empty);
|
||||
}
|
||||
}
|
||||
|
||||
private class DirectoryMock : IDirectory
|
||||
{
|
||||
private Dictionary<string, string> _files;
|
||||
public DirectoryMock(Dictionary<string, string> files)
|
||||
private readonly TemporaryDirectoryMock _temporaryDirectory;
|
||||
|
||||
public DirectoryMock(Dictionary<string, string> files, string temporaryDirectory)
|
||||
{
|
||||
_files = files;
|
||||
_temporaryDirectory = new TemporaryDirectoryMock(temporaryDirectory);
|
||||
}
|
||||
|
||||
public ITemporaryDirectory CreateTemporaryDirectory()
|
||||
{
|
||||
return _temporaryDirectory;
|
||||
}
|
||||
|
||||
public bool Exists(string path)
|
||||
|
|
@ -95,6 +123,23 @@ namespace Microsoft.Extensions.DependencyModel.Tests
|
|||
return _files.Keys.Any(k => k.StartsWith(path));
|
||||
}
|
||||
}
|
||||
|
||||
private class TemporaryDirectoryMock : ITemporaryDirectoryMock
|
||||
{
|
||||
public bool DisposedTemporaryDirectory { get; private set; }
|
||||
|
||||
public TemporaryDirectoryMock(string temporaryDirectory)
|
||||
{
|
||||
DirectoryPath = temporaryDirectory;
|
||||
}
|
||||
|
||||
public string DirectoryPath { get; }
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
DisposedTemporaryDirectory = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,12 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using Microsoft.Extensions.EnvironmentAbstractions;
|
||||
|
||||
namespace Microsoft.DotNet.Tools.Test.Utilities.Mock
|
||||
{
|
||||
internal interface ITemporaryDirectoryMock : ITemporaryDirectory
|
||||
{
|
||||
bool DisposedTemporaryDirectory { get; }
|
||||
}
|
||||
}
|
||||
|
|
@ -1,3 +1,4 @@
|
|||
using System.Runtime.CompilerServices;
|
||||
|
||||
[assembly: InternalsVisibleTo("Microsoft.Extensions.DependencyModel.Tests , PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
|
||||
[assembly: InternalsVisibleTo("Microsoft.Extensions.DependencyModel.Tests , PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
|
||||
[assembly: InternalsVisibleTo("Microsoft.DotNet.Configurer.UnitTests , PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
|
||||
|
|
@ -142,15 +142,17 @@ namespace Microsoft.DotNet.Tools.Publish.Tests
|
|||
|
||||
[Fact]
|
||||
public void CrossPublishingSucceedsAndHasExpectedArtifacts()
|
||||
{
|
||||
var testNugetCache = "packages_cross_publish_test";
|
||||
{
|
||||
TestInstance instance = TestAssetsManager.CreateTestInstance(Path.Combine("PortableTests"));
|
||||
|
||||
|
||||
var testProject = Path.Combine(instance.TestRoot, "StandaloneApp", "project.json");
|
||||
var workingDirectory = Path.GetDirectoryName(testProject);
|
||||
var testNugetCache = Path.Combine(workingDirectory, "packages_cross_publish_test");
|
||||
|
||||
var restoreCommand = new RestoreCommand();
|
||||
|
||||
restoreCommand.WorkingDirectory = Path.GetDirectoryName(testProject);
|
||||
restoreCommand.WorkingDirectory = workingDirectory;
|
||||
|
||||
restoreCommand.Environment["NUGET_PACKAGES"] = testNugetCache;
|
||||
restoreCommand.Execute().Should().Pass();
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,77 @@
|
|||
// Copyright (c) .NET Foundation and contributors. All rights reserved.
|
||||
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
|
||||
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Collections.Generic;
|
||||
using Microsoft.DotNet.Cli.Utils;
|
||||
using Microsoft.DotNet.Cli;
|
||||
using Microsoft.DotNet.TestFramework;
|
||||
using Microsoft.DotNet.Tools.Test.Utilities;
|
||||
using Xunit;
|
||||
using FluentAssertions;
|
||||
|
||||
namespace Microsoft.DotNet.Tests
|
||||
{
|
||||
public class GivenThatTheUserIsRunningDotNetForTheFirstTime : TestBase
|
||||
{
|
||||
private static CommandResult _firstDotnetUseCommandResult;
|
||||
private static DirectoryInfo _nugetCacheFolder;
|
||||
|
||||
static GivenThatTheUserIsRunningDotNetForTheFirstTime()
|
||||
{
|
||||
var testDirectory = TestAssetsManager.CreateTestDirectory("Dotnet_first_time_experience_tests");
|
||||
var testNugetCache = Path.Combine(testDirectory.Path, "nuget_cache");
|
||||
|
||||
var command = new DotnetCommand()
|
||||
.WithWorkingDirectory(testDirectory.Path);
|
||||
command.Environment["NUGET_PACKAGES"] = testNugetCache;
|
||||
|
||||
_firstDotnetUseCommandResult = command.ExecuteWithCapturedOutput("new");
|
||||
|
||||
_nugetCacheFolder = new DirectoryInfo(testNugetCache);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Using_dotnet_for_the_first_time_succeeds()
|
||||
{
|
||||
_firstDotnetUseCommandResult.Should().Pass();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_shows_the_appropriate_message_to_the_user()
|
||||
{
|
||||
const string firstTimeUseWelcomeMessage = @"Welcome to .NET Core!
|
||||
---------------------
|
||||
Learn more about .NET Core @ https://aka.ms/dotnet-docs. Use dotnet --help to see available commands or go to https://aka.ms/dotnet-cli-docs.
|
||||
Telemetry
|
||||
--------------
|
||||
The .NET Core tools collect usage data in order to improve your experience. The data is anonymous and does not include commandline arguments. The data is collected by Microsoft and shared with the community.
|
||||
You can opt out of telemetry by setting a DOTNET_CLI_TELEMETRY_OPTOUT environment variable to 1 using your favorite shell.
|
||||
You can read more about .NET Core tools telemetry @ https://aka.ms/dotnet-cli-telemetry.
|
||||
Configuring...
|
||||
-------------------
|
||||
A command is running to initially populate your local package cache, to improve restore speed and enable offline access. This command will take up to a minute to complete and will only happen once.";
|
||||
|
||||
_firstDotnetUseCommandResult.StdOut.Should().StartWith(firstTimeUseWelcomeMessage);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_restores_the_nuget_packages_to_the_nuget_cache_folder()
|
||||
{
|
||||
_nugetCacheFolder.Should().HaveFile($"{GetDotnetVersion()}.dotnetSentinel");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void It_creates_a_sentinel_file_under_the_nuget_cache_folder()
|
||||
{
|
||||
_nugetCacheFolder.Should().HaveDirectory("Microsoft.NETCore.App");
|
||||
}
|
||||
|
||||
private string GetDotnetVersion()
|
||||
{
|
||||
return new DotnetCommand().ExecuteWithCapturedOutput("--version").StdOut
|
||||
.TrimEnd(Environment.NewLine.ToCharArray());
|
||||
}
|
||||
}
|
||||
}
|
||||
20
tools/Archiver/project.json
Normal file
20
tools/Archiver/project.json
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
{
|
||||
"buildOptions": {
|
||||
"emitEntryPoint": true,
|
||||
"compile": {
|
||||
"include": [
|
||||
"../../src/dotnet-archive/*.cs",
|
||||
"../../src/dotnet/CommandLine/*.cs"
|
||||
]
|
||||
}
|
||||
},
|
||||
"dependencies": {
|
||||
"Microsoft.DotNet.Archive": {
|
||||
"target": "project"
|
||||
},
|
||||
"Microsoft.NETCore.App": "1.0.0-rc3-004442-00"
|
||||
},
|
||||
"frameworks": {
|
||||
"netcoreapp1.0": {}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue