/// <summary>
/// Unpack the package
/// </summary>
public AppletManifest Unpack()
{
switch (this.Compression)
{
case "lzma":
using (MemoryStream ms = new MemoryStream(this.Manifest))
using (var dfs = new LZipStream(ms, SharpCompress.Compressors.CompressionMode.Decompress, true))
return(AppletManifest.Load(dfs));
case "bzip2":
using (MemoryStream ms = new MemoryStream(this.Manifest))
using (var dfs = new BZip2Stream(ms, SharpCompress.Compressors.CompressionMode.Decompress, true))
return(AppletManifest.Load(dfs));
case "gzip":
using (MemoryStream ms = new MemoryStream(this.Manifest))
using (GZipStream dfs = new GZipStream(ms, CompressionMode.Decompress))
return(AppletManifest.Load(dfs));
default:
using (MemoryStream ms = new MemoryStream(this.Manifest))
using (DeflateStream dfs = new DeflateStream(ms, CompressionMode.Decompress))
return(AppletManifest.Load(dfs));
}
}
public TarWriter(Stream destination, TarWriterOptions options)
: base(ArchiveType.Tar, options)
{
finalizeArchiveOnClose = options.FinalizeArchiveOnClose;
if (!destination.CanWrite)
{
throw new ArgumentException("Tars require writable streams.");
}
switch (options.CompressionType)
{
case CompressionType.None:
break;
case CompressionType.BZip2:
{
destination = new BZip2Stream(destination, CompressionMode.Compress, true);
}
break;
case CompressionType.GZip:
{
destination = new GZipStream(destination, CompressionMode.Compress, true);
}
break;
case CompressionType.LZip:
{
destination = new LZipStream(destination, CompressionMode.Compress, true);
}
break;
default:
{
throw new InvalidFormatException("Tar does not support compression: " + options.CompressionType);
}
}
InitalizeStream(destination);
}
/// <summary>
/// Decompresssed a block of data using the LZMA algorithm.
/// </summary>
/// <param name="inData">The compressed data block.</param>
/// <returns>The decompressed data.</returns>
public static byte[] DecompressLZMA(byte[] inData)
{
using var ms = new MemoryStream(inData);
using var input = new LZipStream(ms, CompressionMode.Decompress);
using var decompressedData = new MemoryStream();
input.CopyTo(decompressedData);
return(decompressedData.ToArray());
}
/// <summary>
/// Restore the configuration
/// </summary>
public SanteDBConfiguration Restore()
{
using (var lzs = new LZipStream(File.OpenRead(Path.ChangeExtension(this.m_configPath, "bak.7z")), SharpCompress.Compressors.CompressionMode.Decompress))
{
var retVal = SanteDBConfiguration.Load(lzs);
this.Save(retVal);
ApplicationContext.Current?.ConfigurationManager.Reload();
return(retVal);
}
}
/// <summary>
/// 压缩
/// </summary>
/// <param name="bytes">需要压缩的字节流</param>
/// <returns>压缩后的结果</returns>
public byte[] Compress(byte[] bytes)
{
using (var ms = new MemoryStream())
{
var lzma = new LZipStream(ms, CompressionMode.Compress, true);
lzma.Write(bytes, 0, bytes.Length);
lzma.Close();
return(ms.ToArray());
}
}
public void DecompressFile(string source, string destination)
{
var inFs = new FileStream(source, FileMode.Open, FileAccess.Read);
var outFs = new FileStream(destination, FileMode.Create, FileAccess.Write);
Stream zStream = new LZipStream(inFs, CompressionMode.Decompress);
zStream.CopyTo(outFs);
outFs.Close();
zStream.Close();
inFs.Close();
}
/// <summary>
/// 解压缩
/// </summary>
/// <param name="bytes">需要解压缩的字节流</param>
/// <returns>解压缩的结果</returns>
public byte[] Decompress(byte[] bytes)
{
using (var ms = new MemoryStream())
{
var lzma = new LZipStream(new MemoryStream(bytes), CompressionMode.Decompress, true);
var count = 0;
var data = new byte[4096];
while ((count = lzma.Read(data, 0, data.Length)) != 0)
{
ms.Write(data, 0, count);
}
lzma.Close();
return(ms.ToArray());
}
}
/// <summary>
/// Opens a TarReader for Non-seeking usage with a single volume
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
/// <returns></returns>
public static TarReader Open(Stream stream, ReaderOptions options = null)
{
stream.CheckNotNull(nameof(stream));
options = options ?? new ReaderOptions();
RewindableStream rewindableStream = new RewindableStream(stream);
rewindableStream.StartRecording();
if (GZipArchive.IsGZipFile(rewindableStream))
{
rewindableStream.Rewind(false);
GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress);
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.GZip));
}
throw new InvalidFormatException("Not a tar file.");
}
rewindableStream.Rewind(false);
if (BZip2Stream.IsBZip2(rewindableStream))
{
rewindableStream.Rewind(false);
BZip2Stream testStream = new BZip2Stream(rewindableStream, CompressionMode.Decompress, false);
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.BZip2));
}
throw new InvalidFormatException("Not a tar file.");
}
rewindableStream.Rewind(false);
if (LZipStream.IsLZipFile(rewindableStream))
{
rewindableStream.Rewind(false);
LZipStream testStream = new LZipStream(rewindableStream, CompressionMode.Decompress);
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.LZip));
}
throw new InvalidFormatException("Not a tar file.");
}
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.None));
}
/// <summary>
/// Create an unsigned package
/// </summary>
/// <returns>The package.</returns>
public AppletPackage CreatePackage(String compression = null)
{
AppletPackage retVal = new AppletPackage()
{
Meta = this.Info,
Compression = compression
};
using (MemoryStream ms = new MemoryStream())
{
Stream compressStream = null;
try {
switch (compression)
{
case "lzma":
compressStream = new LZipStream(ms, SharpCompress.Compressors.CompressionMode.Compress, leaveOpen: true);
break;
case "bzip2":
compressStream = new BZip2Stream(ms, SharpCompress.Compressors.CompressionMode.Compress, leaveOpen: true);
break;
case "gzip":
compressStream = new GZipStream(ms, SharpCompress.Compressors.CompressionMode.Compress, leaveOpen: true);
break;
case "none":
compressStream = ms;
break;
default:
compressStream = new DeflateStream(ms, SharpCompress.Compressors.CompressionMode.Compress, leaveOpen: true);
break;
}
XmlSerializer xsz = new XmlSerializer(typeof(AppletManifest));
xsz.Serialize(compressStream, this);
}
finally
{
compressStream.Dispose();
}
retVal.Manifest = ms.ToArray();
}
return(retVal);
}
/// <summary>
/// Create an unsigned package
/// </summary>
/// <returns>The package.</returns>
public AppletPackage CreatePackage()
{
AppletPackage retVal = new AppletPackage()
{
Meta = this.Info
};
this.Info.TimeStamp = DateTime.Now;
using (var ms = new MemoryStream())
{
using (var ls = new LZipStream(ms, SharpCompress.Compressors.CompressionMode.Compress))
{
x_xsz.Serialize(ls, this);
}
retVal.Manifest = ms.ToArray();
}
return(retVal);
}
public int OnExecute(IConsole console)
{
try
{
using (var istm = Util.OpenInputStream(InputFile))
using (var ostm = Util.OpenOutputStream(OutputFile, true))
{
using (var izstm = new LZipStream(istm, CompressionMode.Decompress))
{
izstm.CopyTo(ostm);
}
}
}
catch (Exception e)
{
console.Error.WriteLine($"failed lzip decompression:{e}");
return(1);
}
return(0);
}
public void CompressFile(string source, string destination)
{
var inFs = new FileStream(source, FileMode.Open, FileAccess.Read);
var outFs = new FileStream(destination, FileMode.CreateNew, FileAccess.Write);
Stream zStream = new LZipStream(outFs, CompressionMode.Compress);
byte[] buffer = new byte[BUFFER_SIZE];
SetProgressBounds?.Invoke(this, new ProgressBoundsEventArgs
{
Minimum = 0,
Maximum = inFs.Length
});
while (inFs.Position + BUFFER_SIZE <= inFs.Length)
{
SetProgress?.Invoke(this, new ProgressEventArgs
{
Value = inFs.Position
});
inFs.Read(buffer, 0, buffer.Length);
zStream.Write(buffer, 0, buffer.Length);
}
buffer = new byte[inFs.Length - inFs.Position];
SetProgressBounds?.Invoke(this, new ProgressBoundsEventArgs
{
Minimum = 0,
Maximum = inFs.Length
});
inFs.Read(buffer, 0, buffer.Length);
zStream.Write(buffer, 0, buffer.Length);
inFs.Close();
zStream.Close();
outFs.Dispose();
}
protected override void Dispose(bool isDisposing)
{
if (isDisposing)
{
if (finalizeArchiveOnClose) {
PadTo512(0, true);
PadTo512(0, true);
}
if(OutputStream.GetType()==typeof(BZip2Stream))
{
BZip2Stream b =(BZip2Stream) OutputStream;
b.Finish();
}
else if(OutputStream.GetType() == typeof(LZipStream))
{
LZipStream l =(LZipStream) OutputStream;
l.Finish();
}
//switch (OutputStream)
//{
// case BZip2Stream b:
// {
// b.Finish();
// break;
// }
// case LZipStream l:
// {
// l.Finish();
// break;
// }
//}
}
base.Dispose(isDisposing);
}
/// <summary>
/// Gets the specified URL in raw format
/// </summary>
public byte[] Get(String url)
{
NameValueCollection parameters = new NameValueCollection();
try
{
var requestEventArgs = new RestRequestEventArgs("GET", url, null, null, null);
this.Requesting?.Invoke(this, requestEventArgs);
if (requestEventArgs.Cancel)
{
s_tracer.TraceVerbose("HTTP request cancelled");
return(null);
}
// Invoke
var httpWebReq = this.CreateHttpRequest(url, requestEventArgs.Query);
httpWebReq.Method = "GET";
// Get the responst
byte[] retVal = null;
Exception requestException = null;
var httpTask = httpWebReq.GetResponseAsync().ContinueWith(o =>
{
if (o.IsFaulted)
{
requestException = o.Exception.InnerExceptions.First();
}
else
{
try
{
this.Responding?.Invoke(this, new RestResponseEventArgs("GET", url, null, null, null, 200, o.Result.ContentLength));
byte[] buffer = new byte[2048];
int br = 1;
using (var ms = new MemoryStream())
using (var httpStream = o.Result.GetResponseStream())
{
while (br > 0)
{
br = httpStream.Read(buffer, 0, 2048);
ms.Write(buffer, 0, br);
// Raise event
this.FireProgressChanged(o.Result.ContentType, ms.Length / (float)o.Result.ContentLength);
}
ms.Seek(0, SeekOrigin.Begin);
switch (o.Result.Headers["Content-Encoding"])
{
case "deflate":
using (var dfs = new DeflateStream(ms, CompressionMode.Decompress, leaveOpen: true))
using (var oms = new MemoryStream())
{
dfs.CopyTo(oms);
retVal = oms.ToArray();
}
break;
case "gzip":
using (var gzs = new GZipStream(ms, CompressionMode.Decompress, leaveOpen: true))
using (var oms = new MemoryStream())
{
gzs.CopyTo(oms);
retVal = oms.ToArray();
}
break;
case "bzip2":
using (var lzmas = new BZip2Stream(ms, CompressionMode.Decompress, leaveOpen: true))
using (var oms = new MemoryStream())
{
lzmas.CopyTo(oms);
retVal = oms.ToArray();
}
break;
case "lzma":
using (var lzmas = new LZipStream(ms, CompressionMode.Decompress, leaveOpen: true))
using (var oms = new MemoryStream())
{
lzmas.CopyTo(oms);
retVal = oms.ToArray();
}
break;
default:
retVal = ms.ToArray();
break;
}
}
}
catch (Exception e)
{
s_tracer.TraceError("Error downloading {0}: {1}", url, e.Message);
}
}
}, TaskContinuationOptions.LongRunning);
httpTask.Wait();
if (requestException != null)
{
throw requestException;
}
this.Responded?.Invoke(this, new RestResponseEventArgs("GET", url, null, null, null, 200, 0));
return(retVal);
}
catch (WebException e)
{
switch (this.ValidateResponse(e.Response))
{
case ServiceClientErrorType.Valid:
return(this.Get(url));
default:
throw new RestClientException <byte[]>(
null,
e,
e.Status,
e.Response);
}
}
catch (Exception e)
{
s_tracer.TraceError("Error invoking HTTP: {0}", e.Message);
this.Responded?.Invoke(this, new RestResponseEventArgs("GET", url, null, null, null, 500, 0));
throw;
}
}
public static void ClamScanFileFromRepo(DbFile file)
{
try
{
if (Context.ClamdVersion == null)
{
Failed?.Invoke("clamd is not usable");
return;
}
if (clam == null)
{
Failed?.Invoke("clamd is not initalized");
}
string repoPath;
AlgoEnum algorithm;
if (File.Exists(Path.Combine(Settings.Current.RepositoryPath, file.Sha256[0].ToString(),
file.Sha256[1].ToString(), file.Sha256[2].ToString(),
file.Sha256[3].ToString(), file.Sha256[4].ToString(), file.Sha256 + ".gz")))
{
repoPath = Path.Combine(Settings.Current.RepositoryPath, file.Sha256[0].ToString(),
file.Sha256[1].ToString(), file.Sha256[2].ToString(),
file.Sha256[3].ToString(), file.Sha256[4].ToString(), file.Sha256 + ".gz");
algorithm = AlgoEnum.GZip;
}
else if (File.Exists(Path.Combine(Settings.Current.RepositoryPath, file.Sha256[0].ToString(),
file.Sha256[1].ToString(), file.Sha256[2].ToString(),
file.Sha256[3].ToString(), file.Sha256[4].ToString(),
file.Sha256 + ".bz2")))
{
repoPath = Path.Combine(Settings.Current.RepositoryPath, file.Sha256[0].ToString(),
file.Sha256[1].ToString(), file.Sha256[2].ToString(),
file.Sha256[3].ToString(), file.Sha256[4].ToString(), file.Sha256 + ".bz2");
algorithm = AlgoEnum.BZip2;
}
else if (File.Exists(Path.Combine(Settings.Current.RepositoryPath, file.Sha256[0].ToString(),
file.Sha256[1].ToString(), file.Sha256[2].ToString(),
file.Sha256[3].ToString(), file.Sha256[4].ToString(),
file.Sha256 + ".lzma")))
{
repoPath = Path.Combine(Settings.Current.RepositoryPath, file.Sha256[0].ToString(),
file.Sha256[1].ToString(), file.Sha256[2].ToString(),
file.Sha256[3].ToString(), file.Sha256[4].ToString(),
file.Sha256 + ".lzma");
algorithm = AlgoEnum.LZMA;
}
else if (File.Exists(Path.Combine(Settings.Current.RepositoryPath, file.Sha256[0].ToString(),
file.Sha256[1].ToString(), file.Sha256[2].ToString(),
file.Sha256[3].ToString(), file.Sha256[4].ToString(),
file.Sha256 + ".lz")))
{
repoPath = Path.Combine(Settings.Current.RepositoryPath, file.Sha256[0].ToString(),
file.Sha256[1].ToString(), file.Sha256[2].ToString(),
file.Sha256[3].ToString(), file.Sha256[4].ToString(), file.Sha256 + ".lz");
algorithm = AlgoEnum.LZip;
}
else
{
Failed?.Invoke($"Cannot find file with hash {file.Sha256} in the repository");
return;
}
ClamScanResult result = null;
Stream zStream = null;
if (Settings.Current.ClamdIsLocal)
{
if (algorithm == AlgoEnum.LZMA || algorithm == AlgoEnum.LZip)
{
string tmpFile = Path.Combine(Settings.Current.TemporaryFolder, Path.GetTempFileName());
FileStream outFs = new FileStream(tmpFile, FileMode.Create, FileAccess.Write);
FileStream inFs = new FileStream(repoPath, FileMode.Open, FileAccess.Read);
if (algorithm == AlgoEnum.LZMA)
{
byte[] properties = new byte[5];
inFs.Read(properties, 0, 5);
inFs.Seek(8, SeekOrigin.Current);
zStream = new LzmaStream(properties, inFs, inFs.Length - 13, file.Length);
}
else
{
zStream = new LZipStream(inFs, CompressionMode.Decompress);
}
UpdateProgress?.Invoke("Uncompressing file...", null, 0, 0);
#if DEBUG
stopwatch.Restart();
#endif
zStream.CopyTo(outFs);
zStream.Close();
outFs.Close();
#if DEBUG
stopwatch.Stop();
Console.WriteLine("Core.ClamScanFileFromRepo({0}): Uncompressing took {1} seconds", file,
stopwatch.Elapsed.TotalSeconds);
#endif
UpdateProgress?.Invoke("Requesting local scan to clamd server...", null, 0, 0);
#if DEBUG
stopwatch.Restart();
#endif
Task.Run(async() => { result = await clam.ScanFileOnServerMultithreadedAsync(tmpFile); })
.Wait();
#if DEBUG
stopwatch.Stop();
Console.WriteLine("Core.ClamScanFileFromRepo({0}): Clamd took {1} seconds to scan", file,
stopwatch.Elapsed.TotalSeconds);
#endif
File.Delete(tmpFile);
}
else
{
UpdateProgress?.Invoke("Requesting local scan to clamd server...", null, 0, 0);
#if DEBUG
stopwatch.Restart();
#endif
Task.Run(async() => { result = await clam.ScanFileOnServerMultithreadedAsync(repoPath); })
.Wait();
#if DEBUG
stopwatch.Stop();
Console.WriteLine("Core.ClamScanFileFromRepo({0}): Clamd took {1} seconds to scan", file,
stopwatch.Elapsed.TotalSeconds);
#endif
}
}
else
{
FileStream inFs = new FileStream(repoPath, FileMode.Open, FileAccess.Read);
switch (algorithm)
{
case AlgoEnum.GZip:
zStream = new GZipStream(inFs, CompressionMode.Decompress);
break;
case AlgoEnum.BZip2:
zStream = new BZip2Stream(inFs, CompressionMode.Decompress);
break;
case AlgoEnum.LZMA:
byte[] properties = new byte[5];
inFs.Read(properties, 0, 5);
inFs.Seek(8, SeekOrigin.Current);
zStream = new LzmaStream(properties, inFs, inFs.Length - 13, file.Length);
break;
case AlgoEnum.LZip:
zStream = new LZipStream(inFs, CompressionMode.Decompress);
break;
}
UpdateProgress?.Invoke("Uploading file to clamd server...", null, 0, 0);
#if DEBUG
stopwatch.Restart();
#endif
Task.Run(async() => { result = await clam.SendAndScanFileAsync(zStream); }).Wait();
#if DEBUG
stopwatch.Stop();
Console.WriteLine("Core.ClamScanFileFromRepo({0}): Clamd took {1} seconds to scan", file,
stopwatch.Elapsed.TotalSeconds);
#endif
zStream.Close();
}
if (result.InfectedFiles != null && result.InfectedFiles.Count > 0)
{
file.HasVirus = true;
file.Virus = result.InfectedFiles[0].VirusName;
}
else if (file.HasVirus == null)
{
// If no scan has been done, mark as false.
// If a positive has already existed don't overwrite it.
file.HasVirus = false;
file.Virus = null;
}
file.ClamTime = DateTime.UtcNow;
dbCore.DbOps.UpdateFile(file);
ScanFinished?.Invoke(file);
}
catch (ThreadAbortException) { }
catch (Exception ex)
{
Failed?.Invoke($"Exception {ex.Message} when calling clamd");
#if DEBUG
Console.WriteLine("Exception {0}\n{1}", ex.Message, ex.InnerException);
#endif
}
}
/// <summary>
/// Restore the configuration
/// </summary>
public void Restore()
{
using (var lzs = new LZipStream(File.OpenRead(Path.ChangeExtension(this.m_configPath, "bak.7z")), SharpCompress.Compressors.CompressionMode.Decompress))
this.m_configuration = OpenIZConfiguration.Load(lzs);
this.Save();
}
public static bool TryOpen(Stream stream, ReaderOptions options, ArchiveTypeMask archiveTypes, out IReader reader)
{
stream.CheckNotNull("stream");
options = options ?? new ReaderOptions()
{
LeaveStreamOpen = false
};
RewindableStream rewindableStream = new RewindableStream(stream);
rewindableStream.StartRecording();
if (archiveTypes.HasFlag(ArchiveTypeMask.Zip) && ZipArchive.IsZipFile(rewindableStream, options.Password))
{
rewindableStream.Rewind(true);
reader = ZipReader.Open(rewindableStream, options);
return(true);
}
rewindableStream.Rewind(false);
if (archiveTypes.HasFlag(ArchiveTypeMask.GZip) && GZipArchive.IsGZipFile(rewindableStream))
{
rewindableStream.Rewind(false);
GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress);
if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
reader = new TarReader(rewindableStream, options, CompressionType.GZip);
return(true);
}
rewindableStream.Rewind(true);
reader = GZipReader.Open(rewindableStream, options);
return(true);
}
rewindableStream.Rewind(false);
if (archiveTypes.HasFlag(ArchiveTypeMask.BZip2) && BZip2Stream.IsBZip2(rewindableStream))
{
rewindableStream.Rewind(false);
BZip2Stream testStream = new BZip2Stream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress, false);
if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
reader = new TarReader(rewindableStream, options, CompressionType.BZip2);
return(true);
}
}
rewindableStream.Rewind(false);
if (archiveTypes.HasFlag(ArchiveTypeMask.LZip) && LZipStream.IsLZipFile(rewindableStream))
{
rewindableStream.Rewind(false);
LZipStream testStream = new LZipStream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress);
if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
reader = new TarReader(rewindableStream, options, CompressionType.LZip);
return(true);
}
}
rewindableStream.Rewind(false);
if (archiveTypes.HasFlag(ArchiveTypeMask.Rar) && RarArchive.IsRarFile(rewindableStream, options))
{
rewindableStream.Rewind(true);
reader = RarReader.Open(rewindableStream, options);
return(true);
}
rewindableStream.Rewind(false);
if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(rewindableStream))
{
rewindableStream.Rewind(true);
reader = TarReader.Open(rewindableStream, options);
return(true);
}
rewindableStream.Rewind(false);
if (XZStream.IsXZStream(rewindableStream))
{
rewindableStream.Rewind(true);
XZStream testStream = new XZStream(rewindableStream);
if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
reader = new TarReader(rewindableStream, options, CompressionType.Xz);
return(true);
}
}
reader = null;
return(false);
}
public static void VirusTotalFileFromRepo(DbFile file)
{
try
{
if (!Context.VirusTotalEnabled)
{
Failed?.Invoke("VirusTotal is not usable");
return;
}
if (vTotal == null)
{
Failed?.Invoke("VirusTotal is not initalized");
}
FileReport fResult = null;
UpdateProgress?.Invoke("Requesting existing report to VirusTotal", null, 0, 0);
#if DEBUG
stopwatch.Restart();
#endif
Task.Run(async() =>
{
fResult = await vTotal.GetFileReportAsync(file.Sha256);
}).Wait();
#if DEBUG
stopwatch.Stop();
Console.WriteLine("Core.VirusTotalFileFromRepo({0}): VirusTotal took {1} seconds to answer for SHA256 request",
file, stopwatch.Elapsed.TotalSeconds);
#endif
if (fResult.ResponseCode == FileReportResponseCode.NotPresent)
{
Failed?.Invoke(fResult.VerboseMsg);
return;
}
if (fResult.ResponseCode != FileReportResponseCode.Queued)
{
if (fResult.ResponseCode == FileReportResponseCode.Present)
{
if (fResult.Positives > 0)
{
file.HasVirus = true;
if (fResult.Scans != null)
{
foreach (KeyValuePair <string, ScanEngine> engine in fResult.Scans)
{
if (!engine.Value.Detected)
{
continue;
}
file.Virus = engine.Value.Result;
file.VirusTotalTime = engine.Value.Update;
dbCore.DbOps.UpdateFile(file);
ScanFinished?.Invoke(file);
return;
}
}
}
else
{
// If no scan has been done, mark as false.
// If a positive has already existed don't overwrite it.
file.HasVirus = false;
file.Virus = null;
file.VirusTotalTime = DateTime.UtcNow;
dbCore.DbOps.UpdateFile(file);
ScanFinished?.Invoke(file);
return;
}
}
string repoPath;
AlgoEnum algorithm;
if (File.Exists(Path.Combine(Settings.Current.RepositoryPath, file.Sha256[0].ToString(),
file.Sha256[1].ToString(), file.Sha256[2].ToString(),
file.Sha256[3].ToString(), file.Sha256[4].ToString(),
file.Sha256 + ".gz")))
{
repoPath = Path.Combine(Settings.Current.RepositoryPath, file.Sha256[0].ToString(),
file.Sha256[1].ToString(), file.Sha256[2].ToString(),
file.Sha256[3].ToString(), file.Sha256[4].ToString(),
file.Sha256 + ".gz");
algorithm = AlgoEnum.GZip;
}
else if (File.Exists(Path.Combine(Settings.Current.RepositoryPath, file.Sha256[0].ToString(),
file.Sha256[1].ToString(), file.Sha256[2].ToString(),
file.Sha256[3].ToString(), file.Sha256[4].ToString(),
file.Sha256 + ".bz2")))
{
repoPath = Path.Combine(Settings.Current.RepositoryPath, file.Sha256[0].ToString(),
file.Sha256[1].ToString(), file.Sha256[2].ToString(),
file.Sha256[3].ToString(), file.Sha256[4].ToString(),
file.Sha256 + ".bz2");
algorithm = AlgoEnum.BZip2;
}
else if (File.Exists(Path.Combine(Settings.Current.RepositoryPath, file.Sha256[0].ToString(),
file.Sha256[1].ToString(), file.Sha256[2].ToString(),
file.Sha256[3].ToString(), file.Sha256[4].ToString(),
file.Sha256 + ".lzma")))
{
repoPath = Path.Combine(Settings.Current.RepositoryPath, file.Sha256[0].ToString(),
file.Sha256[1].ToString(), file.Sha256[2].ToString(),
file.Sha256[3].ToString(), file.Sha256[4].ToString(),
file.Sha256 + ".lzma");
algorithm = AlgoEnum.LZMA;
}
else if (File.Exists(Path.Combine(Settings.Current.RepositoryPath, file.Sha256[0].ToString(),
file.Sha256[1].ToString(), file.Sha256[2].ToString(),
file.Sha256[3].ToString(), file.Sha256[4].ToString(),
file.Sha256 + ".lz")))
{
repoPath = Path.Combine(Settings.Current.RepositoryPath, file.Sha256[0].ToString(),
file.Sha256[1].ToString(), file.Sha256[2].ToString(),
file.Sha256[3].ToString(), file.Sha256[4].ToString(),
file.Sha256 + ".lz");
algorithm = AlgoEnum.LZip;
}
else
{
Failed?.Invoke($"Cannot find file with hash {file.Sha256} in the repository");
return;
}
UpdateProgress?.Invoke("Uncompressing file...", null, 0, 0);
var inFs = new FileStream(repoPath, FileMode.Open, FileAccess.Read);
Stream zStream = null;
switch (algorithm)
{
case AlgoEnum.GZip:
zStream = new GZipStream(inFs, CompressionMode.Decompress);
break;
case AlgoEnum.BZip2:
zStream = new BZip2Stream(inFs, CompressionMode.Decompress);
break;
case AlgoEnum.LZMA:
byte[] properties = new byte[5];
inFs.Read(properties, 0, 5);
inFs.Seek(8, SeekOrigin.Current);
zStream = new LzmaStream(properties, inFs, inFs.Length - 13, file.Length);
break;
case AlgoEnum.LZip:
zStream = new LZipStream(inFs, CompressionMode.Decompress);
break;
}
ScanResult sResult = null;
#if DEBUG
stopwatch.Restart();
#endif
// Cannot use zStream directly, VirusTotal.NET requests the size *sigh*
string tmpFile = Path.Combine(Settings.Current.TemporaryFolder, Path.GetTempFileName());
var outFs = new FileStream(tmpFile, FileMode.Create, FileAccess.ReadWrite);
zStream?.CopyTo(outFs);
zStream?.Close();
outFs.Seek(0, SeekOrigin.Begin);
#if DEBUG
stopwatch.Stop();
Console.WriteLine("Core.VirusTotalFileFromRepo({0}): Uncompressing took {1} seconds", file,
stopwatch.Elapsed.TotalSeconds);
#endif
UpdateProgress?.Invoke("Uploading file to VirusTotal...", null, 0, 0);
#if DEBUG
stopwatch.Restart();
#endif
Task.Run(async() =>
{
sResult = await vTotal.ScanFileAsync(outFs, file.Sha256); // Keep filename private, sorry!
}).Wait();
#if DEBUG
stopwatch.Stop();
Console.WriteLine("Core.VirusTotalFileFromRepo({0}): Upload to VirusTotal took {1} seconds", file,
stopwatch.Elapsed.TotalSeconds);
#endif
outFs.Close();
File.Delete(tmpFile);
if (sResult == null ||
sResult.ResponseCode == ScanFileResponseCode.Error)
{
if (sResult == null)
{
Failed?.Invoke("Cannot send file to VirusTotal");
}
else
{
Failed(sResult.VerboseMsg);
}
return;
}
// Seems that we are faster than them, getting a lot of "not queued" responses...
Thread.Sleep(2500);
Task.Run(async() =>
{
fResult = await vTotal.GetFileReportAsync(file.Sha256);
}).Wait();
}
UpdateProgress?.Invoke("Waiting for VirusTotal analysis...", null, 0, 0);
#if DEBUG
stopwatch.Restart();
#endif
int counter = 0;
while (fResult.ResponseCode == FileReportResponseCode.Queued)
{
// Timeout...
if (counter == 10)
{
break;
}
// Wait 15 seconds so we fall in the 4 requests/minute
Thread.Sleep(15000);
Task.Run(async() =>
{
fResult = await vTotal.GetFileReportAsync(file.Sha256);
}).Wait();
counter++;
}
#if DEBUG
stopwatch.Stop();
Console.WriteLine("Core.VirusTotalFileFromRepo({0}): VirusTotal took {1} seconds to do the analysis",
file, stopwatch.Elapsed.TotalSeconds);
#endif
if (fResult.ResponseCode != FileReportResponseCode.Present)
{
Failed?.Invoke(fResult.VerboseMsg);
return;
}
if (fResult.Positives > 0)
{
file.HasVirus = true;
if (fResult.Scans == null)
{
return;
}
foreach (KeyValuePair <string, ScanEngine> engine in fResult.Scans)
{
if (!engine.Value.Detected)
{
continue;
}
file.Virus = engine.Value.Result;
file.VirusTotalTime = engine.Value.Update;
dbCore.DbOps.UpdateFile(file);
ScanFinished?.Invoke(file);
return;
}
}
else
{
// If no scan has been done, mark as false.
// If a positive has already existed don't overwrite it.
file.HasVirus = false;
file.Virus = null;
file.VirusTotalTime = DateTime.UtcNow;
dbCore.DbOps.UpdateFile(file);
ScanFinished?.Invoke(file);
}
}
catch (Exception ex)
{
Failed?.Invoke($"Exception {ex.InnerException.Message} when calling VirusTotal");
#if DEBUG
Console.WriteLine("Exception {0}\n{1}", ex.Message, ex.InnerException);
#endif
}
}
public static void CompressFiles()
{
try
{
if (string.IsNullOrWhiteSpace(Context.DbInfo.Developer))
{
Failed?.Invoke("Developer cannot be empty");
return;
}
if (string.IsNullOrWhiteSpace(Context.DbInfo.Product))
{
Failed?.Invoke("Product cannot be empty");
return;
}
if (string.IsNullOrWhiteSpace(Context.DbInfo.Version))
{
Failed?.Invoke("Version cannot be empty");
return;
}
string destinationFolder = "";
destinationFolder = Path.Combine(destinationFolder, Context.DbInfo.Developer);
destinationFolder = Path.Combine(destinationFolder, Context.DbInfo.Product);
destinationFolder = Path.Combine(destinationFolder, Context.DbInfo.Version);
if (!string.IsNullOrWhiteSpace(Context.DbInfo.Languages))
{
destinationFolder = Path.Combine(destinationFolder, Context.DbInfo.Languages);
}
if (!string.IsNullOrWhiteSpace(Context.DbInfo.Architecture))
{
destinationFolder = Path.Combine(destinationFolder, Context.DbInfo.Architecture);
}
if (Context.DbInfo.Oem)
{
destinationFolder = Path.Combine(destinationFolder, "oem");
}
if (!string.IsNullOrWhiteSpace(Context.DbInfo.Machine))
{
destinationFolder = Path.Combine(destinationFolder, "for " + Context.DbInfo.Machine);
}
string destinationFile = "";
if (!string.IsNullOrWhiteSpace(Context.DbInfo.Format))
{
destinationFile += "[" + Context.DbInfo.Format + "]";
}
if (Context.DbInfo.Files)
{
if (destinationFile != "")
{
destinationFile += "_";
}
destinationFile += "files";
}
if (Context.DbInfo.Netinstall)
{
if (destinationFile != "")
{
destinationFile += "_";
}
destinationFile += "netinstall";
}
if (Context.DbInfo.Source)
{
if (destinationFile != "")
{
destinationFile += "_";
}
destinationFile += "source";
}
if (Context.DbInfo.Update)
{
if (destinationFile != "")
{
destinationFile += "_";
}
destinationFile += "update";
}
if (Context.DbInfo.Upgrade)
{
if (destinationFile != "")
{
destinationFile += "_";
}
destinationFile += "upgrade";
}
if (!string.IsNullOrWhiteSpace(Context.DbInfo.Description))
{
if (destinationFile != "")
{
destinationFile += "_";
}
destinationFile += Context.DbInfo.Description;
}
else if (destinationFile == "")
{
destinationFile = "archive";
}
string destination = Path.Combine(destinationFolder, destinationFile) + ".zip";
Md5Context md5 = new Md5Context();
md5.Init();
byte[] tmp;
string mdid = md5.Data(Encoding.UTF8.GetBytes(destination), out tmp);
Console.WriteLine("MDID: {0}", mdid);
if (dbCore.DbOps.ExistsOs(mdid))
{
if (File.Exists(destination))
{
Failed?.Invoke("OS already exists.");
return;
}
Failed?.Invoke("OS already exists in the database but not in the repository, check for inconsistencies.");
return;
}
if (File.Exists(destination))
{
Failed?.Invoke("OS already exists in the repository but not in the database, check for inconsistencies.");
return;
}
Context.DbInfo.Mdid = mdid;
string filesPath;
if (!string.IsNullOrEmpty(Context.TmpFolder) && Directory.Exists(Context.TmpFolder))
{
filesPath = Context.TmpFolder;
}
else
{
filesPath = Context.Path;
}
string extension = null;
switch (Settings.Current.CompressionAlgorithm)
{
case AlgoEnum.GZip:
extension = ".gz";
break;
case AlgoEnum.BZip2:
extension = ".bz2";
break;
case AlgoEnum.LZMA:
extension = ".lzma";
break;
case AlgoEnum.LZip:
extension = ".lz";
break;
}
long totalSize = 0, currentSize = 0;
foreach (KeyValuePair <string, DbOsFile> file in Context.Hashes)
{
totalSize += file.Value.Length;
}
#if DEBUG
stopwatch.Restart();
#endif
foreach (KeyValuePair <string, DbOsFile> file in Context.Hashes)
{
UpdateProgress?.Invoke("Compressing...", file.Value.Path, currentSize, totalSize);
destinationFolder = Path.Combine(Settings.Current.RepositoryPath, file.Value.Sha256[0].ToString(),
file.Value.Sha256[1].ToString(), file.Value.Sha256[2].ToString(),
file.Value.Sha256[3].ToString(), file.Value.Sha256[4].ToString());
Directory.CreateDirectory(destinationFolder);
destinationFile = Path.Combine(destinationFolder, file.Value.Sha256 + extension);
if (!File.Exists(destinationFile))
{
FileStream inFs = new FileStream(Path.Combine(filesPath, file.Value.Path), FileMode.Open,
FileAccess.Read);
FileStream outFs = new FileStream(destinationFile, FileMode.CreateNew, FileAccess.Write);
Stream zStream = null;
switch (Settings.Current.CompressionAlgorithm)
{
case AlgoEnum.GZip:
zStream = new GZipStream(outFs, CompressionMode.Compress,
CompressionLevel.BestCompression);
break;
case AlgoEnum.BZip2:
zStream = new BZip2Stream(outFs, CompressionMode.Compress);
break;
case AlgoEnum.LZMA:
zStream = new LzmaStream(new LzmaEncoderProperties(), false, outFs);
outFs.Write(((LzmaStream)zStream).Properties, 0,
((LzmaStream)zStream).Properties.Length);
outFs.Write(BitConverter.GetBytes(inFs.Length), 0, 8);
break;
case AlgoEnum.LZip:
zStream = new LZipStream(outFs, CompressionMode.Compress);
break;
}
byte[] buffer = new byte[BUFFER_SIZE];
while (inFs.Position + BUFFER_SIZE <= inFs.Length)
{
UpdateProgress2?.Invoke($"{inFs.Position / (double)inFs.Length:P}",
$"{inFs.Position} / {inFs.Length} bytes", inFs.Position,
inFs.Length);
UpdateProgress?.Invoke("Compressing...", file.Value.Path, currentSize, totalSize);
inFs.Read(buffer, 0, buffer.Length);
zStream.Write(buffer, 0, buffer.Length);
currentSize += buffer.Length;
}
buffer = new byte[inFs.Length - inFs.Position];
UpdateProgress2?.Invoke($"{inFs.Position / (double)inFs.Length:P}",
$"{inFs.Position} / {inFs.Length} bytes", inFs.Position, inFs.Length);
UpdateProgress?.Invoke("Compressing...", file.Value.Path, currentSize, totalSize);
inFs.Read(buffer, 0, buffer.Length);
zStream.Write(buffer, 0, buffer.Length);
currentSize += buffer.Length;
UpdateProgress2?.Invoke($"{inFs.Length / (double)inFs.Length:P}", "Finishing...", inFs.Length,
inFs.Length);
inFs.Close();
zStream.Close();
outFs.Dispose();
}
else
{
currentSize += file.Value.Length;
}
}
#if DEBUG
stopwatch.Stop();
Console.WriteLine("Core.CompressFiles(): Took {0} seconds to compress files",
stopwatch.Elapsed.TotalSeconds);
#endif
if (Context.Metadata != null)
{
MemoryStream xms = new MemoryStream();
XmlSerializer xs = new XmlSerializer(typeof(CICMMetadataType));
xs.Serialize(xms, Context.Metadata);
xms.Position = 0;
JsonSerializer js = new JsonSerializer
{
Formatting = Formatting.Indented,
NullValueHandling = NullValueHandling.Ignore
};
MemoryStream jms = new MemoryStream();
StreamWriter sw = new StreamWriter(jms, Encoding.UTF8, 1048576, true);
js.Serialize(sw, Context.Metadata, typeof(CICMMetadataType));
sw.Close();
jms.Position = 0;
destinationFolder = Path.Combine(Settings.Current.RepositoryPath, "metadata", mdid[0].ToString(),
mdid[1].ToString(), mdid[2].ToString(), mdid[3].ToString(),
mdid[4].ToString());
Directory.CreateDirectory(destinationFolder);
FileStream xfs = new FileStream(Path.Combine(destinationFolder, mdid + ".xml"), FileMode.CreateNew,
FileAccess.Write);
xms.CopyTo(xfs);
xfs.Close();
FileStream jfs = new FileStream(Path.Combine(destinationFolder, mdid + ".json"), FileMode.CreateNew,
FileAccess.Write);
jms.CopyTo(jfs);
jfs.Close();
xms.Position = 0;
jms.Position = 0;
}
FinishedWithText?.Invoke($"Correctly added operating system with MDID {mdid}");
}
catch (ThreadAbortException) { }
catch (Exception ex)
{
if (Debugger.IsAttached)
{
throw;
}
Failed?.Invoke($"Exception {ex.Message}\n{ex.InnerException}");
#if DEBUG
Console.WriteLine("Exception {0}\n{1}", ex.Message, ex.InnerException);
#endif
}
}
/// <summary>
/// Invokes the specified method against the url provided
/// </summary>
/// <param name="method">Method.</param>
/// <param name="url">URL.</param>
/// <param name="contentType">Content type.</param>
/// <param name="body">Body.</param>
/// <param name="query">Query.</param>
/// <typeparam name="TBody">The 1st type parameter.</typeparam>
/// <typeparam name="TResult">The 2nd type parameter.</typeparam>
protected override TResult InvokeInternal <TBody, TResult>(string method, string url, string contentType, WebHeaderCollection additionalHeaders, out WebHeaderCollection responseHeaders, TBody body, NameValueCollection query)
{
if (String.IsNullOrEmpty(method))
{
throw new ArgumentNullException(nameof(method));
}
//if (String.IsNullOrEmpty(url))
// throw new ArgumentNullException(nameof(url));
// Three times:
// 1. With provided credential
// 2. With challenge
// 3. With challenge again
for (int i = 0; i < 2; i++)
{
// Credentials provided ?
HttpWebRequest requestObj = this.CreateHttpRequest(url, query) as HttpWebRequest;
if (!String.IsNullOrEmpty(contentType))
{
requestObj.ContentType = contentType;
}
requestObj.Method = method;
// Additional headers
if (additionalHeaders != null)
{
foreach (var hdr in additionalHeaders.AllKeys)
{
if (hdr == "If-Modified-Since")
{
requestObj.IfModifiedSince = DateTime.Parse(additionalHeaders[hdr]);
}
else
{
requestObj.Headers.Add(hdr, additionalHeaders[hdr]);
}
}
}
#if PERFMON
Stopwatch sw = new Stopwatch();
sw.Start();
#endif
// Body was provided?
try
{
// Try assigned credentials
IBodySerializer serializer = null;
if (body != null)
{
// GET Stream,
Stream requestStream = null;
try
{
// Get request object
using (var requestTask = Task.Run(async() => { return(await requestObj.GetRequestStreamAsync()); }))
{
try
{
if (!requestTask.Wait(this.Description.Endpoint[0].Timeout))
{
requestObj.Abort();
throw new TimeoutException();
}
requestStream = requestTask.Result;
}
catch (AggregateException e)
{
requestObj.Abort();
throw e.InnerExceptions.First();
}
}
if (contentType == null && typeof(TResult) != typeof(Object))
{
throw new ArgumentNullException(nameof(contentType));
}
serializer = this.Description.Binding.ContentTypeMapper.GetSerializer(contentType, typeof(TBody));
// Serialize and compress with deflate
using (MemoryStream ms = new MemoryStream())
{
if (this.Description.Binding.Optimize)
{
switch ((this.Description.Binding as ServiceClientBinding)?.OptimizationMethod)
{
case OptimizationMethod.Lzma:
requestObj.Headers.Add("Content-Encoding", "lzma");
using (var df = new LZipStream(requestStream, CompressionMode.Compress, leaveOpen: true))
serializer.Serialize(df, body);
break;
case OptimizationMethod.Bzip2:
requestObj.Headers.Add("Content-Encoding", "bzip2");
using (var df = new BZip2Stream(requestStream, CompressionMode.Compress, leaveOpen: true))
serializer.Serialize(df, body);
break;
case OptimizationMethod.Gzip:
requestObj.Headers.Add("Content-Encoding", "gzip");
using (var df = new GZipStream(requestStream, CompressionMode.Compress, leaveOpen: true))
serializer.Serialize(df, body);
break;
case OptimizationMethod.Deflate:
requestObj.Headers.Add("Content-Encoding", "deflate");
using (var df = new DeflateStream(requestStream, CompressionMode.Compress, leaveOpen: true))
serializer.Serialize(df, body);
break;
case OptimizationMethod.None:
default:
serializer.Serialize(ms, body);
break;
}
}
else
{
serializer.Serialize(ms, body);
}
// Trace
if (this.Description.Trace)
{
this.m_tracer.TraceVerbose("HTTP >> {0}", Convert.ToBase64String(ms.ToArray()));
}
using (var nms = new MemoryStream(ms.ToArray()))
nms.CopyTo(requestStream);
}
}
finally
{
if (requestStream != null)
{
requestStream.Dispose();
}
}
}
// Response
HttpWebResponse response = null;
try
{
// Get request object
using (var responseTask = Task.Run(async() => { return(await requestObj.GetResponseAsync()); }))
{
try
{
if (!responseTask.Wait(this.Description.Endpoint[0].Timeout))
{
requestObj.Abort();
throw new TimeoutException();
}
response = (HttpWebResponse)responseTask.Result;
}
catch (AggregateException e)
{
requestObj.Abort();
throw e.InnerExceptions.First();
}
}
#if PERFMON
sw.Stop();
ApplicationContext.Current.PerformanceLog(nameof(RestClient), "InvokeInternal", $"{nameof(TBody)}-RCV", sw.Elapsed);
sw.Reset();
sw.Start();
#endif
responseHeaders = response.Headers;
var validationResult = this.ValidateResponse(response);
if (validationResult != ServiceClientErrorType.Valid)
{
this.m_tracer.TraceError("Response failed validation : {0}", validationResult);
throw new WebException(Strings.err_response_failed_validation, null, WebExceptionStatus.Success, response);
}
// No content - does the result want a pointer maybe?
if (response.StatusCode == HttpStatusCode.NoContent)
{
return(default(TResult));
}
else
{
// De-serialize
var responseContentType = response.ContentType;
if (String.IsNullOrEmpty(responseContentType))
{
return(default(TResult));
}
if (responseContentType.Contains(";"))
{
responseContentType = responseContentType.Substring(0, responseContentType.IndexOf(";"));
}
if (response.StatusCode == HttpStatusCode.NotModified)
{
return(default(TResult));
}
serializer = this.Description.Binding.ContentTypeMapper.GetSerializer(responseContentType, typeof(TResult));
TResult retVal = default(TResult);
// Compression?
using (MemoryStream ms = new MemoryStream())
{
if (this.Description.Trace)
{
this.m_tracer.TraceVerbose("Received response {0} : {1} bytes", response.ContentType, response.ContentLength);
}
response.GetResponseStream().CopyTo(ms);
#if PERFMON
sw.Stop();
ApplicationContext.Current.PerformanceLog(nameof(RestClient), "InvokeInternal", $"{nameof(TBody)}-INT", sw.Elapsed);
sw.Reset();
sw.Start();
#endif
ms.Seek(0, SeekOrigin.Begin);
// Trace
if (this.Description.Trace)
{
this.m_tracer.TraceVerbose("HTTP << {0}", Convert.ToBase64String(ms.ToArray()));
}
switch (response.Headers[HttpResponseHeader.ContentEncoding])
{
case "deflate":
using (DeflateStream df = new DeflateStream(ms, CompressionMode.Decompress, leaveOpen: true))
retVal = (TResult)serializer.DeSerialize(df);
break;
case "gzip":
using (GZipStream df = new GZipStream(ms, CompressionMode.Decompress, leaveOpen: true))
retVal = (TResult)serializer.DeSerialize(df);
break;
case "bzip2":
using (var bzs = new BZip2Stream(ms, CompressionMode.Decompress, leaveOpen: true))
retVal = (TResult)serializer.DeSerialize(bzs);
break;
case "lzma":
using (var lzmas = new LZipStream(ms, CompressionMode.Decompress, leaveOpen: true))
retVal = (TResult)serializer.DeSerialize(lzmas);
break;
default:
retVal = (TResult)serializer.DeSerialize(ms);
break;
}
//retVal = (TResult)serializer.DeSerialize(ms);
}
#if PERFMON
sw.Stop();
ApplicationContext.Current.PerformanceLog(nameof(RestClient), "InvokeInternal", $"{nameof(TBody)}-RET", sw.Elapsed);
sw.Reset();
sw.Start();
#endif
return(retVal);
}
}
finally
{
if (response != null)
{
response.Close();
response.Dispose();
}
//responseTask.Dispose();
}
}
catch (TimeoutException e)
{
this.m_tracer.TraceError("Request timed out:{0}", e.Message);
throw;
}
catch (WebException e)
{
var errorResponse = (e.Response as HttpWebResponse);
if (errorResponse?.StatusCode == HttpStatusCode.NotModified)
{
this.m_tracer.TraceInfo("Server indicates not modified {0} {1} : {2}", method, url, e.Message);
responseHeaders = errorResponse?.Headers;
return(default(TResult));
}
this.m_tracer.TraceError("Error executing {0} {1} : {2}", method, url, e.Message);
// status
switch (e.Status)
{
case WebExceptionStatus.ProtocolError:
// Deserialize
object errorResult = default(ErrorResult);
var responseContentType = errorResponse.ContentType;
if (responseContentType.Contains(";"))
{
responseContentType = responseContentType.Substring(0, responseContentType.IndexOf(";"));
}
var ms = new MemoryStream(); // copy response to memory
errorResponse.GetResponseStream().CopyTo(ms);
ms.Seek(0, SeekOrigin.Begin);
try
{
var serializer = this.Description.Binding.ContentTypeMapper.GetSerializer(responseContentType, typeof(TResult));
try
{
switch (errorResponse.Headers[HttpResponseHeader.ContentEncoding])
{
case "deflate":
using (DeflateStream df = new DeflateStream(ms, CompressionMode.Decompress, leaveOpen: true))
errorResult = (TResult)serializer.DeSerialize(df);
break;
case "gzip":
using (GZipStream df = new GZipStream(ms, CompressionMode.Decompress, leaveOpen: true))
errorResult = (TResult)serializer.DeSerialize(df);
break;
case "bzip2":
using (var bzs = new BZip2Stream(ms, CompressionMode.Decompress, leaveOpen: true))
errorResult = (TResult)serializer.DeSerialize(bzs);
break;
case "lzma":
using (var lzmas = new LZipStream(ms, CompressionMode.Decompress, leaveOpen: true))
errorResult = (TResult)serializer.DeSerialize(lzmas);
break;
default:
errorResult = (TResult)serializer.DeSerialize(ms);
break;
}
}
catch
{
serializer = this.Description.Binding.ContentTypeMapper.GetSerializer(responseContentType, typeof(ErrorResult));
ms.Seek(0, SeekOrigin.Begin); // rewind and try generic error codes
switch (errorResponse.Headers[HttpResponseHeader.ContentEncoding])
{
case "deflate":
using (DeflateStream df = new DeflateStream(ms, CompressionMode.Decompress, leaveOpen: true))
errorResult = (ErrorResult)serializer.DeSerialize(df);
break;
case "gzip":
using (GZipStream df = new GZipStream(ms, CompressionMode.Decompress, leaveOpen: true))
errorResult = (ErrorResult)serializer.DeSerialize(df);
break;
case "bzip2":
using (var bzs = new BZip2Stream(ms, CompressionMode.Decompress, leaveOpen: true))
errorResult = (ErrorResult)serializer.DeSerialize(bzs);
break;
case "lzma":
using (var lzmas = new LZipStream(ms, CompressionMode.Decompress, leaveOpen: true))
errorResult = (ErrorResult)serializer.DeSerialize(lzmas);
break;
default:
errorResult = (ErrorResult)serializer.DeSerialize(ms);
break;
}
}
//result = (TResult)serializer.DeSerialize(errorResponse.GetResponseStream());
}
catch (Exception dse)
{
this.m_tracer.TraceError("Could not de-serialize error response! {0}", dse.Message);
}
Exception exception = null;
if (errorResult is TResult)
{
exception = new RestClientException <TResult>((TResult)errorResult, e, e.Status, e.Response);
}
else
{
exception = new RestClientException <ErrorResult>((ErrorResult)errorResult, e, e.Status, e.Response);
}
switch (errorResponse.StatusCode)
{
case HttpStatusCode.Unauthorized: // Validate the response
if (this.ValidateResponse(errorResponse) != ServiceClientErrorType.Valid)
{
throw exception;
}
break;
case HttpStatusCode.NotModified:
responseHeaders = errorResponse?.Headers;
return(default(TResult));
default:
throw exception;
}
break;
case WebExceptionStatus.ConnectFailure:
if ((e.InnerException as SocketException)?.SocketErrorCode == SocketError.TimedOut)
{
throw new TimeoutException();
}
else
{
throw;
}
case WebExceptionStatus.Timeout:
throw new TimeoutException();
default:
throw;
}
}
}
responseHeaders = new WebHeaderCollection();
return(default(TResult));
}
/// <summary>
/// Invokes the specified method against the url provided
/// </summary>
/// <param name="method">Method.</param>
/// <param name="url">URL.</param>
/// <param name="contentType">Content type.</param>
/// <param name="body">Body.</param>
/// <param name="query">Query.</param>
/// <typeparam name="TBody">The 1st type parameter.</typeparam>
/// <typeparam name="TResult">The 2nd type parameter.</typeparam>
protected override TResult InvokeInternal <TBody, TResult>(string method, string url, string contentType, WebHeaderCollection requestHeaders, out WebHeaderCollection responseHeaders, TBody body, NameValueCollection query)
{
if (String.IsNullOrEmpty(method))
{
throw new ArgumentNullException(nameof(method));
}
if (String.IsNullOrEmpty(url))
{
throw new ArgumentNullException(nameof(url));
}
// Three times:
// 1. With provided credential
// 2. With challenge
// 3. With challenge again
for (int i = 0; i < 2; i++)
{
// Credentials provided ?
HttpWebRequest requestObj = this.CreateHttpRequest(url, query) as HttpWebRequest;
if (!String.IsNullOrEmpty(contentType))
{
requestObj.ContentType = contentType;
}
requestObj.Method = method;
// Additional headers
if (requestHeaders != null)
{
foreach (var hdr in requestHeaders.AllKeys)
{
if (hdr == "If-Modified-Since")
{
requestObj.IfModifiedSince = DateTime.Parse(requestHeaders[hdr]);
}
else
{
requestObj.Headers.Add(hdr, requestHeaders[hdr]);
}
}
}
// Body was provided?
try
{
// Try assigned credentials
IBodySerializer serializer = null;
if (body != null)
{
// GET Stream,
Stream requestStream = null;
Exception requestException = null;
try
{
//requestStream = requestObj.GetRequestStream();
var requestTask = requestObj.GetRequestStreamAsync().ContinueWith(r =>
{
if (r.IsFaulted)
{
requestException = r.Exception.InnerExceptions.First();
}
else
{
requestStream = r.Result;
}
}, TaskContinuationOptions.LongRunning);
if (!requestTask.Wait(this.Description.Endpoint[0].Timeout))
{
throw new TimeoutException();
}
else if (requestException != null)
{
throw requestException;
}
if (contentType == null)
{
throw new ArgumentNullException(nameof(contentType));
}
serializer = this.Description.Binding.ContentTypeMapper.GetSerializer(contentType, typeof(TBody));
// Serialize and compress with deflate
if (this.Description.Binding.Optimize)
{
#if HTTP_LZMA
requestObj.Headers.Add("Content-Encoding", "lzma");
using (var df = new LZipStream(requestStream, CompressionMode.Compress, leaveOpen: true))
serializer.Serialize(df, body);
#elif HTTP_GZ
requestObj.Headers.Add("Content-Encoding", "gzip");
using (var df = new GZipStream(requestStream, CompressionMode.Compress, leaveOpen: true))
serializer.Serialize(df, body);
#else
requestObj.Headers.Add("Content-Encoding", "deflate");
using (var df = new DeflateStream(requestStream, CompressionMode.Compress, leaveOpen: true))
serializer.Serialize(df, body);
#endif
}
else
{
serializer.Serialize(requestStream, body);
}
}
finally
{
if (requestStream != null)
{
requestStream.Dispose();
}
}
}
// Response
HttpWebResponse response = null;
Exception responseError = null;
try
{
var responseTask = requestObj.GetResponseAsync().ContinueWith(r =>
{
if (r.IsFaulted)
{
responseError = r.Exception.InnerExceptions.First();
}
else
{
response = r.Result as HttpWebResponse;
}
}, TaskContinuationOptions.LongRunning);
if (!responseTask.Wait(this.Description.Endpoint[0].Timeout))
{
throw new TimeoutException();
}
else
{
if (responseError != null)
{
responseHeaders = new WebHeaderCollection();
if (((responseError as WebException)?.Response as HttpWebResponse)?.StatusCode == HttpStatusCode.NotModified)
{
return(default(TResult));
}
else
{
throw responseError;
}
}
responseHeaders = response.Headers;
}
var validationResult = this.ValidateResponse(response);
if (validationResult != ServiceClientErrorType.Valid)
{
this.traceSource.TraceEvent(TraceEventType.Error, 0, "Response failed validation : {0}", validationResult);
throw new WebException("Response failed validation", null, WebExceptionStatus.Success, response);
}
// De-serialize
var responseContentType = response.ContentType;
if (responseContentType.Contains(";"))
{
responseContentType = responseContentType.Substring(0, responseContentType.IndexOf(";"));
}
if (response.StatusCode == HttpStatusCode.NotModified ||
response.StatusCode == HttpStatusCode.NoContent ||
typeof(TResult) == typeof(object))
{
return(default(TResult));
}
serializer = this.Description.Binding.ContentTypeMapper.GetSerializer(responseContentType, typeof(TResult));
TResult retVal = default(TResult);
using (var ms = new MemoryStream())
{
response.GetResponseStream().CopyTo(ms);
ms.Seek(0, SeekOrigin.Begin);
// Compression?
switch (response.Headers[HttpResponseHeader.ContentEncoding])
{
case "deflate":
using (DeflateStream df = new DeflateStream(ms, CompressionMode.Decompress, leaveOpen: true))
retVal = (TResult)serializer.DeSerialize(df);
break;
case "gzip":
using (GZipStream df = new GZipStream(ms, CompressionMode.Decompress, leaveOpen: true))
retVal = (TResult)serializer.DeSerialize(df);
break;
case "bzip2":
using (var bzs = new BZip2Stream(ms, CompressionMode.Decompress, leaveOpen: true))
retVal = (TResult)serializer.DeSerialize(bzs);
break;
case "lzma":
using (var lzmas = new LZipStream(ms, CompressionMode.Decompress, leaveOpen: true))
retVal = (TResult)serializer.DeSerialize(lzmas);
break;
default:
retVal = (TResult)serializer.DeSerialize(ms);
break;
}
}
return(retVal);
}
finally
{
if (response != null)
{
response.Dispose();
}
}
}
catch (TimeoutException e)
{
this.traceSource.TraceEvent(TraceEventType.Error, 0, "Request timed out:{0}", e);
throw;
}
catch (WebException e)
{
this.traceSource.TraceEvent(TraceEventType.Error, 0, e.ToString());
// status
switch (e.Status)
{
case WebExceptionStatus.ProtocolError:
// Deserialize
TResult result = default(TResult);
var errorResponse = (e.Response as HttpWebResponse);
var responseContentType = errorResponse.ContentType;
if (responseContentType.Contains(";"))
{
responseContentType = responseContentType.Substring(0, responseContentType.IndexOf(";"));
}
try
{
var serializer = this.Description.Binding.ContentTypeMapper.GetSerializer(responseContentType, typeof(TResult));
switch (errorResponse.Headers[HttpResponseHeader.ContentEncoding])
{
case "deflate":
using (DeflateStream df = new DeflateStream(errorResponse.GetResponseStream(), CompressionMode.Decompress, leaveOpen: true))
result = (TResult)serializer.DeSerialize(df);
break;
case "gzip":
using (GZipStream df = new GZipStream(errorResponse.GetResponseStream(), CompressionMode.Decompress, leaveOpen: true))
result = (TResult)serializer.DeSerialize(df);
break;
case "bzip2":
using (var bzs = new BZip2Stream(errorResponse.GetResponseStream(), CompressionMode.Decompress, leaveOpen: true))
result = (TResult)serializer.DeSerialize(bzs);
break;
case "lzma":
using (var lzmas = new LZipStream(errorResponse.GetResponseStream(), CompressionMode.Decompress, leaveOpen: true))
result = (TResult)serializer.DeSerialize(lzmas);
break;
default:
result = (TResult)serializer.DeSerialize(errorResponse.GetResponseStream());
break;
}
}
catch (Exception dse)
{
this.traceSource.TraceEvent(TraceEventType.Error, 0, "Could not de-serialize error response! {0}", dse);
}
switch (errorResponse.StatusCode)
{
case HttpStatusCode.Unauthorized: // Validate the response
if (this.ValidateResponse(errorResponse) != ServiceClientErrorType.Valid)
{
throw new RestClientException <TResult>(
result,
e,
e.Status,
e.Response);
}
break;
default:
throw new RestClientException <TResult>(
result,
e,
e.Status,
e.Response);
}
break;
default:
throw;
}
}
}
responseHeaders = new WebHeaderCollection();
return(default(TResult));
}
/// <summary>
/// Unpack the package
/// </summary>
public AppletManifest Unpack()
{
using (MemoryStream ms = new MemoryStream(this.Manifest))
using (LZipStream gs = new LZipStream(new NonDisposingStream(ms), CompressionMode.Decompress))
return(AppletManifest.Load(gs));
}
/// <summary>
/// Opens a Reader for Non-seeking usage
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
/// <returns></returns>
public static IReader Open(Stream stream, ReaderOptions options = null)
{
stream.CheckNotNull("stream");
options = options ?? new ReaderOptions()
{
LeaveStreamOpen = false
};
RewindableStream rewindableStream = new RewindableStream(stream);
rewindableStream.StartRecording();
if (ZipArchive.IsZipFile(rewindableStream, options.Password))
{
rewindableStream.Rewind(true);
return(ZipReader.Open(rewindableStream, options));
}
rewindableStream.Rewind(false);
if (GZipArchive.IsGZipFile(rewindableStream))
{
rewindableStream.Rewind(false);
GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress);
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.GZip));
}
rewindableStream.Rewind(true);
return(GZipReader.Open(rewindableStream, options));
}
rewindableStream.Rewind(false);
if (BZip2Stream.IsBZip2(rewindableStream))
{
rewindableStream.Rewind(false);
BZip2Stream testStream = new BZip2Stream(rewindableStream, CompressionMode.Decompress, true);
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.BZip2));
}
}
rewindableStream.Rewind(false);
if (LZipStream.IsLZipFile(rewindableStream))
{
rewindableStream.Rewind(false);
LZipStream testStream = new LZipStream(rewindableStream, CompressionMode.Decompress, true);
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.LZip));
}
}
rewindableStream.Rewind(false);
if (RarArchive.IsRarFile(rewindableStream, options))
{
rewindableStream.Rewind(true);
return(RarReader.Open(rewindableStream, options));
}
rewindableStream.Rewind(false);
if (TarArchive.IsTarFile(rewindableStream))
{
rewindableStream.Rewind(true);
return(TarReader.Open(rewindableStream, options));
}
rewindableStream.Rewind(false);
if (XZStream.IsXZStream(rewindableStream))
{
rewindableStream.Rewind(true);
XZStream testStream = new XZStream(rewindableStream);
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.Xz));
}
}
throw new InvalidOperationException("Cannot determine compressed stream type. Supported Reader Formats: Zip, GZip, BZip2, Tar, Rar, LZip, XZ");
}
/// <summary>
/// Performs an installation
/// </summary>
public virtual bool Install(AppletPackage package, bool isUpgrade = false)
{
this.m_tracer.TraceWarning("Installing {0}", package.Meta);
// TODO: Verify package hash / signature
if (!this.VerifyPackage(package))
{
throw new SecurityException("Applet failed validation");
}
else if (!this.m_appletCollection.VerifyDependencies(package.Meta))
{
this.m_tracer.TraceWarning($"Applet {package.Meta} depends on : [{String.Join(", ", package.Meta.Dependencies.Select(o => o.ToString()))}] which are missing or incompatible");
}
var appletSection = ApplicationContext.Current.Configuration.GetSection <AppletConfigurationSection>();
String appletPath = Path.Combine(appletSection.AppletDirectory, package.Meta.Id);
try
{
// Desearialize an prep for install
this.m_tracer.TraceInfo("Installing applet {0} (IsUpgrade={1})", package.Meta, isUpgrade);
ApplicationContext.Current.SetProgress(package.Meta.GetName("en"), 0.0f);
// TODO: Verify the package
// Copy
if (!Directory.Exists(appletSection.AppletDirectory))
{
Directory.CreateDirectory(appletSection.AppletDirectory);
}
if (File.Exists(appletPath))
{
if (!isUpgrade)
{
throw new InvalidOperationException(Strings.err_duplicate_package_name);
}
// Unload the loaded applet version
var existingApplet = this.m_appletCollection.FirstOrDefault(o => o.Info.Id == package.Meta.Id);
if (existingApplet != null)
{
this.UnInstallInternal(existingApplet);
}
}
var mfst = package.Unpack();
// Migrate data.
if (mfst.DataSetup != null)
{
foreach (var itm in mfst.DataSetup.Action)
{
Type idpType = typeof(IDataPersistenceService <>);
idpType = idpType.MakeGenericType(new Type[] { itm.Element.GetType() });
var svc = ApplicationContext.Current.GetService(idpType);
idpType.GetMethod(itm.ActionName).Invoke(svc, new object[] { itm.Element, TransactionMode.Commit, AuthenticationContext.SystemPrincipal });
}
}
// Now export all the binary files out
var assetDirectory = Path.Combine(appletSection.AppletDirectory, "assets", mfst.Info.Id);
if (!Directory.Exists(assetDirectory))
{
Directory.CreateDirectory(assetDirectory);
}
else
{
Directory.Delete(assetDirectory, true);
}
for (int i = 0; i < mfst.Assets.Count; i++)
{
var itm = mfst.Assets[i];
var itmPath = Path.Combine(assetDirectory, itm.Name);
ApplicationContext.Current.SetProgress($"Installing {package.Meta.GetName("en")}", 0.1f + (float)(0.8 * (float)i / mfst.Assets.Count));
// Get dir name and create
if (!Directory.Exists(Path.GetDirectoryName(itmPath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(itmPath));
}
// Extract content
if (itm.Content is byte[])
{
if (Encoding.UTF8.GetString(itm.Content as byte[], 0, 4) == "LZIP")
{
using (var fs = File.Create(itmPath))
using (var ms = new MemoryStream(itm.Content as byte[]))
using (var lzs = new LZipStream(new NonDisposingStream(ms), SharpCompress.Compressors.CompressionMode.Decompress))
lzs.CopyTo(fs);
}
else
{
File.WriteAllBytes(itmPath, itm.Content as byte[]);
}
itm.Content = null;
}
else if (itm.Content is String)
{
File.WriteAllText(itmPath, itm.Content as String);
itm.Content = null;
}
}
// Serialize the data to disk
using (FileStream fs = File.Create(appletPath))
mfst.Save(fs);
// For now sign with SHA256
SHA256 sha = SHA256.Create();
package.Meta.Hash = sha.ComputeHash(File.ReadAllBytes(appletPath));
// HACK: Re-re-remove
appletSection.Applets.RemoveAll(o => o.Id == package.Meta.Id);
appletSection.Applets.Add(package.Meta.AsReference());
ApplicationContext.Current.SetProgress(package.Meta.GetName("en"), 0.98f);
if (ApplicationContext.Current.ConfigurationPersister.IsConfigured)
{
ApplicationContext.Current.ConfigurationPersister.Save(ApplicationContext.Current.Configuration);
}
this.LoadApplet(mfst);
}
catch (Exception e)
{
this.m_tracer.TraceError("Error installing applet {0} : {1}", package.Meta.ToString(), e);
// Remove
if (File.Exists(appletPath))
{
File.Delete(appletPath);
}
throw;
}
return(true);
}
/// <summary>
/// Invokes the specified method against the url provided
/// </summary>
/// <param name="method">Method.</param>
/// <param name="url">URL.</param>
/// <param name="contentType">Content type.</param>
/// <param name="body">Body.</param>
/// <param name="query">Query.</param>
/// <typeparam name="TBody">The 1st type parameter.</typeparam>
/// <typeparam name="TResult">The 2nd type parameter.</typeparam>
protected override TResult InvokeInternal <TBody, TResult>(string method, string url, string contentType, WebHeaderCollection additionalHeaders, out WebHeaderCollection responseHeaders, TBody body, NameValueCollection query)
{
if (String.IsNullOrEmpty(method))
{
throw new ArgumentNullException(nameof(method));
}
//if (String.IsNullOrEmpty(url))
// throw new ArgumentNullException(nameof(url));
// Credentials provided ?
HttpWebRequest requestObj = this.CreateHttpRequest(url, query) as HttpWebRequest;
if (!String.IsNullOrEmpty(contentType))
{
requestObj.ContentType = contentType;
}
requestObj.Method = method;
// Additional headers
if (additionalHeaders != null)
{
foreach (var hdr in additionalHeaders.AllKeys)
{
if (hdr == "If-Modified-Since")
{
requestObj.IfModifiedSince = DateTime.Parse(additionalHeaders[hdr]);
}
else
{
requestObj.Headers.Add(hdr, additionalHeaders[hdr]);
}
}
}
#if PERFMON
Stopwatch sw = new Stopwatch();
sw.Start();
#endif
// Get request object
// Body was provided?
try
{
// Try assigned credentials
IBodySerializer serializer = null;
if (body != null)
{
// GET Stream,
Stream requestStream = null;
try
{
// Get request object
var cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.CancelAfter(this.Description.Endpoint[0].Timeout);
using (var requestTask = Task.Run(async() => { return(await requestObj.GetRequestStreamAsync()); }, cancellationTokenSource.Token))
{
try
{
requestStream = requestTask.Result;
}
catch (AggregateException e)
{
requestObj.Abort();
throw e.InnerExceptions.First();
}
}
if (contentType == null && typeof(TResult) != typeof(Object))
{
throw new ArgumentNullException(nameof(contentType));
}
serializer = this.Description.Binding.ContentTypeMapper.GetSerializer(contentType, typeof(TBody));
// Serialize and compress with deflate
using (MemoryStream ms = new MemoryStream())
{
if (this.Description.Binding.Optimize)
{
switch ((this.Description.Binding as ServiceClientBinding)?.OptimizationMethod)
{
case OptimizationMethod.Lzma:
requestObj.Headers.Add("Content-Encoding", "lzma");
using (var df = new LZipStream(new NonDisposingStream(requestStream), CompressionMode.Compress))
serializer.Serialize(df, body);
break;
case OptimizationMethod.Bzip2:
requestObj.Headers.Add("Content-Encoding", "bzip2");
using (var df = new BZip2Stream(new NonDisposingStream(requestStream), CompressionMode.Compress, false))
serializer.Serialize(df, body);
break;
case OptimizationMethod.Gzip:
requestObj.Headers.Add("Content-Encoding", "gzip");
using (var df = new GZipStream(new NonDisposingStream(requestStream), CompressionMode.Compress))
serializer.Serialize(df, body);
break;
case OptimizationMethod.Deflate:
requestObj.Headers.Add("Content-Encoding", "deflate");
using (var df = new DeflateStream(new NonDisposingStream(requestStream), CompressionMode.Compress))
serializer.Serialize(df, body);
break;
case OptimizationMethod.None:
default:
serializer.Serialize(ms, body);
break;
}
}
else
{
serializer.Serialize(ms, body);
}
// Trace
if (this.Description.Trace)
{
this.m_tracer.TraceVerbose("HTTP >> {0}", Convert.ToBase64String(ms.ToArray()));
}
using (var nms = new MemoryStream(ms.ToArray()))
nms.CopyTo(requestStream);
}
}
finally
{
if (requestStream != null)
{
requestStream.Dispose();
}
}
}
// Response
HttpWebResponse response = null;
try
{
var cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.CancelAfter(this.Description.Endpoint[0].Timeout);
using (var responseTask = Task.Run(async() => { return(await requestObj.GetResponseAsync()); }, cancellationTokenSource.Token))
{
try
{
response = (HttpWebResponse)responseTask.Result;
}
catch (AggregateException e)
{
requestObj.Abort();
throw e.InnerExceptions.First();
}
}
responseHeaders = response.Headers;
// No content - does the result want a pointer maybe?
if (response.StatusCode == HttpStatusCode.NoContent || response.StatusCode == HttpStatusCode.Continue || response.StatusCode == HttpStatusCode.NotModified)
{
return(default(TResult));
}
else if (response.StatusCode == HttpStatusCode.RedirectKeepVerb)
{
return(this.InvokeInternal <TBody, TResult>(method, response.Headers[HttpResponseHeader.Location], contentType, additionalHeaders, out responseHeaders, body, query));
}
else if (response.StatusCode == HttpStatusCode.RedirectMethod)
{
return(this.InvokeInternal <TBody, TResult>("GET", response.Headers[HttpResponseHeader.Location], contentType, additionalHeaders, out responseHeaders, default(TBody), query));
}
else
{
// De-serialize
var responseContentType = response.ContentType;
if (String.IsNullOrEmpty(responseContentType))
{
return(default(TResult));
}
if (responseContentType.Contains(";"))
{
responseContentType = responseContentType.Substring(0, responseContentType.IndexOf(";"));
}
if (response.StatusCode == HttpStatusCode.NotModified)
{
return(default(TResult));
}
serializer = this.Description.Binding.ContentTypeMapper.GetSerializer(responseContentType, typeof(TResult));
TResult retVal = default(TResult);
// Compression?
using (MemoryStream ms = new MemoryStream())
{
if (this.Description.Trace)
{
this.m_tracer.TraceVerbose("Received response {0} : {1} bytes", response.ContentType, response.ContentLength);
}
response.GetResponseStream().CopyTo(ms);
ms.Seek(0, SeekOrigin.Begin);
// Trace
if (this.Description.Trace)
{
this.m_tracer.TraceVerbose("HTTP << {0}", Convert.ToBase64String(ms.ToArray()));
}
switch (response.Headers[HttpResponseHeader.ContentEncoding])
{
case "deflate":
using (DeflateStream df = new DeflateStream(new NonDisposingStream(ms), CompressionMode.Decompress))
retVal = (TResult)serializer.DeSerialize(df);
break;
case "gzip":
using (GZipStream df = new GZipStream(new NonDisposingStream(ms), CompressionMode.Decompress))
retVal = (TResult)serializer.DeSerialize(df);
break;
case "bzip2":
using (var bzs = new BZip2Stream(new NonDisposingStream(ms), CompressionMode.Decompress, false))
retVal = (TResult)serializer.DeSerialize(bzs);
break;
case "lzma":
using (var lzmas = new LZipStream(new NonDisposingStream(ms), CompressionMode.Decompress))
retVal = (TResult)serializer.DeSerialize(lzmas);
break;
default:
retVal = (TResult)serializer.DeSerialize(ms);
break;
}
//retVal = (TResult)serializer.DeSerialize(ms);
}
return(retVal);
}
}
finally
{
if (response != null)
{
response.Close();
response.Dispose();
}
//responseTask.Dispose();
}
}
catch (TimeoutException e)
{
this.m_tracer.TraceError("Request timed out:{0}", e.Message);
throw;
}
catch (WebException e) when(e.Response is HttpWebResponse errorResponse && errorResponse.StatusCode == HttpStatusCode.NotModified)
{
this.m_tracer.TraceInfo("Server indicates not modified {0} {1} : {2}", method, url, e.Message);
responseHeaders = errorResponse?.Headers;
return(default(TResult));
}
catch (WebException e) when(e.Response is HttpWebResponse errorResponse && e.Status == WebExceptionStatus.ProtocolError)
{
this.m_tracer.TraceError("Error executing {0} {1} : {2}", method, url, e.Message);
// Deserialize
object errorResult = null;
var responseContentType = errorResponse.ContentType;
if (responseContentType.Contains(";"))
{
responseContentType = responseContentType.Substring(0, responseContentType.IndexOf(";"));
}
var ms = new MemoryStream(); // copy response to memory
errorResponse.GetResponseStream().CopyTo(ms);
ms.Seek(0, SeekOrigin.Begin);
try
{
var serializer = this.Description.Binding.ContentTypeMapper.GetSerializer(responseContentType, typeof(TResult));
switch (errorResponse.Headers[HttpResponseHeader.ContentEncoding])
{
case "deflate":
using (DeflateStream df = new DeflateStream(new NonDisposingStream(ms), CompressionMode.Decompress))
errorResult = serializer.DeSerialize(df);
break;
case "gzip":
using (GZipStream df = new GZipStream(new NonDisposingStream(ms), CompressionMode.Decompress))
errorResult = serializer.DeSerialize(df);
break;
case "bzip2":
using (var bzs = new BZip2Stream(new NonDisposingStream(ms), CompressionMode.Decompress, false))
errorResult = serializer.DeSerialize(bzs);
break;
case "lzma":
using (var lzmas = new LZipStream(new NonDisposingStream(ms), CompressionMode.Decompress))
errorResult = serializer.DeSerialize(lzmas);
break;
default:
errorResult = serializer.DeSerialize(ms);
break;
}
}
catch
{
errorResult = new RestServiceFault(e);
}
Exception exception = null;
if (errorResult is RestServiceFault rse)
{
exception = new RestClientException <RestServiceFault>(rse, e, e.Status, e.Response);
}
else if (errorResponse is TResult)
{
exception = new RestClientException <TResult>((TResult)errorResult, e, e.Status, e.Response);
}
else
{
exception = new RestClientException <object>(errorResult, e, e.Status, e.Response);
}
switch (errorResponse.StatusCode)
{
case HttpStatusCode.Unauthorized: // Validate the response
throw exception;
case HttpStatusCode.NotModified:
responseHeaders = errorResponse?.Headers;
return(default(TResult));
case (HttpStatusCode)422:
throw exception;
default:
throw exception;
}
}
catch (WebException e) when(e.Status == WebExceptionStatus.Timeout)
{
this.m_tracer.TraceError("Error executing {0} {1} : {2}", method, url, e.Message);
throw new TimeoutException($"Timeout executing REST operation {method} {url}", e);
}
catch (WebException e) when(e.Status == WebExceptionStatus.ConnectFailure)
{
this.m_tracer.TraceError("Error executing {0} {1} : {2}", method, url, e.Message);
if ((e.InnerException as SocketException)?.SocketErrorCode == SocketError.TimedOut)
{
throw new TimeoutException();
}
else
{
throw;
}
}
catch (WebException e)
{
this.m_tracer.TraceError("Error executing {0} {1} : {2}", method, url, e.Message);
throw;
}
catch (InvalidOperationException e)
{
this.m_tracer.TraceError("Invalid Operation: {0}", e.Message);
throw;
}
responseHeaders = new WebHeaderCollection();
return(default(TResult));
}
/// <summary>
/// Backup the configuration
/// </summary>
public void Backup()
{
using (var lzs = new LZipStream(File.Create(Path.ChangeExtension(this.m_configPath, "bak.7z")), SharpCompress.Compressors.CompressionMode.Compress))
this.m_configuration.Save(lzs);
}
