public async Task GenerateJson()
{
var runningVersion = typeof(Core.Constants).GetTypeInfo().Assembly.GetName().Version.ToString(3);
string expectedManifest = @"{
""nameVersion"": """ + runningVersion + @""",
""name"":""NAME.Tests"",
""version"":""1.0.0"",
""infrastructure_dependencies"":[
{
""name"":""Mongo"",
""version"":""" + Constants.SpecificMongoVersion + @""",
""min_version"":""2.6.0"",
""max_version"":""*"",
""value"":""mongodb://" + Constants.SpecificMongoHostname + @":27017/nPVR_Dev_TST""
}
],
""service_dependencies"":[
]
}";
ParsedDependencies dependencies = DependenciesReader.ReadDependencies(CONFIGURATION_FILE, new DummyFilePathMapper(), new Core.NAMESettings(), new Core.NAMEContext());
string manifest = await ManifestGenerator.GenerateJson("NAME.Tests", runningVersion, dependencies);
Assert.Equal(
expectedManifest.Replace(" ", string.Empty).Replace("\t", "").Replace("\r", "").Replace("\n", ""),
manifest.Replace(" ", string.Empty).Replace("\t", "").Replace("\r", "").Replace("\n", ""));
}
public static string CalculateDigest(string path, ManifestFormat format, ITaskHandler handler)
{
var manifestGenerator = new ManifestGenerator(path, format);
handler.RunTask(manifestGenerator);
return(manifestGenerator.Manifest.CalculateDigest());
}
public async Task GenerateJson_ServiceWithoutNAME()
{
var runningVersion = typeof(ManifestGeneratorTests).GetTypeInfo().Assembly.GetName().Version.ToString(3);
string expectedManifest = @"{
""nameVersion"": """ + NAME.Core.Constants.NAME_ASSEMBLY_VERSION + @""",
""name"":""NAME.Tests"",
""version"":""" + runningVersion + @""",
""infrastructure_dependencies"":[
],
""service_dependencies"":[
{
""name"": ""dummy"",
""error"": ""Dependency does not have NAME installed!"",
""status"":""" + NAMEStatusLevel.Warn.ToString() + @""",
""min_version"": ""1.0.0"",
""max_version"": ""2.*"",
""value"": ""http://" + Constants.SpecificServiceHostname + @":5000/endpoint/before/name/middleware""
}
]
}";
ParsedDependencies dependencies = DependenciesReader.ReadDependencies(SERVICE_WITHOUT_NAME_CONFIGURATION_FILE, new DummyFilePathMapper(), new Core.NAMESettings(), new Core.NAMEContext());
string manifest = await ManifestGenerator.GenerateJson("NAME.Tests", runningVersion, dependencies);
Assert.Equal(
expectedManifest.Replace(" ", string.Empty).Replace("\t", "").Replace("\r", "").Replace("\n", ""),
manifest.Replace(" ", string.Empty).Replace("\t", "").Replace("\r", "").Replace("\n", ""));
}
protected override void Run()
{
var invalid = Path.GetInvalidFileNameChars();
if (Name.Any(c => invalid.Contains(c)))
{
throw new PSArgumentException($"The file name '{Name}' contains invalid characters");
}
var organizer = new SnippetOrganizer(Options, FileAssociations);
var package = organizer.CreateCustomWorkspace(Name, Tags, Languages, OrderBy, SortDirection, HideMetaFiles);
package.Publish(Options, Overwrite);
var manifestGenerator = new ManifestGenerator();
manifestGenerator.Add(package);
var manifest = manifestGenerator.ToManifest(OrderBy, SortDirection);
manifest.Publish(Options.WorkspacePath);
if (Sync || Options.AutoSync)
{
CommitAndPush("New custom workspace");
}
}
private Manifest GenerateManifest(string path, string?subdir)
{
if (Directory.Exists(path))
{
if (!string.IsNullOrEmpty(subdir))
{
throw new OptionException(Resources.TooManyArguments + Environment.NewLine + subdir.EscapeArgument(), null);
}
var generator = new ManifestGenerator(path, _algorithm);
Handler.RunTask(generator);
return(generator.Manifest);
}
else if (File.Exists(path))
{
using var tempDir = new TemporaryDirectory("0install");
using (var extractor = ArchiveExtractor.Create(path, tempDir, Archive.GuessMimeType(path)))
{
extractor.Extract = subdir;
Handler.RunTask(extractor);
}
var generator = new ManifestGenerator(tempDir, _algorithm);
Handler.RunTask(generator);
return(generator.Manifest);
}
else
{
throw new FileNotFoundException(string.Format(Resources.FileOrDirNotFound, path));
}
}
private Manifest GenerateManifest(string path, string subdir)
{
if (Directory.Exists(path))
{
if (!string.IsNullOrEmpty(subdir))
{
throw new OptionException(Resources.TooManyArguments, "");
}
var generator = new ManifestGenerator(path, _algorithm);
Handler.RunTask(generator);
return(generator.Result);
}
else if (File.Exists(path))
{
using (var tempDir = new TemporaryDirectory("0install"))
{
using (var extractor = Extractor.FromFile(path, tempDir))
{
extractor.SubDir = subdir;
Handler.RunTask(extractor);
}
var generator = new ManifestGenerator(tempDir, _algorithm);
Handler.RunTask(generator);
return(generator.Result);
}
}
else
{
throw new FileNotFoundException(string.Format(Resources.FileOrDirNotFound, path));
}
}
public void GenerateFullManifest()
{
ManifestGenerator generator = new ManifestGenerator();
IntegrationRequest request = new IntegrationRequest(BuildCondition.ForceBuild, "Somewhere", null);
IntegrationSummary summary = new IntegrationSummary(IntegrationStatus.Success, "A Label", "Another Label", new DateTime(2009, 1, 1));
IntegrationResult result = new IntegrationResult("Test project", "Working directory", "Artifact directory", request, summary);
Modification modification1 = GenerateModification("first file", "Add");
Modification modification2 = GenerateModification("second file", "Modify");
result.Modifications = new Modification[] { modification1, modification2 };
List <string> files = new List <string>();
files.Add("first file");
XmlDocument manifest = generator.Generate(result, files.ToArray());
Assert.IsNotNull(manifest);
string actualManifest = manifest.OuterXml;
string expectedManifest = "<manifest>" +
"<header project=\"Test project\" label=\"A Label\" build=\"ForceBuild\" status=\"Unknown\">" +
"<modification user=\"johnDoe\" changeNumber=\"1\" time=\"2009-01-01T00:00:00\">" +
"<comment>A comment</comment>" +
"<file name=\"first file\" type=\"Add\" />" +
"<file name=\"second file\" type=\"Modify\" />" +
"</modification>" +
"</header>" +
"<file name=\"first file\" />" +
"</manifest>";
Assert.AreEqual(expectedManifest, actualManifest);
}
/// <summary>
/// Initializes a new instance of the <see cref="ManifestGeneratorTests"/> class.
/// </summary>
public ManifestGeneratorTests()
{
Generator = new ManifestGenerator();
TempDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
Directory.CreateDirectory(TempDirectory);
}
public async Task GenerateJson()
{
string fileName = Guid.NewGuid().ToString() + ".json";
try
{
File.WriteAllText(fileName, CONFIGURATION_CONTENTS);
string expectedManifest = @"{
""nameVersion"": """ + Constants.NAME_ASSEMBLY_VERSION + @""",
""name"":""NAME.Tests"",
""version"":""1.0.0"",
""infrastructure_dependencies"":[
],
""service_dependencies"":[
]
}";
string appName = "NAME.Tests";
string appVersion = "123.1.2";
ParsedDependencies dependencies = DependenciesReader.ReadDependencies(fileName, new DummyFilePathMapper(), new NAMESettings(), new NAMEContext());
string manifest = await ManifestGenerator.GenerateJson(appName, appVersion, dependencies);
var manifestObject = (JObject)JsonConvert.DeserializeObject(manifest);
Assert.Equal(Constants.NAME_ASSEMBLY_VERSION, manifestObject["nameVersion"]);
Assert.Equal(appName, manifestObject["name"]);
Assert.Equal(appVersion, manifestObject["version"]);
}
finally
{
File.Delete(fileName);
}
}
static void GenerateManifestIfAbsent()
{
if (!File.Exists(ManifestGenerator.GetManifestPath()))
{
ManifestGenerator.GenerateManifest();
Debug.Log("AndroidManifest.xml was missing, generated new");
}
}
protected override void Run()
{
var organizer = new SnippetOrganizer(Options, FileAssociations);
var manifestGenerator = new ManifestGenerator();
var unpartitioned = organizer.CreateUnpartitionedWorkspace(OrderBy, SortDirection, HideMetaFiles);
try
{
unpartitioned.Publish(Options, Overwrite);
manifestGenerator.Add(unpartitioned);
}
catch (WorkspaceAlreadyExistsException e)
{
WriteWarning(e.Message);
}
var languagePackages = organizer.CreateWorkspacesByLanguage(OrderBy, SortDirection, HideMetaFiles);
foreach (var languagePackage in languagePackages)
{
try
{
languagePackage.Publish(Options, Overwrite);
manifestGenerator.Add(languagePackage);
}
catch (WorkspaceAlreadyExistsException e)
{
WriteWarning(e.Message);
}
}
var tagPackages = organizer.CreateWorkspacesByTag(OrderBy, SortDirection, HideMetaFiles);
foreach (var tagPackage in tagPackages)
{
try
{
tagPackage.Publish(Options, Overwrite);
manifestGenerator.Add(tagPackage);
}
catch (WorkspaceAlreadyExistsException e)
{
WriteWarning(e.Message);
}
}
var manifest = manifestGenerator.ToManifest(OrderBy, SortDirection);
manifest.Publish(Options.WorkspacePath);
if (Sync || Options.AutoSync)
{
CommitAndPush("New standard workspace");
}
}
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (!this.settings.IsManifestEndpointEnabled())
{
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}
int currentHopCount;
if (request.Headers.TryGetValues(Constants.HOP_COUNT_HEADER_NAME, out IEnumerable <string> headerValues))
{
if (!int.TryParse(headerValues.First(), out currentHopCount))
{
currentHopCount = 0;
LogWarning($"The received hop count header it not a valid int value ({headerValues.First()}), defaulting to 0.", false);
}
}
else
{
currentHopCount = 0;
}
currentHopCount++;
if (currentHopCount == this.settings.ServiceDependencyMaxHops)
{
return new HttpResponseMessage {
StatusCode = (HttpStatusCode)Constants.SERVICE_HOPS_ERROR_STATUS_CODE
}
}
;
var context = new NAMEContext()
{
ServiceDependencyCurrentNumberOfHops = currentHopCount
};
ParsedDependencies innerDependencies = DependenciesReader.ReadDependencies(this.dependenciesFile, this.pathMapper, this.settings, context);
var manifest = await ManifestGenerator.GenerateJson(this.apiName, this.apiVersion, innerDependencies).ConfigureAwait(false);
var content = new StringContent(manifest);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
return(new HttpResponseMessage {
Content = content
});
}
}
public void GenerateManifest_GeneratesCorrectManifest()
{
// Arrange
var plugin = new PluginDefinition(typeof(Plugin));
var actions = new List <ActionDefinition>
{
new ActionDefinition(typeof(Action))
};
var sut = new ManifestGenerator(plugin, actions);
// Act
string manifestJson = sut.GenerateManifest();
// Assert
Approvals.Verify(manifestJson);
}
private static void GenerateManifest(ToolContext context)
{
var generatorArgs = new ManifestGenerator.Arguments()
{
ApplicationPrefix = context.Arguments.ApplicationPrefix,
ServicePackageNamePrefix = context.Arguments.ServicePackagePrefix,
InputAssembly = context.InputAssembly,
ActorTypes = context.ActorTypes,
OutputPath = context.Arguments.OutputPath,
ApplicationPackagePath = context.Arguments.ApplicationPackagePath,
ServicePackagePath = context.Arguments.ServicePackagePath,
Version = context.Arguments.Version
};
ManifestGenerator.Generate(generatorArgs);
}
protected DirectoryOperationTestBase()
{
File1Path = Path.Combine(TempDir, "file1");
FileUtils.Touch(File1Path);
SubdirPath = Path.Combine(TempDir, "subdir");
Directory.CreateDirectory(SubdirPath);
File2Path = Path.Combine(SubdirPath, "file2");
FileUtils.Touch(File2Path);
var generator = new ManifestGenerator(TempDir, ManifestFormat.Sha256New);
generator.Run();
Manifest = generator.Manifest;
}
public virtual void SetUp()
{
TempDir = new TemporaryDirectory("0install-unit-tests");
File1Path = Path.Combine(TempDir, "file1");
FileUtils.Touch(File1Path);
SubdirPath = Path.Combine(TempDir, "subdir");
Directory.CreateDirectory(SubdirPath);
File2Path = Path.Combine(SubdirPath, "file2");
FileUtils.Touch(File2Path);
var generator = new ManifestGenerator(TempDir, ManifestFormat.Sha256New);
generator.Run();
Manifest = generator.Manifest;
}
public virtual void SetUp()
{
TempDir = new TemporaryDirectory("0install-unit-tests");
File1Path = Path.Combine(TempDir, "file1");
FileUtils.Touch(File1Path);
SubdirPath = Path.Combine(TempDir, "subdir");
Directory.CreateDirectory(SubdirPath);
File2Path = Path.Combine(SubdirPath, "file2");
FileUtils.Touch(File2Path);
var generator = new ManifestGenerator(TempDir, ManifestFormat.Sha256New);
generator.Run();
Manifest = generator.Manifest;
}
private static async Task GenerateLibraryManifest(GenerateLibraryManifestOptions genManOpts)
{
var manGen = new ManifestGenerator(new LocalFileSystemFileLoader(m_Logger));
string publicKeyXml;
var maninfest = await manGen.CreateManifest(Location.FromPath(genManOpts.LibraryPath),
genManOpts.Version,
genManOpts.CertificatePath, genManOpts.CertificatePassword, out publicKeyXml);
new UserSettingsService().StoreSettings(maninfest,
Path.Combine(genManOpts.LibraryPath, "library.manifest"),
new BaseValueSerializer <ILocation>(x => x.ToId(), null));
if (!string.IsNullOrEmpty(genManOpts.PublicKeyFile))
{
await System.IO.File.WriteAllTextAsync(genManOpts.PublicKeyFile, publicKeyXml);
}
}
/// <summary>
/// Generates the <see cref="ManifestDigest"/> for a directory.
/// </summary>
/// <param name="path">The path of the directory to generate the digest for.</param>
/// <param name="handler">A callback object used when the the user is to be informed about progress.</param>
/// <param name="keepDownloads"><see langword="true"/> to store the directory as an implementation in the default <see cref="IStore"/>.</param>
/// <returns>The newly generated digest.</returns>
/// <exception cref="OperationCanceledException">The user canceled the operation.</exception>
/// <exception cref="IOException">There is a problem access a temporary file.</exception>
/// <exception cref="UnauthorizedAccessException">Read or write access to a temporary file is not permitted.</exception>
public static ManifestDigest GenerateDigest([NotNull] string path, [NotNull] ITaskHandler handler, bool keepDownloads = false)
{
#region Sanity checks
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
#endregion
var digest = new ManifestDigest();
// Generate manifest for each available format...
foreach (var format in ManifestFormat.Recommended)
// ... and add the resulting digest to the return value
{
var generator = new ManifestGenerator(path, format);
handler.RunTask(generator);
digest.ParseID(generator.Result.CalculateDigest());
}
if (digest.PartialEquals(ManifestDigest.Empty))
{
Log.Warn(Resources.EmptyImplementation);
}
if (keepDownloads)
{
try
{
StoreFactory.CreateDefault().AddDirectory(path, digest, handler);
}
catch (ImplementationAlreadyInStoreException)
{}
}
return(digest);
}
public void CheckAllProperties()
{
PackagePublisher publisher = new PackagePublisher();
publisher.AlwaysPackage = true;
Assert.AreEqual(true, publisher.AlwaysPackage);
publisher.CompressionLevel = 9;
Assert.AreEqual(9, publisher.CompressionLevel);
//publisher.Flatten = true;
//Assert.AreEqual(true, publisher.Flatten);
ManifestGenerator generator = new ManifestGenerator();
publisher.ManifestGenerator = generator;
Assert.AreSame(generator, publisher.ManifestGenerator);
publisher.PackageName = "Package name";
Assert.AreEqual("Package name", publisher.PackageName);
publisher.PackageList = new IPackageItem[] {
new PackageFile()
};
Assert.AreEqual(1, publisher.PackageList.Length);
}
private async Task GetManifest(HttpContext context)
{
context.Response.ContentType = "application/json";
int currentHopCount;
if (context.Request.Headers.TryGetValue(Constants.HOP_COUNT_HEADER_NAME, out StringValues headerValues))
{
if (!int.TryParse(headerValues.First(), out currentHopCount))
{
currentHopCount = 0;
Trace.TraceWarning($"The received hop count header it not a valid int value ({headerValues.First()}), defaulting to 0.");
}
}
else
{
currentHopCount = 0;
}
currentHopCount++;
var nameContext = new NAMEContext()
{
ServiceDependencyCurrentNumberOfHops = currentHopCount
};
var dependencies = DependenciesReader.ReadDependencies(this.nameConfiguration.DependenciesFilePath, this.pathMapper, this.settings, nameContext);
if (currentHopCount == this.settings.ServiceDependencyMaxHops)
{
context.Response.StatusCode = Constants.SERVICE_HOPS_ERROR_STATUS_CODE;
return;
}
string manifest = await ManifestGenerator.GenerateJson(this.nameConfiguration.APIName, this.nameConfiguration.APIVersion, dependencies);
context.Response.ContentType = "application/json";
await context.Response.WriteAsync(manifest);
}
private async Task GetManifest(HttpListenerContext context, NAMEHttpListenerConfiguration configuration)
{
context.Response.ContentType = "application/json";
int currentHopCount = 0;
var hopCountHeaders = context.Request.Headers.GetValues(Constants.HOP_COUNT_HEADER_NAME);
if (hopCountHeaders?.Length > 0)
{
if (!int.TryParse(hopCountHeaders.First(), out currentHopCount))
{
currentHopCount = 0;
LogWarning($"The received hop count header it not a valid int value ({hopCountHeaders.First()}), defaulting to 0.", this.nameConfiguration.LogHealthCheckToConsole);
}
}
currentHopCount++;
var nameContext = new NAMEContext()
{
ServiceDependencyCurrentNumberOfHops = currentHopCount
};
var dependencies = DependenciesReader.ReadDependencies(configuration.DependenciesFilePath, this.pathMapper, this.settings, nameContext);
if (currentHopCount == this.settings.ServiceDependencyMaxHops)
{
context.Response.StatusCode = Constants.SERVICE_HOPS_ERROR_STATUS_CODE;
return;
}
string manifest = await ManifestGenerator.GenerateJson(configuration.APIName, configuration.APIVersion, dependencies).ConfigureAwait(false);
context.Response.ContentType = "application/json";
var manifestBytes = Encoding.UTF8.GetBytes(manifest);
context.Response.OutputStream.Write(manifestBytes, 0, manifestBytes.Length);
}
/// <summary>
/// Processes the desired command with the arguments specified in the command line arguments from Main().
/// </summary>
/// <param name="args">
/// The optional command line arguments, used to override the arguments with which the application was started.
/// </param>
public static void Process(string args = "")
{
if (args != string.Empty)
{
Arguments.Populate(args);
}
string command = string.Empty;
try
{
if (Operands.Count > 1)
{
command = Operands[1].ToLower();
}
if (command == "manifest")
{
ManifestGenerator generator = new ManifestGenerator();
generator.Updated += Update;
PackageManifest manifest = generator.GenerateManifest(Directory, HashFiles, ManifestFile);
if (string.IsNullOrEmpty(ManifestFile) && manifest != default(PackageManifest))
{
Console.WriteLine(manifest.ToJson());
}
}
else if (command == "extract-manifest")
{
ManifestExtractor extractor = new ManifestExtractor();
extractor.Updated += Update;
PackageManifest manifest = extractor.ExtractManifest(PackageFile, ManifestFile);
if (string.IsNullOrEmpty(ManifestFile) && manifest != default(PackageManifest))
{
Console.WriteLine(manifest.ToJson());
}
}
else if (command == "package")
{
PackageCreator creator = new PackageCreator();
creator.Updated += Update;
string privateKey = string.Empty;
if (!string.IsNullOrEmpty(PrivateKeyFile))
{
privateKey = File.ReadAllText(PrivateKeyFile);
}
creator.CreatePackage(Directory, ManifestFile, PackageFile, SignPackage, privateKey, Passphrase, KeybaseUsername);
}
else if (command == "extract-package")
{
PackageExtractor extractor = new PackageExtractor();
extractor.Updated += Update;
string publicKey = string.Empty;
if (!string.IsNullOrEmpty(PublicKeyFile))
{
publicKey = File.ReadAllText(PublicKeyFile);
}
extractor.ExtractPackage(PackageFile, Directory, publicKey, Overwrite, SkipVerification);
}
else if (command == "trust")
{
PackageTruster truster = new PackageTruster();
truster.Updated += Update;
truster.TrustPackage(PackageFile, File.ReadAllText(PrivateKeyFile), Passphrase);
}
else if (command == "verify")
{
PackageVerifier verifier = new PackageVerifier();
verifier.Updated += Update;
string publicKey = string.Empty;
if (!string.IsNullOrEmpty(PublicKeyFile))
{
publicKey = File.ReadAllText(PublicKeyFile);
}
verifier.VerifyPackage(PackageFile, publicKey);
}
else
{
HelpPrinter.PrintHelp(Operands.Count > 2 ? Operands[2] : default(string));
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
}
private async Task <string> GetManifest(NAMEContext context)
{
ParsedDependencies innerDependencies = DependenciesReader.ReadDependencies(this.dependenciesFileLocation, this.pathMapper, this.settings, context);
return(await ManifestGenerator.GenerateJson(this.ApiName, this.ApiVersion, innerDependencies).ConfigureAwait(false));
}
