public void MemoryStream_CopyTo_Invalid()
{
ChunkedMemoryStream memoryStream;
const string BufferSize = "bufferSize";
using (memoryStream = new ChunkedMemoryStream(this.allocator))
{
const string Destination = "destination";
Assert.Throws <ArgumentNullException>(Destination, () => memoryStream.CopyTo(destination: null));
// Validate the destination parameter first.
Assert.Throws <ArgumentNullException>(Destination, () => memoryStream.CopyTo(destination: null, bufferSize: 0));
Assert.Throws <ArgumentNullException>(Destination, () => memoryStream.CopyTo(destination: null, bufferSize: -1));
// Then bufferSize.
Assert.Throws <ArgumentOutOfRangeException>(BufferSize, () => memoryStream.CopyTo(Stream.Null, bufferSize: 0)); // 0-length buffer doesn't make sense.
Assert.Throws <ArgumentOutOfRangeException>(BufferSize, () => memoryStream.CopyTo(Stream.Null, bufferSize: -1));
}
// After the Stream is disposed, we should fail on all CopyTos.
Assert.Throws <ArgumentOutOfRangeException>(BufferSize, () => memoryStream.CopyTo(Stream.Null, bufferSize: 0)); // Not before bufferSize is validated.
Assert.Throws <ArgumentOutOfRangeException>(BufferSize, () => memoryStream.CopyTo(Stream.Null, bufferSize: -1));
ChunkedMemoryStream disposedStream = memoryStream;
// We should throw first for the source being disposed...
Assert.Throws <ObjectDisposedException>(() => memoryStream.CopyTo(disposedStream, 1));
// Then for the destination being disposed.
memoryStream = new ChunkedMemoryStream(this.allocator);
Assert.Throws <ObjectDisposedException>(() => memoryStream.CopyTo(disposedStream, 1));
memoryStream.Dispose();
}
public void MemoryStream_ReadTest_Negative()
{
var ms2 = new ChunkedMemoryStream(this.allocator);
Assert.Throws <ArgumentNullException>(() => ms2.Read(null, 0, 0));
Assert.Throws <ArgumentOutOfRangeException>(() => ms2.Read(new byte[] { 1 }, -1, 0));
Assert.Throws <ArgumentOutOfRangeException>(() => ms2.Read(new byte[] { 1 }, 0, -1));
Assert.Throws <ArgumentException>(() => ms2.Read(new byte[] { 1 }, 2, 0));
Assert.Throws <ArgumentException>(() => ms2.Read(new byte[] { 1 }, 0, 2));
ms2.Dispose();
Assert.Throws <ObjectDisposedException>(() => ms2.Read(new byte[] { 1 }, 0, 1));
}
private static bool ReCalculateFileMD5(string path)
{
if (!XLPack.IsFileExist(path))
{
return(false);
}
var position = XLPack.FOpen(path, "r");
long fileSize = XLPack.FSize(position);
const int bufSize = 0x4000;
byte[] buffer = new byte[bufSize];
IntPtr bufPtr = Marshal.UnsafeAddrOfPinnedArrayElement(buffer, 0);
// TODO: Do this without reading the entire file into memory to calculate the MD5
// Maybe try to use the XLPack.DLL's MD5Init, MD5Update and MD5 Finalize functions ?
// Using ChunkedMemoryStream instead of MemoryStream to hopefully avoid outofmemory errors on large files
ChunkedMemoryStream ms = new ChunkedMemoryStream();
long readTotalSize = 0;
while (readTotalSize < fileSize)
{
long readSize = fileSize - readTotalSize;
if (readSize > bufSize)
{
readSize = bufSize;
}
XLPack.FRead(position, bufPtr, readSize);
ms.Write(buffer, 0, (int)readSize); // readSize should never be out of int range, so it's safe to cast it
readTotalSize += readSize;
}
XLPack.FClose(ref position);
ms.Position = 0;
MD5 md5Hash = MD5.Create();
string md5String = GetMd5Hash(md5Hash, ms).Replace("-", "").ToLower();
ms.Dispose();
var res = SetFileMD5(path, md5String);
return(res);
}
public void InsertRecord(TextWriter sw, char[] buf, string escaping, Action <TextWriter, char> mappings)
{
var pref = PostgresTuple.BuildSlashEscape(escaping.Length);
if (mappings != null)
{
foreach (var p in pref)
{
mappings(sw, p);
}
}
else
{
sw.Write(pref);
}
sw.Write('x');
Value.ToPostgresBytea(sw);
if (Dispose)
{
Value.Dispose();
}
}
internal static Stream ExecuteCommands <TFormat>(
IProcessingEngine engine,
IWireSerialization serialization,
IServerCommandDescription <TFormat>[] commands,
IRequestContext request,
IResponseContext response,
string accept)
{
var result = Execute(engine, commands, request, response);
if (result.Error != null)
{
return(result.Error);
}
if (result.Result == null)
{
response.ContentType = accept;
return(null);
}
if (accept == "application/octet-stream")
{
response.ContentType = "application/octet-stream";
if (result.Result is Stream)
{
return(result.Result as Stream);
}
else if (result.Result is StreamReader)
{
return((result.Result as StreamReader).BaseStream);
}
else if (result.Result is StringBuilder)
{
var sb = result.Result as StringBuilder;
var cms = ChunkedMemoryStream.Create();
var sw = cms.GetWriter();
for (int i = 0; i < sb.Length;)
{
var min = Math.Min(sb.Length - i, cms.CharBuffer.Length);
sb.CopyTo(i, cms.CharBuffer, 0, min);
i += min;
sw.Write(cms.CharBuffer, 0, min);
}
sw.Flush();
cms.Position = 0;
return(cms);
}
else if (result.Result is byte[])
{
return(new MemoryStream(result.Result as byte[]));
}
else if (result.Result is string)
{
var cms = ChunkedMemoryStream.Create();
var sw = cms.GetWriter();
sw.Write(result.Result as string);
sw.Flush();
cms.Position = 0;
return(cms);
}
else if (result.Result is char[])
{
var cms = ChunkedMemoryStream.Create();
var sw = cms.GetWriter();
sw.Write(result.Result as char[]);
sw.Flush();
cms.Position = 0;
return(cms);
}
return(response.ReturnError(
"Unexpected command result. Can't convert "
+ result.Result.GetType().FullName + " to octet-stream. Use application/x-dotnet mime type for .NET binary serialization",
HttpStatusCode.UnsupportedMediaType));
}
if (accept == "application/base64")
{
response.ContentType = "application/base64";
if (result.Result is Stream)
{
var stream = result.Result as Stream;
try
{
var cms = stream as ChunkedMemoryStream;
if (cms != null)
{
return(cms.ToBase64Stream());
}
else
{
cms = new ChunkedMemoryStream(stream);
try { return(cms.ToBase64Stream()); }
finally { cms.Dispose(); }
}
}
finally { stream.Dispose(); }
}
else if (result.Result is StreamReader)
{
var sr = result.Result as StreamReader;
try
{
var cms = sr.BaseStream as ChunkedMemoryStream;
if (cms != null)
{
return(cms.ToBase64Stream());
}
else
{
cms = new ChunkedMemoryStream(sr.BaseStream);
try { return(cms.ToBase64Stream()); }
finally { cms.Dispose(); }
}
}
finally { sr.Dispose(); }
}
else if (result.Result is StringBuilder)
{
var sb = result.Result as StringBuilder;
using (var cms = ChunkedMemoryStream.Create())
{
var sw = cms.GetWriter();
for (int i = 0; i < sb.Length;)
{
var min = Math.Min(sb.Length - i, cms.CharBuffer.Length);
sb.CopyTo(i, cms.CharBuffer, 0, min);
i += min;
sw.Write(cms.CharBuffer, 0, min);
}
sw.Flush();
cms.Position = 0;
return(cms.ToBase64Stream());
}
}
else if (result.Result is byte[])
{
var bytes = result.Result as byte[];
using (var cms = ChunkedMemoryStream.Create())
{
cms.Write(bytes, 0, bytes.Length);
cms.Position = 0;
return(cms.ToBase64Stream());
}
}
else if (result.Result is string)
{
using (var cms = ChunkedMemoryStream.Create())
{
var sw = cms.GetWriter();
sw.Write(result.Result as string);
sw.Flush();
cms.Position = 0;
return(cms.ToBase64Stream());
}
}
else if (result.Result is char[])
{
using (var cms = ChunkedMemoryStream.Create())
{
var sw = cms.GetWriter();
sw.Write(result.Result as char[]);
sw.Flush();
cms.Position = 0;
return(cms.ToBase64Stream());
}
}
return(response.ReturnError("Unexpected command result. Can't convert to base64.", HttpStatusCode.UnsupportedMediaType));
}
if (accept == "application/x-dotnet")
{
response.ContentType = "application/x-dotnet";
var bf = new BinaryFormatter();
bf.AssemblyFormat = FormatterAssemblyStyle.Simple;
var cms = ChunkedMemoryStream.Create();
bf.Serialize(cms, result.Result);
cms.Position = 0;
return(cms);
}
var ms = ChunkedMemoryStream.Create();
response.ContentType = serialization.Serialize(result.Result, accept, ms);
ms.Position = 0;
return(ms);
}