public void cant_abort_without_transaction_identifier()
{
var frame = new BasicFrame("ABORT");
var client = Substitute.For <IStompClient>();
var sut = new AbortHandler();
Action actual = () => sut.Process(client, frame);
actual.ShouldThrow <BadRequestException>();
}
private async void WebSocketOnClosed()
{
connection.Trace(TraceLevels.Events, "WS: OnClose()");
if (disconnectToken.IsCancellationRequested || AbortHandler.TryCompleteAbort())
{
return;
}
await DoReconnect().ConfigureAwait(false);
}
// virtual for testing
internal virtual void OnClose()
{
_connection.Trace(TraceLevels.Events, "WS: OnClose()");
// Make sure to try to fail start even if an abort has started.
var startFailed = TryFailStart(new IOException(Resources.Error_TransportDisconnectedBeforeConnectionFullyInitialized));
if (!AbortHandler.TryCompleteAbort() && !_disconnectToken.IsCancellationRequested && !startFailed)
{
DoReconnect();
}
}
public void abort_if_transaction_was_specified()
{
var frame = new BasicFrame("ABORT");
frame.Headers["transaction"] = "aa";
var client = Substitute.For <IStompClient>();
var sut = new AbortHandler();
sut.Process(client, frame);
client.Received().RollbackTransaction("aa");
}
private void WebsocketClosed(IWebSocket webSocket, WebSocketClosedEventArgs eventArgs)
{
_connection.Trace(TraceLevels.Events, "WS: WebsocketClosed - Code: {0}, Reason {1}", eventArgs.Code, eventArgs.Reason);
DisposeSocket();
if (AbortHandler.TryCompleteAbort() || _disconnectToken.IsCancellationRequested)
{
return;
}
Task.Run(() => Reconnect(_connection, _connectionData));
}
// virtual for testing
internal virtual void OnClose()
{
_connection.Trace(TraceLevels.Events, "WS: OnClose()");
if (_disconnectToken.IsCancellationRequested)
{
return;
}
if (AbortHandler.TryCompleteAbort())
{
return;
}
DoReconnect();
}
private Task OnAfterPoll(Exception exception)
{
if (AbortHandler.TryCompleteAbort())
{
// Abort() was called, so don't reconnect
StopPolling();
}
else
{
_reconnectInvoker = new ThreadSafeInvoker();
if (exception != null)
{
// Delay polling by the error delay
return(TaskAsyncHelper.Delay(ErrorDelay));
}
}
return(TaskAsyncHelper.Empty);
}
/// <summary>
/// Fully stops the polling loop.
/// </summary>
private void StopPolling()
{
lock (_stopLock)
{
if (Interlocked.Exchange(ref _running, 0) == 1)
{
_disconnectRegistration.Dispose();
// Complete any ongoing calls to Abort()
// If someone calls Abort() later, have it no-op
AbortHandler.CompleteAbort();
if (_currentRequest != null)
{
// This will no-op if the request is already finished
_currentRequest.Abort();
}
}
}
}
private void PollingSetup(IConnection connection,
string data,
CancellationToken disconnectToken,
PollingRequestHandler requestHandler,
Action onInitialized)
{
// reconnectInvoker is created new on each poll
var reconnectInvoker = new ThreadSafeInvoker();
var disconnectRegistration = disconnectToken.SafeRegister(state =>
{
reconnectInvoker.Invoke();
requestHandler.Stop();
}, null);
requestHandler.ResolveUrl = () =>
{
var url = connection.Url;
if (connection.MessageId == null)
{
url += "connect";
connection.Trace(TraceLevels.Events, "LP Connect: {0}", url);
}
else if (IsReconnecting(connection))
{
url += "reconnect";
connection.Trace(TraceLevels.Events, "LP Reconnect: {0}", url);
}
else
{
url += "poll";
connection.Trace(TraceLevels.Events, "LP Poll: {0}", url);
}
url += GetReceiveQueryString(connection, data);
return(url);
};
requestHandler.PrepareRequest += req =>
{
connection.PrepareRequest(req);
};
requestHandler.OnMessage += message =>
{
var shouldReconnect = false;
var disconnectedReceived = false;
connection.Trace(TraceLevels.Messages, "LP: OnMessage({0})", message);
TransportHelper.ProcessResponse(connection,
message,
out shouldReconnect,
out disconnectedReceived,
onInitialized);
if (IsReconnecting(connection))
{
// If the timeout for the reconnect hasn't fired as yet just fire the
// event here before any incoming messages are processed
TryReconnect(connection, reconnectInvoker);
}
if (shouldReconnect)
{
// Transition into reconnecting state
connection.EnsureReconnecting();
}
if (disconnectedReceived)
{
connection.Trace(TraceLevels.Messages, "Disconnect command received from server.");
connection.Disconnect();
}
};
requestHandler.OnError += exception =>
{
reconnectInvoker.Invoke();
if (!TransportHelper.VerifyLastActive(connection))
{
return;
}
// Transition into reconnecting state
connection.EnsureReconnecting();
// Sometimes a connection might have been closed by the server before we get to write anything
// so just try again and raise OnError.
if (!ExceptionHelper.IsRequestAborted(exception) && !(exception is IOException))
{
connection.OnError(exception);
}
else
{
requestHandler.Stop();
}
};
requestHandler.OnPolling += () =>
{
// Capture the cleanup within a closure so it can persist through multiple requests
TryDelayedReconnect(connection, reconnectInvoker);
};
requestHandler.OnAfterPoll = exception =>
{
if (AbortHandler.TryCompleteAbort())
{
// Abort() was called, so don't reconnect
requestHandler.Stop();
}
else
{
reconnectInvoker = new ThreadSafeInvoker();
if (exception != null)
{
// Delay polling by the error delay
return(TaskAsyncHelper.Delay(ErrorDelay));
}
}
return(TaskAsyncHelper.Empty);
};
requestHandler.OnAbort += _ =>
{
disconnectRegistration.Dispose();
// Complete any ongoing calls to Abort()
// If someone calls Abort() later, have it no-op
AbortHandler.CompleteAbort();
};
}
public virtual void Abort(IConnection connection, TimeSpan timeout, string connectionData)
{
_finished = true;
AbortHandler.Abort(connection, timeout, connectionData);
}
private void OpenConnection(IConnection connection,
string data,
CancellationToken disconnectToken,
Action initializeCallback,
Action <Exception> errorCallback)
{
// If we're reconnecting add /connect to the url
bool reconnecting = initializeCallback == null;
var callbackInvoker = new ThreadSafeInvoker();
var requestDisposer = new Disposer();
Action initializeInvoke = () =>
{
callbackInvoker.Invoke(initializeCallback);
};
var url = connection.Url + (reconnecting ? "reconnect" : "connect") + GetReceiveQueryString(connection, data);
connection.Trace(TraceLevels.Events, "SSE: GET {0}", url);
HttpClient.Get(url, req =>
{
_request = req;
_request.Accept = "text/event-stream";
connection.PrepareRequest(_request);
}, isLongRunning: true).ContinueWith(task =>
{
if (task.IsFaulted || task.IsCanceled)
{
Exception exception;
if (task.IsCanceled)
{
exception = new OperationCanceledException(Resources.Error_TaskCancelledException);
}
else
{
exception = task.Exception.Unwrap();
}
if (errorCallback != null)
{
callbackInvoker.Invoke((cb, ex) => cb(ex), errorCallback, exception);
}
else if (!_stop && reconnecting)
{
// Only raise the error event if we failed to reconnect
connection.OnError(exception);
Reconnect(connection, data, disconnectToken);
}
requestDisposer.Dispose();
}
else
{
// If the disconnect token is canceled the response to the task doesn't matter.
if (disconnectToken.IsCancellationRequested)
{
return;
}
var response = task.Result;
Stream stream = response.GetStream();
var eventSource = new EventSourceStreamReader(connection, stream);
var esCancellationRegistration = disconnectToken.SafeRegister(state =>
{
_stop = true;
((IRequest)state).Abort();
},
_request);
eventSource.Opened = () =>
{
// This will noop if we're not in the reconnecting state
if (connection.ChangeState(ConnectionState.Reconnecting, ConnectionState.Connected))
{
// Raise the reconnect event if the connection comes back up
connection.OnReconnected();
}
};
eventSource.Message = sseEvent =>
{
if (sseEvent.EventType == EventType.Data)
{
if (sseEvent.Data.Equals("initialized", StringComparison.OrdinalIgnoreCase))
{
return;
}
bool shouldReconnect;
bool disconnected;
TransportHelper.ProcessResponse(connection, sseEvent.Data, out shouldReconnect, out disconnected, initializeInvoke);
if (disconnected)
{
_stop = true;
connection.Disconnect();
}
}
};
eventSource.Closed = exception =>
{
if (exception != null)
{
// Check if the request is aborted
bool isRequestAborted = ExceptionHelper.IsRequestAborted(exception);
if (!isRequestAborted)
{
// Don't raise exceptions if the request was aborted (connection was stopped).
connection.OnError(exception);
}
}
requestDisposer.Dispose();
esCancellationRegistration.Dispose();
response.Dispose();
if (_stop)
{
AbortHandler.CompleteAbort();
}
else if (AbortHandler.TryCompleteAbort())
{
// Abort() was called, so don't reconnect
}
else
{
Reconnect(connection, data, disconnectToken);
}
};
eventSource.Start();
}
});
var requestCancellationRegistration = disconnectToken.SafeRegister(state =>
{
if (state != null)
{
// This will no-op if the request is already finished.
((IRequest)state).Abort();
}
if (errorCallback != null)
{
callbackInvoker.Invoke((cb, token) =>
{
#if !NET35
cb(new OperationCanceledException(Resources.Error_ConnectionCancelled, token));
#else
cb(new OperationCanceledException(Resources.Error_ConnectionCancelled));
#endif
}, errorCallback, disconnectToken);
}
}, _request);
requestDisposer.Set(requestCancellationRegistration);
}
internal void OpenConnection(IConnection connection, string data, CancellationToken disconnectToken, bool reconnecting)
{
// If we're reconnecting add /connect to the url
var url = reconnecting
? UrlBuilder.BuildReconnect(connection, Name, data)
: UrlBuilder.BuildConnect(connection, Name, data);
connection.Trace(TraceLevels.Events, "SSE: GET {0}", url);
var getTask = HttpClient.Get(url, req =>
{
_request = req;
_request.Accept = "text/event-stream";
connection.PrepareRequest(_request);
}, isLongRunning: true);
var requestCancellationRegistration = disconnectToken.SafeRegister(state =>
{
_stop = true;
// This will no-op if the request is already finished.
((IRequest)state).Abort();
}, _request);
getTask.ContinueWith(task =>
{
if (task.IsFaulted || task.IsCanceled)
{
var exception = task.IsCanceled
? new OperationCanceledException(Resources.Error_TaskCancelledException)
: task.Exception.Unwrap();
if (!reconnecting)
{
// It shouldn't be possible for Start to have already succeeded at this point.
TryFailStart(exception);
}
else if (!_stop)
{
// Only raise the error event if the error wasn't raised from Start and we're reconnecting.
connection.OnError(exception);
Reconnect(connection, data, disconnectToken);
}
requestCancellationRegistration.Dispose();
}
else
{
// If the disconnect token is canceled the response to the task doesn't matter.
if (disconnectToken.IsCancellationRequested)
{
return;
}
var response = task.Result;
Stream stream = response.GetStream();
var eventSource = new EventSourceStreamReader(connection, stream);
eventSource.Opened = () =>
{
// This will noop if we're not in the reconnecting state
if (connection.ChangeState(ConnectionState.Reconnecting, ConnectionState.Connected))
{
// Raise the reconnect event if the connection comes back up
connection.OnReconnected();
}
};
eventSource.Message = sseEvent =>
{
if (sseEvent.EventType == EventType.Data &&
!sseEvent.Data.Equals("initialized", StringComparison.OrdinalIgnoreCase))
{
ProcessResponse(connection, sseEvent.Data);
}
};
eventSource.Closed = exception =>
{
// Make sure to try to fail start even if the disconnectToken tripped and set _stop to true.
var startFailed = TryFailStart(exception);
if (exception != null && !startFailed)
{
// Check if the request is aborted
if (!ExceptionHelper.IsRequestAborted(exception))
{
// Don't raise exceptions if the request was aborted (connection was stopped).
connection.OnError(exception);
}
}
requestCancellationRegistration.Dispose();
response.Dispose();
if (_stop)
{
AbortHandler.CompleteAbort();
}
else if (!AbortHandler.TryCompleteAbort() && !startFailed)
{
// If Abort() was called or Start() failed, don't reconnect.
Reconnect(connection, data, disconnectToken);
}
};
eventSource.Start();
}
});
}
/// <summary>
/// Executes the module on the given graph using the provided context.
/// </summary>
/// <remarks>
/// The layout will be calculated <see cref="RunInBackground">optionally</see>
/// in a separate thread in method <see cref="RunModuleAsync"/>.
/// </remarks>
/// <param name="graph">The graph to execute on.</param>
/// <param name="newContext">The context to use. This method will query a <c>ISelectionModel<IModelItem></c></param>
/// for the selected nodes and edges and the <c>GraphControl</c> to morph the layout.
protected virtual async Task StartWithIGraph(IGraph graph, ILookup newContext)
{
this.graph = graph;
if (ShouldConfigureTableLayout())
{
PrepareTableLayout();
}
ISelectionModel <IModelItem> selectionModel = newContext.Lookup <ISelectionModel <IModelItem> >();
LayoutGraphAdapter adapter = new LayoutGraphAdapter(graph, selectionModel);
this.layoutGraph = adapter.CreateCopiedLayoutGraph();
ILookup additionalLookup = Lookups.Single(layoutGraph, typeof(LayoutGraph));
ILookup wrappedLookup = Lookups.Wrapped(newContext, additionalLookup);
try {
ICompoundEdit compoundEdit = graph.BeginEdit("Layout", "Layout");
CheckReentrant(wrappedLookup);
ConfigureModule();
if (RunInBackground)
{
// without the LayoutExecutor helper class on the layout graph side of things, we register the aborthandler
// to the layout graph with the utility method provided by AbortHandler
var abortHandler = AbortHandler.CreateForGraph(layoutGraph);
// now create the dialog that controls the abort handler
abortDialog = new AbortDialog {
AbortHandler = abortHandler, Owner = Application.Current.MainWindow
};
// start the layout in another thread.
var layoutThread = new Thread(async() => await RunModuleAsync(wrappedLookup, graph, compoundEdit));
// now if we are not doing a quick layout - and if it takes more than a few seconds, we open the dialog to
// enable the user to stop or cancel the execution
var showDialogTimer = new DispatcherTimer(DispatcherPriority.Normal, abortDialog.Dispatcher)
{
Interval = TimeSpan.FromSeconds(2)
};
showDialogTimer.Tick += delegate {
// it could be that the layout is already done - so check whether we still
// need to open the dialog
var dialogInstance = abortDialog;
if (dialogInstance != null)
{
// open the abort dialog
dialogInstance.Show();
}
// we only want to let it go off once - so stop the timer
showDialogTimer.Stop();
};
// kick-off the timer and the layout
showDialogTimer.Start();
layoutThread.Start();
}
else
{
await RunModuleAsync(wrappedLookup, graph, compoundEdit);
}
} catch (Exception e) {
FreeReentrant();
TableLayoutConfigurator.CleanUp(graph);
OnDone(new LayoutEventArgs(e));
//optionally do something here...
}
}
private void RunMultipageLayout()
{
// parse the pageWidth and pageHeight parameters
double pageWidth;
double pageHeight;
if (!Double.TryParse(pageWidthTextBox.Text, out pageWidth))
{
pageWidth = 800;
}
if (!Double.TryParse(pageHeightTextBox.Text, out pageHeight))
{
pageHeight = 800;
}
// get the core layout
string coreLayoutKey = coreLayoutComboBox.SelectedItem as string;
if (coreLayoutKey != null && coreLayouts.ContainsKey(coreLayoutKey))
{
coreLayout = coreLayouts[coreLayoutKey];
}
else
{
coreLayout = coreLayouts["Hierarchic"];
}
// a data provider for the node, edge, and label IDs:
// this data provider returns the node/edge/label instances themselves
var multiPageLayoutData = new MultiPageLayoutData
{
NodeIds = { Delegate = node => node },
EdgeIds = { Delegate = edge => edge },
NodeLabelIds = { Delegate = label => label },
EdgeLabelIds = { Delegate = label => label },
AbortHandler = abortHandler = new AbortHandler()
};
// apply the multi page layout
// multiPageLayout contains a list with the single page graphs
MultiPageLayout multiPageLayout = new MultiPageLayout(coreLayout)
{
MaximumPageSize = new YDimension(pageWidth, pageHeight),
LayoutCallback = new DelegateLayoutCallback(result => BeginInvoke(new Action(() => {
ApplyLayoutResult(result, pageWidth, pageHeight);
abortHandler = null;
ShowLoadingIndicator(false);
// force to update the command state
CommandManager.InvalidateRequerySuggested();
})))
};
// execute layout in thread to prevent ui blocking
new Thread(() => {
try {
modelGraph.ApplyLayout(multiPageLayout, multiPageLayoutData);
} catch (AlgorithmAbortedException) {
// layout was aborted
BeginInvoke(new Action(() => {
// reset abortHandler and loading indicator in the view thread
abortHandler = null;
ShowLoadingIndicator(false);
}));
}
}).Start();
}
