public async Task CrawlAsync(SitePage sitePage) { try { OnPageDownloadBegin?.Invoke(this, sitePage); await Downloader.Execute(sitePage); OnPageDownloadComplete?.Invoke(this, sitePage); SitePageTemplateExtractor.FindAll(sitePage.Uri, sitePage.Contents, _filters) .ForEach(async i => { Interlocked.Increment(ref _numberOfLinksLeft); await CrawlAsync(i); }); } catch (Exception exc) { OnError?.Invoke(this, exc); } if (Interlocked.Decrement(ref _numberOfLinksLeft) == 0) { OnDownloadCompleted?.Invoke(this, EventArgs.Empty); } }
public void Save(byte[] buffer) { if (!HasError) { try { writer.Write(buffer); WritenBytesCount += buffer.Length; OnDownloadUpdateProgress?.Invoke(Convert.ToInt32((WritenBytesCount / (double)FileLength) * 100f)); if (WritenBytesCount >= FileLength) { IsOpen = false; Completed = true; Close(); OnDownloadCompleted?.Invoke(Folder, FileName); } } catch { HasError = true; IsOpen = false; OnDownloadFailed?.Invoke(Folder, FileName); } } }
void DownloadCompleted(bool cancelled) { client.Dispose(); client = null; if (cancelled) { try { OnDownloadCancelled?.Invoke(this, EventArgs.Empty); } catch { } return; } setting.SendLog(string.Format("{0}", I18N("DownloadCompleted"))); if (UpdateCore()) { try { OnDownloadCompleted?.Invoke(this, EventArgs.Empty); } catch { } } else { try { OnDownloadFail?.Invoke(this, EventArgs.Empty); } catch { } } }
private void FromReaderToFile(StreamReader src, FileStream dest, ref DownloaderMetric metric, ref Stopwatch stopwatch, CancellationToken ct) { var buffer = new byte[32 * 1024]; int bytesRead; while ((bytesRead = src.BaseStream.Read(buffer, 0, buffer.Length)) > 0) { if (ct.IsCancellationRequested) { dest.Flush(true); dest.Close(); dest.Dispose(); return; } dest.Write(buffer, 0, bytesRead); metric.DownloadedBytes += bytesRead; metric.ElapsedTime = stopwatch.Elapsed; OnDownloading?.Invoke(metric); } OnDownloadCompleted?.Invoke(metric); dest.Flush(true); dest.Close(); dest.Dispose(); }
private void Remote_OnDownloadCompleted(object sender, BlobCompleteEventArgs e) { if (downloadTokenSources.ContainsKey(e.Filename)) { downloadTokenSources.Remove(e.Filename); } OnDownloadCompleted?.Invoke(this, e); }
public FileDownloader(string downloadUrl, string savePath) { DownloadUrl = downloadUrl; SavePath = savePath; _downloadClient.DownloadFileCompleted += (s, e) => { OnDownloadCompleted?.Invoke(!e.Cancelled && e.Error == null); }; _downloadClient.DownloadProgressChanged += (sender, args) => OnProgressChanged?.Invoke(args.ProgressPercentage, "Downloading..."); }
private async Task <byte[]> DownloadAsync(CloudBlockBlob blob, CancellationToken token) { string fullpath = blob.Container.Name + "/" + blob.Name; byte[] buffer = null; Stopwatch watch = new Stopwatch(); using (MemoryStream stream = new MemoryStream()) { watch.Start(); double time = watch.Elapsed.TotalMilliseconds; long bytesTransferred = 0; IProgress <StorageProgress> progressHandler = new Progress <StorageProgress>( progress => { bytesTransferred = bytesTransferred < progress.BytesTransferred ? progress.BytesTransferred : bytesTransferred; if (watch.Elapsed.TotalMilliseconds > time + 1000.0 && bytesTransferred <= progress.BytesTransferred) { time = time + 1000.0; OnDownloadBytesTransferred?.Invoke(this, new BytesTransferredEventArgs(fullpath, blob.Properties.Length, progress.BytesTransferred)); } }); try { await blob.DownloadToStreamAsync(stream, default(AccessCondition), default(BlobRequestOptions), default(OperationContext), progressHandler, token); buffer = stream.ToArray(); watch.Stop(); } catch (Exception ex) { watch.Stop(); if (ex.InnerException is TaskCanceledException) { buffer = null; } else { throw ex; } } OnDownloadCompleted?.Invoke(this, new BlobCompleteEventArgs(fullpath, token.IsCancellationRequested)); } return(buffer); }
void Download() { string fileName = _packageName; string tpl = resData("DownloadLinkTpl"); string url = string.Format(tpl, _version, fileName); Lib.Utils.SupportProtocolTLS12(); client = new WebClient(); int preProgress = -100; client.DownloadProgressChanged += (s, a) => { var percentage = a.ProgressPercentage; if (percentage >= 1) { var e = new Model.Data.IntEvent(a.ProgressPercentage); try { OnProgress?.Invoke(this, e); } catch { } } if (percentage - preProgress >= 20) { preProgress = percentage; setting.SendLog(string.Format("{0}: {1}%", I18N("DownloadProgress"), percentage)); } }; client.DownloadFileCompleted += (s, a) => { if (a.Cancelled) { OnDownloadCancelled?.Invoke(this, EventArgs.Empty); } else { setting.SendLog(string.Format("{0}", I18N("DownloadCompleted"))); OnDownloadCompleted?.Invoke(this, EventArgs.Empty); } client.Dispose(); client = null; }; setting.SendLog(string.Format("{0}:{1}", I18N("Download"), url)); client.DownloadFileAsync(new Uri(url), fileName); }
public void DownloadEventDataAsync() { WebClient web = new WebClient(); web.OpenReadCompleted += web_OpenReadCompleted; try { //web.OpenReadAsync(new Uri("http://mobile.formula1.com")); web.OpenReadAsync(new Uri("https://www.f1calendar.com/")); } catch (Exception) { OnDownloadCompleted.Invoke(new RacingEvent(), CompletionStatus.Failed); } }
void NotifyDownloadResults(bool status) { try { if (status) { OnDownloadCompleted?.Invoke(this, EventArgs.Empty); } else { OnDownloadFail?.Invoke(this, EventArgs.Empty); } } catch { } }
private IEnumerator DownloadUpdateAsync() { var initHandle = Addressables.InitializeAsync(); yield return(initHandle); Addressables.Release(initHandle); var checkHandle = Addressables.CheckForCatalogUpdates(false); yield return(checkHandle); var catalogs = checkHandle.Result; Addressables.Release(checkHandle); if (catalogs == null || catalogs.Count <= 0) { yield break; } SaveOriginalCatalogs(); yield return(StartCoroutine(UpdateCatalogsAsync(catalogs))); yield return(StartCoroutine(CalculateUpdateSizeAsync())); if (downloadSize <= 0) { yield break; } yield return(StartCoroutine(RequestDownloadHandle?.Invoke(downloadSize))); if (Result == RequestDownloadResult.Agree) { DeleteOriginalCatalogs(); } else { CancelDownload(); } yield return(StartCoroutine(UpdateResourceLocatorsAsync())); if (Result == RequestDownloadResult.Disagree) { yield break; } yield return(StartCoroutine(DownloadAsync())); OnDownloadCompleted?.Invoke(downloadSize); yield return(StartCoroutine(AfterDownloadHandle?.Invoke())); }
void DownloadPackage() { string ver = resData("Version"); string fileName = pkgName; string tpl = resData("DownloadLinkTpl"); string url = string.Format(tpl, ver, fileName); Lib.Utils.SupportProtocolTLS12(); WebClient client = new WebClient(); client.DownloadFileCompleted += (s, a) => { OnDownloadCompleted?.Invoke(this, null); }; Debug.WriteLine("Download: " + url); client.DownloadFileAsync(new Uri(url), fileName); }
private IEnumerator DownloadingFile(string url, string filePath, ICancellationToken cancellationToken, OnDownloadCompleted onCompleted, OnDownloadProgressChanged onProgressChanged) { bool anyError = true; using (UnityWebRequest unityWebRequest = new UnityWebRequest(url, UnityWebRequest.kHttpVerbGET)) { unityWebRequest.downloadHandler = new DownloadHandlerFile(filePath) { removeFileOnAbort = true }; UnityWebRequestAsyncOperation asyncOperation = unityWebRequest.SendWebRequest(); int lastPercents = 0; while (!asyncOperation.isDone) { yield return(new WaitForEndOfFrame()); if (cancellationToken.Canceled) { unityWebRequest.Abort(); break; } int currentPercents = Mathf.RoundToInt(asyncOperation.progress * 100f); if (lastPercents < currentPercents) { onProgressChanged?.Invoke(currentPercents); lastPercents = currentPercents; } } anyError = unityWebRequest.isNetworkError || unityWebRequest.isHttpError; if (anyError) { Debug.LogError(unityWebRequest.error); } else { Debug.Log($"{nameof(HttpClient)}: File successfully downloaded and saved to " + filePath); } } onCompleted?.Invoke(!anyError); }
private void Operations_OnDownloadCompleted(object sender, BlobCompleteEventArgs e) { OnDownloadCompleted?.Invoke(this, e); }
public IEnumerator DownloadingFiles(List <UrlFilePath> urlFilePaths, ICancellationToken cancellationToken, OnDownloadCompleted onCompleted, OnDownloadProgressChanged onProgressChanged) { bool noError = true; for (int i = 0; i < urlFilePaths.Count; i++) { if (cancellationToken.Canceled) { noError = false; break; } int currentI = i; int currentCount = urlFilePaths.Count; UrlFilePath item = urlFilePaths[i]; yield return(GameLogicUpdateSystem.StartCoroutine(DownloadingFile(item.Url, item.FilePath, cancellationToken, (ne) => { if (!ne) { noError = ne; } }, (percents) => { int currentPercents = Mathf.RoundToInt((100 * currentI + percents) / (float)currentCount); onProgressChanged?.Invoke(currentPercents); }))); } onCompleted?.Invoke(noError); }
void ProcessFileTransmissionInfo(byte[] data) { string datastr = encoding.GetString(data); byte[] filedatabuffer; if (datastr.StartsWith("Req:")) { ResourceData resource = ResourceManager.GetResource(datastr.Substring(4, datastr.IndexOf("$") - 4)); if (!FTContainer.UploadQueue.Contains(resource.path)) { UploadFile(resource); } return; } if (datastr.StartsWith("FT:")) { int infodelim = datastr.IndexOf("$"), iddelim = datastr.IndexOf('|'); string filename = datastr.Substring(3, iddelim - 3), Id = datastr.Substring(iddelim + 1, infodelim - iddelim - 1); if (ResourceManager.GetResource(Id) != null) { FTContainer.Transdata = ResourceManager.GetResource(Id); FTContainer.Transdata.ChangeResourcePath(Path.GetDirectoryName(FTContainer.Transdata.path) + filename, FTContainer.Transdata.URI.IsAbsoluteUri ? UriKind.Absolute : UriKind.Relative); FTContainer.IsReceivingUpdate = true; } else { FTContainer.Transdata = new ResourceData(ResourceManager.GetDLResourceFolderPath() + filename, Id, UriKind.Relative); } string cstr = datastr.Substring(0, infodelim + 1); FTContainer.filestream = new FileStream(FTContainer.Transdata.path, FileMode.Create); int clength = data.Length - encoding.GetByteCount(cstr); if (clength > 0) { filedatabuffer = new byte[clength]; Buffer.BlockCopy(data, encoding.GetByteCount(cstr), filedatabuffer, 0, filedatabuffer.Length); FTContainer.filestream.Write(filedatabuffer, 0, filedatabuffer.Length); } else { filedatabuffer = new byte[0]; } DebugLogging("File Receiving..." + FTContainer.Transdata.name + FTContainer.Transdata.extension + " Id : " + FTContainer.Transdata.Id); DebugLogging("Received File Data :" + FTContainer.filestream.Length + " ( +" + FTContainer.filestream.Length); if (datastr.EndsWith("$End")) { FTContainer.filestream?.Close(); if (FTContainer.IsReceivingUpdate) { FTContainer.Transdata.IssueFinishedUpdateNotify(); } else { ResourceManager.AddResource(FTContainer.Transdata); } OnDownloadCompleted?.Invoke(FTContainer); DebugLogging("File Received successfully " + FTContainer.Transdata.name + FTContainer.Transdata.extension + " Id : " + FTContainer.Transdata.Id); FTContainer.IsReceivingUpdate = false; FTContainer.Transdata = null; } } else if (datastr.EndsWith("$End")) { int slength = data.Length - encoding.GetByteCount("$End"); if (slength > 0) { byte[] fdata = new byte[data.Length - encoding.GetByteCount("$End")]; Buffer.BlockCopy(data, 0, fdata, 0, fdata.Length); //FTContainer.filebuffer = FTContainer.filebuffer.Concat(fdata).ToArray(); FTContainer.filestream.Write(fdata, 0, fdata.Length); DebugLogging("Received File Data :" + FTContainer.filestream.Length + " ( +" + fdata.Length); } try { FTContainer.filestream?.Close(); if (FTContainer.IsReceivingUpdate) { FTContainer.Transdata.IssueFinishedUpdateNotify(); } else { ResourceManager.AddResource(FTContainer.Transdata); } OnDownloadCompleted?.Invoke(FTContainer); DebugLogging("File Received successfully " + FTContainer.Transdata.name + FTContainer.Transdata.extension + " Id : " + FTContainer.Transdata.Id); FTContainer.IsReceivingUpdate = false; FTContainer.Transdata = null; } catch (Exception ex) { DebugLogging(ex.Message + "\n" + ex.StackTrace); } } else { if (!FTContainer.filestream.CanWrite) { return; } FTContainer.filestream.Write(data, 0, data.Length); //FTContainer.filebuffer = FTContainer.filebuffer.Concat(data).ToArray(); DebugLogging("Received File Data :" + FTContainer.filestream.Length + " ( +" + data.Length); } }
public void DownloadFileAsync(string url, string filePath, ICancellationToken cancellationToken, OnDownloadCompleted onCompleted, OnDownloadProgressChanged onProgressChanged) => GameLogicUpdateSystem.StartCoroutine(DownloadingFile(url, filePath, cancellationToken, onCompleted, onProgressChanged));
internal void TriggerDownloadCompletedEvent(DownloadDetails details) { details.UpdateStatus(DownloadDetails.Status.Downloaded); OnDownloadCompleted?.Invoke(this, details); }
public void DownloadFileAsync(UrlFilePath urlFilePath, ICancellationToken cancellationToken, OnDownloadCompleted onCompleted, OnDownloadProgressChanged onProgressChanged) => DownloadFileAsync(urlFilePath.Url, urlFilePath.FilePath, cancellationToken, onCompleted, onProgressChanged);
public async Task <byte[]> DownloadFileAsync(string path, string share, string filename, CancellationToken token = default(CancellationToken)) { if (string.IsNullOrEmpty(path)) { throw new ArgumentNullException("path"); } if (string.IsNullOrEmpty(share)) { throw new ArgumentNullException("share"); } if (string.IsNullOrEmpty("filename")) { throw new ArgumentNullException("filename"); } Exception error = null; Stopwatch watch = new Stopwatch(); watch.Start(); double time = watch.Elapsed.TotalMilliseconds; long bytesTransferred = 0; byte[] buffer = null; try { CloudFileShare choudShare = client.GetShareReference(share); CloudFileDirectory dir = choudShare.GetRootDirectoryReference(); CloudFile file = dir.GetFileReference(filename); IProgress <StorageProgress> progressHandler = new Progress <StorageProgress>( progress => { bytesTransferred = bytesTransferred < progress.BytesTransferred ? progress.BytesTransferred : bytesTransferred; if (watch.Elapsed.TotalMilliseconds > time + 1000.0 && bytesTransferred <= progress.BytesTransferred) { OnDownloadBytesTransferred?.Invoke(this, new BytesTransferredEventArgs(share, filename, bytesTransferred, file.Properties.Length)); } }); buffer = new byte[file.Properties.Length]; await file.DownloadRangeToByteArrayAsync(buffer, 0, 0, buffer.Length, default(AccessCondition), default(FileRequestOptions), default(OperationContext), progressHandler, token); } catch (Exception ex) { if (ex.InnerException is TaskCanceledException) { buffer = null; } else { error = ex; throw ex; } } finally { watch.Stop(); OnDownloadCompleted?.Invoke(this, new BlobCompleteEventArgs(share, filename, token.IsCancellationRequested, error)); } return(buffer); }
public void DownloadFilesAsync(List <UrlFilePath> urlFilePaths, ICancellationToken cancellationToken, OnDownloadCompleted onCompleted, OnDownloadProgressChanged onProgressChanged) => GameLogicUpdateSystem.StartCoroutine(DownloadingFiles(urlFilePaths, cancellationToken, onCompleted, onProgressChanged));
void web_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e) { try { string page = ""; using (StreamReader sr = new StreamReader(e.Result)) { page = sr.ReadToEnd(); } e.Result.Close(); RacingEvent f1Event = new RacingEvent(); f1Event.Circuit = ""; f1Event.Country = "unknown"; List <SessionInfo> sessions = new List <SessionInfo>(); Match m = Regex.Match(page, "<tbody .*? class=\".*?next-event.*?\">(.*?)</tbody>", RegexOptions.Singleline); if (m.Groups.Count > 1) { string str; Match ms = Regex.Match(m.Groups[1].Value, "<tr class=\"first-practice.*?>(.*?)</tr>", RegexOptions.Singleline); if (ms.Groups.Count > 1) { SessionInfo practice1 = new SessionInfo(); practice1.Type = "Practice 1"; str = ms.Groups[1].Value; var date = Regex.Match(str, "<td class=\"date-column\">(.*?)</td>", RegexOptions.Singleline); if (date.Groups.Count > 1) { var time = Regex.Match(date.Groups[1].Value, "<abbr .*? title=\"(.*?)\".*?</abbr>", RegexOptions.Singleline); if (time.Groups.Count > 1) { practice1.Start = DateTime.Parse(time.Groups[1].Value); practice1.Time = SessionTimeSpan.Practice1; sessions.Add(practice1); } } } ms = Regex.Match(m.Groups[1].Value, "<tr class=\"second-practice.*?>(.*?)</tr>", RegexOptions.Singleline); if (ms.Groups.Count > 1) { SessionInfo practice2 = new SessionInfo(); practice2.Type = "Practice 2"; str = ms.Groups[1].Value; var date = Regex.Match(str, "<td class=\"date-column\">(.*?)</td>", RegexOptions.Singleline); if (date.Groups.Count > 1) { var time = Regex.Match(date.Groups[1].Value, "<abbr .*? title=\"(.*?)\".*?</abbr>", RegexOptions.Singleline); if (time.Groups.Count > 1) { practice2.Start = DateTime.Parse(time.Groups[1].Value); practice2.Time = SessionTimeSpan.Practice2; sessions.Add(practice2); } } } ms = Regex.Match(m.Groups[1].Value, "<tr class=\"third-practice.*?>(.*?)</tr>", RegexOptions.Singleline); if (ms.Groups.Count > 1) { SessionInfo practice3 = new SessionInfo(); practice3.Type = "Practice 3"; str = ms.Groups[1].Value; var date = Regex.Match(str, "<td class=\"date-column\">(.*?)</td>", RegexOptions.Singleline); if (date.Groups.Count > 1) { var time = Regex.Match(date.Groups[1].Value, "<abbr .*? title=\"(.*?)\".*?</abbr>", RegexOptions.Singleline); if (time.Groups.Count > 1) { practice3.Start = DateTime.Parse(time.Groups[1].Value); practice3.Time = SessionTimeSpan.Practice3; sessions.Add(practice3); } } } ms = Regex.Match(m.Groups[1].Value, "<tr class=\"qualifying.*?>(.*?)</tr>", RegexOptions.Singleline); if (ms.Groups.Count > 1) { SessionInfo quali = new SessionInfo(); quali.Type = "Qualifying"; str = ms.Groups[1].Value; var date = Regex.Match(str, "<td class=\"date-column\">(.*?)</td>", RegexOptions.Singleline); if (date.Groups.Count > 1) { var time = Regex.Match(date.Groups[1].Value, "<abbr .*? title=\"(.*?)\".*?</abbr>", RegexOptions.Singleline); if (time.Groups.Count > 1) { quali.Start = DateTime.Parse(time.Groups[1].Value); quali.Time = SessionTimeSpan.Qualifying; sessions.Add(quali); } } } ms = Regex.Match(m.Groups[1].Value, "<tr class=\"race.*?>(.*?)</tr>", RegexOptions.Singleline); if (ms.Groups.Count > 1) { SessionInfo race = new SessionInfo(); race.Type = "Race"; str = ms.Groups[1].Value; var date = Regex.Match(str, "<td class=\"date-column\">(.*?)</td>", RegexOptions.Singleline); if (date.Groups.Count > 1) { var time = Regex.Match(date.Groups[1].Value, "<abbr.*?title=\"(.*?)\".*?</abbr>", RegexOptions.Singleline); if (time.Groups.Count > 1) { race.Start = DateTime.Parse(time.Groups[1].Value); race.Time = SessionTimeSpan.Race; sessions.Add(race); } } } ms = Regex.Match(m.Groups[1].Value, "<span class=\"location\">(.*?)</span>", RegexOptions.Singleline); if (ms.Groups.Count > 1) { f1Event.Country = ms.Groups[1].Value.Trim(); } } SessionInfo selectedSession = null; var now = DateTime.Now; foreach (var session in sessions) { selectedSession = session; if (now < session.Start) { break; } else if (now <= session.Start + session.Time) { break; } } if (selectedSession != null) { f1Event.Session = selectedSession.Type; f1Event.SessionStartTime = selectedSession.Start; f1Event.UpdateRemainingTime(); } f1Event.DownloadTimestamp = DateTime.Now; OnDownloadCompleted.Invoke(f1Event, CompletionStatus.Completed); } catch (Exception) { OnDownloadCompleted.Invoke(new RacingEvent(), CompletionStatus.Failed); } }
public void Method() { OnDownloadCompleted?.Invoke(this, EventArgs.Empty); }
public async Task DownloadBlockBlobToFile(string filePath, string containerName, string blobFilename, CancellationToken token = default(CancellationToken)) { if (string.IsNullOrEmpty(filePath)) { throw new ArgumentNullException("filenamePath"); } if (string.IsNullOrEmpty(containerName)) { throw new ArgumentNullException("containerName"); } if (string.IsNullOrEmpty("blobFilename")) { throw new ArgumentNullException("blobFilename"); } if (!File.Exists(filePath)) { throw new FileNotFoundException(filePath); } Exception error = null; Stopwatch watch = new Stopwatch(); watch.Start(); double time = watch.Elapsed.TotalMilliseconds; long bytesTransferred = 0; IProgress <StorageProgress> progressHandler = new Progress <StorageProgress>( progress => { bytesTransferred = bytesTransferred < progress.BytesTransferred ? progress.BytesTransferred : bytesTransferred; FileInfo info = new FileInfo(filePath); if (watch.Elapsed.TotalMilliseconds > time + 1000.0 && bytesTransferred <= progress.BytesTransferred) { OnDownloadBytesTransferred?.Invoke(this, new BytesTransferredEventArgs(containerName, blobFilename, bytesTransferred, info.Length)); } }); try { CloudBlobContainer container = await GetContainerReferenceAsync(containerName); CloudBlockBlob blob = container.GetBlockBlobReference(blobFilename); await blob.DownloadToFileAsync(filePath, FileMode.Create, default(AccessCondition), default(BlobRequestOptions), default(OperationContext), progressHandler, token); } catch (Exception ex) { if (!(ex.InnerException is TaskCanceledException)) { error = ex; throw ex; } } finally { watch.Stop(); OnDownloadCompleted?.Invoke(this, new BlobCompleteEventArgs(containerName, blobFilename, token.IsCancellationRequested, error)); } }
private async Task ProcessDownloadAsync(Uri uri, string filename, CancellationToken ct) { try { dynamic request = null; #region Get file size if (uri.Scheme == Uri.UriSchemeHttp) { request = WebRequest.Create(uri) as HttpWebRequest; request !.Method = WebRequestMethods.Http.Head; } else if (uri.Scheme == Uri.UriSchemeFtp) { request = WebRequest.Create(uri) as FtpWebRequest; request !.Method = WebRequestMethods.Ftp.GetFileSize; } var metric = new DownloaderMetric { FileName = Path.GetFileName(filename) }; using (var response = await request !.GetResponseAsync()) { metric.TotalBytes = response.ContentLength; } #endregion // Set start download position long startPos = 0; var fi = new FileInfo(filename); if (fi.Exists) { if (metric.TotalBytes > fi.Length) { metric.DownloadedBytes = startPos = fi.Length - 1024; } else if (metric.TotalBytes == fi.Length) { return; } } #region Read Content Stream Asynchronously if (uri.Scheme == Uri.UriSchemeHttp) { request = WebRequest.Create(uri) as HttpWebRequest; request = (HttpWebRequest)request; request !.Method = WebRequestMethods.Http.Get; request.AddRange(startPos, metric.TotalBytes); } else if (uri.Scheme == Uri.UriSchemeFtp) { request = WebRequest.Create(uri) as FtpWebRequest; request !.Method = WebRequestMethods.Ftp.DownloadFile; request.ContentOffset = startPos; } var stopwatch = new Stopwatch(); stopwatch.Start(); if (!Directory.Exists(Path.GetDirectoryName(filename))) { Directory.CreateDirectory(Path.GetDirectoryName(filename) !); } var fileStream = new FileStream(filename, FileMode.OpenOrCreate, FileAccess.ReadWrite) { Position = metric.DownloadedBytes }; await Task.Run(async() => { if (ct.IsCancellationRequested) { return; } using var streamReader = new StreamReader((await request.GetResponseAsync()).GetResponseStream()); OnDownloadStart?.Invoke(metric); FromReaderToFile(streamReader, fileStream, ref metric, ref stopwatch, ct); OnDownloadCompleted?.Invoke(metric); }, ct); #endregion } catch (OperationCanceledException) { const string msg = "Download cancelled by user"; OnError?.Invoke(new DownloaderClientException(msg)); } catch (Exception ex) { const string msg = "An unexpected error occurred."; OnError?.Invoke( new DownloaderClientException($"{msg}\n\nDownload failed. See inner exception for details.", ex)); } }
public void Download(IRelease release, string cookie, string tempDir) { if (release == null) { throw new ArgumentNullException(nameof(release)); } if (string.IsNullOrWhiteSpace(cookie)) { throw new ArgumentNullException(nameof(cookie)); } if (release.DefaultDistribution == null) { throw new InvalidOperationException("Release contains no valid default distribution"); } var url = new Uri(release.DefaultDistribution.Downloads.First(x => x.StartsWith("http"))); var filename = release.DefaultDistribution.FileNames.First(x => x.EndsWith("zip")); var filepath = Path.Combine(tempDir, filename); if (File.Exists(filepath)) { // Release has already been downloaded previously; just report back with the filepath OnDownloadCompleted?.Invoke(new DownloadResult(filepath, release)); return; } if (!Directory.Exists(tempDir)) { Directory.CreateDirectory(tempDir); } var downloadOptions = new DownloadOptions { Uri = url, BlockOptions = new BlocksCount(1), Cookies = cookie, FilePath = filepath, RequestTimeout = new TimeSpan(0, 24, 0, 0) }; var context = new DownloadContext(downloadOptions); if (OnProgressChanged != null) { context.OnProgressChanged += OnProgressChanged; } if (OnDownloadCompleted != null) { context.OnDownloadCompleted += () => { OnDownloadCompleted?.Invoke(new DownloadResult(filepath, release)); }; } if (OnErrorOccurred != null) { context.OnErrorOccurred += OnErrorOccurred; } context.Download(); }
//Obsluhuje čtení dat ze serveru a zápis na disk. Běží v samostatném vlákně. private void DownloadWorker() { HttpWebResponse response = null; Stream receiveStream = null; try { HttpWebRequest request = WebRequest.CreateHttp(Url); request.Proxy = null; request.Timeout = requestTimeout; if (append) { if (File.Exists(FullPath)) { FileInfo file = new FileInfo(FullPath); BytesDownloaded = file.Length; } else { BytesDownloaded = 0; } } if (BytesDownloaded > 0) { request.AddRange(BytesDownloaded); } response = (HttpWebResponse)request.GetResponse(); //když je FileName prázdný, ještě nebyl získan název souboru ze serveru, jinak se použije stávající if (FileName == "") { string header = response.Headers["Content-Disposition"]; if (header != null) { string s = header.Replace("attachment; ", "").Replace("attachment;", "").Replace("filename=", "").Replace("filename*=UTF-8''", "").Replace("\"", ""); // z: form%c3%a1ln%c3%ad%20%c3%baprava%20podle%20norem.docx // na: formální úprava podle norem.docx FileName = WebUtility.UrlDecode(s); } else { Uri uri = new Uri(Url); FileName = Path.GetFileName(uri.LocalPath); } //pokud již existuje soubor se stejným jménem, přidá se číslo int i = 1; string baseName = FileName; while (File.Exists(FullPath) && i <= maxRenameCount) { FileName = $"{Path.GetFileNameWithoutExtension(baseName)} ({i}){Path.GetExtension(baseName)}"; i++; } if (File.Exists(FullPath)) //pokud existuje i 999. soubor, vyhodí se error { CallError(Lang.Translate("lang_file_exists")); return; } } receiveStream = response.GetResponseStream(); //když se navazuje stahování, ale celková velikost souboru se liší - soubor na serveru byl změněn, //nebo odkaz přestal platit if (append && TotalBytes > 0 && TotalBytes != BytesDownloaded + response.ContentLength) { CallError(Lang.Translate("lang_file_size_mismatch")); } else { System.IO.Directory.CreateDirectory(Directory); if (BytesDownloaded > 0) { fs = new FileStream(FullPath, FileMode.Append, FileAccess.Write, FileShare.Read); } else { fs = new FileStream(FullPath, FileMode.Create, FileAccess.Write, FileShare.Read); } TotalBytes = BytesDownloaded + response.ContentLength; operation.Post(new SendOrPostCallback(delegate(object state) { OnDownloadInit?.Invoke(this); }), null); byte[] buffer = new byte[bufferSize]; int receivedCount; while ((receivedCount = receiveStream.Read(buffer, 0, bufferSize)) > 0 && State != States.Canceled) //dokud není přečten celý stream { fs.Write(buffer, 0, receivedCount); BytesDownloaded += receivedCount; processed += receivedCount; while (State == States.Paused || State == States.Queue) { Thread.Sleep(pauseSleep); } if (State == States.Starting) { State = States.Downloading; } if (SpeedLimit > 0 && processed >= SpeedLimit) { Thread.Sleep(speedlimitSleep); } } } } catch (WebException e) //server neexistuje; errory 400, 500; { CallError(e.Message); } catch (ArgumentException e) { CallError(e.Message); } catch (IOException e) //k souboru nelze přistupovat { CallError(e.Message); } catch (Exception e) { CallError(e.Message); } finally { response?.Close(); receiveStream?.Close(); fs?.Close(); timer.Stop(); BytesPerSecond = 0; processed = 0; if (State == States.Canceled) { File.Delete(FullPath); } else if (BytesDownloaded == TotalBytes && TotalBytes > 0) { State = States.Completed; operation.Post(new SendOrPostCallback(delegate(object state) { OnDownloadCompleted?.Invoke(this); }), null); } else if (State != States.Error) { Console.WriteLine("restarting"); State = States.Starting; timer.Start(); DownloadWorker(); } } }