/// <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 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();
}
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);
}
