private TValue GetTask(long blockposition)
{
lock (_object)
{
ContentStream.Position = blockposition;
byte[] check = new byte[2];
ContentStream.Read(check, 0, 2);
if (check[0] != startbyteone && check[1] != startbytetwo)
{
return(default(TValue));
}
byte[] counter = new byte[4];
ContentStream.Read(counter, 0, 4);
int len = BitConverter.ToInt32(counter, 0);
byte[] content = new byte[len];
ContentStream.Read(content, 0, len);
return(this.ValueConverter.FromByte(content));
}
}
private Stream ReplaceContentStreamWithMemoryStream()
{
if (ContentStream is DurableMemoryStream)
{
return(ContentStream);
}
var buffer = new byte[4096];
var stream = new MemoryStream();
var count = 0;
do
{
if (ContentStream == null)
{
continue;
}
count = ContentStream.Read(buffer, 0, buffer.Length);
stream.Write(buffer, 0, count);
} while (count != 0);
if (ContentStream != null)
{
ContentStream.Close();
ContentStream.Dispose();
}
if (stream.CanSeek)
{
stream.Position = 0;
}
return(new DurableMemoryStream(stream));
}
public virtual void WriteBodyToConnection(Connection connection)
{
try
{
Byte[] lBuffer;
if (HasOnTransferProgress)
{
connection.OnBytesSent += new EventHandler(HandleOnBytesSent);
connection.ResetStatistics();
}
switch (ContentSource)
{
case ContentSource.ContentBytes:
TriggerOnTransferStart(TransferDirection.Send, ContentBytes.Length);
connection.Send(ContentBytes);
TriggerOnTransferEnd(TransferDirection.Send);
break;
case ContentSource.ContentStream:
TriggerOnTransferStart(TransferDirection.Send, ContentStream.Length);
lBuffer = new Byte[BUFFER_SIZE];
Int32 lBytesRead;
do
{
lBytesRead = ContentStream.Read(lBuffer, 0, BUFFER_SIZE);
if (lBytesRead != 0)
{
connection.Send(lBuffer, 0, lBytesRead);
}
}while (lBytesRead > 0);
if (CloseStream)
{
ContentStream.Close();
}
TriggerOnTransferEnd(TransferDirection.Send);
break;
case ContentSource.ContentNone:
/* Nothing to do */
break;
}
if (HasOnTransferProgress)
{
connection.OnBytesSent -= new EventHandler(HandleOnBytesSent);
}
}
finally
{
fContentBytes = null;
fContentStream = null;
fContentString = null;
}
}
/// <summary>
/// Writes attachments contents to the specificed XML writer object
/// using base64 encoding.
/// </summary>
public void WriteAsBase64(XmlWriter writer)
{
ContentStream.Position = 0;
const int bufferSize = 1000;
int bytesRead;
var buffer = new byte[bufferSize];
while ((bytesRead = ContentStream.Read(buffer, 0, bufferSize)) > 0)
{
writer.WriteBase64(buffer, 0, bytesRead);
}
}
/// <summary>
/// Attaches the body to web request.
/// </summary>
/// <param name="request">The request.</param>
private void AttachBodyToWebRequest(WebRequest request)
{
using (var webstream = request.GetRequestStream())
{
var buffer = new byte[Constants.CHUNK_SIZE];
int amt;
while ((amt = ContentStream.Read(buffer, 0, buffer.Length)) != 0)
{
webstream.Write(buffer, 0, amt);
// Fire the progress event
if (this.Progress != null)
{
this.Progress(amt);
}
}
ContentStream.Close();
webstream.Flush();
}
}
/// <summary>
/// Writes attachments contents to the specificed output stream object
/// using base64 encoding.
/// </summary>
public void WriteAsBase64(TextWriter writer)
{
const int bufferSize = (BASE64_LINE_LENGTH / 4) * 3;
var buffer = new byte[bufferSize];
ContentStream.Position = 0;
var noContent = true;
int bytesRead;
while ((bytesRead = ContentStream.Read(buffer, 0, bufferSize)) > 0)
{
noContent = false;
writer.Write(Convert.ToBase64String(buffer, 0, bytesRead));
writer.Write(XRoadMessageWriter.NEW_LINE);
}
if (noContent)
{
writer.Write(XRoadMessageWriter.NEW_LINE);
}
}
internal virtual async Task Execute(string storageUrl, string authToken)
{
var uri = GetUri(storageUrl);
if (ContentStream != null && AutoResetStreamPosition)
{
ContentStream.Position = 0;
}
#if DEBUG
Debug.WriteLine(uri.ToString());
#endif
var request = HttpWebRequest.CreateHttp(uri);
request.Method = this.Method.ToString();
if (!AllowAnonymously)
{
TryAddHeader(HeaderKeys.XAuthToken, authToken);
}
// set Accept header
if (headers.ContainsKey(HeaderKeys.Accept))
{
request.Accept = headers[HeaderKeys.Accept];
headers.Remove(HeaderKeys.Accept);
}
// set Content-Type header
if (headers.ContainsKey(HeaderKeys.ContentType))
{
request.ContentType = headers[HeaderKeys.ContentType];
headers.Remove(HeaderKeys.ContentType);
}
// set Content-Length header
// todo: make SetContLength method
if (headers.ContainsKey(HeaderKeys.ContentLenght))
{
request.ContentLength = long.Parse(headers[HeaderKeys.ContentLenght]);
headers.Remove(HeaderKeys.ContentLenght);
}
// set custom headers
if (headers != null)
{
foreach (var kv in headers.Where(x => !string.IsNullOrEmpty(x.Value)))
{
request.Headers.Add(kv.Key, kv.Value);
}
}
if (ContentStream != null)
{
long fsLength = 0;
using (Stream rs = request.GetRequestStream())
{
var buffer = new byte[BufferSize];
int readed;
while ((readed = ContentStream.Read(buffer, 0, BufferSize)) != 0)
{
await rs.WriteAsync(buffer, 0, readed);
fsLength += readed;
}
if (AutoCloseStream)
{
ContentStream.Close();
}
}
}
try
{
var response = request.GetResponse();
var status = ((HttpWebResponse)response).StatusCode;
if (DownloadData)
{
var responseStream = response.GetResponseStream();
if (!responseStream.CanSeek || responseStream.CanTimeout)
{
//Buffer it
var memStream = new FileStream(Path.GetTempFileName(), FileMode.Open, FileAccess.ReadWrite, FileShare.Read, BufferSize, FileOptions.DeleteOnClose);
try
{
var buffer = new byte[BufferSize];
int readed;
while ((readed = responseStream.Read(buffer, 0, BufferSize)) != 0)
{
memStream.Write(buffer, 0, readed);
}
}
finally
{
responseStream.Close();
}
memStream.Position = 0;
responseStream = memStream;
}
this.Parse(response.Headers, responseStream, status);
}
else
{
using (var rs = response.GetResponseStream())
{
ParseString(response, status, rs);
}
}
}
catch (WebException ex)
{
var status = ((HttpWebResponse)ex.Response).StatusCode;
ParseError(ex, status);
}
catch (Exception ex)
{
throw (ex);
}
}
public override int Read(byte[] buffer, int offset, int count)
{
return(ContentStream.Read(buffer, offset, count));
}
