public void LoadFile(string path)
{
try
{
if (!File.Exists(path))
{
return;
}
var alreadyOpened = Items.FirstOrDefault(it => it.ToolTip == path);
if (alreadyOpened != null)
{
ActivateItem(alreadyOpened);
return;
}
var fileReceiver = new FileReceiver
{
FileToWatch = path,
LogFormat = _logReaderFactory.GetLogFormatByFileExtension(Path.GetExtension(path))
};
AddReceiver(fileReceiver);
}
catch (Exception e)
{
DialogService.Current.ShowErrorMessageBox(e);
}
}
public void FileReceive(FilePackage filePackage_0)
{
try
{
if (filePackage_0.PackageType == PackageType.NewChildFolder)
{
Directory.CreateDirectory(this.string_0 + Encoding.UTF8.GetString(filePackage_0.Data));
}
else if (filePackage_0.PackageType == PackageType.FoldTransferingNextFile)
{
if ((this.enisnmwGbe != null) && (this.enisnmwGbe.imethod_6() > this.enisnmwGbe.imethod_9()))
{
this.emptyAgileLogger_0.LogWithTime(string.Format("当前文件[{0}]还未接收完，就收到了准备接收下个文件的指令！", this.enisnmwGbe.imethod_5()));
}
FoldTransferingNextFileInfo info = CompactPropertySerializer.Default.Deserialize <FoldTransferingNextFileInfo>(filePackage_0.Data, 0);
string str = this.string_0 + info.RelativeFilePath;
this.enisnmwGbe = new FileReceiver(this.emptyAgileLogger_0, this.string_3, str, info.FileLength, this.string_4);
this.enisnmwGbe.FileTransDisruptted += new CbFileTransDisruptted(this.method_5);
this.enisnmwGbe.FileTransCompleted += new CbGeneric <string>(this.OnFileTransCompleted);
this.enisnmwGbe.FileTransProgress += new CbFileSendedProgress(this.method_3);
}
else if (filePackage_0.PackageType == PackageType.FileTransferingPackage)
{
this.enisnmwGbe.FileReceive(filePackage_0);
}
else
{
this.FileTransReceived(this.string_3);
}
}
catch (Exception exception)
{
this.emptyAgileLogger_0.Log(exception, "CJPlus.FileTransceiver.DirectoryReceiver.Receive", ErrorLevel.Standard);
}
}
public void StartFileReceiver()
{
while (!shutdownEvent.WaitOne(0))
{
FileReceiver.Start();
}
}
/// <summary>
/// Function to receive upload message
/// </summary>
/// <param name="uploadMessage">The message to be received</param>
private void ReceivedUpload(UploadMessage uploadMessage)
{
if (uploadMessage.type.Equals(TypeCode.REQUEST))
{
int replyPort = uploadMessage.port;
string uuid = uploadMessage.fromUuid;
if (DiskHelper.GetTotalAvailableSpace(@"C:\") > uploadMessage.filesize)
{
uploadMessage.statusCode = StatusCode.ACCEPTED;
Console.WriteLine(@"Request accepted");
}
else
{
Console.WriteLine(@"Not enough space");
uploadMessage.statusCode = StatusCode.INSUFFICIENT_STORAGE;
}
uploadMessage.CreateReply();
uploadMessage.port = _ports.GetAvailablePort();
_fileReceiver =
new FileReceiver(this._path + @".hidden\" + uuid + @"\" + uploadMessage.fullFilename + @"\",
uploadMessage.chunkHash, uploadMessage.port);
_fileReceiver.Start();
uploadMessage.Send(replyPort);
}
_ports.Release(uploadMessage.port);
}
// ============================================
// PRIVATE (Methods) Event Handlers
// ============================================
private void OnAdded(object sender)
{
Gtk.Application.Invoke(delegate {
FileReceiver fileRecv = sender as FileReceiver;
FileProgressObject obj = new FileProgressObject();
obj.Delete += new BlankEventHandler(OnButtonDelete);
// Setup Image
string ext = FileUtils.GetExtension(fileRecv.MyDiskName);
obj.Image = StockIcons.GetFileIconPixbuf(TextUtils.UpFirstChar(ext));
// Set Transfer Info
SetTransferInfo(obj, fileRecv);
// Set Info
UserInfo userInfo = fileRecv.Peer.Info as UserInfo;
obj.SetName(fileRecv.Name, userInfo.Name);
// Add Update
progressObjects.Add(fileRecv, obj);
vbox.PackStart(obj, false, false, 2);
obj.ShowAll();
});
}
private void OnButtonDelete(object sender)
{
Gtk.Application.Invoke(delegate {
FileProgressObject obj = sender as FileProgressObject;
obj.Delete -= new BlankEventHandler(OnButtonDelete);
FileReceiver fileReceiver = null;
lock (progressObjects) {
foreach (FileReceiver fileRecv in progressObjects.Keys)
{
if (progressObjects[fileRecv] == obj)
{
fileReceiver = fileRecv;
break;
}
}
if (obj.Finished != true)
{
fileReceiver.Abort();
}
progressObjects.Remove(fileReceiver);
vbox.Remove(obj);
}
});
}
private void UpdateFileReceiver(FileReceiver recv)
{
UserInfo userInfo = recv.Peer.Info as UserInfo;
SetName(recv.FileName, userInfo.Name);
SetTransferInfo(recv.FileSavedSize, recv.FileSize, recv.ReceivedPercent);
}
public void Add(FileReceiver fileReceiver)
{
FileProgressObject widget = AddFileProgress(fileReceiver);
this.vbox.PackStart(widget, false, false, 2);
this.ShowAll();
}
private void OnFinishReceivingFiles()
{
StopTimer();
lock (this)
{
if (!Canceled)
{
ThreadUtils.RunOnUiAndWait(() =>
{
Status = "Done!";
Percent = 100;
if (_receivedFiles != null && _receivedFiles.Count == _session.WillReceiveFiles.Count)
{
OnReceivedSuccessfully(_receivedFiles);
}
});
Thread.Sleep(300);
}
}
_currentReceiver = null;
CloseUi();
}
public void UseDefaultFileReceiver()
{
FileReceiver = new FileReceiver(Settings);
FileReceiver.EventOccurred += HandleServerEventOccurred;
FileReceiver.SocketEventOccurred += HandleSocketEventOccurred;
FileReceiver.FileTransferProgress += HandleFileTransferProgress;
}
public FileProgressObject(FileReceiver recv)
{
this.fileReceiver = recv;
InitializeObject(true);
// Initialize Info
UpdateFileReceiver(this.fileReceiver);
}
protected FileProgressObject AddFileProgress(FileReceiver fileReceiver)
{
FileProgressObject widget = new FileProgressObject(fileReceiver);
widget.Delete += new BlankEventHandler(OnDeleteClicked);
this.progressObjects.Add(fileReceiver, widget);
return(widget);
}
private async void ReceiveFile(object sender, RoutedEventArgs e)
{
result = await this.ShowProgressAsync("Receiving file", "Please wait...", true);
FileReceiver receive = new FileReceiver(Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "\\", result);
result.SetProgress(.7);
result.Canceled += CancelDialog;
}
public void Update(FileReceiver fileReceiver)
{
FileProgressObject widget = Lookup(fileReceiver);
if (widget != null)
{
widget.Update();
}
}
public void Remove(FileReceiver fileReceiver)
{
FileProgressObject widget = Lookup(fileReceiver);
if (widget != null)
{
this.vbox.Remove(widget);
DelFileProgress(widget, fileReceiver);
}
}
private FileReceiver CreateFileReceiver()
{
var settings = new FileReceiverSettings(_watchedDirectory, "*.*", 20, TimeSpan.FromMilliseconds(100));
FileReceiver receiver = new FileReceiver();
receiver.Configure(settings);
return(receiver);
}
// ============================================
// PRIVATE Methods
// ============================================
private void SetTransferInfo(FileProgressObject obj, FileReceiver fr)
{
if (obj != null)
{
int percent = fr.ReceivedPercent;
if (percent < 0)
{
percent = 0;
}
obj.SetTransferInfo(fr.SavedSize, fr.Size, percent);
}
}
private void ReceiveFiles()
{
var receivingFiles = _session.WillReceiveFiles;
_receivedFiles = new List <string>(receivingFiles.Count);
for (var i = 0; i < receivingFiles.Count; i++)
{
lock (this)
{
if (Canceled)
{
break;
}
}
using (var receiver = _session.AcceptReceiverAsync().Result)
{
_currentReceiver = receiver;
var receivingCount = i + 1;
ThreadUtils.RunOnUiAndWait(() =>
{
Title = "Receiver";
Status = $"Receiving {receivingCount}/{receivingFiles.Count}";
Percent = 0;
});
receiver.AcceptedHeader = () =>
{
ThreadUtils.RunOnUiAndWait(() =>
{
var neighbor = _station.GetNeighbor(receiver.RemoteAddress);
Title = $"Receiving from {neighbor}";
CurrentFileName = $"{receiver.FileName} ({FileUtils.BytesToString(receiver.TotalBytes)})";
});
};
Debugger.Log($"Receiving {receiver.FileName} from {receiver.RemoteAddress}");
receiver.Receive();
Debugger.Log($"Sent {receiver.FileName}: " + (receiver.ReceivedBytes < receiver.TotalBytes ? "FAIL" : "OK"));
if (receiver.ReceivedBytes < receiver.TotalBytes)
{
throw new Exception("Operation was aborted by sender");
}
ThreadUtils.RunOnUiAndWait(() => Percent = 100);
_receivedFiles.Add(receiver.SavedPath);
}
}
}
private void Remove (object sender) {
FileProgressObject fileProgress = (FileProgressObject) sender;
object fileInfo = fileProgress.FileInfo;
if (fileInfo.GetType() == typeof(FileSender)) {
FileSender fs = (FileSender) fileInfo;
Protocol.UploadManager.Abort(fs);
window.Viewer.Remove(fs);
} else if (fileInfo.GetType() == typeof(FileReceiver)) {
FileReceiver fr = (FileReceiver) fileInfo;
Protocol.DownloadManager.Abort(fr);
window.Viewer.Remove(fr);
}
}
private void OnAborted(object sender)
{
Gtk.Application.Invoke(delegate {
try {
FileReceiver fileRecv = sender as FileReceiver;
FileProgressObject obj = (FileProgressObject)progressObjects[fileRecv];
SetTransferInfo(obj, fileRecv);
obj.Info += " <b>ABORTED</b>";
obj.Finished = true;
} catch (Exception e) {
Debug.Log("Download Viewer Abort: {0}", e.Message);
}
});
}
private void OnFinished(object sender)
{
Gtk.Application.Invoke(delegate {
try {
FileReceiver fileRecv = sender as FileReceiver;
FileProgressObject obj = (FileProgressObject)progressObjects[fileRecv];
obj.ProgressBar.Visible = false;
obj.Info = "<b>(Finished)</b>";
obj.Finished = true;
} catch (Exception e) {
Debug.Log("Download Viewer Finished: {0}", e.Message);
}
});
}
/// <summary>
/// Called when the form is first shown
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void HideIt_Shown(object sender, EventArgs e)
{
this._receiver = new FileReceiver(this._acceptFile);
try
{
this._receiver.Listen(Options_Form.Port);
}
catch (Exception exc)
{
UIMessage.Error("An error occured while starting the listener. " +
"Application will not be able to receive files.\r\n" +
"Error: " + exc.Message, TITLE);
}
}
private static IEnumerable <string> StartReceiving(FileReceiver receiver, TimeSpan timeout)
{
var signal = new ManualResetEvent(false);
var receiveProcessor = new FileReceivedProcessor(signal);
var tokenSource = new CancellationTokenSource();
tokenSource.Token.Register(receiver.StopReceiving);
tokenSource.CancelAfter(timeout);
Task.Factory.StartNew(() => receiver.StartReceiving((m, c) => receiveProcessor.OnFileReceived(m, c), tokenSource.Token), tokenSource.Token);
signal.WaitOne(timeout);
return(receiveProcessor.ReceivedFiles.ToList());
}
private void AcceptCB(IAsyncResult ar)
{
Socket socket = listensocket.EndAccept(ar);
FileReceiver task = new FileReceiver();
task.Socket = socket;
task.EnabledIOBuffer = true;
task.BlockFinished += new BlockFinishedEventHandler(task_BlockFinished);
task.ConnectLost += new EventHandler(task_ConnectLost);
task.AllFinished += new EventHandler(task_AllFinished);
task.BlockHashed += new BlockFinishedEventHandler(task_BlockHashed);
task.ErrorOccurred += new FileTransmissionErrorOccurEventHandler(task_ErrorOccurred);
//task.FilePath = @"A:";
task.Start();
listensocket.BeginAccept(AcceptCB, null);
}
private void Form1_Load(object sender, EventArgs e)
{
IPEndPoint ep = new IPEndPoint(IPAddress.Parse("192.168.1.2"), 3477);
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(ep);
FileReceiver task = new FileReceiver();
task.Socket = socket;
task.EnabledIOBuffer = true;
task.BlockFinished += new BlockFinishedEventHandler(task_BlockFinished);
task.ConnectLost += new EventHandler(task_ConnectLost);
task.AllFinished += new EventHandler(task_AllFinished);
task.BlockHashed += new BlockFinishedEventHandler(task_BlockHashed);
task.ErrorOccurred += new FileTransmissionErrorOccurEventHandler(task_ErrorOccurred);
//task.FilePath = @"A:";
task.Start();
}
IEnumerator Start()
{
fileReceiver = new FileReceiver();
fileReceiver.directory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
fileReceiver.Listen(Receiver.DefaultPort);
fileReceiver.OnReady += OnReady;
fileReceiver.OnReceive += OnReceive;
fileReceiver.OnFinish += OnFinish;
fileReceiver.OnError += OnError;
fileReceiver.OnException += OnException;
yield return(new WaitForSeconds(1));
memoryReceiver = new MemoryReceiver();
memoryReceiver.Listen(Receiver.DefaultPort + 10);
yield return(new WaitForSeconds(1));
string dir = Path.Combine(Application.dataPath, "XTC/RCP/Scripts");
foreach (string file in Directory.GetFiles(dir))
{
string filename = Path.GetFileName(file);
byte[] data = File.ReadAllBytes(file);
MemoryStream mStream = new MemoryStream(data);
Sender sender = new Sender();
sender.Send("127.0.0.1", Receiver.DefaultPort, mStream, filename);
//sender.Send("127.0.0.1", Receiver.DefaultPort + 1, mStream, filename);
yield return(new WaitForEndOfFrame());
}
Debug.Log("-----------------");
yield return(new WaitForSeconds(1));
//big file
{
// 2M
byte[] data = new byte[1024 * 1024 * 2];
MemoryStream mStream = new MemoryStream(data);
Sender sender = new Sender();
sender.Send("127.0.0.1", Receiver.DefaultPort, mStream, "1.bin");
}
}
protected override void OnLoad(EventArgs e)
{
// Display Version
versionLabel.Text = AboutForm.AssemblyTitle + @" v" + AboutForm.AssemblyVersion;
//Load log file if specified as first argument on the command line
if (!string.IsNullOrEmpty(LogFile) && File.Exists(LogFile))
{
var fileReceiver = new FileReceiver
{
FileToWatch = LogFile,
FileFormat = FileReceiver.FileFormatEnums.Log4jXml,
ShowFromBeginning = true
};
InitializeReceiver(fileReceiver);
}
DoubleBuffered = true;
base.OnLoad(e);
}
private static void Main(string[] args)
{
var nodeId = int.Parse(args[0]);
Console.Title = nodeId.ToString();
var dataNodeStoragePath = $"{Resources.StoragePath}DataNode_{nodeId}";
if (!Directory.Exists(dataNodeStoragePath))
{
Directory.CreateDirectory(dataNodeStoragePath);
}
var info = new DataNodeInfo
{
Id = nodeId,
TcpPort = 44400 + nodeId,
StorageDirectory = new DirectoryInfo(dataNodeStoragePath)
};
var tokenSource = new CancellationTokenSource();
var udpConnection = UdpUser.ConnectTo(Resources.MasterMulticastIp, Resources.MasterMulticastPort);
var hearbeatsSender = new HeartbeatsSender(udpConnection, info, tokenSource.Token);
hearbeatsSender.Start();
var udpMessageReceiver = new MessageReceiver(udpConnection, info, tokenSource.Token);
udpMessageReceiver.Start();
var fileReceiver = new FileReceiver(info, tokenSource.Token);
fileReceiver.Start();
Console.WriteLine("press any key to close this data node");
Console.ReadLine();
tokenSource.Cancel();
udpConnection.Close();
}
private void OnReceivedPart(object sender)
{
Gtk.Application.Invoke(delegate {
try {
FileReceiver fileRecv = sender as FileReceiver;
FileProgressObject obj = (FileProgressObject)progressObjects[fileRecv];
if (obj == null)
{
OnAdded(sender);
obj = (FileProgressObject)progressObjects[fileRecv];
}
else if (obj.Finished == true)
{
return;
}
SetTransferInfo(obj, fileRecv);
} catch (Exception e) {
Debug.Log("Download Viewer Received Part: {0}", e.Message);
}
});
}
internal async Task HandleFileAsync(ControllerParameter parameter)
{
var profile = parameter.SenderProfile;
var handler = NewFileReceiver;
if (profile == null || handler == null || parameter.ConnectionType != LinkConnectionType.Tcp)
{
return;
}
var data = parameter.Packet.Data;
var name = data["name"].As <string>();
var length = data["length"].As <long>();
using (var receiver = new FileReceiver(this, profile, parameter.Stream, name, length))
{
await parameter.ResponseAsync(new { status = "wait" });
await UpdateUIAsync(() => handler.Invoke(receiver));
await receiver.LoopAsync();
}
}
