void INetworkListener.OnFileError(string sender, string recipient, string filename) { CCBLogConfig.GetLogger().Debug("Tagging file completed with error: {0}\n", filename); try { CCBP2PFile infile = GetInFile(filename); if ((null != infile) && infile.CheckNode(sender, recipient)) { infile.OnError(); m_signal.Set(); } lock (m_outbox) { foreach (CCBP2PFile outfile in m_outbox.Values) { if ((0 == string.Compare(outfile.LocalName, filename)) && outfile.CheckNode(sender, recipient)) { outfile.OnError(); m_signal.Set(); } } } } catch (IOException ioex) { CCBLogConfig.GetLogger().Error("IO Exception OnFileError {0}: {1}", filename, ioex.Message); } catch (Exception ex) { CCBLogConfig.GetLogger().Error("Exception OnFileError {0}: {1}", filename, ex.Message); } }
//After having written the file, we mark it as finalized, which will make the file worker thread //calculate and check the hash. void INetworkListener.OnFileComplete(string filename, byte[] hash) { CCBLogConfig.GetLogger().Debug("Completing file: {0}\n", filename); try { CCBP2PFile infile = GetInFile(filename); if (null == infile) { CCBLogConfig.GetLogger().Debug("No file data for {0}, ignoring file completion event.", filename); } else { infile.OnFinalized(hash); m_signal.Set(); } } catch (IOException ioex) { CCBLogConfig.GetLogger().Error("IO Exception OnFileData {0}: {1}", filename, ioex.Message); } catch (Exception ex) { CCBLogConfig.GetLogger().Error("Exception OnFileData {0}: {1}", filename, ex.Message); } }
//We write the data directly on the networker thread. The reason is that if the write is fast, it's ok; //if it's slow, the file worker thread would back up while the chunks came in, leaving significant parts //of the file in memory. With only 2 threads, it's better to write the data out immediately. If the file //transfer system needs to scale up, this should be changed and more file worker threads should be added. void INetworkListener.OnFileData(string filename, long offset, byte[] data) { CCBLogConfig.GetLogger().Debug(string.Format("Receiving {0} bytes of {1}\n", data.Length, filename)); try { CCBP2PFile infile = GetInFile(filename); if (null == infile) { CCBLogConfig.GetLogger().Error("No file data for {0}, ignoring file data.", filename); } else { infile.WriteData(offset, data); } } catch (IOException ioex) { CCBLogConfig.GetLogger().Error("IO Exception OnFileData {0}: {1}", filename, ioex.Message); } catch (Exception ex) { CCBLogConfig.GetLogger().Error("Exception OnFileData {0}: {1}", filename, ex.Message); } }
public void PrepareInFile(string sender, string recipient, string remoteFile, string localFile) { CCBP2PFile newFile = new CCBP2PFile(localFile, remoteFile, sender, recipient); lock (m_inbox) { m_inbox[remoteFile] = newFile; } MaybeStart(); }
public void MarkDataSent(string filename, CCBP2PFileDataEnvelope data) { lock (m_outbox) { CCBP2PFile fileToSend = m_outbox[filename]; if (null != fileToSend) { fileToSend.MarkDataSent(data); } } }
public int RetrieveDataToSend(string filename, ref CCBP2PFileDataEnvelope data) { lock (m_outbox) { CCBP2PFile fileToSend = m_outbox[filename]; if (null != fileToSend) { return(fileToSend.RetrieveDataToSend(ref data)); } } return(0); }
public TStatusUpdate GetFileStatus(string filename, out long cbXfer, out long cbMax) { cbXfer = 0; cbMax = 0; lock (m_outbox) { if (m_outbox.Keys.Contains(filename)) { CCBP2PFile outfile = m_outbox[filename]; cbMax = outfile.FileSize; cbXfer = outfile.BytesSent; return(TStatusUpdate.tsuFileWork); } } return(TStatusUpdate.tsuNone); }
private long LoadNext() { CCBP2PFile nextFileToLoad = GetNextFileToLoad(); if (CCBSettings.m_simSlowIO) { Thread.Sleep(991); } if (null != nextFileToLoad) { //Do not load while file has data yet to be sent. if (!nextFileToLoad.HasDataToSend()) { return(nextFileToLoad.LoadNextBlob()); } } return(0); }
public bool IsSent(string filename, ref byte[] hash, ref string recipient) { CCBP2PFile file = null; lock (m_outbox) { if (m_outbox.ContainsKey(filename)) { file = m_outbox[filename]; } } if (null != file) { if (file.IsSent()) { hash = new byte[file.Hash.Length]; file.Hash.CopyTo(hash, 0); recipient = file.Recipient; return(true); } } return(false); }
public string HasErrorFile(ref string sender, ref string recipient) { lock (m_outbox) { foreach (string filename in m_outbox.Keys) { CCBP2PFile outfile = m_outbox[filename]; if (outfile.Error) { sender = outfile.Sender; recipient = outfile.Recipient; //Remove object first, so we don't go in a tizzy when //getting the notification back. m_outbox.Remove(filename); return(outfile.LocalName); } } } lock (m_inbox) { foreach (string filename in m_inbox.Keys) { CCBP2PFile infile = m_inbox[filename]; if (infile.Error) { sender = infile.Sender; recipient = infile.Recipient; m_inbox.Remove(filename); return(infile.RemoteName); } } } return(null); }