public async Task Run(IProgress<double> progress, CancellationToken cancellationToken) { var users = _userManager.Users .DistinctBy(ChannelDownloadScheduledTask.GetUserDistinctValue) .Select(i => i.Id.ToString("N")) .ToList(); var numComplete = 0; foreach (var user in users) { double percentPerUser = 1; percentPerUser /= users.Count; var startingPercent = numComplete * percentPerUser * 100; var innerProgress = new ActionableProgress<double>(); innerProgress.RegisterAction(p => progress.Report(startingPercent + (percentPerUser * p))); await DownloadContent(user, cancellationToken, innerProgress).ConfigureAwait(false); numComplete++; double percent = numComplete; percent /= users.Count; progress.Report(percent * 100); } progress.Report(100); }
protected override async Task FillDataTo(System.Net.WebRequest webrqst, CancellationToken cancellationToken, IProgress<ProgressReport> progress) { progress.ReportWhenNotNull(() => ProgressReport .CreateNew(RequestResponseSteps .Requesting_N_Uploading, 0, 1)); var qd = System.Text.Encoding.UTF8.GetBytes(JsonClientHelper.GetQueryData(RequestData.PostFieldValues)); webrqst.ContentType = "application/x-www-form-urlencoded"; #if SILVERLIGHT_4||SILVERLIGHT_5||DOTNET45 webrqst.ContentLength = qd.Length; #endif var rqstStrm = await webrqst.GetRequestStreamAsync().ConfigureAwait(false); await rqstStrm.WriteAsync(qd, 0, qd.Length).ConfigureAwait(false); progress.ReportWhenNotNull(() => ProgressReport .CreateNew(RequestResponseSteps .Requesting_N_Uploading, 1, 1)); }
/// <inheritdoc/> public async Task<Uri> UploadMessageAsync(Stream content, DateTime expirationUtc, string contentType, string contentEncoding, IProgress<int> bytesCopiedProgress, CancellationToken cancellationToken = default(CancellationToken)) { Requires.NotNull(content, "content"); Requires.Range(expirationUtc > DateTime.UtcNow, "expirationUtc"); string blobName = Utilities.CreateRandomWebSafeName(DesktopUtilities.BlobNameLength); if (expirationUtc < DateTime.MaxValue) { DateTime roundedUp = expirationUtc - expirationUtc.TimeOfDay + TimeSpan.FromDays(1); blobName = roundedUp.ToString("yyyy.MM.dd") + "/" + blobName; } var blob = this.container.GetBlockBlobReference(blobName); // Set metadata with the precise expiration time, although for efficiency we also put the blob into a directory // for efficient deletion based on approximate expiration date. if (expirationUtc < DateTime.MaxValue) { blob.Metadata["DeleteAfter"] = expirationUtc.ToString(CultureInfo.InvariantCulture); } blob.Properties.ContentType = contentType; blob.Properties.ContentEncoding = contentEncoding; await blob.UploadFromStreamAsync(content.ReadStreamWithProgress(bytesCopiedProgress), cancellationToken); return blob.Uri; }
async Task<string> LoadContents(IResourceNetworkLayer networkLayer, IProgress<float> progress, CancellationToken token) { var reset = _cancelTokenSource.AddToken(token); if (_pageContentLoadPack == null || reset) { lock(this) { if (_pageContentLoadPack == null || reset) { if (_originalUrl.Contains("&ajax=1")) _pageContentLoadPack = Tuple.Create(networkLayer.Get(_originalUrl, _cancelTokenSource.Token, progress, null, false), progress); else _pageContentLoadPack = Tuple.Create(networkLayer.Get(_originalUrl + "&ajax=1", token, progress, null, false), progress); } } } if (_pageContentLoadPack.Item2 != progress) { HttpClientUtility.NetworkLayer.JoinProgress(_pageContentLoadPack.Item2, progress); } try { return await _pageContentLoadPack.Item1; } finally { _cancelTokenSource.Clear(); } }
public Task Run(IProgress<double> progress, CancellationToken cancellationToken) { var items = _libraryManager.RootFolder.RecursiveChildren.ToList(); var boxsets = items.OfType<BoxSet>().ToList(); var numComplete = 0; foreach (var boxset in boxsets) { foreach (var child in boxset.Children.Concat(boxset.GetLinkedChildren()).OfType<ISupportsBoxSetGrouping>()) { var boxsetIdList = child.BoxSetIdList.ToList(); if (!boxsetIdList.Contains(boxset.Id)) { boxsetIdList.Add(boxset.Id); } child.BoxSetIdList = boxsetIdList; } numComplete++; double percent = numComplete; percent /= boxsets.Count; progress.Report(percent * 100); } progress.Report(100); return Task.FromResult(true); }
public async Task InstallPackage(IProgress<double> progress, PackageVersionInfo package, CancellationToken cancellationToken) { // Target based on if it is an archive or single assembly // zip archives are assumed to contain directory structures relative to our ProgramDataPath var isArchive = string.Equals(Path.GetExtension(package.targetFilename), ".zip", StringComparison.OrdinalIgnoreCase); var target = Path.Combine(isArchive ? _appPaths.TempUpdatePath : _appPaths.PluginsPath, package.targetFilename); // Download to temporary file so that, if interrupted, it won't destroy the existing installation var tempFile = await _httpClient.GetTempFile(new HttpRequestOptions { Url = package.sourceUrl, CancellationToken = cancellationToken, Progress = progress }).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); // Validate with a checksum if (package.checksum != Guid.Empty) // support for legacy uploads for now { using (var crypto = new MD5CryptoServiceProvider()) using (var stream = new BufferedStream(File.OpenRead(tempFile), 100000)) { var check = Guid.Parse(BitConverter.ToString(crypto.ComputeHash(stream)).Replace("-", String.Empty)); if (check != package.checksum) { throw new ApplicationException(string.Format("Download validation failed for {0}. Probably corrupted during transfer.", package.name)); } } } cancellationToken.ThrowIfCancellationRequested(); // Success - move it to the real target try { File.Copy(tempFile, target, true); //If it is an archive - write out a version file so we know what it is if (isArchive) { File.WriteAllText(target+".ver", package.versionStr); } } catch (IOException e) { _logger.ErrorException("Error attempting to move file from {0} to {1}", e, tempFile, target); throw; } try { File.Delete(tempFile); } catch (IOException e) { // Don't fail because of this _logger.ErrorException("Error deleting temp file {0]", e, tempFile); } }
/// <summary> /// Runs the specified progress. /// </summary> /// <param name="progress">The progress.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>Task.</returns> public async Task Run(IProgress<double> progress, CancellationToken cancellationToken) { var files = _libraryManager.GetAllIntroFiles().ToList(); var numComplete = 0; foreach (var file in files) { cancellationToken.ThrowIfCancellationRequested(); try { await RefreshIntro(file, cancellationToken).ConfigureAwait(false); } catch (OperationCanceledException) { throw; } catch (Exception ex) { _logger.ErrorException("Error refreshing intro {0}", ex, file); } numComplete++; double percent = numComplete; percent /= files.Count; progress.Report(percent * 100); } }
internal async Task Load_File(CancellationToken cancellation, IProgress<Tuple<string, int>> currentTaskAndPercentComplete) { if (UnsavedChangesPresent && !_window.Confirm_Discard_Changes()) return; var dialog = new OpenFileDialog { DefaultExt = DataFileExt, Filter = DataFileFilter }; if (dialog.ShowDialog() ?? false) { FileList = await FileAccess.LoadInfo(dialog.FileName, cancellation, currentTaskAndPercentComplete); if (cancellation.IsCancellationRequested) { return; } UnsavedChangesPresent = false; if (FileList.Any()) { FileIndex = 0; RectangleIndex = 0; RectangleHasFocus = false; await _window.Canvas.LoadImage(this, FileIndex); _window.Canvas.LoadRectangles(this, FileIndex); } } }
internal static Task<Report> CreateReport(string projectPath, CancellationToken cancellationToken, IProgress<string> progress, ICodeInspectSettings codeInspectSettings) { TaskCompletionSource<Report> completedTask = new TaskCompletionSource<Report>(); try { if (cancellationToken.IsCancellationRequested) { completedTask.TrySetCanceled(); return completedTask.Task; } if (projectPath.EndsWith("xml")) { completedTask.TrySetResult(CreateReportFromXml(projectPath)); } else { return CreateReportFromProject( codeInspectSettings.InspectCodePath, projectPath, Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location), DateTime.Now.Ticks + ".xml"), progress: progress); } } catch (Exception ex) { completedTask.TrySetException(ex); } return completedTask.Task; }
private async Task SyncInternal(ServerInfo server, IProgress<double> progress, CancellationToken cancellationToken) { _logger.Debug("Beginning ServerSync with server {0}, Id {1}", server.Name, server.Id); if (string.IsNullOrWhiteSpace(server.AccessToken) && string.IsNullOrWhiteSpace(server.ExchangeToken)) { _logger.Info("Skipping sync process for server " + server.Name + ". No server authentication information available."); progress.Report(100); return; } // Don't need these here var result = await _connectionManager.Connect(server, new ConnectionOptions { EnableWebSocket = false, ReportCapabilities = false, UpdateDateLastAccessed = false }, cancellationToken).ConfigureAwait(false); if (result.State == ConnectionState.SignedIn) { await SyncInternal(server, result.ApiClient, progress, cancellationToken).ConfigureAwait(false); progress.Report(100); } else { _logger.Info("Skipping sync process for server " + server.Name + ". ConnectionManager returned a state of {0}", result.State.ToString()); progress.Report(100); } }
private static async Task DownloadToCacheFileAsync(Uri uri, string fileName, IProgress<int> progress) { try { using (var client = new HttpClient()) { var request = new HttpRequestMessage(HttpMethod.Get, uri); var response = await client.SendAsync(request); response.EnsureSuccessStatusCode(); long length = response.Content.Headers.ContentLength ?? 0; using (var responseStream = await response.Content.ReadAsStreamAsync()) using (var fileStream = await CreateTempFileStreamAsync(fileName)) { IProgress<long> absoluteProgress = null; if (progress != null) { absoluteProgress = new Progress<long>(bytesCopied => { if (length > 0) progress.Report((int) (100*bytesCopied/length)); else progress.Report(-1); }); } await responseStream.CopyToAsync(fileStream, absoluteProgress); } } } catch { await DeleteTempFileAsync(fileName); throw; } }
/// <summary> /// Runs the specified progress. /// </summary> /// <param name="progress">The progress.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>Task.</returns> public async Task Run(IProgress<double> progress, CancellationToken cancellationToken) { var allSongs = _libraryManager.RootFolder .GetRecursiveChildren(i => !i.IsFolder && (i is IHasArtist)) .Cast<IHasArtist>() .ToList(); var allArtists = _libraryManager.GetArtists(allSongs).ToList(); var numComplete = 0; var numArtists = allArtists.Count; foreach (var artistItem in allArtists) { cancellationToken.ThrowIfCancellationRequested(); try { await artistItem.RefreshMetadata(cancellationToken).ConfigureAwait(false); } catch (IOException ex) { _logger.ErrorException("Error validating Artist {0}", ex, artistItem.Name); } // Update progress numComplete++; double percent = numComplete; percent /= numArtists; progress.Report(100 * percent); } }
public static IEnumerable<AnnotationRepository> CreateRepositoriesFromFolder(string folderPath, IProgress progress) { foreach (var path in GetChorusNotesFilePaths(folderPath)) { yield return AnnotationRepository.FromFile("id", path, progress); } }
private DataResult<IList<Employee>> LoadEmployees(CancellationToken token, IProgress<double> progress) { var employees = XDocument.Load(@"data\sampledata.xml") .Descendants("Employee") .Select(x => new Employee { Number = int.Parse(x.Descendants("Number").First().Value), Name = x.Descendants("Name").First().Value, Surname = x.Descendants("Surname").First().Value, Salary = double.Parse(x.Descendants("Salary").First().Value) }) .ToList(); var itemIndex = 0; var result = new DataResult<IList<Employee>> { Result = new List<Employee>() }; try { foreach (var employee in employees) { Thread.CurrentThread.Join(100); result.Result.Add(employee); token.ThrowIfCancellationRequested(); progress.Report((++itemIndex*100)/employees.Count); } } catch (OperationCanceledException ex) { result.Exception = ex; } return result; }
public virtual Task<string> Put(string key, Stream stream, IProgress<ProgressInBytes> progress = null, CancellationToken cancellation = default(CancellationToken)) { var bytes = new byte[stream.Length]; stream.Read(bytes, 0, (int)stream.Length); store.GetOrAdd(key, bytes); return Task.FromResult(key); }
public static void Decompress(Stream inStream, Stream outStream, IProgress<ProgressReport> progress) { byte[] properties = new byte[5]; if (inStream.Read(properties, 0, 5) != 5) throw (new Exception("input .lzma is too short")); SevenZip.Compression.LZMA.Decoder decoder = new SevenZip.Compression.LZMA.Decoder(); decoder.SetDecoderProperties(properties); long outSize = 0; for (int i = 0; i < 8; i++) { int v = inStream.ReadByte(); if (v < 0) throw (new Exception("Can't Read 1")); outSize |= ((long)(byte)v) << (8 * i); } long compressedSize = inStream.Length - inStream.Position; var lzmaProgress = new LzmaProgress(progress, "Decompressing", outSize, MeasureBy.Output); lzmaProgress.SetProgress(0, 0); decoder.Code(inStream, outStream, compressedSize, outSize, lzmaProgress); lzmaProgress.SetProgress(inStream.Length, outSize); }
internal static void PushHumptyOffTheWall(IProgress progress, bool writeVerbose, string mainFilePathname) { Guard.AgainstNull(progress, "progress"); FileWriterService.CheckFilename(mainFilePathname); var rootDirectoryName = Path.GetDirectoryName(mainFilePathname); // NB: This is strictly an ordered list of method calls. // Don't even 'think' of changing any of them. CheckForUserCancelRequested(progress); DeleteOldFiles(rootDirectoryName); CheckForUserCancelRequested(progress); WriteVersionFile(mainFilePathname); // Outer Dict has the class name for its key and a sorted (by guid) dictionary as its value. // The inner dictionary has a caseless guid as the key and the byte array as the value. // (Only has current concrete classes.) var classData = GenerateBasicClassData(); var wellUsedElements = new Dictionary<string, XElement> { {SharedConstants.LangProject, null}, {SharedConstants.LexDb, null} }; var guidToClassMapping = WriteOrCacheProperties(mainFilePathname, classData, wellUsedElements); CheckForUserCancelRequested(progress); BaseDomainServices.PushHumptyOffTheWall(progress, writeVerbose, rootDirectoryName, wellUsedElements, classData, guidToClassMapping); #if DEBUG // Enable ONLY for testing a round trip. // FLExProjectUnifier.PutHumptyTogetherAgain(progress, writeVerbose, mainFilePathname); #endif }
/// <summary> /// </summary> /// <param name="path"></param> /// <param name="progress"></param> /// <returns></returns> public Task<GenerationResult> Generate(string path, IProgress<ProgressResult> progress) { return Task.Run(() => { var db = Schema.Database; var content = Resources.selection_builder; var output = PathUtils.FilePath(path, db.PackageName, db.ProviderFolder + Constants.Util); content = string.Format(content, db.PackageName, db.ProviderFolder + Constants.Util); if (progress != null) { progress.Report(new ProgressResult { Name = this.GetType().Name, Value = 1 }); } return new GenerationResult{ Content = new List<string>{ content }, Path = new List<string>{ output + "SelectionBuilder.java" } }; }); }
/// <summary> /// Returns the task to be executed /// </summary> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="progress">The progress.</param> /// <returns>Task.</returns> public Task Execute(CancellationToken cancellationToken, IProgress<double> progress) { return Task.Run(() => { // Delete log files more than n days old var minDateModified = DateTime.UtcNow.AddDays(-(ConfigurationManager.CommonConfiguration.LogFileRetentionDays)); var filesToDelete = new DirectoryInfo(ConfigurationManager.CommonApplicationPaths.LogDirectoryPath).EnumerateFileSystemInfos("*", SearchOption.AllDirectories) .Where(f => f.LastWriteTimeUtc < minDateModified) .ToList(); var index = 0; foreach (var file in filesToDelete) { double percent = index; percent /= filesToDelete.Count; progress.Report(100 * percent); cancellationToken.ThrowIfCancellationRequested(); File.Delete(file.FullName); index++; } progress.Report(100); }); }
public LzmaProgress(IProgress<ProgressReport> progress, string phase, long totalSize, MeasureBy measureBy) { this.progress = progress; this.totalSize = totalSize; this.phase = phase; this.measureBy = measureBy; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Import a file containing translations for one or more lists. /// </summary> /// ------------------------------------------------------------------------------------ public bool ImportTranslatedLists(string filename, FdoCache cache, IProgress progress) { #if DEBUG DateTime dtBegin = DateTime.Now; #endif using (var inputStream = FileUtils.OpenStreamForRead(filename)) { var type = Path.GetExtension(filename).ToLowerInvariant(); if (type == ".zip") { using (var zipStream = new ZipInputStream(inputStream)) { var entry = zipStream.GetNextEntry(); // advances it to where we can read the one zipped file. using (var reader = new StreamReader(zipStream, Encoding.UTF8)) ImportTranslatedLists(reader, cache, progress); } } else { using (var reader = new StreamReader(inputStream, Encoding.UTF8)) ImportTranslatedLists(reader, cache, progress); } } #if DEBUG DateTime dtEnd = DateTime.Now; TimeSpan span = new TimeSpan(dtEnd.Ticks - dtBegin.Ticks); Debug.WriteLine(String.Format("Elapsed time for loading translated list(s) from {0} = {1}", filename, span.ToString())); #endif return true; }
public async Task<IEnumerable<Tuple<string, string>>> PlayableStreams(IResourceNetworkLayer networkLayer, IProgress<float> progress, System.Threading.CancellationToken cancelToken) { string gfyName = GetGfyName(_originalUrl); var jsonResult = await networkLayer.Get("http://gfycat.com/cajax/get/" + gfyName, cancelToken, progress, null, false); var gfyResult = JsonConvert.DeserializeObject<GfyResult>(jsonResult); return new List<Tuple<string, string>> { Tuple.Create(gfyResult.gfyItem.mp4Url, "MP4") }; }
/// <summary> /// Runs the specified progress. /// </summary> /// <param name="progress">The progress.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>Task.</returns> public async Task Run(IProgress<double> progress, CancellationToken cancellationToken) { var names = _itemRepo.GetMusicGenreNames(); var numComplete = 0; var count = names.Count; foreach (var name in names) { try { var item = _libraryManager.GetMusicGenre(name); await item.RefreshMetadata(cancellationToken).ConfigureAwait(false); } catch (OperationCanceledException) { // Don't clutter the log break; } catch (Exception ex) { _logger.ErrorException("Error refreshing {0}", ex, name); } numComplete++; double percent = numComplete; percent /= count; percent *= 100; progress.Report(percent); } progress.Report(100); }
public static bool TryMergeEntries(LexEntry entry1, LexEntry entry2, string[] traitsWithMultiplicity, IProgress progress) { if (!entry1.LexicalForm.CanBeUnifiedWith(entry2.LexicalForm)) { progress.WriteMessageWithColor("gray","Attempting to merge entries, but could not because their Lexical Forms clash in some writing system."); return false; } if (!SenseMerger.TryMergeProperties(entry1, entry2, traitsWithMultiplicity, "entries for "+entry1.ToString(), progress)) return false; // at this point, we're committed to doing the merge entry1.LexicalForm.MergeIn(entry2.LexicalForm); var senses = entry2.Senses.ToArray(); foreach (var sense in senses) { MergeOrAddSense(entry1, sense, traitsWithMultiplicity, progress); } if (entry2.ModificationTime > entry1.ModificationTime) { entry1.ModificationTime = entry2.ModificationTime; } entry1.IsDirty = true; return true; }
/// <summary> /// /// </summary> /// <param name="cancellationToken"></param> /// <param name="progress"></param> /// <returns></returns> public async Task Execute(CancellationToken cancellationToken, IProgress<double> progress) { var users = _userManager.Users.Where(u => UserHelper.GetTraktUser(u) != null).ToList(); // No point going further if we don't have users. if (users.Count == 0) { _logger.Info("No Users returned"); return; } // purely for progress reporting var percentPerUser = 100 / users.Count; double currentProgress = 0; var numComplete = 0; foreach (var user in users) { try { await SyncTraktDataForUser(user, currentProgress, cancellationToken, progress, percentPerUser).ConfigureAwait(false); numComplete++; currentProgress = percentPerUser * numComplete; progress.Report(currentProgress); } catch (Exception ex) { _logger.ErrorException("Error syncing trakt data for user {0}", ex, user.Name); } } }
private void ExtractImage(List<WriteableBitmap> tempTiles, BitmapSource image, int spacing, int offset, IProgress<ProgressDialogState> progress = null) { var sourceImage = BitmapFactory.ConvertToPbgra32Format(image); var jump = 16 + spacing; var totalTiles = ((image.PixelWidth - offset) / jump) * ((image.PixelHeight - offset) / jump); var currentTile = 0; for (var y = offset; y < image.PixelHeight; y += jump) { for (var x = offset; x < image.PixelWidth; x += jump) { var tileImage = new WriteableBitmap(16, 16, 96, 96, PixelFormats.Pbgra32, null); tileImage.Blit(new System.Windows.Rect(0, 0, 16, 16), sourceImage, new System.Windows.Rect(x, y, 16, 16)); tempTiles.Add(tileImage); currentTile++; if (progress != null) { progress.Report(new ProgressDialogState() { ProgressPercentage = currentTile * 100 / totalTiles, Description = string.Format("Extracting {0} / {1}", currentTile, totalTiles) }); } } } }
private void RunInternal(IProgress<double> progress, CancellationToken cancellationToken) { var allItems = _libraryManager.RootFolder .RecursiveChildren .ToList(); var musicAlbums = allItems .OfType<MusicAlbum>() .ToList(); AttachMovieSoundtracks(allItems, musicAlbums, cancellationToken); progress.Report(25); AttachTvSoundtracks(allItems, musicAlbums, cancellationToken); progress.Report(50); AttachGameSoundtracks(allItems, musicAlbums, cancellationToken); progress.Report(75); AttachAlbumLinks(allItems, musicAlbums, cancellationToken); progress.Report(100); }
public override IEnumerable<ISystemEntry> GetChildren(CancellationToken token, IProgress<double> progress) { return ProcessUtility.GetChildProcessIds(this.ProcessId) .WithCancellation(token) .Select(id => Process.GetProcessById(id)) .Select(proc => new ProcessSystemEntry(this, proc.Id.ToString(), proc)); }
public Task DoAsync(IProgress<int> Progress) { Progress.Report(1); Thread.Sleep(800); Progress.Report(95); return Task.FromResult<object>(null); }
public async Task ExportTexturesAsync(string textureDir, IProgress<string> progress = null, CancellationToken cancellation = default(CancellationToken)) { foreach (var texture in Textures.Values) { if (cancellation.IsCancellationRequested) return; progress?.Report(texture.Name); await FileUtils.WriteAllBytesAsync(Path.Combine(textureDir, texture.Name), TexturesData[texture.Name], cancellation); } }
public static Synchronizer FromProjectConfiguration(ProjectFolderConfiguration project, IProgress progress) { var hg = HgRepository.CreateOrUseExisting(project.FolderPath, progress); return(new Synchronizer(hg.PathToRepo, project, progress)); }
// Run the tournament async public Task RunAsync(int rounds, CrossTable crossTable, CancellationToken cancellationToken, IProgress <RunProgress> progress) { return(Task.Run(() => { int completedMatches = 0; int num = crossTable.Players.Count; crossTable.Scores.Clear(); int numGames = num * (num - 1) / 2; table = crossTable; completedMatches = 0; var roundMatchups = crossTable.NextRoundSchedule(); while (roundMatchups != null) { Parallel.For(0, roundMatchups.Count, n => { var match = roundMatchups[n]; cancellationToken.ThrowIfCancellationRequested(); var player1 = match.Item1; var player2 = match.Item2; if (player1 != null && player2 != null) { // check for bye var headTohead = PlayMatch(rounds, player1, player2); Interlocked.Increment(ref completedMatches); double completedRatio = completedMatches; completedRatio /= numGames; progress.Report(new RunProgress { RatioCompleted = completedRatio, HeadToHeadScore = headTohead }); } }); roundMatchups = crossTable.NextRoundSchedule(); } } )); }
private async Task <Tuple <ulong, bool> > GetUrlsAsync(IProgress <DownloadProgress> progress, CancellationToken ct, PauseToken pt) { var semaphoreSlim = new SemaphoreSlim(shellService.Settings.ParallelScans); var trackedTasks = new List <Task>(); var numberOfPostsCrawled = 0; var apiLimitHit = false; var completeGrab = true; ulong lastId = GetLastPostId(); await UpdateTotalPostCount(); int totalPosts = blog.Posts; ulong highestId = await GetHighestPostId(); foreach (int pageNumber in GetPageNumbers()) { await semaphoreSlim.WaitAsync(); if (!completeGrab) { break; } if (ct.IsCancellationRequested) { break; } if (pt.IsPaused) { pt.WaitWhilePausedWithResponseAsyc().Wait(); } trackedTasks.Add(new Func <Task>(async() => { try { XDocument document = await GetApiPageAsync(pageNumber); completeGrab = CheckPostAge(document, lastId); var tags = new List <string>(); if (!string.IsNullOrWhiteSpace(blog.Tags)) { tags = blog.Tags.Split(',').Select(x => x.Trim()).ToList(); } AddUrlsToDownloadList(document, tags); } catch (WebException webException) { if (webException.Message.Contains("429")) { // TODO: add retry logic? apiLimitHit = true; Logger.Error("TumblrDownloader:GetUrls:WebException {0}", webException); shellService.ShowError(webException, Resources.LimitExceeded, blog.Name); } } finally { semaphoreSlim.Release(); } numberOfPostsCrawled += blog.PageSize; UpdateProgressQueueInformation(progress, Resources.ProgressGetUrlLong, numberOfPostsCrawled, totalPosts); })()); } await Task.WhenAll(trackedTasks); producerConsumerCollection.CompleteAdding(); if (!ct.IsCancellationRequested && completeGrab) { UpdateBlogStats(); } return(new Tuple <ulong, bool>(highestId, apiLimitHit)); }
public bool Write(BinaryReader r, BinaryWriter w, TagData tag, IProgress <float> writeProgress = null) { bool result = true; // Constraint-check on non-supported values if (FieldCodeFixedLength > 0) { if (tag.Pictures != null) { foreach (PictureInfo picInfo in tag.Pictures) { if (PictureInfo.PIC_TYPE.Unsupported.Equals(picInfo.PicType) && (picInfo.TagType.Equals(getImplementedTagType()))) { if ((-1 == picInfo.NativePicCode) && (Utils.ProtectValue(picInfo.NativePicCodeStr).Length != FieldCodeFixedLength)) { throw new NotSupportedException("Field code fixed length is " + FieldCodeFixedLength + "; detected field '" + Utils.ProtectValue(picInfo.NativePicCodeStr) + "' is " + Utils.ProtectValue(picInfo.NativePicCodeStr).Length + " characters long and cannot be written"); } } } } foreach (MetaFieldInfo fieldInfo in tag.AdditionalFields) { if (fieldInfo.TagType.Equals(getImplementedTagType()) || MetaDataIOFactory.TAG_ANY == fieldInfo.TagType) { string fieldCode = Utils.ProtectValue(fieldInfo.NativeFieldCode); if (fieldCode.Length != FieldCodeFixedLength && !fieldCode.Contains("----")) // "----" = exception for MP4 extended fields (e.g. ----:com.apple.iTunes:CONDUCTOR) { throw new NotSupportedException("Field code fixed length is " + FieldCodeFixedLength + "; detected field '" + fieldCode + "' is " + fieldCode.Length + " characters long and cannot be written"); } } } } structureHelper.Clear(); tagData.Pictures.Clear(); // Read all the fields in the existing tag (including unsupported fields) ReadTagParams readTagParams = new ReadTagParams(true, true); readTagParams.PrepareForWriting = true; if (embedder != null && embedder.HasEmbeddedID3v2 > 0) { readTagParams.offset = embedder.HasEmbeddedID3v2; } this.read(r, readTagParams); if (embedder != null && getImplementedTagType() == MetaDataIOFactory.TAG_ID3V2) { structureHelper.Clear(); structureHelper.AddZone(embedder.Id3v2Zone); } // Give engine something to work with if the tag is really empty if (!tagExists && 0 == Zones.Count) { structureHelper.AddZone(0, 0); } TagData dataToWrite; dataToWrite = tagData; dataToWrite.IntegrateValues(tag); // Merge existing information + new tag information dataToWrite.Cleanup(); FileSurgeon surgeon = new FileSurgeon(structureHelper, embedder, getImplementedTagType(), getDefaultTagOffset(), writeProgress); result = surgeon.RewriteZones(w, new FileSurgeon.WriteDelegate(writeAdapter), Zones, dataToWrite, tagExists); // Update tag information without calling Read /* TODO - this implementation is too risky : * - if one of the writing operations fails, data is updated as if everything went right * - any picture slot with a markForDeletion flag is recorded as-is in the tag */ tagData = dataToWrite; return(result); }
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { LogVersionInformation(); await base.InitializeAsync(cancellationToken, progress); await InitializeLoggingAsync(); await GetServiceAsync(typeof(IUsageTracker)); // Avoid delays when there is ongoing UI activity. // See: https://github.com/github/VisualStudio/issues/1537 await JoinableTaskFactory.RunAsync(VsTaskRunContext.UIThreadNormalPriority, InitializeMenus); }
public TumblrSearchCrawler(IShellService shellService, CancellationToken ct, PauseToken pt, IProgress <DownloadProgress> progress, ICrawlerService crawlerService, IWebRequestFactory webRequestFactory, ISharedCookieService cookieService, IDownloader downloader, IPostQueue <TumblrPost> postQueue, IBlog blog) : base(shellService, ct, progress, webRequestFactory, cookieService, postQueue, blog) { this.downloader = downloader; this.pt = pt; }
/// <summary> /// The entry point for the extension. This is executed when the tool window is activated. /// </summary> protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken); await NewsWindowCommand.InitializeAsync(this); }
protected abstract Task <IReadOnlyCollection <TChild> > LoadChildrenAsync(IProgress <TChild> progress);
public MainAppContext(IAppSetting appSetting, IDnsManager dnsManager, IFileUpdater fileUpdater) { // Get config settings. _appSetting = appSetting; // Populate fields. _dnsManager = dnsManager; _fileUpdater = fileUpdater; // Subscribed to the application's exit event. Application.ApplicationExit += OnApplicationExit; // Make sure the 'Data' folder exists. if (!Directory.Exists(_appSetting.StorageInfo.Path)) { Directory.CreateDirectory(_appSetting.StorageInfo.Path); } // Construct the notification's context menu. var contextMenu = new ContextMenuStrip(); // Create menus for DNS entries. var tempUpdateDNSMenus = new List <ToolStripItem>(); foreach (Source source in _appSetting.Sources) { tempUpdateDNSMenus.Add(MenuBuilder.CreateMenu(source.Name).HookClickEvent(OnSetDNSMenuClicked)); } _updateDNSMenus = new ToolStripMenuItem[tempUpdateDNSMenus.Count]; tempUpdateDNSMenus.CopyTo(_updateDNSMenus); // Other essential menus. contextMenu.Items.AddRange(new ToolStripItem[] { MenuBuilder.CreateMenu($"DNS Resolver v{Application.ProductVersion}"), MenuBuilder.CreateMenu("Querying host file data..."), MenuBuilder.CreateMenu("DNS").AddManyChildMenu(_updateDNSMenus), MenuBuilder.CreateSeparator(), MenuBuilder.CreateMenu("Open Host File...").HookClickEvent(OnOpenHostFileMenuClicked), MenuBuilder.CreateSeparator(), MenuBuilder.CreateMenu("Reset DNS").HookClickEvent(OnDNSResetMenuClicked), MenuBuilder.CreateMenu("Clear Host File").HookClickEvent(OnHostFileResetMenuClicked), MenuBuilder.CreateSeparator(), MenuBuilder.CreateMenu("Exit").HookClickEvent(OnExitMenuClicked), }); contextMenu.Renderer = new CustomToolStripMenuRenderer(); // Make sure that the menu checked condition is refreshed everytime it is opening. contextMenu.Opening += OnNotifyIconContextMenuOpening; // Finally, the notification icon itself. _notifyIcon = new NotifyIcon { Icon = Resources.AppIcon, Text = Application.ProductName, Visible = true, ContextMenuStrip = contextMenu, BalloonTipIcon = ToolTipIcon.Info, BalloonTipTitle = Application.ProductName }; // Update the notify icon's text. UpdateNotifyIconText(); // Create menus for Host file data entries. _hostFileProgress = new Progress <ToolStripMenuItem[]>(HostFileMenusProgressHandler); Task.Run(() => ConstructHostFileContextMenu()); }
public override async Task ExecuteAsync(ReportRequest request, CancellationToken token, IProgress <OperationStatus> progress = null) { #region Reporting initialization if (request == null) { throw new ArgumentNullException(nameof(request)); } request = await StartRequestAsync(request); var criterion = await _serviceFacade.ReportCriterionRepository.GetByIdAsync(request.ReportCriteriaId) ?? throw new GraException($"Report criteria {request.ReportCriteriaId} for report request id {request.Id} could not be found."); if (criterion.SiteId == null) { throw new ArgumentNullException(nameof(criterion.SiteId)); } string title = ""; if (criterion.SystemId.HasValue) { title = (await _systemRepository.GetByIdAsync(criterion.SystemId.Value)).Name; } var report = new StoredReport { Title = title, AsOf = _serviceFacade.DateTimeProvider.Now }; var reportData = new List <object[]>(); #endregion Reporting initialization #region Collect data UpdateProgress(progress, 1, "Starting report...", request.Name); // header row report.HeaderRow = new object[] { criterion.SystemId.HasValue ? "System Name" : "Branch Name" }; var programs = await _programRepository.GetAllAsync(criterion.SiteId.Value); foreach (var program in programs) { report.HeaderRow = report.HeaderRow.Append(program.Name); } report.HeaderRow = report.HeaderRow.Append("Total"); int count = 0; var users = await _userRepository.GetUsersByCriterionAsync(criterion); if (criterion.SystemId.HasValue) { users = users.Where(_ => _.SystemId == criterion.SystemId); var branches = await _branchRepository.GetBySystemAsync(criterion.SystemId.Value); foreach (var branch in branches) { if (token.IsCancellationRequested) { break; } UpdateProgress(progress, ++count * 100 / branches.Count(), $"Processing: {branch.SystemName} - {branch.Name}", request.Name); var branchUsers = users.Where(_ => _.BranchId == branch.Id); IEnumerable <object> row = new object[] { branch.Name }; foreach (var program in programs) { row = row.Append(branchUsers.Where(_ => _.ProgramId == program.Id).Count()); } row = row.Append(branchUsers.Count()); reportData.Add(row.ToArray()); } } else { var systems = await _systemRepository.GetAllAsync(criterion.SiteId.Value); foreach (var system in systems) { if (token.IsCancellationRequested) { break; } UpdateProgress(progress, ++count * 100 / systems.Count(), $"Processing: {system.Name}", request.Name); var systemUsers = users.Where(_ => _.SystemId == system.Id); IEnumerable <object> row = new object[] { system.Name }; foreach (var program in programs) { row = row.Append(systemUsers.Where(_ => _.ProgramId == program.Id).Count()); } row = row.Append(systemUsers.Count()); reportData.Add(row.ToArray()); } } report.Data = reportData.ToArray(); IEnumerable <object> footerRow = new object[] { "Total" }; foreach (var program in programs) { footerRow = footerRow.Append(users.Where(_ => _.ProgramId == program.Id).Count()); } footerRow = footerRow.Append(users.Count()); report.FooterRow = footerRow.ToArray(); #endregion Collect data #region Finish up reporting _logger.LogInformation($"Report {GetType().Name} with criterion {criterion.Id} ran in {StopTimer()}"); request.Success = !token.IsCancellationRequested; if (request.Success == true) { ReportSet.Reports.Add(report); request.Finished = _serviceFacade.DateTimeProvider.Now; request.ResultJson = Newtonsoft.Json.JsonConvert.SerializeObject(ReportSet); } await _serviceFacade.ReportRequestRepository.UpdateSaveNoAuditAsync(request); #endregion Finish up reporting }
protected override Task ValidateChildrenInternal(IProgress <double> progress, System.Threading.CancellationToken cancellationToken, bool recursive, bool refreshChildMetadata, Providers.MetadataRefreshOptions refreshOptions, Providers.IDirectoryService directoryService) { return(Task.FromResult(true)); }
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { await base.InitializeAsync(cancellationToken, progress); var componentModel = await GetServiceAsync(typeof(SComponentModel)) as IComponentModel; _globalRunSettings = componentModel.GetService <IGlobalRunSettingsInternal>(); await this.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken); _generalOptions = (GeneralOptionsDialogPage)GetDialogPage(typeof(GeneralOptionsDialogPage)); _parallelizationOptions = (ParallelizationOptionsDialogPage)GetDialogPage(typeof(ParallelizationOptionsDialogPage)); _googleTestOptions = (GoogleTestOptionsDialogPage)GetDialogPage(typeof(GoogleTestOptionsDialogPage)); _globalRunSettings.RunSettings = GetRunSettingsFromOptionPages(); _generalOptions.PropertyChanged += OptionsChanged; _parallelizationOptions.PropertyChanged += OptionsChanged; _googleTestOptions.PropertyChanged += OptionsChanged; SwitchCatchExceptionsOptionCommand.Initialize(this); SwitchBreakOnFailureOptionCommand.Initialize(this); SwitchParallelExecutionOptionCommand.Initialize(this); SwitchPrintTestOutputOptionCommand.Initialize(this); DisplayReleaseNotesIfNecessary(); var logger = new ActivityLogLogger(this, () => _generalOptions.DebugMode); var debuggerAttacher = new VsDebuggerAttacher(this); _debuggerAttacherServiceHost = new DebuggerAttacherServiceHost(_debuggingNamedPipeId, debuggerAttacher, logger); try { _debuggerAttacherServiceHost.Open(); } catch (CommunicationException) { _debuggerAttacherServiceHost.Abort(); _debuggerAttacherServiceHost = null; } }
static IEnumerator AsObservableCore <T>(T asyncOperation, IObserver <T> observer, IProgress <float> reportProgress, CancellationToken cancel) where T : AsyncOperation { if (reportProgress != null) { while (!asyncOperation.isDone && !cancel.IsCancellationRequested) { try { reportProgress.Report(asyncOperation.progress); } catch (Exception ex) { observer.OnError(ex); yield break; } yield return(null); } } else { if (!asyncOperation.isDone) { yield return(asyncOperation); } } if (cancel.IsCancellationRequested) { yield break; } if (reportProgress != null) { try { reportProgress.Report(asyncOperation.progress); } catch (Exception ex) { observer.OnError(ex); yield break; } } observer.OnNext(asyncOperation); observer.OnCompleted(); }
/// <summary> /// Initialization of the package; this method is called right after the package is sited, so this is the place /// where you can put all the initialization code that rely on services provided by VisualStudio. /// </summary> /// <param name="cancellationToken">A cancellation token to monitor for initialization cancellation, which can occur when VS is shutting down.</param> /// <param name="progress">A provider for progress updates.</param> /// <returns>A task representing the async work of package initialization, or an already completed task if there is none. Do not return null from this method.</returns> protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { // When initialized asynchronously, the current thread may be a background thread at this point. // Do any initialization that requires the UI thread after switching to the UI thread. await this.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken); await MainCommand.InitializeAsync(this); }
public IErrorsInfo UpdateEntities(string EntityName, object UploadData, IProgress <PassedArgs> progress) { return(GetDataSourceObject(EntityName).UpdateEntities(EntityName, UploadData, progress)); }
public static void Unpack(this BXF3Reader bxf, string bhdName, string bdtName, string targetDir, IProgress <float> progress) { Directory.CreateDirectory(targetDir); var xws = new XmlWriterSettings(); xws.Indent = true; var xw = XmlWriter.Create($"{targetDir}\\_yabber-bxf3.xml", xws); xw.WriteStartElement("bxf3"); xw.WriteElementString("bhd_filename", bhdName); xw.WriteElementString("bdt_filename", bdtName); xw.WriteElementString("version", bxf.Version); xw.WriteElementString("format", bxf.Format.ToString()); xw.WriteElementString("bigendian", bxf.BigEndian.ToString()); xw.WriteElementString("bitbigendian", bxf.BitBigEndian.ToString()); YBinder.WriteBinderFiles(bxf, xw, targetDir, progress); xw.WriteEndElement(); xw.Close(); }
/// <summary> /// If you needs return value, use AsAsyncOperationObservable instead. /// </summary> public static IObservable <AsyncOperation> AsObservable(this AsyncOperation asyncOperation, IProgress <float> progress = null) { return(ObservableUnity.FromCoroutine <AsyncOperation>((observer, cancellation) => AsObservableCore(asyncOperation, observer, progress, cancellation))); }
// T: where T : AsyncOperation is ambigious with IObservable<T>.AsObservable public static IObservable <T> AsAsyncOperationObservable <T>(this T asyncOperation, IProgress <float> progress = null) where T : AsyncOperation { return(ObservableUnity.FromCoroutine <T>((observer, cancellation) => AsObservableCore(asyncOperation, observer, progress, cancellation))); }
/// <summary> /// Transfers a file from the source FTP Server to the destination FTP Server via the FXP protocol asynchronously. /// </summary> private async Task <bool> TransferFileFXPInternalAsync(string sourcePath, FtpClient remoteClient, string remotePath, bool createRemoteDir, FtpRemoteExists existsMode, IProgress <FtpProgress> progress, CancellationToken token, FtpProgress metaProgress) { FtpReply reply; long offset = 0; bool fileExists = false; long fileSize = 0; var ftpFxpSession = await OpenPassiveFXPConnectionAsync(remoteClient, progress != null, token); if (ftpFxpSession != null) { try { ftpFxpSession.SourceServer.ReadTimeout = (int)TimeSpan.FromMinutes(30.0).TotalMilliseconds; ftpFxpSession.TargetServer.ReadTimeout = (int)TimeSpan.FromMinutes(30.0).TotalMilliseconds; // check if the file exists, and skip, overwrite or append if (existsMode == FtpRemoteExists.ResumeNoCheck) { offset = await remoteClient.GetFileSizeAsync(remotePath, -1, token); if (offset == -1) { offset = 0; // start from the beginning } } else { fileExists = await remoteClient.FileExistsAsync(remotePath, token); switch (existsMode) { case FtpRemoteExists.Skip: if (fileExists) { LogStatus(FtpTraceLevel.Info, "Skipping file because Skip is enabled and file already exists (Source: " + sourcePath + ", Dest: " + remotePath + ")"); //Fix #413 - progress callback isn't called if the file has already been uploaded to the server //send progress reports if (progress != null) { progress.Report(new FtpProgress(100.0, 0, 0, TimeSpan.FromSeconds(0), sourcePath, remotePath, metaProgress)); } return(true); } break; case FtpRemoteExists.Overwrite: if (fileExists) { await remoteClient.DeleteFileAsync(remotePath, token); } break; case FtpRemoteExists.Resume: if (fileExists) { offset = await remoteClient.GetFileSizeAsync(remotePath, 0, token); } break; } } fileSize = await GetFileSizeAsync(sourcePath, -1, token); // ensure the remote dir exists .. only if the file does not already exist! if (createRemoteDir && !fileExists) { var dirname = remotePath.GetFtpDirectoryName(); if (!await remoteClient.DirectoryExistsAsync(dirname, token)) { await remoteClient.CreateDirectoryAsync(dirname, token); } } if (offset == 0 && existsMode != FtpRemoteExists.ResumeNoCheck) { // send command to tell the source server to 'send' the file to the destination server if (!(reply = await ftpFxpSession.SourceServer.ExecuteAsync($"RETR {sourcePath}", token)).Success) { throw new FtpCommandException(reply); } //Instruct destination server to store the file if (!(reply = await ftpFxpSession.TargetServer.ExecuteAsync($"STOR {remotePath}", token)).Success) { throw new FtpCommandException(reply); } } else { //tell source server to restart / resume if (!(reply = await ftpFxpSession.SourceServer.ExecuteAsync($"REST {offset}", token)).Success) { throw new FtpCommandException(reply); } // send command to tell the source server to 'send' the file to the destination server if (!(reply = await ftpFxpSession.SourceServer.ExecuteAsync($"RETR {sourcePath}", token)).Success) { throw new FtpCommandException(reply); } //Instruct destination server to append the file if (!(reply = await ftpFxpSession.TargetServer.ExecuteAsync($"APPE {remotePath}", token)).Success) { throw new FtpCommandException(reply); } } var transferStarted = DateTime.Now; long lastSize = 0; var sourceFXPTransferReply = ftpFxpSession.SourceServer.GetReplyAsync(token); var destinationFXPTransferReply = ftpFxpSession.TargetServer.GetReplyAsync(token); // while the transfer is not complete while (!sourceFXPTransferReply.IsCompleted || !destinationFXPTransferReply.IsCompleted) { // send progress reports every 1 second if (ftpFxpSession.ProgressServer != null) { // send progress reports if (progress != null && fileSize != -1) { offset = await ftpFxpSession.ProgressServer.GetFileSizeAsync(remotePath, -1, token); if (offset != -1 && lastSize <= offset) { long bytesProcessed = offset - lastSize; lastSize = offset; ReportProgress(progress, fileSize, offset, bytesProcessed, DateTime.Now - transferStarted, sourcePath, remotePath, metaProgress); } } } await Task.Delay(FXPProgressInterval, token); } FtpTrace.WriteLine(FtpTraceLevel.Info, $"FXP transfer of file {sourcePath} has completed"); await NoopAsync(token); await remoteClient.NoopAsync(token); ftpFxpSession.Dispose(); return(true); } // Fix: catch all exceptions and dispose off the FTP clients if one occurs catch (Exception ex) { ftpFxpSession.Dispose(); throw ex; } } else { FtpTrace.WriteLine(FtpTraceLevel.Error, "Failed to open FXP passive Connection"); return(false); } }
public IErrorsInfo UpdateEntities(string EntityName, object UploadData, IProgress <PassedArgs> progress) { throw new NotImplementedException(); }
/// <summary> /// Validate if all required output files exist /// </summary> /// <param name="basePath">Base filename and path to use for checking</param> /// <param name="system">KnownSystem type representing the media</param> /// <param name="type">MediaType type representing the media</param> /// <param name="progress">Optional result progress callback</param> /// <returns></returns> public override bool CheckAllOutputFilesExist(string basePath, KnownSystem?system, MediaType?type, IProgress <Result> progress = null) { string missingFiles = string.Empty; switch (type) { case MediaType.UMD: if (!File.Exists($"{basePath}_disc.txt")) { missingFiles += $";{basePath}_disc.txt"; } if (!File.Exists($"{basePath}_mainError.txt")) { missingFiles += $";{basePath}_mainError.txt"; } if (!File.Exists($"{basePath}_mainInfo.txt")) { missingFiles += $";{basePath}_mainInfo.txt"; } if (!File.Exists($"{basePath}_volDesc.txt")) { missingFiles += $";{basePath}_volDesc.txt"; } break; default: // Non-dumping commands will usually produce no output, so this is irrelevant return(true); } // Use the missing files list as an indicator if (string.IsNullOrEmpty(missingFiles)) { return(true); } else { progress?.Report(Result.Failure($"The following files were missing: {missingFiles.TrimStart(';')}")); return(false); } }
/// <summary> /// Transfer the specified file from the source FTP Server to the destination FTP Server asynchronously using the FXP protocol. /// High-level API that takes care of various edge cases internally. /// </summary> /// <param name="sourcePath">The full or relative path to the file on the source FTP Server</param> /// <param name="remoteClient">Valid FTP connection to the destination FTP Server</param> /// <param name="remotePath">The full or relative path to destination file on the remote FTP Server</param> /// <param name="createRemoteDir">Indicates if the folder should be created on the remote FTP Server</param> /// <param name="existsMode">If the file exists on disk, should we skip it, resume the download or restart the download?</param> /// <param name="verifyOptions">Sets if checksum verification is required for a successful download and what to do if it fails verification (See Remarks)</param> /// <param name="progress">Provide a callback to track download progress.</param> /// <param name="token">The token that can be used to cancel the entire process</param> /// Returns a FtpStatus indicating if the file was transfered. /// <remarks> /// If verification is enabled (All options other than <see cref="FtpVerify.None"/>) the hash will be checked against the server. If the server does not support /// any hash algorithm, then verification is ignored. If only <see cref="FtpVerify.OnlyChecksum"/> is set then the return of this method depends on both a successful /// upload & verification. Additionally, if any verify option is set and a retry is attempted then overwrite will automatically be set to true for subsequent attempts. /// </remarks> public async Task <FtpStatus> TransferFileAsync(string sourcePath, FtpClient remoteClient, string remotePath, bool createRemoteDir = false, FtpRemoteExists existsMode = FtpRemoteExists.Resume, FtpVerify verifyOptions = FtpVerify.None, IProgress <FtpProgress> progress = null, FtpProgress metaProgress = null, CancellationToken token = default(CancellationToken)) { sourcePath = sourcePath.GetFtpPath(); remotePath = remotePath.GetFtpPath(); LogFunc(nameof(TransferFileAsync), new object[] { sourcePath, remoteClient, remotePath, FXPDataType, createRemoteDir, existsMode, verifyOptions }); // verify input params VerifyTransferFileParams(sourcePath, remoteClient, remotePath, existsMode); // ensure source file exists if (!await FileExistsAsync(sourcePath, token)) { throw new FtpException("Source File " + sourcePath + " cannot be found or does not exists!"); } bool fxpSuccess; var verified = true; var attemptsLeft = verifyOptions.HasFlag(FtpVerify.Retry) ? m_retryAttempts : 1; do { fxpSuccess = await TransferFileFXPInternalAsync(sourcePath, remoteClient, remotePath, createRemoteDir, existsMode, progress, token, metaProgress is null?new FtpProgress(1, 0) : metaProgress); attemptsLeft--; // if verification is needed if (fxpSuccess && verifyOptions != FtpVerify.None) { verified = await VerifyFXPTransferAsync(sourcePath, remoteClient, remotePath, token); LogStatus(FtpTraceLevel.Info, "File Verification: " + (verified ? "PASS" : "FAIL")); if (!verified && attemptsLeft > 0) { LogStatus(FtpTraceLevel.Verbose, "Retrying due to failed verification." + (existsMode == FtpRemoteExists.Resume ? " Overwrite will occur." : "") + " " + attemptsLeft + " attempts remaining"); // Force overwrite if a retry is required existsMode = FtpRemoteExists.Overwrite; } } } while (!verified && attemptsLeft > 0); if (fxpSuccess && !verified && verifyOptions.HasFlag(FtpVerify.Delete)) { await remoteClient.DeleteFileAsync(remotePath, token); } if (fxpSuccess && !verified && verifyOptions.HasFlag(FtpVerify.Throw)) { throw new FtpException("Destination file checksum value does not match source file"); } return(fxpSuccess && verified ? FtpStatus.Success : FtpStatus.Failed); }
public async Task <ChatLog> GetChatLogAsync(AuthToken token, string channelId, DateTimeOffset?after = null, DateTimeOffset?before = null, IProgress <double>?progress = null) { // Get channel var channel = await GetChannelAsync(token, channelId); // Get the chat log return(await GetChatLogAsync(token, channel, after, before, progress)); }
/// <summary> /// CALCULO DE FATORIAL ASSINCRONO COM SUPORTE A CANCELAMENTO E BARRA DE PROGRESSO /// </summary> /// <param name="valorCliente">VALOR QUE USUARIO DIGITOU</param> /// <param name="cancellationToken">VERIFICA SE O CLIENTE CLICOU NO BOTÃO DE CANCELAR</param> /// <param name="progresso">USAMOS A INTERFACE DE PROGRESS PARA ENVIAR O REPORT DE ATUALIZAÇÃO</param> /// <returns>LISTA DE NUMEROS FATORIAIS</returns> internal static async Task <string> RetornaNumerosContadorAsyncCancelProgress(int valorCliente, CancellationToken cancellationToken, IProgress <int> progresso) { return(await Task.Run(() => { var retorno = new BigInteger(1); for (int i = 1; i < valorCliente; i++) { //CASO O CLIENTE SOLICITE O CANCELAMENTO EU //APRESENTO UMA EXCEPTION cancellationToken.ThrowIfCancellationRequested(); retorno *= i; //TAMBEM DEVO NOTIFICAR O CLIENTE CASO TENHA ALGUM PROGRESSO //A CADA 10 NOTIFICO A APLICAÇÃO QUE EXISTE UMA ATUALIZAÇÃO if (i % 10 == 0) { progresso.Report(i); } } return Convert.ToString(retorno); })); }
public ICacheChip <T> CreateCacheChip(string hashKey, DateTime?expTime = null, IProgress <int> progress = null) { if (this._cacheIndexs.ContainsKey(hashKey)) { return(_cacheIndexs[hashKey]); } else { ICacheChip <T> instance = new ServiceCacheChip <T>(this._cacheIndexs, hashKey, this._cacheFolder, expTime); this._cacheIndexs.Add(hashKey, instance); return(instance); } }
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken); var menuCommandService = (IMenuCommandService) await GetServiceAsync(typeof(IMenuCommandService)); // ReSharper disable ObjectCreationAsStatement new SetUtf8WithBomCommand(menuCommandService); var statusBar = new StatusBarProvider(Application.Current.MainWindow); DocumentInfoControl.AddTo(statusBar); Debug.WriteLine("* Init Harurow.One *"); }
public async ValueTask <IncomingResponseFrame> SendRequestAsync( OutgoingRequestFrame outgoingRequest, bool oneway, bool synchronous, IInvocationObserver?observer, IProgress <bool> progress, CancellationToken cancel) { cancel.ThrowIfCancellationRequested(); IChildInvocationObserver?childObserver = null; int requestId = 0; // The CollocatedRequestHandler is an internal object so it's safe to lock (this) as long as our // code doesn't use the collocated request handler as a lock. The lock here is useful to ensure // the protocol trace and observer call is output or called in the same order as the request ID // is allocated. lock (_mutex) { if (!oneway) { requestId = ++_requestId; } if (observer != null) { childObserver = observer.GetCollocatedObserver(_adapter, requestId, outgoingRequest.Size); childObserver?.Attach(); } if (_adapter.Communicator.TraceLevels.Protocol >= 1) { ProtocolTrace.TraceCollocatedFrame(_adapter.Communicator, (byte)Ice1Definitions.FrameType.Request, requestId, outgoingRequest); } } Task <OutgoingResponseFrame> task; if (_adapter.TaskScheduler != null || !synchronous || oneway || _reference.InvocationTimeout > 0) { // Don't invoke from the user thread if async or invocation timeout is set. We also don't dispatch // oneway from the user thread to match the non-collocated behavior where the oneway synchronous // request returns as soon as it's sent over the transport. task = Task.Factory.StartNew(() => { progress.Report(false); return(DispatchAsync(outgoingRequest, requestId, cancel)); }, cancel, TaskCreationOptions.None, _adapter.TaskScheduler ?? TaskScheduler.Default).Unwrap(); if (oneway) { childObserver?.Detach(); return(IncomingResponseFrame.WithVoidReturnValue(outgoingRequest.Protocol, outgoingRequest.Encoding)); } } else // Optimization: directly call DispatchAsync { Debug.Assert(!oneway); progress.Report(false); task = DispatchAsync(outgoingRequest, requestId, cancel); } try { OutgoingResponseFrame outgoingResponseFrame = await task.WaitAsync(cancel).ConfigureAwait(false); var incomingResponseFrame = new IncomingResponseFrame( outgoingRequest.Protocol, VectoredBufferExtensions.ToArray(outgoingResponseFrame.Data)); if (_adapter.Communicator.TraceLevels.Protocol >= 1) { ProtocolTrace.TraceCollocatedFrame(_adapter.Communicator, (byte)Ice1Definitions.FrameType.Reply, requestId, incomingResponseFrame); } childObserver?.Reply(incomingResponseFrame.Size); return(incomingResponseFrame); } catch (Exception ex) { childObserver?.Failed(ex.GetType().FullName ?? "System.Exception"); throw; } finally { childObserver?.Detach(); } }
public Synchronizer(string localRepositoryPath, ProjectFolderConfiguration project, IProgress progress) { _progress = progress; _project = project; _localRepositoryPath = localRepositoryPath; _handlers = ChorusFileTypeHandlerCollection.CreateWithInstalledHandlers(); ExtraRepositorySources = new List <RepositoryAddress>(); ExtraRepositorySources.Add(RepositoryAddress.Create(RepositoryAddress.HardWiredSources.UsbKey, "USB flash drive", false)); }
public async Task <ChatLog> GetChatLogAsync(AuthToken token, Channel channel, DateTimeOffset?after = null, DateTimeOffset?before = null, IProgress <double>?progress = null) { // Get guild var guild = !string.IsNullOrWhiteSpace(channel.GuildId) ? await GetGuildAsync(token, channel.GuildId) : Guild.DirectMessages; // Get the chat log return(await GetChatLogAsync(token, guild, channel, after, before, progress)); }
public static async Task <IReadOnlyList <ExecutedQuery> > ExecuteQueriesAsync(this QueryService queryService, IReadOnlyList <Query> queries, IProgress <double> progress = null) { var result = new List <ExecutedQuery>(queries.Count); for (var i = 0; i < queries.Count; i++) { var executedQuery = await queryService.ExecuteQueryAsync(queries[i]); result.Add(executedQuery); progress?.Report((i + 1.0) / queries.Count); } return(result); }