public void Load(BinaryReader reader, Action <int, long> values, int count)
{
long factor = (long)CountCompression.Deserialize(reader);
List <long> rawValues = (List <long>)DeltaCompression.CoreDecompress(reader);
for (int i = 0; i < count; i++)
{
values(i, factor * rawValues[i]);
}
}
public void Load(BinaryReader reader, Action <int, long> values, int count)
{
if (reader.ReadByte() != VERSION)
{
throw new Exception("Invalid Int64IndexerPersist version.");
}
long factor = (long)CountCompression.Deserialize(reader);
DeltaCompression.Decompress(reader, (idx, val) => values(idx, factor * val), count);
}
private PackageFromBuiltInFeedResource AttemptDeltaPush(string fileName, Stream contents, bool replaceExisting)
{
if (!repository.HasLink("PackageDeltaSignature"))
{
Logger.Info("Server does not support delta compression for package push");
return(null);
}
if (!PackageIdentityParser.TryParsePackageIdAndVersion(Path.GetFileNameWithoutExtension(fileName), out var packageId, out var version))
{
Logger.Info("Could not determine the package ID and/or version based on the supplied filename");
return(null);
}
PackageSignatureResource signatureResult;
try
{
Logger.Info($"Requesting signature for delta compression from the server for upload of a package with id '{packageId}' and version '{version}'");
signatureResult = repository.Client.Get <PackageSignatureResource>(repository.Link("PackageDeltaSignature"), new { packageId, version });
}
catch (OctopusResourceNotFoundException)
{
Logger.Info("No package with the same ID exists on the server");
return(null);
}
using (var deltaTempFile = new TemporaryFile())
{
var shouldUpload = DeltaCompression.CreateDelta(contents, signatureResult, deltaTempFile.FileName);
if (!shouldUpload)
{
return(null);
}
using (var delta = File.OpenRead(deltaTempFile.FileName))
{
var result = repository.Client.Post <FileUpload, PackageFromBuiltInFeedResource>(
repository.Link("PackageDeltaUpload"),
new FileUpload()
{
Contents = delta, FileName = Path.GetFileName(fileName)
},
new { replace = replaceExisting, packageId, signatureResult.BaseVersion });
Logger.Info($"Delta transfer completed");
return(result);
}
}
}
public void Store(BinaryWriter writer, Func <int, decimal> values, int count)
{
writer.Write(VERSION);
DeltaCompression.Helper helper = null;
long[] array = null;
int digits;
try
{
digits = GetMaxDigits(values, count);
if (digits <= 15)
{
helper = new DeltaCompression.Helper();
array = new long[count];
decimal koef = (decimal)Math.Pow(10, digits);
for (int i = 0; i < count; i++)
{
decimal value = values(i);
long v = checked ((long)Math.Round(value * koef));
array[i] = v;
helper.Add(v);
}
}
else
{
digits = -1;
}
}
catch (OverflowException)
{
digits = -1;
}
writer.Write((sbyte)digits);
if (digits >= 0)
{
DeltaCompression.Compress(writer, array, 0, count, helper);
}
else
{
for (int i = 0; i < count; i++)
{
writer.Write(values(i));
}
}
}
public void Store(BinaryWriter writer, Func <int, decimal> values, int count)
{
DeltaCompression.Helper helper = null;
List <long> rawValues = null;
int maxDigits;
try
{
maxDigits = GetMaxDigits(values, count);
if (maxDigits <= 15)
{
helper = new DeltaCompression.Helper();
rawValues = new List <long>(count);
decimal koef = (decimal)Math.Pow(10, maxDigits);
for (int i = 0; i < count; i++)
{
decimal value = values(i);
long v = checked ((long)Math.Round(value * koef));
helper.AddValue(v);
rawValues.Add(v);
}
}
else
{
maxDigits = -1;
}
}
catch (OverflowException)
{
maxDigits = -1;
}
writer.Write((sbyte)maxDigits);
if (maxDigits >= 0)
{
DeltaCompression.CoreCompress(writer, rawValues, helper);
}
else
{
for (int i = 0; i < count; i++)
{
writer.Write(values(i));
}
}
}
public void Load(BinaryReader reader, Action <int, float> values, int count)
{
int digits = reader.ReadSByte();
if (digits >= 0)
{
double koef = Math.Pow(10, digits);
List <long> rawValues = (List <long>)DeltaCompression.CoreDecompress(reader);
for (int i = 0; i < count; i++)
{
values(i, (float)Math.Round(rawValues[i] / koef, digits));
}
}
else //native read
{
for (int i = 0; i < count; i++)
{
values(i, reader.ReadSingle());
}
}
}
public void Load(BinaryReader reader, Action <int, decimal> values, int count)
{
if (reader.ReadByte() != VERSION)
{
throw new Exception("Invalid DecimalIndexerPersist version.");
}
int digits = reader.ReadSByte();
if (digits >= 0)
{
double koef = Math.Pow(10, digits);
DeltaCompression.Decompress(reader, (idx, val) => values(idx, (decimal)Math.Round(val / koef, digits)), count);
}
else //native read
{
for (int i = 0; i < count; i++)
{
values(i, reader.ReadDecimal());
}
}
}
public void Store(BinaryWriter writer, Func <int, long> values, int count)
{
writer.Write(VERSION);
long[] array = new long[count];
int index = factors.Length - 1;
for (int i = 0; i < count; i++)
{
long value = values(i);
array[i] = value;
while (index >= 0)
{
if (value % factors[index] == 0)
{
break;
}
else
{
index--;
}
}
}
long factor = index >= 0 ? factors[index] : 1;
DeltaCompression.Helper helper = new DeltaCompression.Helper();
for (int i = 0; i < count; i++)
{
array[i] /= factor;
helper.Add(array[i]);
}
CountCompression.Serialize(writer, checked ((ulong)factor));
DeltaCompression.Compress(writer, array, 0, count, helper);
}
public void Store(BinaryWriter writer, Func <int, long> values, int count)
{
List <long> list = new List <long>(count);
int index = factors.Length - 1;
for (int i = 0; i < count; i++)
{
long value = values(i);
list.Add(value);
while (index >= 0)
{
if (value % factors[index] == 0)
{
break;
}
else
{
index--;
}
}
}
long factor = index >= 0 ? factors[index] : 1;
DeltaCompression.Helper helper = new DeltaCompression.Helper();
for (int i = 0; i < count; i++)
{
list[i] = list[i] / factor;
helper.AddValue(list[i]);
}
CountCompression.Serialize(writer, checked ((ulong)factor));
DeltaCompression.CoreCompress(writer, list, helper);
}
private async Task <FeedPackageResult> AttemptDeltaPush(Stream stream, string originalFilename, bool replace, string region)
{
var(packageId, version) = PackageIdAndVersionParser.Parse(Path.GetFileNameWithoutExtension(originalFilename));
try
{
_client.Log.Info($"Requesting signature for delta compression from the server for upload of a package '{packageId}' version '{version}'");
var signature = await _client.FeedClientWrapper.Get <PackageDeltaSignatureResult>(
UrlTemplate.Resolve(
_feedRootUri + "/packages/{packageId}/{version}/delta-signature",
new { packageId, version }
)
);
var tempFile = Path.GetTempFileName();
try
{
var shouldUpload = DeltaCompression.CreateDelta(_client.Log, stream, signature, tempFile);
if (!shouldUpload)
{
return(null);
}
using (var delta = File.OpenRead(tempFile))
{
var result = await _client.FeedClientWrapper.Create <FeedPackageResult>(
UrlTemplate.Resolve(
_feedRootUri + "/packages/{packageId}/{baseVersion}/delta{?replace,region}",
new { packageId, baseVersion = signature.BaseVersion, replace, region }
),
delta,
originalFilename,
new Dictionary <string, string>()
);
_client.Log.Info($"Delta transfer completed");
return(result);
}
}
finally
{
try
{
File.Delete(tempFile);
}
catch
{
}
}
}
catch (FeedzHttpRequestException hre) when(hre.Code == HttpStatusCode.NotFound)
{
_client.Log.Info("No package with the same ID exists on the server");
return(null);
}
catch (FeedzHttpRequestException hre) when(hre.Code == HttpStatusCode.Conflict)
{
throw new Exception("The package already exists");
}
catch (Exception)
{
_client.Log.Info("An error occured calculating the package delta");
return(null);
}
}
private PackageFromBuiltInFeedResource AttemptDeltaPush(string fileName, Stream contents, OverwriteMode overwriteMode)
{
if (!repository.HasLink("PackageDeltaSignature"))
{
Logger.Info("Server does not support delta compression for package push");
return(null);
}
if (!PackageIdentityParser.TryParsePackageIdAndVersion(Path.GetFileNameWithoutExtension(fileName), out var packageId, out var version))
{
Logger.Info("Could not determine the package ID and/or version based on the supplied filename");
return(null);
}
PackageSignatureResource signatureResult;
try
{
Logger.Info($"Requesting signature for delta compression from the server for upload of a package with id '{packageId}' and version '{version}'");
signatureResult = repository.Client.Get <PackageSignatureResource>(repository.Link("PackageDeltaSignature"), new { packageId, version });
}
catch (OctopusResourceNotFoundException)
{
Logger.Info("No package with the same ID exists on the server");
return(null);
}
using (var deltaTempFile = new TemporaryFile())
{
var shouldUpload = DeltaCompression.CreateDelta(contents, signatureResult, deltaTempFile.FileName);
if (!shouldUpload)
{
return(null);
}
using (var delta = File.OpenRead(deltaTempFile.FileName))
{
var link = repository.Link("PackageDeltaUpload");
object pathParameters;
// if the link contains overwriteMode then we're connected to a new server, if not use the old `replace` parameter
if (link.Contains(OverwriteModeLink.Link))
{
pathParameters = new { overwriteMode = overwriteMode, packageId, signatureResult.BaseVersion };
}
else
{
pathParameters = new { replace = overwriteMode.ConvertToLegacyReplaceFlag(Logger), packageId, signatureResult.BaseVersion };
}
var result = repository.Client.Post <FileUpload, PackageFromBuiltInFeedResource>(
link,
new FileUpload()
{
Contents = delta, FileName = Path.GetFileName(fileName)
},
pathParameters);
Logger.Info($"Delta transfer completed");
return(result);
}
}
}
