public LocalPackageManager(AppInfo app)
{
this.app = app ?? throw new ArgumentNullException(nameof(app));
logger = app.LoggerFactory.CreateLogger <LocalPackageManager>();
PackageRepositoryPath = app.DataRootPathPackageRepository;
sequenceForNewPackages = PackageSequenceBaseInfo.Default;
}
public CreatePackageDataStreamController(ClientVersion version, ILoggerFactory loggerFactory, CryptoProvider cryptoProvider, PackageSequenceBaseInfo sequenceBaseInfo, string packageRootPath)
{
logger = (loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory))).CreateLogger <CreatePackageDataStreamController>();
this.version = version;
this.cryptoProvider = cryptoProvider ?? throw new ArgumentNullException(nameof(cryptoProvider));
this.sequenceBaseInfo = sequenceBaseInfo ?? throw new ArgumentNullException(nameof(sequenceBaseInfo));
this.packageRootPath = packageRootPath ?? throw new ArgumentNullException(nameof(packageRootPath));
segmentHashes = new List <Hash>();
}
public WritePackageDataStreamController(ILoggerFactory loggerFactory, CryptoProvider cryptoProvider, string packageRootPath, PackageSequenceBaseInfo sequenceBaseInfo, IEnumerable <PackageDataStreamPart> partsToWrite)
{
logger = (loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory))).CreateLogger <WritePackageDataStreamController>();
this.cryptoProvider = cryptoProvider ?? throw new ArgumentNullException(nameof(cryptoProvider));
this.packageRootPath = packageRootPath;
this.sequenceBaseInfo = sequenceBaseInfo ?? throw new ArgumentNullException(nameof(sequenceBaseInfo));
parts = (partsToWrite ?? throw new ArgumentNullException(nameof(partsToWrite))).ToArray();
Length = parts.Sum(p => p.PartLength);
}
/// <param name="nestedStream">Can be null if you just want to validate hashes.</param>
public ValidatePackageDataStreamController(ILoggerFactory loggerFactory, CryptoProvider cryptoProvider, PackageSequenceBaseInfo sequenceBaseInfo, Dto.PackageHashes hashes, IEnumerable <PackageDataStreamPart> partsToValidate, Stream nestedStream)
{
logger = (loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory))).CreateLogger <WritePackageDataStreamController>();
this.cryptoProvider = cryptoProvider ?? throw new ArgumentNullException(nameof(cryptoProvider));
this.sequenceBaseInfo = sequenceBaseInfo ?? throw new ArgumentNullException(nameof(sequenceBaseInfo));
this.hashes = hashes ?? throw new ArgumentNullException(nameof(hashes));
parts = (partsToValidate ?? throw new ArgumentNullException(nameof(partsToValidate))).ToArray();
Length = parts.Sum(p => p.PartLength);
// where to write validated data?
this.nestedStream = nestedStream;
writeToNestedStream = nestedStream != null;
if (writeToNestedStream)
{
memStream = new MemoryStream(capacity: (int)sequenceBaseInfo.SegmentLength);
}
}
public PackageSequenceInfo(PackageSequenceBaseInfo baseInfo, long packageSize) : base(baseInfo)
{
PackageSize = packageSize;
// calculate data files
DataFilesCount = (int)((PackageSize + DataFileLength - 1) / DataFileLength);
DataFileLastLength = PackageSize % DataFileLength;
if (DataFileLastLength == 0 && PackageSize > 0)
{
DataFileLastLength = DataFileLength;
}
// calculate segments
SegmentsCount = (int)((PackageSize + SegmentLength - 1) / SegmentLength);
SegmentLastLength = PackageSize % SegmentLength;
if (SegmentLastLength == 0 && PackageSize > 0)
{
SegmentLastLength = SegmentLength;
}
}
private IEnumerable <PackageDataStreamPart> GetPartsInternal(string packageRootPath, PackageSequenceBaseInfo sequenceBaseInfo, long?length, int[] requestedSegments)
{
PackageSequenceInfo sequenceInfo = null;
bool isInfinite = length == null;
if (!isInfinite)
{
sequenceInfo = new PackageSequenceInfo(sequenceBaseInfo, length.Value);
}
IEnumerable <int> segmentIndexEnumerable;
if (requestedSegments != null)
{
segmentIndexEnumerable = requestedSegments;
}
else
{
segmentIndexEnumerable = Enumerable.Range(0, isInfinite ? int.MaxValue : sequenceInfo.SegmentsCount);
}
foreach (var segmentIndex in segmentIndexEnumerable)
{
// validate is requested correct index
if (!isInfinite && (segmentIndex < 0 || segmentIndex >= sequenceInfo.SegmentsCount))
{
throw new ArgumentOutOfRangeException(nameof(requestedSegments), "Requested part is out of range.");
}
int segmentIndexInDataFile = (segmentIndex % sequenceBaseInfo.SegmentsPerDataFile);
int dataFileIndex = (segmentIndex / sequenceBaseInfo.SegmentsPerDataFile);
yield return(new PackageDataStreamPart()
{
DataFileIndex = dataFileIndex,
SegmentIndex = segmentIndex,
PartLength = isInfinite ? sequenceBaseInfo.SegmentLength : sequenceInfo.GetSizeOfSegment(segmentIndex),
Path = GetBlockFilePath(packageRootPath, dataFileIndex),
SegmentOffsetInDataFile = segmentIndexInDataFile * sequenceBaseInfo.SegmentLength,
DataFileLength = isInfinite ? sequenceBaseInfo.DataFileLength : sequenceInfo.GetSizeOfDataFile(dataFileIndex)
});
}
}
public IEnumerable <PackageDataStreamPart> GetPartsInfinite(string packageRootPath, PackageSequenceBaseInfo sequenceBaseInfo)
{
return(GetPartsInternal(packageRootPath, sequenceBaseInfo, length: null, requestedSegments: null));
}
public PackageSequenceBaseInfo(PackageSequenceBaseInfo copyFrom) : this(
dataFileLength : copyFrom.DataFileLength,
segmentLength : copyFrom.SegmentLength
)
{
}
