private static void WebRequestRobust(DateTime nextEventTime, WebClient wc, string URL)
{
WaitProgressivelyLonger wpl = new WaitProgressivelyLonger(600000, 5000, 15000);
while (true)
{
if (DateTime.Now >= nextEventTime)
{
Logger.Info("Cancelled web request (" + URL + ") due to the next event time being reached.");
return;
}
try
{
wc.DownloadString(URL);
return;
}
catch (ThreadAbortException) { throw; }
catch (Exception ex)
{
Logger.Info("Exception thrown attempting web request (" + URL + "): " + ex.Message);
}
}
}
/// <summary>
/// Writes the specified amount of data to the outbound stream, not returning until all data has been placed in the underlying memory-mapped file. This method typically returns before the remote reader has finished reading the written data.
/// </summary>
/// <param name="buffer">The buffer containing data to write.</param>
/// <param name="offset">The offset within the buffer at which to begin copying data.</param>
/// <param name="count">The number of bytes to write. Must be less than or equal to the length of the buffer minus the offset.</param>
public override void Write(byte[] buffer, int offset, int count)
{
if (count == 0)
{
return;
}
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (buffer.Length == 0)
{
throw new ArgumentException("buffer must have size larger than 0", "buffer");
}
if (count < 0 || count > buffer.Length - offset)
{
throw new ArgumentOutOfRangeException("count", "Value " + count + " is out of range");
}
if (offset < 0 || offset >= buffer.Length)
{
throw new ArgumentOutOfRangeException("offset", "Value " + offset + " is out of range");
}
if (count > buffer.Length - offset)
{
throw new ArgumentOutOfRangeException("count", count, "value exceeds the size of the buffer minus the offset");
}
int totalAmountWritten = 0;
WaitProgressivelyLonger waiter = new WaitProgressivelyLonger();
do
{
ulong bytesReadByRemote = GetBytesReadByRemote();
int bufferSpaceAlreadyConsumed = (int)(myBytesWritten - bytesReadByRemote);
int bufferSpaceAvailable = bufferSize - bufferSpaceAlreadyConsumed;
int currentPositionInMyWriteBuffer = (int)(myBytesWritten % bufferSize);
int availableBeforeEndOfBuffer = bufferSize - currentPositionInMyWriteBuffer;
int amountToWrite = Math.Min(bufferSpaceAvailable, Math.Min(count - totalAmountWritten, availableBeforeEndOfBuffer));
if (amountToWrite > 0)
{
waiter.Reset();
long actualWritePosition = myOutgoingStreamStartsAt + currentPositionInMyWriteBuffer;
try
{
viewAccessor.WriteArray(actualWritePosition, buffer, offset + totalAmountWritten, amountToWrite);
myBytesWritten += (ulong)amountToWrite;
totalAmountWritten += amountToWrite;
}
finally
{
SetBytesWrittenByMe();
}
}
else
{
waiter.Wait();
}
}while (totalAmountWritten < count);
if (totalAmountWritten != count)
{
throw new Exception("Total amount written to viewAccessor (" + totalAmountWritten + ") did not match count (" + count + "). Possible logic error.");
}
}
/// <summary>
/// Reads the specified amount of data from the incoming stream, not returning until all the requested data is read.
/// </summary>
/// <param name="buffer">The buffer to store data in as it is read.</param>
/// <param name="offset">The offset in the buffer to begin storing data.</param>
/// <param name="count">The number of bytes to read. Must be less than or equal to the length of the buffer minus the offset.</param>
/// <returns>The number of bytes read. This will always be equal to count.</returns>
public override int Read(byte[] buffer, int offset, int count)
{
if (count == 0)
{
return(0);
}
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (buffer.Length == 0)
{
throw new ArgumentException("buffer must have size larger than 0", "buffer");
}
if (count < 0 || count > buffer.Length - offset)
{
throw new ArgumentOutOfRangeException("count", "Value " + count + " is out of range");
}
if (offset < 0 || offset >= buffer.Length)
{
throw new ArgumentOutOfRangeException("offset", "Value " + offset + " is out of range");
}
int totalAmountRead = 0;
WaitProgressivelyLonger waiter = new WaitProgressivelyLonger();
do
{
ulong bytesWrittenByRemote = GetBytesWrittenByRemote();
int bytesAvailableToRead = (int)(bytesWrittenByRemote - myBytesRead);
int currentPositionInMyReadBuffer = (int)(myBytesRead % bufferSize);
int availableBeforeEndOfBuffer = bufferSize - currentPositionInMyReadBuffer;
int amountToRead = Math.Min(bytesAvailableToRead, Math.Min(count - totalAmountRead, availableBeforeEndOfBuffer));
if (amountToRead > 0)
{
waiter.Reset();
long actualReadPosition = myIncomingStreamStartsAt + currentPositionInMyReadBuffer;
try
{
int amountRead = viewAccessor.ReadArray(actualReadPosition, buffer, offset + totalAmountRead, amountToRead);
myBytesRead += (ulong)amountRead;
totalAmountRead += amountRead;
if (amountRead != amountToRead)
{
throw new Exception("Read " + amountRead + " from viewAccessor, but meant to read " + amountToRead + ". Possible logic error.");
}
}
finally
{
SetBytesReadByMe();
}
}
else
{
waiter.Wait();
}
}while (totalAmountRead < count);
if (totalAmountRead != count)
{
throw new Exception("Total amount read from viewAccessor (" + totalAmountRead + ") did not match count (" + count + "). Possible logic error.");
}
return(count);
}
