/// <summary>
///
/// </summary>
/// <param name="del">SignalDelegate listener to add.</param>
/// <typeparam name="T">Must inherit from Signal class.</typeparam>
public void AddListener <T>(SignalDelegate <T> del) where T : Signal
{
if (!delegateCache.ContainsKey(del))
{
delegateCache[del] = new List <DelegatePair>();
}
var delegateType = typeof(T);
if (!delegates.ContainsKey(delegateType))
{
delegates[delegateType] = new List <SignalDelegate>();
}
//Do not add delegate if it is already subscribed
SignalDelegate internalDelegate;
if (TryGetInternalDelegate(delegateType, del, out internalDelegate))
{
return;
}
// Create a new non-generic delegate which calls our generic one.
// This is the delegate we actually invoke.
internalDelegate = e => del((T)e);
var delegatePair = new DelegatePair
{
Type = delegateType,
Delegate = internalDelegate
};
delegateCache[del].Add(delegatePair);
delegates[delegateType].Add(internalDelegate);
}
public void WhenDispatchGuessResultSignal_UpdateGallowVisibilityViewModel()
{
SignalDelegate callback = null;
_eventDispatcherService
.When(service => service.Subscribe <GuessResultSignal>(Arg.Any <SignalDelegate>()))
.Do(info => callback = info.Arg <SignalDelegate>());
var isEnabledObserver1 = Substitute.For <IObserver <bool> >();
_inGameViewModel.IsGallowPartVisible.Clear();
var gallowImageProperty1 = _inGameViewModel.SubscribeGallowImage();
gallowImageProperty1.Subscribe(isEnabledObserver1);
isEnabledObserver1.ClearReceivedCalls();
var isEnabledObserver2 = Substitute.For <IObserver <bool> >();
var gallowImageProperty2 = _inGameViewModel.SubscribeGallowImage();
gallowImageProperty2.Subscribe(isEnabledObserver2);
isEnabledObserver2.ClearReceivedCalls();
var inGamePresenter = new InGamePresenter(_inGameViewModel, _eventDispatcherService);
callback(new GuessResultSignal(_letterToGuess, "word", true));
callback(new GuessResultSignal(_letterToGuess, "word", false));
callback(new GuessResultSignal(_letterToGuess, "word", true));
callback(new GuessResultSignal(_letterToGuess, "word", false));
callback(new GuessResultSignal(_letterToGuess, "word", true));
Received.InOrder(() =>
{
isEnabledObserver1.Received().OnNext(true);
isEnabledObserver2.Received().OnNext(true);
});
}
/// <summary>
/// Add a unique listener to the signal.
/// </summary>
public void AddListener(SignalDelegate listener)
{
if (SendSignal != null && SendSignal.GetInvocationList().Contains(listener))
{
Debug.LogWarning(string.Format("Signal already has registered the listener {0}", listener.Method.Name));
}
SendSignal += listener;
}
public void Listen(SignalDelegate <TMessage> listener)
{
if (listener == null)
{
throw new ArgumentNullException(nameof(listener));
}
_listeners.Add(new WeakReference(listener));
}
public void Unlisten(SignalDelegate <TMessage> listener)
{
if (listener == null)
{
throw new ArgumentNullException(nameof(listener));
}
_listeners.RemoveAll(t => t.Target == listener);
}
private async void DrainDeferredEvents(SignalDelegate signal, CancellationToken token)
{
EventData data;
while (_deferredEvents.TryGetEvent(out data) && !token.IsCancellationRequested)
{
await signal(data.Id, token, () => data);
}
}
public void Unsubscribe <T>(SignalDelegate callback) where T : ISignal
{
var type = typeof(T);
if (_events.ContainsKey(type))
{
_events[type] -= callback;
}
}
/// <summary>
/// Add a unique listener to the signal.
/// </summary>
public void AddListener(SignalDelegate listener)
{
if (SendSignal == null)
{
SendSignal += listener;
}
else if (!SendSignal.GetInvocationList().Contains(listener))
{
SendSignal += listener;
}
}
public void Subscribe <T>(SignalDelegate callback) where T : ISignal
{
var type = typeof(T);
if (!_events.ContainsKey(type))
{
_events.Add(type, null);
}
_events[type] += callback;
}
public void Unsubscribe <T>(SignalDelegate <T> callback) where T : ISignal
{
Delegate strippedDelegate = Delegate.Remove(GetDelegate <T>(), callback);
if (strippedDelegate == null)
{
subscriptions.Remove(typeof(T));
}
else
{
subscriptions[typeof(T)] = strippedDelegate;
}
}
internal static void MakeRouters(IApplicationBuilder app, KraftGlobalConfigurationSettings kraftGlobalConfigurationSettings)
{
RouteHandler routesHandler;
ToolSettings tool = GetTool(kraftGlobalConfigurationSettings, "recorder"); //////////////////////////////Recorder/////////////////////////////
if (tool != null && tool.Enabled) //Recorder enabled from configuration
{
kraftGlobalConfigurationSettings.GeneralSettings.ToolsSettings.RequestRecorder.IsEnabled = tool.Enabled;
routesHandler = new RouteHandler(RecorderDelegate.ExecutionDelegate(app, kraftGlobalConfigurationSettings));
RouteBuilder routesBuilder = new RouteBuilder(app, routesHandler);
//we expect the routing to be like this:
//domain.com/recorder/0|1|2?lang=de
routesBuilder.MapRoute(
name: "recorder",
template: tool.Url,
defaults: null,
constraints: null,
dataTokens: new { key = "recorder" }
);
app.UseRouter(routesBuilder.Build());
}
tool = GetTool(kraftGlobalConfigurationSettings, "signals"); //////////////////////////////Signals/////////////////////////////
if (tool != null && tool.Enabled) //Signals enabled from configuration
{
routesHandler = new RouteHandler(SignalDelegate.ExecutionDelegate(app, kraftGlobalConfigurationSettings));
RouteBuilder routesBuilder = new RouteBuilder(app, routesHandler);
//we expect the routing to be like this:
//domain.com/signals/0|1|2?lang=de
routesBuilder.MapRoute(
name: "signals",
template: tool.Url,
defaults: null,
constraints: null,
dataTokens: new { key = "signals" }
);
app.UseRouter(routesBuilder.Build());
}
//tool = GetTool(kraftGlobalConfigurationSettings, "errors");//////////////////////////////Errors/////////////////////////////
//if (tool != null && tool.Enabled)//Errors enabled from configuration
//{
//}
tool = GetTool(kraftGlobalConfigurationSettings, "profiler"); //////////////////////////////Profiler/////////////////////////////
if (tool != null && tool.Enabled) //Profiler enabled from configuration
{
app.UseBindKraftProfiler();
}
}
public void WhenDispatchGuessResultSignal_UpdateKeyButtonViewModel(bool isCorrect)
{
SignalDelegate callback = null;
_eventDispatcherService
.When(service => service.Subscribe <GuessResultSignal>(Arg.Any <SignalDelegate>()))
.Do(info => callback = info.Arg <SignalDelegate>());
var inGamePresenter = new InGamePresenter(_inGameViewModel, _eventDispatcherService);
callback(new GuessResultSignal(_letterToGuess, "word", isCorrect));
_colorObserver.Received().OnNext(isCorrect ? InGameViewModel.CorrectColor : InGameViewModel.IncorrectColor);
_isKetEnabledObserver.Received().OnNext(false);
}
private async void DrainMessages(SignalDelegate signal, CancellationToken token)
{
string message;
while (_warningMessages.TryDequeue(out message) && !token.IsCancellationRequested)
{
await signal(Events.Warning, token, () => EventHelper.CreateLogEvent(message));
}
while (_debugMessages.TryDequeue(out message) && !token.IsCancellationRequested)
{
await signal(Events.Debug, token, () => EventHelper.CreateLogEvent(message));
}
}
/// <summary>
/// Print event details to the provided stream
/// </summary>
/// <param name="getEventData">The event data to print</param>
/// <param name="signal">The delegate for signaling events to the runtime</param>
/// <param name="token">The cancellation token for the request</param>
/// <param name="streamName">The name of the stream to print data to</param>
/// <param name="eventName">The name of the event to be printed</param>
public static async void Print(this GetEventData getEventData, SignalDelegate signal, CancellationToken token, string streamName, string eventName)
{
var eventDisplayName = SplitPascalCase(eventName).ToUpperInvariant();
var data = EventDataConverter.ConvertFrom(getEventData()); // also, we manually use our TypeConverter to return an appropriate type
if (data.Id != "Verbose" && data.Id != "Warning" && data.Id != "Debug" && data.Id != "Information" && data.Id != "Error")
{
await signal(streamName, token, () => EventHelper.CreateLogEvent($"{eventDisplayName} The contents are '{data?.Id}' and '{data?.Message}'"));
if (data != null)
{
await signal(streamName, token, () => EventHelper.CreateLogEvent($"{eventDisplayName} Parameter: '{data.Parameter}'\n{eventDisplayName} RequestMessage '{data.RequestMessage}'\n{eventDisplayName} Response: '{data.ResponseMessage}'\n{eventDisplayName} Value: '{data.Value}'"));
await signal(streamName, token, () => EventHelper.CreateLogEvent($"{eventDisplayName} ExtendedData Type: '{data.ExtendedData?.GetType()}'\n{eventDisplayName} ExtendedData '{data.ExtendedData}'"));
}
}
}
public void WhenDispatchNewWordSignal_UpdateTheVisibilityInViewModel()
{
SignalDelegate callback = null;
_eventDispatcherService
.When(service => service.Subscribe <NewWordSignal>(Arg.Any <SignalDelegate>()))
.Do(info => callback = info.Arg <SignalDelegate>());
var observer = Substitute.For <IObserver <bool> >();
_inGameViewModel.IsVisible.Subscribe(observer);
var inGamePresenter = new InGamePresenter(_inGameViewModel, _eventDispatcherService);
callback(new NewWordSignal("word"));
observer.Received().OnNext(true);
}
public void WhenDispatchNewWordSignal_UpdateTheWordInViewModel()
{
SignalDelegate callback = null;
_eventDispatcherService
.When(service => service.Subscribe <NewWordSignal>(Arg.Any <SignalDelegate>()))
.Do(info => callback = info.Arg <SignalDelegate>());
var wordObserver = Substitute.For <IObserver <string> >();
_inGameViewModel.CurrentWord.Subscribe(wordObserver);
var inGamePresenter = new InGamePresenter(_inGameViewModel, _eventDispatcherService);
callback(new NewWordSignal("word"));
wordObserver.Received().OnNext("w o r d");
}
public void WhenDispatchNewWordSignal_UpdateTheViewModel()
{
var mainMenuViewModel = Substitute.For <MainMenuViewModel>();
var eventDispatcherService = Substitute.For <IEventDispatcherService>();
SignalDelegate callback = null;
eventDispatcherService
.When(service => service.Subscribe <NewWordSignal>(Arg.Any <SignalDelegate>()))
.Do(info => callback = info.Arg <SignalDelegate>());
var mainMenuPresenter = new MainMenuPresenter(mainMenuViewModel, eventDispatcherService);
var observer = Substitute.For <IObserver <bool> >();
mainMenuViewModel.IsVisible.Subscribe(observer);
callback(new NewWordSignal("word"));
observer.Received().OnNext(false);
}
public void WhenDispatchUpdateLoadingScreenSignal_UpdateTheViewModel()
{
var loadingViewModel = Substitute.For <LoadingViewModel>();
var eventDispatcherService = Substitute.For <IEventDispatcherService>();
SignalDelegate callback = null;
eventDispatcherService
.When(service => service.Subscribe <UpdateLoadingScreenSignal>(Arg.Any <SignalDelegate>()))
.Do(info => callback = info.Arg <SignalDelegate>());
var loadingPresenter = new LoadingPresenter(loadingViewModel, eventDispatcherService);
var observer = Substitute.For <IObserver <bool> >();
loadingViewModel.IsVisible.Subscribe(observer);
callback(new UpdateLoadingScreenSignal(true));
observer.Received().OnNext(false);
}
private bool TryGetInternalDelegate(Type type, Delegate del, out SignalDelegate internalDelegate)
{
internalDelegate = null;
if (!delegateCache.ContainsKey(del))
{
return(false);
}
for (var i = 0; i < delegateCache[del].Count; i++)
{
var pair = delegateCache[del][i];
if (pair.Type == type)
{
internalDelegate = pair.Delegate;
return(true);
}
}
return(false);
}
public void WhenDispatchRestartGameSignal_RestartKeyboard()
{
SignalDelegate callback = null;
_eventDispatcherService
.When(service => service.Subscribe <RestartGameSignal>(Arg.Any <SignalDelegate>()))
.Do(info => callback = info.Arg <SignalDelegate>());
var inGamePresenter = new InGamePresenter(_inGameViewModel, _eventDispatcherService);
_keyButtonViewModel.Color.Value = "";
_keyButtonViewModel.IsEnabled.Value = false;
_colorObserver.ClearReceivedCalls();
_isKetEnabledObserver.ClearReceivedCalls();
Assert.AreNotEqual(InGameViewModel.DefaultColor, _keyButtonViewModel.Color.Value);
Assert.AreNotEqual(true, _keyButtonViewModel.IsEnabled.Value);
callback(new RestartGameSignal());
_colorObserver.Received().OnNext(InGameViewModel.DefaultColor);
_isKetEnabledObserver.Received().OnNext(true);
}
/// <summary>
/// Remove a listener from an signal type.
/// </summary>
/// <param name="del">SignalDelegate listener to remove.</param>
/// <typeparam name="T">Must inherit from Signal class.</typeparam>
public void RemoveListener <T>(SignalDelegate <T> del) where T : Signal
{
var delegateType = typeof(T);
SignalDelegate internalDelegate;
if (!TryGetInternalDelegate(delegateType, del, out internalDelegate))
{
return;
}
if (delegates.ContainsKey(delegateType))
{
var i = delegates[delegateType].IndexOf(internalDelegate);
if (i >= 0)
{
delegates[delegateType][i] = null;
}
RemoveInternalDelegate(delegateType, del);
RemoveAllNull(delegateType);
}
}
public void WhenDispatchRestartGameSignal_RestartEndGameVisibilityInViewModel()
{
SignalDelegate callback = null;
_eventDispatcherService
.When(service => service.Subscribe <RestartGameSignal>(Arg.Any <SignalDelegate>()))
.Do(info => callback = info.Arg <SignalDelegate>());
var isEndGameVisibleObserver = Substitute.For <IObserver <bool> >();
_inGameViewModel.IsEndGameVisible.Subscribe(isEndGameVisibleObserver);
var isGameOverVisibleObserver = Substitute.For <IObserver <bool> >();
_inGameViewModel.IsGameOverVisible.Subscribe(isGameOverVisibleObserver);
var isVictoryVisibleObserver = Substitute.For <IObserver <bool> >();
_inGameViewModel.IsVictoryVisible.Subscribe(isVictoryVisibleObserver);
var inGamePresenter = new InGamePresenter(_inGameViewModel, _eventDispatcherService);
callback(new RestartGameSignal());
isEndGameVisibleObserver.Received().OnNext(false);
isGameOverVisibleObserver.Received().OnNext(false);
isVictoryVisibleObserver.Received().OnNext(false);
}
public void WhenDispatchRestartGameSignal_RestartGallow()
{
SignalDelegate callback = null;
_eventDispatcherService
.When(service => service.Subscribe <RestartGameSignal>(Arg.Any <SignalDelegate>()))
.Do(info => callback = info.Arg <SignalDelegate>());
var isEnabledObserver = Substitute.For <IObserver <bool> >();
_inGameViewModel.IsGallowPartVisible.Clear();
var gallowImageProperty = _inGameViewModel.SubscribeGallowImage();
var inGamePresenter = new InGamePresenter(_inGameViewModel, _eventDispatcherService);
gallowImageProperty.Subscribe(isEnabledObserver);
gallowImageProperty.Value = true;
_inGameViewModel.NextGallowPartToShow = 2;
Assert.AreNotEqual(0, _inGameViewModel.NextGallowPartToShow);
Assert.IsTrue(gallowImageProperty.Value);
callback(new RestartGameSignal());
Assert.AreEqual(0, _inGameViewModel.NextGallowPartToShow);
isEnabledObserver.Received().OnNext(false);
}
public EventedEventWaitHandleList(SignalDelegate Signal)
{
this.Signal = Signal;
}
/// <summary>
/// Pipeline delegate to add a unique id header to an outgoing request
/// </summary>
/// <param name="request">The outgpoing request</param>
/// <param name="token">The cancellation token</param>
/// <param name="cancel">Additional cancellation action if the operation is cancelled</param>
/// <param name="signal">Signal delegate for logging events</param>
/// <param name="next">The next setp in the pipeline</param>
/// <returns>Amended pipeline for retrieving a response</returns>
public Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken token, Action cancel, SignalDelegate signal, NextDelegate next)
{
var userAgents = new ProductInfoHeaderValue[] { new ProductInfoHeaderValue("AzurePowerShell", $"Az4.0.0-preview") };
// add user agent haeaders
foreach (var userAgent in userAgents)
{
request.Headers.UserAgent.Add(userAgent);
}
// continue with pipeline.
return(next(request, token, cancel, signal));
}
public static extern uint g_signal_connect_data(IntPtr obj, string name, SignalDelegate cb, IntPtr data, IntPtr p, int flags);
public Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken token, Action cancel, SignalDelegate signal, NextDelegate next)
{
request.Headers.Add("x-ms-client-request-id", processRecordId);
request.Headers.Add("CommandName", invocationInfo?.InvocationName);
request.Headers.Add("FullCommandName", invocationInfo?.MyCommand?.Name);
request.Headers.Add("ParameterSetName", parameterSetName);
// continue with pipeline.
return(next(request, token, cancel, signal));
}
public void Subscribe <T>(SignalDelegate <T> callback) where T : ISignal
{
subscriptions[typeof(T)] = Delegate.Combine(GetDelegate <T>(), callback);
}
internal async Task OnBeforeCall(string id, CancellationToken cancellationToken, GetEventData getEventData, SignalDelegate signal, string processRecordId)
{
var data = EventDataConverter.ConvertFrom(getEventData()); // also, we manually use our TypeConverter to return an appropriate type
var request = data?.RequestMessage as HttpRequestMessage;
if (request != null)
{
AzurePSQoSEvent qos;
IEnumerable <string> headerValues;
if (_telemetry.TryGetValue(processRecordId, out qos))
{
foreach (var headerName in ClientHeaders)
{
if (request.Headers.TryGetValues(headerName, out headerValues) && headerValues.Any())
{
qos.ClientRequestId = headerValues.First();
break;
}
}
}
/// Print formatted request message
await signal(Events.Debug, cancellationToken,
() => EventHelper.CreateLogEvent(GeneralUtilities.GetLog(request)));
}
}
internal async Task OnCmdletEndProcessing(string id, CancellationToken cancellationToken, GetEventData getEventData, SignalDelegate signal, string processRecordId)
{
AzurePSQoSEvent qos;
if (_telemetry.TryGetValue(processRecordId, out qos))
{
qos.IsSuccess = (qos.Exception == null);
await signal(Events.Debug, cancellationToken,
() => EventHelper.CreateLogEvent($"[{id}]: Sending new QosEvent for command '{qos.CommandName}': {qos.ToString()}"));
_telemetry.LogEvent(processRecordId);
_previousEndTime = DateTimeOffset.Now;
}
}
internal async Task OnCmdletBeginProcessing(string id, CancellationToken cancellationToken, GetEventData getEventData, SignalDelegate signal, string processRecordId)
{
await signal(Events.Debug, cancellationToken,
() => EventHelper.CreateLogEvent($"[{id}]: Starting command"));
}
internal async Task OnFinally(string id, CancellationToken cancellationToken, GetEventData getEventData, SignalDelegate signal, string processRecordId)
{
var data = EventDataConverter.ConvertFrom(getEventData());
if (data?.ResponseMessage is HttpResponseMessage response)
{
AzurePSQoSEvent qos;
if (_telemetry.TryGetValue(processRecordId, out qos))
{
if (!response.IsSuccessStatusCode && qos.Exception == null)
{
// add "InternalException" as message because it is just for telemtry tracking.
AzPSCloudException ex = (response.StatusCode == HttpStatusCode.NotFound) ?
new AzPSResourceNotFoundCloudException("InternalException") : new AzPSCloudException("InternalException");
try
{
string responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
CloudError cloudError = SafeJsonConvert.DeserializeObject <CloudError>(responseContent, DeserializationSettings);
ex.Body = cloudError;
ex.Data[AzurePSErrorDataKeys.CloudErrorCodeKey] = cloudError.Code;
}
catch (Exception exception)
{
await signal(Events.Debug, cancellationToken,
() => EventHelper.CreateLogEvent($"[{id}]: Cannot deserialize due to {exception.Message}"));
}
qos.Exception = ex;
await signal(Events.Debug, cancellationToken,
() => EventHelper.CreateLogEvent($"[{id}]: Getting exception '{qos.Exception}' from response"));
}
}
}
}
