/// <summary> /// Parse Flux CSV response to <see cref="IFluxResponseConsumer"/>. /// </summary> /// <param name="source">CSV Data source</param> /// <param name="cancellable">to cancel parsing</param> /// <param name="consumer">to accept <see cref="FluxTable"/> or <see cref="FluxRecord"/></param> public void ParseFluxResponse(Stream source, ICancellable cancellable, IFluxResponseConsumer consumer) { Arguments.CheckNotNull(source, "source"); using var csv = new CsvReader(new StreamReader(source), CultureInfo.InvariantCulture); var state = new ParseFluxResponseState { csv = csv }; while (csv.Read()) { if (cancellable != null && cancellable.IsCancelled()) { return; } foreach (var(table, record) in ParseNextFluxResponse(state)) { if (record == null) { consumer.Accept(state.tableIndex, cancellable, table); } else { consumer.Accept(state.tableIndex - 1, cancellable, record); } } } }
void cancellable_item_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e) { ICancellable worker = (ICancellable)sender; worker.Completed -= new System.ComponentModel.RunWorkerCompletedEventHandler(cancellable_item_RunWorkerCompleted); cancellables.Remove(worker); }
void ShowTextInfoThreadProc(ICancellable cnc) { UITaskHelper.BeginInvoke(this, () => { var td = ucText.GetTextData(GetEolOption( )); if (cnc.IsCancellationRequested) { return; } lblTextInfo.Visibility = lblTextInfo.Visibility == Visibility.Visible || td.Text.Length != 0 ? Visibility.Visible : Visibility.Collapsed; if (lblTextInfo.Visibility == Visibility.Visible) { int text_elements = td.LengthInTextElements; string s = $"(Length: {td.Text.Length:#,##0}"; if (text_elements != td.Text.Length) { s += $", Text Elements: {text_elements:#,##0}"; } if (ucTextHadFocus) { s += $", Index: {td.SelectionStart:#,##0}"; } s += ")"; lblTextInfo.Text = s; } }); }
public static RSSFile Download(string url, ProgressDelegate listener, ICancellable cancelObject) { try { Logger.Log("Downloading RSS file from {0}", url); var request = HttpWebRequest.Create(url); request.Timeout = 15000; using (var response = request.GetResponse()) { using (var stream = new ProgressStream(response.GetResponseStream(), response.ContentLength, listener, cancelObject)) { try { return(new RSSFile(stream)); } finally { stream.Close(); } } } } catch (Exception e) { Logger.Log("Caught exception: {0}", e.ToString()); return(null); } }
private static T CallEventAction <T>(T data, EventHandler.EventPriority priority, EventHandlerContainer hc) { ICancellable cancellable = null; if (data.GetType().GetInterfaces().Contains(typeof(ICancellable))) { cancellable = (ICancellable)data; } var listners = new List <IEventListener>(hc.Handlers[priority].Keys); foreach (var listener in listners) { if (cancellable != null && cancellable.Cancelled) { return(data); } try { hc.Handlers[priority][listener].Invoke(listener, new object[] { data }); } catch (TargetInvocationException) { Call(new EventLogging("Invoke Exception for: " + data.GetType().Name)); } } return(data); }
public ServerRequestResponseChannelActor( IRequestChannelConsumerProvider provider, int port, string name, int processorPoolSize, int maxBufferPoolSize, int maxMessageSize, long probeInterval, long probeTimeout) { _name = name; _port = port; var requestBufferPool = new ConsumerByteBufferPool(ElasticResourcePool <IConsumerByteBuffer, string> .Config.Of(maxBufferPoolSize), maxMessageSize); _processors = StartProcessors(provider, name, processorPoolSize, requestBufferPool, probeInterval, probeTimeout); try { Logger.Info($"{GetType().Name}: OPENING PORT: {port}"); _channel = new Socket(SocketType.Stream, ProtocolType.Tcp); _channel.Bind(new IPEndPoint(IPAddress.Any, port)); _channel.Listen(120); } catch (Exception e) { Logger.Error($"Failure opening socket because: {e.Message}", e); throw; } _cancellable = Stage.Scheduler.Schedule(SelfAs <IScheduled <object?> >(), null, TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(probeInterval)); }
public static RSSFile Download(string url, ProgressDelegate listener, ICancellable cancelObject) { try { var request = HttpWebRequest.Create(url); request.Timeout = 15000; using (var response = request.GetResponse()) { using (var stream = new ProgressStream(response.GetResponseStream(), response.ContentLength, listener, cancelObject)) { try { return(new RSSFile(stream)); } finally { stream.Close(); } } } } catch (IOException) { return(null); } catch (WebException) { return(null); } }
internal static string GetVersion(ICancellable cnc) { string stdout_contents; string stderr_contents; string version; if (!ProcessUtilities.InvokeExe(cnc, GetClientExePath( ), "v", "", out stdout_contents, out stderr_contents, EncodingEnum.UTF8) || !string.IsNullOrWhiteSpace(stderr_contents) || string.IsNullOrWhiteSpace(stdout_contents)) { version = "Unknown version"; } else { try { var v = JsonSerializer.Deserialize <ResponseVersion>(stdout_contents); version = v.Version; } catch (Exception) { if (Debugger.IsAttached) { Debugger.Break( ); } version = "Unknown version"; } } return(version); }
public static string GetIcuVersion(ICancellable cnc) { MemoryStream stdout_contents; string stderr_contents; Action <Stream> stdinWriter = s => { using (var bw = new BinaryWriter(s, Encoding.Unicode, leaveOpen: false)) { bw.Write("v"); } }; if (!ProcessUtilities.InvokeExe(cnc, GetIcuClientExePath( ), null, stdinWriter, out stdout_contents, out stderr_contents, EncodingEnum.Unicode)) { return("Unknown version"); } using (var br = new BinaryReader(stdout_contents, Encoding.Unicode)) { string version = br.ReadString( ); return(version); } }
void LocalUnderliningThreadProc(ICancellable cnc) { List <Info> infos = null; bool is_focused = true; ChangeEventHelper.Invoke(CancellationToken.None, () => { infos = GetUnderliningInfos(cnc); is_focused = rtbMatches.IsFocused; }); if (cnc.IsCancellationRequested) { return; } var inlines_to_underline = new List <Inline>( ); if (is_focused) { foreach (var info in infos) { if (cnc.IsCancellationRequested) { break; } switch (info) { case MatchInfo mi: inlines_to_underline.Add(mi.ValueInline); break; case GroupInfo gi: if (gi.IsSuccess) { inlines_to_underline.Add(gi.ValueInline); } break; case CaptureInfo ci: inlines_to_underline.Add(ci.ValueInline); break; } } } if (cnc.IsCancellationRequested) { return; } ChangeEventHelper.Invoke(CancellationToken.None, () => { LocalUnderliningAdorner.SetRangesToUnderline( inlines_to_underline .Select(i => (i.ContentStart, i.ContentEnd)) .ToList( )); });
internal void CancelTimer() { if (cancellable != null) { cancellable.Cancel(); cancellable = null; } }
public virtual void StartTimer(TimeSpan timeout) { if (timeout.TotalMilliseconds > 0 && scheduler != null) { // 2ms delayBefore prevents timeout until after return from here cancellable = scheduler.ScheduleOnce(this, null, TimeSpan.FromMilliseconds(2), timeout); } }
public void disableInterface(ICancellable cancellable_item) { cancellables.Add(cancellable_item); cancellable_item.Completed += new System.ComponentModel.RunWorkerCompletedEventHandler(cancellable_item_RunWorkerCompleted); Translator.WPF.TranslationHelpers.translate(CancelButton.Label, "Stop"); setInterfaceEnabledness(false); ProgressHandler.saveMessage(); }
private void ClearTimer() { if (cancellable != null) { cancellable.Cancel(); cancellable = null; } }
public void CancelTimer() { if (cancellable != null) { cancellable.Cancel(); cancellable = null; } }
public void HighlightPattern(ICancellable cnc, Highlights highlights, string pattern, int selectionStart, int selectionEnd, Segment visibleSegment) { int par_size = 1; int bracket_size = 1; Regex regex = GetCachedHighlightingRegex( ); HighlightHelper.CommonHighlighting(cnc, highlights, pattern, selectionStart, selectionEnd, visibleSegment, regex, par_size, bracket_size); }
public RequestSenderProbeActor(Client.Configuration configuration, IResponseChannelConsumer consumer, string testId) { _channel = ClientConsumerCommons.ClientChannel(configuration, consumer, Logger); _cancellable = Stage.Scheduler.Schedule( SelfAs <IScheduled <object?> >(), null, TimeSpan.FromMilliseconds(1), TimeSpan.FromMilliseconds(configuration.ProbeInterval)); _buffer = new MemoryStream(configuration.WriteBufferSize); }
public static bool TryCancel(object target) { ICancellable cancellable = target as ICancellable; if (cancellable != null) { cancellable.Cancel(); return(true); } return(false); }
public void HighlightPattern(ICancellable cnc, Highlights highlights, string pattern, int selectionStart, int selectionEnd, Segment visibleSegment) { var helper = OptionsControl.CreateOnigurumaHelper( ); int par_size = helper.IsONIG_SYN_OP_ESC_LPAREN_SUBEXP ? 2 : 1; int bracket_size = 1; Regex regex = GetCachedHighlightingRegex(helper); HighlightHelper.CommonHighlighting(cnc, highlights, pattern, selectionStart, selectionEnd, visibleSegment, regex, par_size, bracket_size); }
public ProgressStream(Stream innerStream, long lengthHint, ProgressDelegate listener, ICancellable cancelObject) { m_innerStream = innerStream; m_listener = listener; m_cancelObject = cancelObject; m_length = lengthHint; m_position = 0; m_lastProgress = -1; EmitProgress(); }
public ProgressStream( Stream innerStream, long lengthHint, ProgressDelegate listener, ICancellable cancelObject ) { m_innerStream = innerStream; m_listener = listener; m_cancelObject = cancelObject; m_length = lengthHint; m_position = 0; m_lastProgress = -1; EmitProgress(); }
public SsePublisherActor(string streamName, Type feedClass, int feedPayload, int feedInterval, string feedDefaultId) { _feed = Stage.ActorFor <ISseFeed>(Definition.Has(feedClass, Definition.Parameters(streamName, feedPayload, feedDefaultId))); _subscribers = new Dictionary <string, SseSubscriber>(); _cancellable = Stage.Scheduler.Schedule( SelfAs <IScheduled <object?> >(), null, TimeSpan.FromMilliseconds(10), TimeSpan.FromMilliseconds(feedInterval)); Logger.Info($"SsePublisher started for: {streamName}"); }
//========================================= // Stoppable //========================================= public override void Stop() { if (_cancellable != null) { _cancellable.Cancel(); _cancellable = null; } _reader?.Close(); base.Stop(); }
private SingletonReentrantTask(ICancellable cancellable, string id) { this.Cancellable = cancellable; this.Cancellable.CancellationRequested += this.OnCancellationRequested; this.Instance = Instances.AddOrUpdate(id, new SingletonReentrantTaskContainer(id, this), (key, value) => { if (!value.Instances.Add(this)) { throw new InvalidOperationException(string.Format("Failed to register instance with id: {0}", id)); } return(value); }); }
public State( Client.Configuration configuration, IClientRequestResponseChannel channel, ResponseParser?parser, ICancellable probe, MemoryStream buffer) { Configuration = configuration; Channel = channel; Parser = parser; Probe = probe; Buffer = buffer; }
public DispatcherControlActor( IDispatcher <Dispatchable <TEntry, TState> > dispatcher, IDispatcherControlDelegate <TEntry, TState> @delegate, long checkConfirmationExpirationInterval, long confirmationExpiration) { _dispatcher = dispatcher; _delegate = @delegate; _checkConfirmationExpirationInterval = checkConfirmationExpirationInterval; _confirmationExpiration = confirmationExpiration; _cancellable = Scheduler.Schedule(this, null, TimeSpan.FromMilliseconds(DefaultRedispatchDelay), TimeSpan.FromMilliseconds(checkConfirmationExpirationInterval)); _dispatcher.ControlWith(this); }
public SocketChannelSelectionProcessorActor( IRequestChannelConsumerProvider provider, string name, int maxBufferPoolSize, int messageBufferSize, long probeInterval) { _provider = provider; _name = name; _messageBufferSize = messageBufferSize; _responder = SelfAs <IResponseSenderChannel <Socket> >(); _cancellable = Stage.Scheduler.Schedule(SelfAs <IScheduled <object> >(), null, TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(probeInterval)); }
protected void ParseFluxResponseToLines(Action <String> onResponse, ICancellable cancellable, Stream bufferedStream) { using (var sr = new StreamReader(bufferedStream)) { string line; while ((line = sr.ReadLine()) != null && !cancellable.IsCancelled()) { onResponse(line); } } }
public void HighlightPattern(ICancellable cnc, Highlights highlights, string pattern, int selectionStart, int selectionEnd, Segment visibleSegment) { GrammarEnum grammar = OptionsControl.GetGrammar( ); int par_size = 1; int bracket_size = 1; if (grammar == GrammarEnum.basic || grammar == GrammarEnum.grep) { par_size = 2; } var regex = GetCachedHighlightingRegex(grammar); HighlightHelper.CommonHighlighting(cnc, highlights, pattern, selectionStart, selectionEnd, visibleSegment, regex, par_size, bracket_size); }
public SocketChannelSelectionProcessorActor( IRequestChannelConsumerProvider provider, string name, IResourcePool <IConsumerByteBuffer, string> requestBufferPool, long probeInterval, long probeTimeout) { _provider = provider; _name = name; _requestBufferPool = requestBufferPool; _probeTimeout = probeTimeout; _contexts = new List <Context>(); _responder = SelfAs <IResponseSenderChannel>(); _cancellable = Stage.Scheduler.Schedule(SelfAs <IScheduled <object?> >(), null, TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(probeInterval)); }
public void ColourisePattern(ICancellable cnc, ColouredSegments colouredSegments, string pattern, Segment visibleSegment) { Regex regex = ColouringRegex; foreach (Match m in regex.Matches(pattern)) { Debug.Assert(m.Success); if (cnc.IsCancellationRequested) { return; } // escapes, '\...' { var g = m.Groups["escape"]; if (g.Success) { if (cnc.IsCancellationRequested) { return; } foreach (Capture c in g.Captures) { if (cnc.IsCancellationRequested) { return; } var intersection = Segment.Intersection(visibleSegment, c.Index, c.Length); if (!intersection.IsEmpty) { colouredSegments.Escapes.Add(intersection); } } } } if (cnc.IsCancellationRequested) { return; } } }
public virtual void LoadThreadPageAsync(ThreadData thread, int pageNumber = 0, int postNumber = -1) { if (pageNumber < 0 || pageNumber > thread.MaxPages) { string error = string.Format("ThreadViewerViewModel: pageNumber {0} not in range 1 to {1}.", pageNumber, thread.MaxPages); Awful.Core.Event.Logger.AddEntry(error); Awful.Core.Event.Logger.AddEntry("Setting page index to 0 instead, to fetch last page..."); pageNumber = 0; } this.IsPageLoading = true; if (thread.ThreadTitle == null) { this.ThreadTitle = ((SAThread)thread).ThreadURL; } else { this.ThreadTitle = thread.ThreadTitle; } this.Posts = null; this._CurrentPage = pageNumber; this._TotalPages = thread.MaxPages; this._currentThreadData = thread; // else fetch page from cache SAThread saThread = thread as SAThread; SAThreadPage tPage = null; if (this.CurrentUserID == 0) { tPage = this.LoadFromDatabase(saThread, pageNumber); } if (tPage == null) { tPage = new SAThreadPage(saThread, pageNumber, this.CurrentUserID); this._Cancellable = SAThreadPageFactory.BuildAsync((result, page) => { postNumber = thread.LastViewedPostIndex; thread.LastViewedPageIndex = 0; thread.LastViewedPostIndex = -1; ThreadPool.QueueUserWorkItem(state => { this.HandleResult(result, page, postNumber); }, null); }, tPage); } else { ThreadPool.QueueUserWorkItem(state => { this.HandleResult(Awful.Core.Models.ActionResult.Success, tPage, postNumber); }, null); } }
public static bool InstallGame( string gameTitle, string gameVersion, ProgressDelegate listener, ICancellable cancelObject ) { var downloadPath = GetDownloadPath( gameTitle, gameVersion ); var installPath = GetInstallPath( gameTitle, gameVersion ); if( File.Exists( downloadPath ) ) { try { using( var zipFile = new ZipFile( downloadPath ) ) { // Delete old install if( Directory.Exists( installPath ) ) { Directory.Delete( installPath, true ); } Directory.CreateDirectory( installPath ); // Extract new install int totalFiles = zipFile.Entries.Count; int filesInstalled = 0; int lastProgress = 0; listener.Invoke( 0 ); foreach( var entry in zipFile.Entries ) { // Extract the file var entryInstallPath = Path.Combine( installPath, entry.FileName ); if( entry.IsDirectory ) { Directory.CreateDirectory( entryInstallPath ); } else { Directory.CreateDirectory( Path.GetDirectoryName( entryInstallPath ) ); using( var file = File.OpenWrite( entryInstallPath ) ) { try { using( var reader = new ProgressStream( entry.OpenReader(), -1, delegate { // TODO: Emit progress during installation of large individual files? }, cancelObject ) ) { try { reader.CopyTo( file ); if( Program.Platform == Platform.Linux || Program.Platform == Platform.OSX ) { Mono.Unix.Native.Syscall.chmod( entryInstallPath, Mono.Unix.Native.FilePermissions.ACCESSPERMS ); } } finally { reader.Close(); } } } finally { file.Close(); } } } // Check for cancellation if( cancelObject.Cancelled ) { throw new IOCancelledException(); } // Notify the progress listener filesInstalled++; int progress = (filesInstalled * 100) / totalFiles; if( progress != lastProgress ) { listener.Invoke( progress ); lastProgress = progress; } } } return true; } catch( IOException ) { if( Directory.Exists( installPath ) ) { Directory.Delete( installPath, true ); } return false; } catch( ZipException ) { if( Directory.Exists( installPath ) ) { Directory.Delete( installPath, true ); } return false; } } return false; }
public static bool DownloadGame( string gameTitle, string gameVersion, string url, string username, string password, ProgressDelegate listener, ICancellable cancelObject, out bool o_authFailure, out string o_customMessage ) { if( url == null ) { o_authFailure = false; o_customMessage = null; return false; } var downloadPath = GetDownloadPath( gameTitle, gameVersion ); try { var request = HttpWebRequest.Create( url ); request.Timeout = 15000; if( username != null && password != null ) { request.Credentials = new NetworkCredential( username, password ); } using( var response = request.GetResponse() ) { // Read the message o_customMessage = response.Headers.Get( "X-IndieLauncher-Message" ); // Read the content using( var stream = new ProgressStream( response.GetResponseStream(), response.ContentLength, listener, cancelObject ) ) { try { // Delete old download if( File.Exists( downloadPath ) ) { File.Delete( downloadPath ); } // Create new download Directory.CreateDirectory( Path.GetDirectoryName( downloadPath ) ); using( var output = File.OpenWrite( downloadPath ) ) { try { stream.CopyTo( output ); } finally { output.Close(); } } } finally { stream.Close(); } } } o_authFailure = false; return true; } catch( IOException ) { if( File.Exists( downloadPath ) ) { File.Delete( downloadPath ); } o_customMessage = null; o_authFailure = false; return false; } catch( WebException e ) { if( File.Exists( downloadPath ) ) { File.Delete( downloadPath ); } if( e.Response != null ) { o_customMessage = e.Response.Headers.Get( "X-IndieLauncher-Message" ); if( ((HttpWebResponse)e.Response).StatusCode == HttpStatusCode.Unauthorized ) { o_authFailure = true; } else { o_authFailure = false; } } else { o_customMessage = null; o_authFailure = false; } return false; } }
public static bool ExtractEmbeddedGame( ProgressDelegate listener, ICancellable cancelObject ) { string gameTitle, gameVersion, gameURL, username, password; if( GetEmbeddedGameInfo( out gameTitle, out gameVersion, out gameURL, out username, out password ) && gameVersion != null ) { var downloadPath = GetDownloadPath( gameTitle, gameVersion ); try { var assembly = Assembly.GetExecutingAssembly(); var stream = assembly.GetManifestResourceStream( "EmbeddedGame." + Program.Platform + ".zip" ); if( stream == null ) { stream = assembly.GetManifestResourceStream( "EmbeddedGame.zip" ); } if( stream != null ) { using( stream ) { try { using( var progressStream = new ProgressStream( stream, -1, listener, cancelObject ) ) { // Delete old download if( File.Exists( downloadPath ) ) { File.Delete( downloadPath ); } // Create new download try { Directory.CreateDirectory( Path.GetDirectoryName( downloadPath ) ); using( var output = File.OpenWrite( downloadPath ) ) { try { progressStream.CopyTo( output ); } finally { output.Close(); } } } finally { progressStream.Close(); } } } finally { stream.Close(); } } return true; } return false; } catch( IOException ) { if( File.Exists( downloadPath ) ) { File.Delete( downloadPath ); } return false; } } return false; }
public static RSSFile Download( string url, ProgressDelegate listener, ICancellable cancelObject ) { try { var request = HttpWebRequest.Create( url ); request.Timeout = 15000; using( var response = request.GetResponse() ) { using( var stream = new ProgressStream( response.GetResponseStream(), response.ContentLength, listener, cancelObject ) ) { try { return new RSSFile( stream ); } finally { stream.Close(); } } } } catch( IOException ) { return null; } catch( WebException ) { return null; } }
public void CancelAsync() { if (this._Cancellable != null) { this._Cancellable.Cancel(); this._Cancellable = null; } }
public virtual void ReloadCurrentPageAsync(ThreadData thread, int postNumber = -1) { this.IsPageLoading = true; this.ThreadTitle = thread.ThreadTitle; this.Posts = null; this._TotalPages = thread.MaxPages; this._reload = true; SAThread saThread = thread as SAThread; SAThreadPage tPage = new SAThreadPage(saThread, this._CurrentPage, this.CurrentUserID); this._Cancellable = SAThreadPageFactory.BuildAsync((result, page) => { postNumber = thread.LastViewedPostIndex; thread.LastViewedPageIndex = 0; thread.LastViewedPostIndex = -1; ThreadPool.QueueUserWorkItem(state => { this.HandleResult(result, page, postNumber); }, null); }, tPage); }
public static ITask WillCancel(this ITask task, ICancellable taskToCancel) { return new TaskCancel(task, taskToCancel); }