/// <summary> /// Calculates the bandwidth. /// </summary> /// <param name='transmittedBytes'> /// Transmitted bytes. /// </param> private void CalculateBandwidth(int transmittedBytes) { this.bytesTransmittedSinceLastSecond += transmittedBytes; TimeSpan diff = DateTime.Now - this.start; long? pos; long? length = null; try { pos = Stream.Position; if (pos > this.transmissionEvent.Status.Length) { length = this.Stream.Length; } } catch (NotSupportedException) { pos = null; } if (diff.Seconds >= 1) { long?result = TransmissionProgressEventArgs.CalcBitsPerSecond(this.start, DateTime.Now, this.bytesTransmittedSinceLastSecond); this.transmissionEvent.ReportProgress(new TransmissionProgressEventArgs { ActualPosition = pos, BitsPerSecond = result, Length = length }); this.bytesTransmittedSinceLastSecond = 0; this.start = this.start + diff; this.blockingDetectionTimer.Stop(); this.blockingDetectionTimer.Start(); } else { this.transmissionEvent.ReportProgress(new TransmissionProgressEventArgs { ActualPosition = pos, Length = length }); } }
/// <summary> /// Initializes a new instance of the <see cref="CmisSync.Lib.Streams.ProgressStream"/> class. /// The given transmission event will be used to report the progress /// </summary> /// <param name='stream'> /// Stream which progress should be monitored. /// </param> /// <param name='e'> /// Transmission event where the progress should be reported to. /// </param> public ProgressStream(Stream stream, FileTransmissionEvent e) : base(stream) { if (e == null) { throw new ArgumentNullException("The event, where to publish the prgress cannot be null"); } try { e.Status.Length = stream.Length; } catch (NotSupportedException) { e.Status.Length = null; } this.transmissionEvent = e; this.blockingDetectionTimer = new Timer(2000); this.blockingDetectionTimer.Elapsed += delegate(object sender, ElapsedEventArgs args) { var transmissionArgs = new TransmissionProgressEventArgs { BitsPerSecond = (long)(this.bytesTransmittedSinceLastSecond / this.blockingDetectionTimer.Interval) }; this.transmissionEvent.ReportProgress(transmissionArgs); this.bytesTransmittedSinceLastSecond = 0; }; }
private void TransmissionEvent(object sender, TransmissionProgressEventArgs status) { lock (disposeLock) { if (disposed) { return; } TimeSpan diff = DateTime.Now - updateTime; if (diff.Seconds < updateInterval) { return; } updateTime = DateTime.Now; ParentControl.BeginInvoke((Action) delegate() { lock (disposeLock) { if (disposed) { return; } Text = TransmissionStatus(status); } }); } }
public void CalculationOfBitsPerSecondFailsOnIllegalDifference() { DateTime start = DateTime.Now; DateTime end = start.AddSeconds(1); Assert.Throws <ArgumentException>(() => TransmissionProgressEventArgs.CalcBitsPerSecond(end, start, 100)); }
private void TransmissionEvent(object sender, TransmissionProgressEventArgs e) { lock (disposeLock) { if (disposed) { return; } TimeSpan diff = DateTime.Now - updateTime; if (diff.Seconds < updateInterval) { return; } if (run) { return; } run = true; updateTime = DateTime.Now; string title = TransmissionStatus(e); BeginInvokeOnMainThread(delegate { lock (disposeLock) { if (!disposed) { Title = title; } } }); run = false; } }
private void UpdateFileStatus(FileTransmissionEvent transmission, TransmissionProgressEventArgs e) { if (e == null) { e = transmission.Status; } string filePath = transmission.CachePath; if (filePath == null || !File.Exists(filePath)) { filePath = transmission.Path; } if (!File.Exists(filePath)) { Logger.Debug(String.Format("None exist {0} for file status update", filePath)); return; } if ((e.Aborted == true || e.Completed == true || e.FailedException != null)) { Notifications.FileSystemProgress.RemoveFileProgress(filePath); } else { double percent = transmission.Status.Percent.GetValueOrDefault() / 100; if (percent < 1) { Notifications.FileSystemProgress.SetFileProgress(filePath, percent); } else { Notifications.FileSystemProgress.RemoveFileProgress(filePath); } } }
private void UpdateFileStatus(FileTransmissionEvent transmission, TransmissionProgressEventArgs e) { if (e == null) { e = transmission.Status; } string filePath = transmission.CachePath; if (filePath == null || !File.Exists(filePath)) { filePath = transmission.Path; } if (!File.Exists(filePath)) { Logger.Error(String.Format("None exist {0} for file status update", filePath)); return; } string extendAttrKey = "com.apple.progress.fractionCompleted"; if ((e.Aborted == true || e.Completed == true || e.FailedException != null)) { Syscall.removexattr(filePath, extendAttrKey); try { NSFileAttributes attr = NSFileManager.DefaultManager.GetAttributes(filePath); attr.CreationDate = (new FileInfo(filePath)).CreationTime; NSFileManager.DefaultManager.SetAttributes(attr, filePath); } catch (Exception ex) { Logger.Error(String.Format("Exception to set {0} creation time for file status update: {1}", filePath, ex)); } } else { double percent = transmission.Status.Percent.GetValueOrDefault() / 100; if (percent < 1) { Syscall.setxattr(filePath, extendAttrKey, Encoding.ASCII.GetBytes(percent.ToString())); try { NSFileAttributes attr = NSFileManager.DefaultManager.GetAttributes(filePath); attr.CreationDate = new DateTime(1984, 1, 24, 8, 0, 0, DateTimeKind.Utc); NSFileManager.DefaultManager.SetAttributes(attr, filePath); } catch (Exception ex) { Logger.Error(String.Format("Exception to set {0} creation time for file status update: {1}", filePath, ex)); } } else { Syscall.removexattr(filePath, extendAttrKey); try { NSFileAttributes attr = NSFileManager.DefaultManager.GetAttributes(filePath); attr.CreationDate = (new FileInfo(filePath)).CreationTime; NSFileManager.DefaultManager.SetAttributes(attr, filePath); } catch (Exception ex) { Logger.Error(String.Format("Exception to set {0} creation time for file status update: {1}", filePath, ex)); } } } }
public void CalculateBitsPerSecondWithOneMilisecondDifference() { DateTime start = DateTime.Now; DateTime end = start.AddMilliseconds(1); long? bitsPerSecond = TransmissionProgressEventArgs.CalcBitsPerSecond(start, end, 1); Assert.AreEqual(8000, bitsPerSecond); }
/// <summary> /// Close this instance and calculates the bandwidth of the last second. /// </summary> public override void Close() { long?result = TransmissionProgressEventArgs.CalcBitsPerSecond(this.start, DateTime.Now.AddMilliseconds(1), this.bytesTransmittedSinceLastSecond); this.transmissionEvent.ReportProgress(new TransmissionProgressEventArgs() { BitsPerSecond = result }); base.Close(); }
public void CalcBitsPerSecondWithOneSecondDifference() { DateTime start = DateTime.Now; DateTime end = start.AddSeconds(1); long? bitsPerSecond = TransmissionProgressEventArgs.CalcBitsPerSecond(start, end, 1); Assert.AreEqual(8, bitsPerSecond); bitsPerSecond = TransmissionProgressEventArgs.CalcBitsPerSecond(start, start, 100); Assert.Null(bitsPerSecond); bitsPerSecond = TransmissionProgressEventArgs.CalcBitsPerSecond(start, end, 100); Assert.AreEqual(8 * 100, bitsPerSecond); }
private void TransmissionReport(object sender, TransmissionProgressEventArgs e) { using (var a = new NSAutoreleasePool()) { FileTransmissionEvent transmission = sender as FileTransmissionEvent; if (transmission == null) { return; } lock (transmissionLock) { if ((e.Aborted == true || e.Completed == true || e.FailedException != null)) { transmission.TransmissionStatus -= TransmissionReport; transmissionFiles.Remove(transmission.Path); } else { TimeSpan diff = NSDate.Now - transmissionFiles [transmission.Path]; if (diff.Seconds < notificationInterval) { return; } transmissionFiles [transmission.Path] = NSDate.Now; } // UpdateFileStatus (transmission, e); } notificationCenter.BeginInvokeOnMainThread(delegate { lock (transmissionLock) { NSUserNotification[] notifications = notificationCenter.DeliveredNotifications; foreach (NSUserNotification notification in notifications) { if (!IsNotificationTransmission(notification)) { continue; } bool pathCorrect = notification.InformativeText == transmission.Path; bool isCompleted = transmission.Status.Completed == true; bool isAlreadyStarted = startedTransmissions.Contains(transmission.Path); if (pathCorrect && (!isAlreadyStarted || isCompleted)) { notificationCenter.RemoveDeliveredNotification(notification); notification.DeliveryDate = NSDate.Now; notification.Subtitle = TransmissionStatus(transmission); notificationCenter.DeliverNotification(notification); return; } } } }); } }
/// <summary> /// If a transmission is reported as finished/aborted/failed, the transmission is removed from the collection /// </summary> /// <param name='sender'> /// The transmission event. /// </param> /// <param name='e'> /// The progress parameters of the transmission. /// </param> private void TransmissionFinished(object sender, TransmissionProgressEventArgs e) { if (e.Aborted == true || e.Completed == true || e.FailedException != null) { lock (this.collectionLock) { FileTransmissionEvent transmission = sender as FileTransmissionEvent; if (transmission != null && this.activeTransmissions.Contains(transmission)) { this.activeTransmissions.Remove(transmission); transmission.TransmissionStatus -= this.TransmissionFinished; Logger.Debug("Transmission removed"); } } } }
private string TransmissionStatus(TransmissionProgressEventArgs e) { double?percent = e.Percent; long? bitsPerSecond = e.BitsPerSecond; if (percent != null && bitsPerSecond != null) { return(String.Format("{0} ({1} {2})", System.IO.Path.GetFileName(transmissionEvent.Path), CmisSync.Lib.Utils.FormatPercent((double)percent), CmisSync.Lib.Utils.FormatBandwidth((long)bitsPerSecond))); } else { return(System.IO.Path.GetFileName(transmissionEvent.Path)); } }
private string TransmissionStatus(TransmissionProgressEventArgs status) { double percent = (status.Percent != null) ? (double)status.Percent : 0; long? bitsPerSecond = status.BitsPerSecond; if (bitsPerSecond != null) { return(String.Format("{0} ({1} {2})", System.IO.Path.GetFileName(Path), CmisSync.Lib.Utils.FormatPercent(percent), CmisSync.Lib.Utils.FormatBandwidth((long)bitsPerSecond))); } else { return(String.Format("{0} ({1})", System.IO.Path.GetFileName(Path), CmisSync.Lib.Utils.FormatPercent(percent))); } }
public void PercentTest() { string filename = "test.txt"; FileTransmissionEvent transmission = new FileTransmissionEvent(FileTransmissionType.DOWNLOAD_NEW_FILE, filename); double?percent = null; transmission.TransmissionStatus += delegate(object sender, TransmissionProgressEventArgs e) { percent = e.Percent; }; transmission.ReportProgress(new TransmissionProgressEventArgs { }); Assert.Null(percent); this.expectedArgs = new TransmissionProgressEventArgs { Length = 100, ActualPosition = 0 }; transmission.ReportProgress(this.expectedArgs); Assert.AreEqual(0, percent); transmission.ReportProgress(new TransmissionProgressEventArgs() { ActualPosition = 10 }); Assert.AreEqual(10, percent); transmission.ReportProgress(new TransmissionProgressEventArgs() { ActualPosition = 100 }); Assert.AreEqual(100, percent); transmission.ReportProgress(new TransmissionProgressEventArgs() { Length = 1000 }); Assert.AreEqual(10, percent); transmission.ReportProgress(new TransmissionProgressEventArgs() { ActualPosition = 1000, Length = 2000 }); Assert.AreEqual(50, percent); }
private void AssertThatProgressFitsMinimumLimits(TransmissionProgressEventArgs args, long minLength, double minPercent, long minPos) { // Console.WriteLine(e.ToString()); if (args.Length != null) { Assert.GreaterOrEqual(args.Length, minLength); Assert.LessOrEqual(args.Length, this.localContent.Length); } if (args.Percent != null) { Assert.GreaterOrEqual(args.Percent, minPercent); Assert.LessOrEqual(args.Percent, 100); } if (args.ActualPosition != null) { Assert.GreaterOrEqual(args.ActualPosition, minPos); Assert.LessOrEqual(args.ActualPosition, this.localContent.Length); } }
public void ReportProgressTest() { string filename = "test.txt"; FileTransmissionEvent transmission = new FileTransmissionEvent(FileTransmissionType.DOWNLOAD_NEW_FILE, filename); transmission.TransmissionStatus += this.TransmissionEventHandler; this.expectedArgs = new TransmissionProgressEventArgs() { Length = 0, ActualPosition = 0, BitsPerSecond = 0 }; transmission.ReportProgress(this.expectedArgs); this.expectedArgs.BitsPerSecond = 1024; transmission.ReportProgress(this.expectedArgs); this.expectedArgs.Completed = false; transmission.ReportProgress(this.expectedArgs); this.expectedArgs.Length = 1024; transmission.ReportProgress(this.expectedArgs); TransmissionProgressEventArgs otherArgs = new TransmissionProgressEventArgs() { Length = this.expectedArgs.Length, ActualPosition = this.expectedArgs.ActualPosition, BitsPerSecond = this.expectedArgs.BitsPerSecond, Completed = this.expectedArgs.Completed }; transmission.ReportProgress(otherArgs); TransmissionProgressEventArgs nullArgs = new TransmissionProgressEventArgs() { Length = null, ActualPosition = null, BitsPerSecond = null, Completed = null }; transmission.ReportProgress(nullArgs); }
public void TestInit() { this.expectedArgs = null; }
private void TransmissionEventHandler(object sender, TransmissionProgressEventArgs e) { Assert.AreEqual(this.expectedArgs, e, "The reported transmission events doesn't fit to the expected ones"); Assert.AreEqual(this.expectedArgs.BitsPerSecond, e.BitsPerSecond); }