public async void SendQueued(string message)
{
if (string.IsNullOrEmpty(message))
{
Logger.Warn("Cannot send empty string. Check your code.");
return;
}
lock (_sendQueue)
{
if (_sendQueue.Count > 1000)
{
_sendQueuedSkips.Update(1);
}
else
{
_sendQueue.Enqueue(message);
}
}
if (Interlocked.Exchange(ref _flushingQueue, 1) == 0)
{
try
{
await FlushQueue().ConfigureAwait(false);
}
finally
{
Interlocked.Exchange(ref _flushingQueue, 0);
}
}
}
public override int Read(byte[] buffer, int offset, int count)
{
var read = _baseStream.Read(buffer, offset, count);
_rederSpeedAverage.Update(read);
return(read);
}
public static void DownloadChunk(string uri, byte[] buffer, long filePosition, int readLength)
{
if (readLength > buffer.Length)
{
throw new ArgumentException("Requested to read more than buffer size");
}
var sw = PerfTimer.StartNew();
var req = (HttpWebRequest)WebRequest.Create(uri);
req.ReadWriteTimeout = 4000;
req.AddRangeTrick(filePosition, filePosition + readLength - 1);
req.Proxy = null;
req.KeepAlive = true;
req.Timeout = 4000;
req.ServicePoint.ConnectionLimit = HttpUploadItem.Manager.ConnectionsPerServer;
using (var response = req.GetResponse())
using (var stream = response.GetResponseStream())
{
stream.ReadTimeout = 4000;
int read = 0;
while (read < readLength)
{
read += stream.Read(buffer, read, Math.Min(readLength - read, 64 * 1024));
}
}
sw.Stop();
SegmentDownloadTime.Update((int)sw.ElapsedMilliseconds);
DownloadSpeed.Update(readLength);
}
private void HandleReceived(byte[] buffer, int bufferOffset, int bytesReceived)
{
_downloadSpeed.Update(bytesReceived);
_lastUpdate = Stopwatch.GetTimestamp();
ParseRaw(buffer, bufferOffset, bytesReceived);
DownloadSpeedLimit.Update(bytesReceived);
DownloadSpeedLimitGlobal.Update(bytesReceived);
}
private void HubSearchRequest(object sender, SearchRequestEventArgs e)
{
var ea = new EngineSearchRequestEventArgs
{
HubConnection = (HubConnection)sender,
Message = e.Message
};
OnSearchRequest(ea);
if (ea.Cancel)
{
return;
}
if (Share != null && e.Message.SearchType == SearchType.TTH)
{
_searchesAverage.Update(1);
var results = Share.Search(new SearchQuery {
Query = e.Message.SearchRequest, SearchType = SearchType.TTH
});
if (results.Count > 0)
{
var result = results[0];
var hub = (HubConnection)sender;
var res = new SRMessage
{
FileName = result.VirtualPath,
FileSize = result.Magnet.Size,
Nickname = hub.Settings.Nickname,
FreeSlots =
Settings.MaxUploadThreads > 0
? Settings.MaxUploadThreads - TransferManager.TransfersCount
: 0,
HubAddress = hub.RemoteAddressString,
HubName = "TTH:" + result.Magnet.TTH,
TotalSlots = Settings.MaxUploadThreads
};
if (e.Message.SearchAddress.StartsWith("Hub:"))
{
res.TargetNickname = e.Message.SearchAddress.Remove(0, 4);
hub.SendMessage(res.Raw);
}
else
{
UdpConnection.SendMessage(res.Raw, e.Message.SearchAddress);
}
}
}
}
public override void Dispose()
{
if (_disposed)
{
return;
}
if (_isResponding)
{
_fails.Update(1);
}
ReleaseSegment();
DownloadItem = null;
if (UploadItem != null)
{
var ea = new UploadItemEventArgs();
try
{
OnUploadItemDispose(ea);
}
catch (Exception x)
{
Logger.Error("Exception when disposing transfer {0} {1}", x.Message, x.StackTrace);
}
if (!ea.Handled)
{
var ui = UploadItem;
if (ui != null)
{
ui.Dispose();
}
UploadItem = null;
}
}
DisconnectAsync();
_disposed = true;
}
private async void OnMessageAdcget(ADCGETMessage adcgetMessage)
{
var reqItem = new ContentItem();
if (adcgetMessage.Type == ADCGETType.Tthl)
{
SendMessageAsync(new ErrorMessage {
Error = "File Not Available"
}.Raw);
return;
}
if (adcgetMessage.Type == ADCGETType.File)
{
if (adcgetMessage.Request.StartsWith("TTH/"))
{
reqItem.Magnet = new Magnet {
TTH = adcgetMessage.Request.Remove(0, 4)
};
}
else
{
reqItem.Magnet = new Magnet {
FileName = adcgetMessage.Request
};
}
}
_requests.Update(1);
_isResponding = true;
if (!SlotUsed)
{
var ea = new CancelEventArgs();
OnSlotRequest(ea);
if (ea.Cancel)
{
Logger.Info("Can't start upload to {0}, no slots available", Source);
SendMessageAsync(new MaxedOutMessage().Raw);
return;
}
SlotUsed = true;
}
if (UploadItem == null || UploadItem.Content.Magnet.TTH != reqItem.Magnet.TTH)
{
var ea = new UploadItemEventArgs {
Transfer = this, Content = reqItem
};
OnUploadItemNeeded(ea);
if (UploadItem != null)
{
var uea = new UploadItemEventArgs();
OnUploadItemDispose(uea);
if (!uea.Handled)
{
UploadItem.Dispose();
}
}
UploadItem = ea.UploadItem;
if (ea.UploadItem == null)
{
SendMessageAsync(new ErrorMessage {
Error = "File Not Available"
}.Raw);
return;
}
}
if (adcgetMessage.Start >= UploadItem.Content.Magnet.Size)
{
SendMessageAsync(new ErrorMessage {
Error = "File Not Available"
}.Raw);
return;
}
if (adcgetMessage.Start + adcgetMessage.Length > UploadItem.Content.Magnet.Size)
{
Logger.Warn("Trim ADCGET length to file actual length {0}/{1}",
adcgetMessage.Start + adcgetMessage.Length, UploadItem.Content.Magnet.Size);
adcgetMessage.Length = UploadItem.Content.Magnet.Size - adcgetMessage.Start;
}
var uploadItem = UploadItem;
if (_disposed || uploadItem == null)
{
return;
}
var sw = PerfTimer.StartNew();
await SendAsync(new ADCSNDMessage
{
Type = ADCGETType.File,
Request = adcgetMessage.Request,
Start = adcgetMessage.Start,
Length = adcgetMessage.Length
}.Raw + "|").ConfigureAwait(false);
try
{
if (_disposed)
{
return;
}
await uploadItem.SendChunkAsync(this, adcgetMessage.Start, (int)adcgetMessage.Length).ConfigureAwait(false);
Stream.Flush();
sw.Stop();
_isResponding = false;
ServiceTime.Update((int)sw.ElapsedMilliseconds);
}
catch (Exception x)
{
Logger.Error("Upload read error {0} (L:{1}) {2} {3} ms",
x.Message,
adcgetMessage.Length,
uploadItem.Content.SystemPath,
sw.ElapsedMilliseconds);
Dispose();
}
}
public override void Write(byte[] buffer, int offset, int count)
{
_baseStream.Write(buffer, offset, count);
_writeSpeedAverage.Update(count);
}
private void HandleSent(int bytesSent)
{
_uploadSpeed.Update(bytesSent);
UploadSpeedLimit.Update(bytesSent);
UploadSpeedLimitGlobal.Update(bytesSent);
}
public void QueueWorkItem(ThreadStart workItem)
{
workItem.BeginInvoke(null, null);
_threadCalls.Update(1);
}