public void AddPackageAsFiles()
{
string file1Content = "file 1 content";
string file2Content = "file 2 content";
Stream file1 = StreamsHelper.StreamFromString(file1Content);
Stream file2 = StreamsHelper.StreamFromString(file2Content);
string expectedFullhash = HashServiceHelper.Instance().FromString(
HashServiceHelper.Instance().FromString("folder1/file1.txt") +
HashServiceHelper.Instance().FromString(file1Content) +
HashServiceHelper.Instance().FromString("folder2/file2.txt") +
HashServiceHelper.Instance().FromString(file2Content));
PackageCreateArguments postArgs = new PackageCreateArguments
{
Id = Guid.NewGuid().ToString(),
Files = new PackageCreateItem[]
{
new PackageCreateItem(file1, "folder1/file1.txt"),
new PackageCreateItem(file2, "folder2/file2.txt")
}
};
PackageCreateResult result = _packageService.CreatePackage(postArgs);
Assert.True(result.Success);
Assert.Equal(2, TestingWorkspace.Repository.Count());
Assert.Empty(TestingWorkspace.Incoming);
Assert.Equal(expectedFullhash, result.PackageHash);
}
public void CreateWithNoArguments()
{
// empty argument list
PackageCreateArguments args = new PackageCreateArguments();
PackageCreateResult result = PackageCreate.CreatePackage(args);
Assert.Equal(PackageCreateErrorTypes.MissingValue, result.ErrorType);
Assert.Equal("Files collection is empty.", result.PublicError);
}
public void AddPackageAsArchive()
{
Dictionary <string, string> files = new Dictionary <string, string>();
string file1Content = "file 1 content";
string file2Content = "file 2 content";
string expectedFullhash = HashServiceHelper.Instance().FromString(
HashServiceHelper.Instance().FromString("folder1/file1.txt") +
HashServiceHelper.Instance().FromString(file1Content) +
HashServiceHelper.Instance().FromString("folder2/file2.txt") +
HashServiceHelper.Instance().FromString(file2Content));
files.Add("folder1/file1.txt", file1Content);
files.Add("folder2/file2.txt", file2Content);
MemoryStream zipStream = new MemoryStream();
using (ZipArchive archive = new ZipArchive(zipStream, ZipArchiveMode.Create, true))
{
foreach (var file in files)
{
ZipArchiveEntry fileEntry = archive.CreateEntry(file.Key);
using (var entryStream = fileEntry.Open())
using (var streamWriter = new StreamWriter(entryStream))
{
streamWriter.Write(file.Value);
}
}
}
PackageCreateArguments postArgs = new PackageCreateArguments
{
Id = Guid.NewGuid().ToString(),
IsArchive = true,
Files = new PackageCreateItem[]
{
new PackageCreateItem(zipStream, "folder/archive.zip")
}
};
PackageCreateResult result = _packageService.CreatePackage(postArgs);
if (!result.Success)
{
throw new Exception(result.PublicError);
}
Assert.True(result.Success);
Assert.Equal(2, TestingWorkspace.Repository.Count());
Assert.Empty(TestingWorkspace.Incoming);
Assert.Equal(expectedFullhash, result.PackageHash);
}
public void CreateWithNoName()
{
PackageCreateArguments args = new PackageCreateArguments();
Stream fileStream = StreamsHelper.StreamFromString("some text");
args.Files.Add(new PackageCreateItem(fileStream, "folder/file"));
PackageCreateResult result = PackageCreate.CreatePackage(args);
Assert.Equal(PackageCreateErrorTypes.MissingValue, result.ErrorType);
Assert.Equal("Id is required.", result.PublicError);
}
public void CreateWithEmptyFiles()
{
PackageCreateArguments args = new PackageCreateArguments
{
// empty files list
Files = new List <PackageCreateItem>()
};
PackageCreateResult result = PackageCreate.CreatePackage(args);
Assert.Equal(PackageCreateErrorTypes.MissingValue, result.ErrorType);
Assert.Equal("Files collection is empty.", result.PublicError);
}
public void CreateBasic()
{
List <PackageCreateItem> files = new List <PackageCreateItem>();
string fileContent = "some file content";
int filesToAdd = 10;
string packageId = "my package";
for (int i = 0; i < filesToAdd; i++)
{
Stream fileStream = StreamsHelper.StreamFromString(fileContent);
files.Add(new PackageCreateItem(fileStream, $"folder{i}/file{i}"));
}
PackageCreateArguments package = new PackageCreateArguments
{
Id = packageId,
Files = files
};
PackageCreateResult result = PackageCreate.CreatePackage(package);
Assert.True(result.Success);
Assert.Null(result.PublicError);
Assert.NotEmpty(result.PackageHash);
Assert.Null(result.ErrorType);
// check that package can be listed
IEnumerable <string> packageIds = IndexReader.GetAllPackageIds();
Assert.Contains(packageId, packageIds);
Assert.Single(packageIds);
// check that package can be retrieved as manifest
Manifest manifest = IndexReader.GetManifest(packageId);
Assert.NotNull(manifest);
Assert.Equal(manifest.Files.Count, filesToAdd);
// check that a file can be retrieved directly using manifest id
GetFileResponse response = IndexReader.GetFile(manifest.Files[0].Id);
using (StreamReader reader = new StreamReader(response.Content)) {
string retrievedContent = reader.ReadToEnd();
Assert.Equal(retrievedContent, fileContent);
}
// ensure that workspace has been cleaned up
Assert.Empty(Directory.GetDirectories(base.Settings.TempPath));
}
public void EnsureSingleFileWhenAddArchive()
{
Stream file = StreamsHelper.StreamFromString("some content");
PackageCreateArguments postArgs = new PackageCreateArguments
{
Id = Guid.NewGuid().ToString(),
IsArchive = true,
Files = new PackageCreateItem[]
{
new PackageCreateItem(file, "folder1/file.txt"),
new PackageCreateItem(file, "folder2/file.txt"),
}
};
PackageCreateResult result = _packageService.CreatePackage(postArgs);
Assert.False(result.Success);
Assert.Equal(PackageCreateErrorTypes.InvalidFileCount, result.ErrorType);
}
public void CreateArchiveWithTooManyFiles()
{
string packageId = "my package";
Stream fileStream = StreamsHelper.StreamFromString("some text");
PackageCreateArguments package = new PackageCreateArguments
{
Id = packageId,
IsArchive = true,
Files = new List <PackageCreateItem>()
{
new PackageCreateItem(fileStream, "folder/file"),
new PackageCreateItem(fileStream, "folder/file")
}
};
PackageCreateResult result = PackageCreate.CreatePackage(package);
Assert.False(result.Success);
Assert.Equal(PackageCreateErrorTypes.InvalidFileCount, result.ErrorType);
}
public void CreateDuplicatePackage()
{
string packageId = "my package";
Stream fileStream = StreamsHelper.StreamFromString("some text");
PackageCreateArguments package = new PackageCreateArguments
{
Id = packageId,
Files = new List <PackageCreateItem>()
{
new PackageCreateItem(fileStream, "folder/file")
}
};
PackageCreateResult result = PackageCreate.CreatePackage(package);
Assert.True(result.Success);
// attempt to create package with same name
result = PackageCreate.CreatePackage(package);
Assert.False(result.Success);
Assert.Equal(PackageCreateErrorTypes.PackageExists, result.ErrorType);
}
public ActionResult AddPackage([FromForm] PackageCreateFromPost post)
{
Stopwatch sw = new Stopwatch();
sw.Start();
try
{
_log.LogInformation("Package upload request started");
// check if there is space available
DiskUseStats useStats = FileHelper.GetDiskUseSats();
if (useStats.ToPercent() < _settings.SpaceSafetyThreshold)
{
return(Responses.InsufficientSpace("Insufficient space on storage drive."));
}
PackageCreateResult result = _packageService.CreatePackage(new PackageCreateArguments
{
Description = post.Description,
Files = post.Files.Select(r => new PackageCreateItem {
Content = r.OpenReadStream(),
// packages uploaded via webform are forced to include leading folder in path, these can be marked for removal
FileName = post.RemoveFirstDirectoryFromPath ? FileHelper.RemoveFirstDirectoryFromPath(r.FileName) : r.FileName
}).ToList(),
Id = post.Id,
IsArchive = post.IsArchive
});
// force flush in-memory list of packages
if (result.Success)
{
_packageListCache.Clear();
}
if (result.Success)
{
// force flush in-memory list of packages
_packageListCache.Clear();
sw.Stop();
return(new JsonResult(new
{
success = new
{
id = post.Id,
hash = result.PackageHash,
description = "Package successfully created",
processingTime = sw.Elapsed.TotalSeconds
}
}));
}
if (result.ErrorType == PackageCreateErrorTypes.InvalidArchiveFormat)
{
return(Responses.InvalidArchiveFormatError(post.Format));
}
if (result.ErrorType == PackageCreateErrorTypes.InvalidFileCount)
{
return(Responses.InvalidArchiveContent());
}
if (result.ErrorType == PackageCreateErrorTypes.PackageExists)
{
return(Responses.PackageExistsError(post.Id));
}
if (result.ErrorType == PackageCreateErrorTypes.MissingValue)
{
return(Responses.MissingInputError(result.PublicError));
}
return(Responses.UnexpectedError());
}
catch (Exception ex)
{
_log.LogError(ex, "An unexpected error occurred.");
return(Responses.UnexpectedError());
}
finally
{
_log.LogInformation($"Package request processed. {post.Id} took {0} seconds", sw.Elapsed.TotalSeconds);
}
}
