Exemplo n.º 1
0
        private async void ExecuteSpeedTest(SpeedTestSource source, Server server = null)
        {
            try
            {
                SpeedGrid.IsEnabled = false;

                DownloadSpeed speed = null;

                if (source == SpeedTestSource.Speedtest)
                {
                    speed = await SpeedTestClient.GetDownloadSpeed(server, SpeedTestUnit.KiloBitsPerSecond);
                }
                else
                {
                    speed = await FastClient.GetDownloadSpeed(SpeedTestUnit.KiloBitsPerSecond);
                }

                var message = $"Source: {speed.Source} Download Speed: {speed?.Speed} {speed.Unit}";

                if (speed?.Server?.Id != null)
                {
                    message += $" (Server Id = {speed?.Server?.Id})";
                }

                ShowMessage(message);
                SpeedGrid.IsEnabled = true;
            }
            catch (System.Exception ex)
            {
                ShowMessage(ex.Message);
                SpeedGrid.IsEnabled = true;
            }
        }
 protected override void StartNextDownload()
 {
     try
     {
         Directory.CreateDirectory(DownloadsController.CurrentDownload.Destination.FullPath);
         //Http is way more simple than FTP, since it has a built in background worker, no authentication and no folders
         using (client = new CustomWebClient())
         {
             speed = new DownloadSpeed(client);
             speed.Start();
             client.Credentials              = Credentials;
             client.DownloadProgressChanged += CustomWebClientDownloadProgressChanged;
             client.DownloadFileCompleted   += CustomWebClientDownloadCompleted;
             OnDownloadStarted();
             //downloads the file and save in the selected destination
             client.DownloadFileAsync(new Uri(DownloadsController.CurrentDownload.RemoteFileInfo.Url), UpdateFileNameWithDistinguishedName());
         }
     }
     catch (Exception e)
     {
         DownloadsController.CurrentDownload.ChangeState(DownloadState.Error, true);
         OnProcessError(new DownloadErrorEventArgs(ErrorType.GeneralErrorOnDownload, DownloadsController.CurrentDownload.RemoteFileInfo.FileFullName, e));
     }
     finally
     {
         //the progress of the download list has changed
         OnOverallProgressChanged();
     }
 }
Exemplo n.º 3
0
        public void DownloadSpeedWithoutData_EstimatedDuration_ReturnsInfinity()
        {
            var startDate     = DateTime.Now;
            var downloadSpeed = new DownloadSpeed(startDate);

            Assert.AreEqual(TimeSpan.FromHours(1), downloadSpeed.EstimatedDuration);
        }
Exemplo n.º 4
0
 /// <summary>
 /// Instantiates a new instance of the DownloadTask.DownloadProgress class.
 /// </summary>
 /// <param name="percent">Percent completed.</param>
 /// <param name="bytes">Number of bytes downloaded so far.</param>
 /// <param name="totalBytes">Total number of bytes to be downloaded, i.e. the file size.</param>
 /// <param name="speed">Download speed.</param>
 /// <param name="eta">Estimated time of arrival (completion).</param>
 public DownloadProgress(double percent, FileSize bytes, FileSize totalBytes, DownloadSpeed speed, TimeSpan eta, TimeSpan elapsed)
 {
     _percentComplete = percent;
     _bytesDownloaded = bytes;
     _totalBytes      = totalBytes;
     _speed           = speed;
     _eta             = eta;
     _elapsed         = elapsed;
 }
Exemplo n.º 5
0
        public void DownloadSpeed_SettingsCapacity_SetsNewCapacity()
        {
            var startDate     = DateTime.Now;
            var downloadSpeed = new DownloadSpeed(startDate);

            downloadSpeed.Capacity = 10;

            Assert.AreEqual(10, downloadSpeed.Capacity);
        }
Exemplo n.º 6
0
        public void DownloadSpeed()
        {
            const int totalBytes    = 10000;
            var       startDate     = DateTime.Now;
            var       downloadSpeed = new DownloadSpeed(startDate);

            downloadSpeed.ReportProgress(startDate, totalBytes, 0);

            Assert.AreEqual(0, downloadSpeed.BytesPerSecond);
        }
Exemplo n.º 7
0
        public void DownloadSpeed_WithSingleItem_CalculatesCorrectSpeed()
        {
            const int totalBytes    = 10000;
            var       startDate     = DateTime.Now;
            var       downloadSpeed = new DownloadSpeed(startDate);

            downloadSpeed.ReportProgress(startDate.AddMilliseconds(1000), totalBytes, 500);

            Assert.AreEqual(500, downloadSpeed.BytesPerSecond);
        }
Exemplo n.º 8
0
 private void CheckAllConversionsAgainstOneBitPerSecond(DownloadSpeed downloadSpeed)
 {
     Assert.AreEqual(1, downloadSpeed.BitsPerSecond);
     Assert.AreEqual(0.125, downloadSpeed.BytesPerSecond);
     Assert.AreEqual(0.001, downloadSpeed.Kbps);
     Assert.AreEqual(0.000125, downloadSpeed.KBps);
     Assert.AreEqual(1e-6, downloadSpeed.Mbps);
     Assert.AreEqual(1.25e-7, downloadSpeed.MBps);
     Assert.AreEqual(1e-9, downloadSpeed.Gbps);
     Assert.AreEqual(1.25e-10, downloadSpeed.GBps);
 }
Exemplo n.º 9
0
        public void DownloadSpeedWithTwoItems_EstimatedRemainingDuration_CalculatesCorrectDuration()
        {
            const int totalBytes    = 10000;
            var       startDate     = DateTime.Now;
            var       downloadSpeed = new DownloadSpeed(startDate);

            downloadSpeed.ReportProgress(startDate.AddMilliseconds(500), totalBytes, 500);
            downloadSpeed.ReportProgress(startDate.AddMilliseconds(1000), totalBytes, 1000);

            Assert.AreEqual(TimeSpan.FromSeconds(9), downloadSpeed.EstimatedRemainingDuration);
        }
Exemplo n.º 10
0
        public override string ToString()
        {
            string toReturn = string.Empty;

            toReturn += "FileName: " + FileName + Environment.NewLine;
            toReturn += "FileLocation: " + FileLocation + Environment.NewLine;
            toReturn += "DownloadSpeed: " + DownloadSpeed.ToString() + Environment.NewLine;
            toReturn += "FileSize: " + FileSize.ToString() + Environment.NewLine;
            toReturn += "DownloadProgress: " + DownloadProgress.ToString() + Environment.NewLine;
            toReturn += "DownloadStatus " + DownloadStatus.ToString() + Environment.NewLine;
            return(toReturn);
        }
Exemplo n.º 11
0
        public void DownloadSpeedWithTwoItems_AfterReset_ValuesAreResetted()
        {
            const int totalBytes    = 10000;
            var       startDate     = DateTime.Now;
            var       downloadSpeed = new DownloadSpeed(startDate);

            downloadSpeed.ReportProgress(startDate.AddMilliseconds(500), totalBytes, 500);
            downloadSpeed.ReportProgress(startDate.AddMilliseconds(1000), totalBytes, 1000);

            downloadSpeed.Reset();

            Assert.AreEqual(0, downloadSpeed.BytesPerSecond);
        }
        private void StartDownload(string downloadUrl)
        {
            _webClient = new WebClient();
            _webClient.DownloadProgressChanged += WebClientOnDownloadProgressChanged;
            _webClient.DownloadFileCompleted   += WebClientOnDownloadFileCompleted;
            var uri      = new Uri(downloadUrl);
            var filename = _pathSafe.GetFileName(uri.LocalPath);

            _downloadSpeed = new DownloadSpeed(_webClient);

            _downloadLocation = _tempFolderProvider.TempFolder;
            _directory.CreateDirectory(_downloadLocation);
            _downloadLocation = _pathSafe.Combine(_downloadLocation, filename);
            _webClient.DownloadFileAsync(uri, _downloadLocation);
        }
Exemplo n.º 13
0
        private void StartDownload(string downloadUrl)
        {
            _webClient = new WebClient();
            _webClient.DownloadProgressChanged += WebClientOnDownloadProgressChanged;
            _webClient.DownloadFileCompleted   += WebClientOnDownloadFileCompleted;
            var    uri      = new Uri(downloadUrl);
            string filename = Path.GetFileName(uri.LocalPath);

            _downloadSpeed = new DownloadSpeed(_webClient);

            _downloadLocation = GetTempPath();
            Directory.CreateDirectory(_downloadLocation);
            _downloadLocation = Path.Combine(_downloadLocation, filename);
            _webClient.DownloadFileAsync(uri, _downloadLocation);
        }
Exemplo n.º 14
0
        public void DownloadSpeed_WithCapacity_WithDoubleCapacityItems_CalculatesCorrectSpeedForSecondHalf()
        {
            const int totalBytes    = 10000;
            var       startDate     = DateTime.Now;
            var       downloadSpeed = new DownloadSpeed(startDate);

            downloadSpeed.Capacity = 2;

            downloadSpeed.ReportProgress(startDate.AddMilliseconds(500), totalBytes, 500);
            downloadSpeed.ReportProgress(startDate.AddMilliseconds(1000), totalBytes, 1000);

            downloadSpeed.ReportProgress(startDate.AddMilliseconds(1500), totalBytes, 2000);
            downloadSpeed.ReportProgress(startDate.AddMilliseconds(2000), totalBytes, 3000);

            Assert.AreEqual(2000, downloadSpeed.BytesPerSecond);
        }
Exemplo n.º 15
0
        public async Task StartDownloadAsync(IApplicationVersion version)
        {
            if (_downloadTask == null)
            {
                _cancellationSource = _cancellationSourceFactory.CreateSource();
                _downloadTask       = Task.Run(() =>
                {
                    _httpClient = new HttpClient();

                    DownloadSpeed = new DownloadSpeed();

                    OnProgressChanged  += DownloadSpeed.DownloadProgressChanged;
                    OnDownloadFinished += DownloadSpeed.webClient_DownloadFileCompleted;

                    var downloadFileWithRange = DownloadFileWithRange(version);
                    OnDownloadFinished?.Invoke(this, new UpdateProgressChangedEventArgs(downloadFileWithRange, 0, 0, 0));
                    _downloadTask = null;
                }, _cancellationSource.Token);
            }

            await _downloadTask;
        }
Exemplo n.º 16
0
        public void StartDownload(IApplicationVersion version)
        {
            if (isDownloading)
            {
                return;
            }

            _httpClient = new HttpClient();

            Task.Run(() =>
            {
                isDownloading = true;
                DownloadSpeed = new DownloadSpeed();

                OnProgressChanged  += DownloadSpeed.DownloadProgressChanged;
                OnDownloadFinished += DownloadSpeed.webClient_DownloadFileCompleted;

                var downloadFileWithRange = DownloadFileWithRange(version);
                OnDownloadFinished?.Invoke(this, new UpdateProgressChangedEventArgs(downloadFileWithRange, 0, 0, 0));
                isDownloading = false;
            });
        }
Exemplo n.º 17
0
        public void VerifyDownloadSpeedConversionsFromGigaBytePerSecond()
        {
            var downloadSpeed = new DownloadSpeed(DownloadSpeed.Type.GBps, 1.25e-10);

            CheckAllConversionsAgainstOneBitPerSecond(downloadSpeed);
        }
Exemplo n.º 18
0
        public void VerifyDownloadSpeedConversionsFromMegaBitPerSecond()
        {
            var downloadSpeed = new DownloadSpeed(DownloadSpeed.Type.Mbps, 1e-6);

            CheckAllConversionsAgainstOneBitPerSecond(downloadSpeed);
        }
Exemplo n.º 19
0
        public void VerifyDownloadSpeedConversionsFromKiloBytePerSecond()
        {
            var downloadSpeed = new DownloadSpeed(DownloadSpeed.Type.KBps, 0.000125);

            CheckAllConversionsAgainstOneBitPerSecond(downloadSpeed);
        }
Exemplo n.º 20
0
        /// <summary>
        /// Starts downloading the file.
        /// </summary>
        /// <param name="saveLocation">Path to where the file will be saved.</param>
        /// <param name="onProgressChanged">Interface to track download progress.</param>
        /// <returns>A System.Threading.Task that represents the download operation.</returns>
        /// <exception cref="System.NotSupportedException">
        /// Invalid URI scheme.
        /// </exception>
        /// <exception cref="System.Security.SecurityException">
        /// Permission is not granted to connect to remote server.
        /// </exception>
        /// <exception cref="System.UriFormatException">The download URL is invalid.</exception>
        /// <exception cref="System.Net.WebException">An error occurred while processing the request.</exception>
        /// <exception cref="System.ArgumentException">
        /// path is an empty string (""), contains only white space, or contains one
        /// or more invalid characters.
        /// </exception>
        /// <exception cref="System.IO.IOException">
        /// An I/O error, such as specifying FileMode.CreateNew when the file specified
        /// by path already exists, occurred. -or-The stream has been closed.
        /// </exception>
        /// <exception cref="System.Security.SecurityException">
        /// The caller does not have the required permission.
        /// </exception>
        /// <exception cref="System.IO.DirectoryNotFoundException">
        /// The specified path is invalid, such as being on an unmapped drive.
        /// </exception>
        /// <exception cref="System.UnauthorizedAccessException">
        /// The access requested is not permitted by the operating system for the specified
        /// path, such as when access is Write or ReadWrite and the file or directory
        /// is set for read-only access.
        /// </exception>
        /// <exception cref="System.IO.PathTooLongException">
        /// The specified path, file name, or both exceed the system-defined maximum
        /// length. For example, on Windows-based platforms, paths must be less than
        /// 248 characters, and file names must be less than 260 characters.
        /// </exception>
        public Task DownloadAsync(string saveLocation, IProgress <DownloadProgress> onProgressChanged = null)
        {
            if (!IsInitialized)
            {
                throw new InvalidOperationException("The object has not been initialized. You must call DownloadTask.Initialize() first.");
            }

            if (isDisposed)
            {
                throw new ObjectDisposedException("DownloadTask", "Cannot start because this instance has been disposed.");
            }

            if (Status == DownloadTaskStatus.Failed || Status == DownloadTaskStatus.Canceled)
            {
                downloadWatch.Reset();
            }

            Status = DownloadTaskStatus.Starting;

            downloadWatch.Start();
            elapsedTimer.Start();

            FullPath = saveLocation; // filename after download
            FileName = Path.GetFileName(FullPath);

            _saveToIncomlete = FullPath + IncompleteDlExt;    // save here temporarily (until download completes)
            progressReporter = onProgressChanged;             // save so that it can be used for resumption
            cancelSource     = new CancellationTokenSource(); // disposed after paused, canceled, completed. a new one is use when resuming

            return(Task.Factory.StartNew(() => {
                HttpWebResponse response = null;
                FileStream fStream = null;

                try {
                    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(_url);
                    request.UseDefaultCredentials = true;
                    request.Proxy = WebRequest.GetSystemWebProxy();

                    byte[] buffer = new byte[BufferSize];
                    FileMode mode;
                    long bytesDownloaded = 0;

                    if (File.Exists(_saveToIncomlete) && ResumeSupported)   // dl has been started before; try to resume
                    {
                        FileInfo fInfo = new FileInfo(_saveToIncomlete);

                        if (fInfo.Length < this.Size.Value)   // incomplete file must be smaller than total download size
                        // add range header to resume where left off
                        {
                            request.AddRange(fInfo.Length);
                            bytesDownloaded = fInfo.Length;
                            mode = FileMode.Append;
                        }
                        else   // otherwise, it's another file with the same name or it got currupted
                        {
                            File.Delete(_saveToIncomlete);
                            mode = FileMode.Create;
                        }
                    }
                    else   // resume not supported; start from beginning
                    {
                        mode = FileMode.Create;
                    }

                    // begin download
                    fStream = new FileStream(_saveToIncomlete, mode, FileAccess.Write);
                    response = (HttpWebResponse)request.GetResponse();

                    using (Stream dlStream = response.GetResponseStream()) { // download stream
                        // for measuring speed
                        const int reportInterval = 200;                      // ms
                        int tmpBytes = 0;

                        Stopwatch watch = new Stopwatch();
                        Func <DownloadProgress> ProgressSnapshot = () => {
                            double percent;
                            TimeSpan eta;
                            FileSize totalSize;
                            FileSize curSize = new FileSize(bytesDownloaded);
                            DownloadSpeed speed;

                            if (Status == DownloadTaskStatus.Completed)
                            {
                                speed = new DownloadSpeed(Size.Value, Elapsed);
                            }
                            else
                            {
                                speed = new DownloadSpeed(tmpBytes, watch.Elapsed); // current speed
                            }

                            if (Size.Value > 0)   // got file size from server
                            {
                                totalSize = new FileSize(this.Size.Value);
                                percent = (double)bytesDownloaded / Size.Value * 100;
                                eta = TimeSpan.FromSeconds((this.Size.Value - bytesDownloaded) / (bytesDownloaded / Elapsed.TotalSeconds)); // eta from average speed
                            }
                            else                                                                                                            // size is not known (happens with webpages)
                            {
                                totalSize = new FileSize(bytesDownloaded);                                                                  // use number of bytes downloaded so far as size
                                percent = -1;
                                eta = TimeSpan.FromSeconds(-1);
                            }

                            return new DownloadProgress(percent, curSize, totalSize, speed, eta, Elapsed);
                        };

                        while (true)
                        {
                            Status = DownloadTaskStatus.Downloading;

                            watch.Start();
                            int bytesRead = dlStream.Read(buffer, 0, buffer.Length);
                            watch.Stop();

                            if (watch.ElapsedMilliseconds >= reportInterval)
                            {
                                lock (Progress) {
                                    Progress.Update(ProgressSnapshot());
                                }
                                if (onProgressChanged != null)
                                {
                                    onProgressChanged.Report(Progress);
                                }

                                tmpBytes = 0;
                                watch.Reset();
                            }

                            bytesDownloaded += bytesRead;        // total downloaded so far
                            tmpBytes += bytesRead;               // total since last progress report

                            if (bytesRead < 1)                   // dl completed or failed
                            {
                                if (fStream.Length < Size.Value) // downloaded less than required
                                {
                                    Status = DownloadTaskStatus.Failed;
                                }
                                else
                                {
                                    Status = DownloadTaskStatus.Completed;
                                }
                                lock (Progress) {
                                    Progress.Update(ProgressSnapshot());
                                }
                                if (onProgressChanged != null)
                                {
                                    onProgressChanged.Report(Progress);
                                }

                                break;
                            }

                            // write block to file
                            fStream.Write(buffer, 0, bytesRead);
                            fStream.Flush();

                            try { // check for cancellation (pause or cancel)
                                cancelSource.Token.ThrowIfCancellationRequested();
                            }
                            catch (OperationCanceledException) {
                                if (Status == DownloadTaskStatus.Pausing)
                                {
                                    Status = DownloadTaskStatus.Paused;
                                }
                                else
                                {
                                    Status = DownloadTaskStatus.Canceled;
                                }

                                throw;
                            }
                        }
                    }
                }
                catch (Exception ex) {
                    if (!(ex is OperationCanceledException))   // something went wrong
                    {
                        Status = DownloadTaskStatus.Failed;

                        throw;
                    }
                }
                finally {
                    downloadWatch.Stop();
                    elapsedTimer.Stop();

                    if (response != null)
                    {
                        response.Dispose();
                    }

                    if (fStream != null)
                    {
                        fStream.Dispose();
                    }

                    if (cancelSource != null)
                    {
                        cancelSource.Dispose();
                        cancelSource = null;
                    }

                    if (Status == DownloadTaskStatus.Completed)
                    {
                        File.Move(_saveToIncomlete, _saveTo); // rename temporary file
                    }
                    else if (Status == DownloadTaskStatus.Canceled)
                    {
                        if (DeleteWhenCanceled)
                        {
                            File.Delete(_saveToIncomlete);
                        }
                    }
                }
            }, TaskCreationOptions.LongRunning));
        }
Exemplo n.º 21
0
 /// <summary>
 /// Instantiates a new instance of the DownloadTask.DownloadSpeed class.
 /// </summary>
 /// <param name="ds">An existing DownloadSpeed instance.</param>
 public DownloadSpeed(DownloadSpeed ds)
     : this()
 {
     Value = ds.Value;
 }