private Page(Session client, Target target, FrameTree frameTree, bool ignoreHTTPSErrors, TaskQueue screenshotTaskQueue)
{
_client = client;
_target = target;
Keyboard = new Keyboard(client);
_mouse = new Mouse(client, Keyboard);
Touchscreen = new Touchscreen(client, Keyboard);
_frameManager = new FrameManager(client, frameTree, this);
_networkManager = new NetworkManager(client, _frameManager);
_emulationManager = new EmulationManager(client);
Tracing = new Tracing(client);
_pageBindings = new Dictionary <string, Func <object> >();
_ignoreHTTPSErrors = ignoreHTTPSErrors;
_screenshotTaskQueue = screenshotTaskQueue;
//TODO: Do we need this bubble?
_frameManager.FrameAttached += (sender, e) => FrameAttached?.Invoke(this, e);
_frameManager.FrameDetached += (sender, e) => FrameDetached?.Invoke(this, e);
_frameManager.FrameNavigated += (sender, e) => FrameNavigated?.Invoke(this, e);
_networkManager.RequestCreated += (sender, e) => RequestCreated?.Invoke(this, e);
_networkManager.RequestFailed += (sender, e) => RequestFailed?.Invoke(this, e);
_networkManager.ResponseCreated += (sender, e) => ResponseCreated?.Invoke(this, e);
_networkManager.RequestFinished += (sender, e) => RequestFinished?.Invoke(this, e);
_client.MessageReceived += client_MessageReceived;
}
/// <summary>
/// Raises the <see cref="RequestFailed"/> event. Note, sender is null.
/// </summary>
/// <param name="inUri"></param>
internal static void onRequestFailed(Uri inUri, HttpWebResponse inResponse, TMDbStatusResponse inStatusResponse)
{
// Written, 24.11.2019
Console.WriteLine("Request failed: {0} Code {1}.", inStatusResponse.status_message, inStatusResponse.status_code);
RequestFailed?.Invoke(null, new RequestFailedEventArgs(inUri, inResponse, inStatusResponse));
}
public NewAuthorViewModel()
{
async void execute(string value)
{
try
{
author.Name = value;
await Constants.BaseServiceUrl.AppendPathSegment(typeof(Author).Name).PostJsonAsync(author);
AuthorAdded?.Invoke(this, author);
}
// Se webservice retornar erro, lança uma FlurlHttpException
catch (FlurlHttpException ex)
{
// Nesse caso, pega o corpo da resposta de erro e
// desserializa como um DTO ErrorResponse
var error = await ex.GetResponseJsonAsync <ErrorResponse>();
// Invoca evento de requisição zoada.
RequestFailed?.Invoke(this, error);
}
}
// Atribui valor ao comando.
PostCommand = new Command <string>(execute);
}
internal override void OnMessage(string method, JsonElement?serverParams)
{
switch (method)
{
case "close":
Close?.Invoke(this, EventArgs.Empty);
break;
case "bindingCall":
BindingCall?.Invoke(
this,
new() { BindingCall = serverParams?.GetProperty("binding").ToObject <BindingCallChannel>(Connection.DefaultJsonSerializerOptions).Object });
break;
case "route":
var route = serverParams?.GetProperty("route").ToObject <RouteChannel>(Connection.DefaultJsonSerializerOptions).Object;
var request = serverParams?.GetProperty("request").ToObject <RequestChannel>(Connection.DefaultJsonSerializerOptions).Object;
Route?.Invoke(
this,
new() { Route = route, Request = request });
break;
case "page":
Page?.Invoke(
this,
new() { PageChannel = serverParams?.GetProperty("page").ToObject <PageChannel>(Connection.DefaultJsonSerializerOptions) });
break;
case "crBackgroundPage":
BackgroundPage?.Invoke(
this,
new() { PageChannel = serverParams?.GetProperty("page").ToObject <PageChannel>(Connection.DefaultJsonSerializerOptions) });
break;
case "crServiceWorker":
ServiceWorker?.Invoke(
this,
new() { WorkerChannel = serverParams?.GetProperty("worker").ToObject <WorkerChannel>(Connection.DefaultJsonSerializerOptions) });
break;
case "request":
Request?.Invoke(this, serverParams?.ToObject <BrowserContextChannelRequestEventArgs>(Connection.DefaultJsonSerializerOptions));
break;
case "requestFinished":
RequestFinished?.Invoke(this, serverParams?.ToObject <BrowserContextChannelRequestEventArgs>(Connection.DefaultJsonSerializerOptions));
break;
case "requestFailed":
RequestFailed?.Invoke(this, serverParams?.ToObject <BrowserContextChannelRequestEventArgs>(Connection.DefaultJsonSerializerOptions));
break;
case "response":
Response?.Invoke(this, serverParams?.ToObject <BrowserContextChannelResponseEventArgs>(Connection.DefaultJsonSerializerOptions));
break;
}
}
// processes elastic message queue
private void ElasticQueueThreadProc()
{
while (!disconnecting && connection != null)
{
if (elasticQueue.Count > 0)
{
if (!disconnecting && elasticActiveTasks.Count > maxNumberOfSendRequests)
{
Task.WaitAny(elasticActiveTasks.Values.ToArray(), disconnectingCancel.Token);
}
if (!disconnecting && elasticActiveTasks.Count <= maxNumberOfSendRequests)
{
SignalNowMessageAction messageAction;
if (!elasticQueue.TryDequeue(out messageAction))
{
continue;
}
long now = DateTime.UtcNow.Ticks;
Action fullAction = () =>
{
try
{
if (!disconnecting && connection != null && !messageAction.Completed && !messageAction.Cancelled)
{
messageAction.Run();
}
}
catch (Exception ex)
{
if (!disconnecting)
{
RequestFailed?.Invoke(this, $"Exception when sending an elastic message: {ex.Message}");
}
}
Task removed = null;
while (elasticActiveTasks.ContainsKey(now))
{
if (!elasticActiveTasks.TryRemove(now, out removed))
{
Task.Delay(0);
}
}
};
elasticActiveTasks[now] = Task.Run(fullAction);
}
}
else
{
WaitHandle.WaitAny(new WaitHandle[] { newMessageTaskEvent, disconnectingCancel.Token.WaitHandle });
}
}
}
private async Task <bool> EnsureMessageToken()
{
if (disconnecting || connection == null)
{
return(false);
}
if (!string.IsNullOrEmpty(MessageToken) && DateTime.UtcNow < MessageTokenValidTo)
{
return(true);
}
using (HttpRequestMessage request = httpClient.CreateHttpRequest("/api/GetMessageToken", HttpMethod.Post))
{
request.Headers.Add("authToken", string.IsNullOrEmpty(MessageToken) ?
ClientToken :
MessageToken);
try
{
string tokenString = await httpClient.SendRequestLiteWithResultAsync(request);
if (tokenString == null)
{
return(false); // no need to handle the error because already done
}
JwtSecurityTokenHandler JwtTokenHandler = new JwtSecurityTokenHandler();
if (JwtTokenHandler.CanReadToken(tokenString))
{
var token = JwtTokenHandler.ReadJwtToken(tokenString);
MessageTokenValidTo = token.ValidTo - TimeSpan.FromMinutes(MessageTokenRefreshInAdvanceMinutes) - ClientServerTimeDiff;
MessageToken = tokenString;
}
}
catch (Exception ex)
{
RequestFailed?.Invoke(this, $"Exception when renewing a Message Token: {ex.Message}");
}
bool bOK = !string.IsNullOrEmpty(MessageToken);
return(bOK);
}
}
public void Run()
{
while (true)
{
var i = WaitHandle.WaitAny(new WaitHandle[] { stop, doWork });
if (i == 0)
{
break;
}
var processRequest = true;
while (processRequest)
{
var request = GetRequest();
if (request != null)
{
try
{
log.Info(String.Format("Processing request: type = {0}, parameter = {{ {1} }}", request.RequestType.ToString(), request.Argument));
var analyzer = new PerformanceAnalyzer();
request.DoWorkFunction(request.Argument);
analyzer.Stop();
log.Performance("Request process time", analyzer.Result);
}
catch (Exception ex)
{
if (RequestFailed != null)
{
RequestFailed.Invoke(request, ex);
}
}
}
else
{
processRequest = false;
}
}
}
}
public async Task <bool> SendMessage(string recipient, bool groupRecipient, string messageType, string messagePayload, bool payloadIsJson = false)
{
if (disconnecting || string.IsNullOrEmpty(MessageToken) || connection == null)
{
return(false);
}
using (HttpRequestMessage request = httpClient.CreateHttpRequest("/api/Message", HttpMethod.Post))
{
request.Headers.Add("authToken", MessageToken);
request.Headers.Add("sendto", recipient);
request.Headers.Add("userorgroup", groupRecipient ? "group" : "user");
request.Headers.Add("messagetype", messageType);
request.Content = new StringContent(
payloadIsJson ? messagePayload : JsonConvert.SerializeObject(messagePayload),
System.Text.Encoding.UTF8, "application/json");
try
{
DateTime now = DateTime.UtcNow;
return(await httpClient.SendRequestLiteAsync(request, false));
}
catch (Exception ex)
{
if (!disconnecting)
{
bool isTaskCancelled =
ex.GetType() == typeof(TaskCanceledException) ||
ex.InnerException != null && ex.InnerException.GetType() == typeof(TaskCanceledException);
if (!isTaskCancelled)
{
RequestFailed?.Invoke(this, $"Exception when sending a message: {ex.Message}");
}
}
return(false);
}
}
}
private void WebClient_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
{
IsDownloading = false;
if (e.Error == null)
{
if (!e.Cancelled)
{
OnRequestCompleted(e.Result);
RequestCompleted.IfNotNull(i => i(this, e.Result));
}
else
{
RequestCanceled.IfNotNull(i => i(this));
}
}
else
{
OnRequestFailed(e.Error);
RequestFailed.IfNotNull(i => i(this, e.Error));
}
}
internal override void OnMessage(string method, JsonElement?serverParams)
{
switch (method)
{
case "close":
Closed?.Invoke(this, EventArgs.Empty);
break;
case "crash":
Crashed?.Invoke(this, EventArgs.Empty);
break;
case "domcontentloaded":
DOMContentLoaded?.Invoke(this, EventArgs.Empty);
break;
case "load":
Load?.Invoke(this, EventArgs.Empty);
break;
case "bindingCall":
BindingCall?.Invoke(
this,
new BindingCallEventArgs
{
BidingCall = serverParams?.GetProperty("binding").ToObject <BindingCallChannel>(Connection.GetDefaultJsonSerializerOptions()).Object,
});
break;
case "route":
Route?.Invoke(
this,
new RouteEventArgs
{
Route = serverParams?.GetProperty("route").ToObject <RouteChannel>(Connection.GetDefaultJsonSerializerOptions()).Object,
Request = serverParams?.GetProperty("request").ToObject <RequestChannel>(Connection.GetDefaultJsonSerializerOptions()).Object,
});
break;
case "popup":
Popup?.Invoke(this, new PageChannelPopupEventArgs
{
Page = serverParams?.GetProperty("page").ToObject <PageChannel>(Connection.GetDefaultJsonSerializerOptions()).Object,
});
break;
case "pageError":
PageError?.Invoke(this, serverParams?.GetProperty("error").GetProperty("error").ToObject <PageErrorEventArgs>(Connection.GetDefaultJsonSerializerOptions()));
break;
case "fileChooser":
FileChooser?.Invoke(this, serverParams?.ToObject <FileChooserChannelEventArgs>(Connection.GetDefaultJsonSerializerOptions()));
break;
case "frameAttached":
FrameAttached?.Invoke(this, new FrameEventArgs(serverParams?.GetProperty("frame").ToObject <FrameChannel>(Connection.GetDefaultJsonSerializerOptions()).Object));
break;
case "frameDetached":
FrameDetached?.Invoke(this, new FrameEventArgs(serverParams?.GetProperty("frame").ToObject <FrameChannel>(Connection.GetDefaultJsonSerializerOptions()).Object));
break;
case "dialog":
Dialog?.Invoke(this, new DialogEventArgs(serverParams?.GetProperty("dialog").ToObject <DialogChannel>(Connection.GetDefaultJsonSerializerOptions()).Object));
break;
case "console":
Console?.Invoke(this, new ConsoleEventArgs(serverParams?.GetProperty("message").ToObject <ConsoleMessage>(Connection.GetDefaultJsonSerializerOptions())));
break;
case "request":
Request?.Invoke(this, new RequestEventArgs {
Request = serverParams?.GetProperty("request").ToObject <RequestChannel>(Connection.GetDefaultJsonSerializerOptions()).Object
});
break;
case "requestFinished":
RequestFinished?.Invoke(this, new RequestEventArgs {
Request = serverParams?.GetProperty("request").ToObject <RequestChannel>(Connection.GetDefaultJsonSerializerOptions()).Object
});
break;
case "requestFailed":
RequestFailed?.Invoke(this, serverParams?.ToObject <PageChannelRequestFailedEventArgs>(Connection.GetDefaultJsonSerializerOptions()));
break;
case "response":
Response?.Invoke(this, new ResponseEventArgs {
Response = serverParams?.GetProperty("response").ToObject <ResponseChannel>(Connection.GetDefaultJsonSerializerOptions()).Object
});
break;
case "download":
Download?.Invoke(this, new DownloadEventArgs()
{
Download = serverParams?.GetProperty("download").ToObject <DownloadChannel>(Connection.GetDefaultJsonSerializerOptions()).Object
});
break;
case "worker":
Worker?.Invoke(
this,
new WorkerChannelEventArgs
{
WorkerChannel = serverParams?.GetProperty("worker").ToObject <WorkerChannel>(Connection.GetDefaultJsonSerializerOptions()),
});
break;
}
}
private void Client_RequestFailed(Microsoft.SignalNow.Client.SignalNowClient signalNow, string errorMessage)
{
Debug.LogError($"Signaling request failed: {errorMessage}");
RequestFailed?.Invoke(this, errorMessage);
}
public virtual void OnRequestFailed(WebEventArgs e)
{
RequestFailed?.Invoke(e.Context, e);
}
public void Execute(string card, string area, int count)
{
var products = SearchProducts("a");
for (var i = 0; i < count; i++)
{
var id = products[rnd.Next(0, products.Count - 1)].Id;
var response = SubmitOrder(new OrderRequest()
{
Id = Guid.NewGuid(),
Product = id,
Address = "Unit 1, 100 John Street, Sydney",
Quantity = rnd.Next(1, 9),
Payment = GenerateCreditCardNumber(card),
Zip = GenerateAreaCode(area),
Country = "Australia"
});
if (response.Data.Status)
{
RequestPassed?.Invoke(this, new EventArgs());
}
else
{
RequestFailed?.Invoke(this, new EventArgs());
}
foreach (var o in response.Downstream)
{
if (o.Endpoint.Contains("payment"))
{
if (o.Version.Equals(1))
{
RequestProcessedByPaymentServer1?.Invoke(this, new EventArgs());
}
if (o.Version.Equals(2))
{
RequestProcessedByPaymentServer2?.Invoke(this, new EventArgs());
}
}
if (o.Endpoint.Contains("address"))
{
if (o.Version.Equals(1))
{
RequestProcessedByAddressServer1?.Invoke(this, new EventArgs());
}
if (o.Version.Equals(2))
{
RequestProcessedByAddressServer2?.Invoke(this, new EventArgs());
}
if (o.Version.Equals(3))
{
RequestProcessedByAddressServer3?.Invoke(this, new EventArgs());
}
}
}
RequestSent?.Invoke(this, new EventArgs());
}
}
public async Task <bool> Connect(string userName, string deviceId, string companyName, string teamName, string authServiceToken, string authServiceName)
{
if (httpClient == null)
{
httpClient = new SignalNowHttp(serverAddress,
(string msg, Exception ex) =>
{
RequestFailed?.Invoke(this, msg);
});
}
string responseString = string.Empty;
UserId = string.Empty;
ClientUrl = string.Empty;
ClientToken = string.Empty;
TurnServersAuthorization = string.Empty;
MessageToken = string.Empty;
MessageTokenValidTo = DateTime.MinValue;
AuthService = authServiceName;
peers.Clear();
if (connection != null)
{
if (connection.State == HubConnectionState.Connected)
{
await Disconnect();
}
connection = null;
}
using (HttpRequestMessage request = httpClient.CreateHttpRequest("/api/Negotiate", HttpMethod.Post))
{
request.Headers.Add("username", userName);
request.Headers.Add("deviceid", deviceId);
request.Headers.Add("companyname", companyName);
request.Headers.Add("teamname", teamName);
request.Headers.Add("authservicetoken", authServiceToken);
request.Headers.Add("authservicename", authServiceName);
#if UNITY_2018_2_OR_NEWER
UnityEngine.Debug.Log($"Connecting to {serverAddress}.");
#else
System.Diagnostics.Debug.WriteLine($"Connecting to {serverAddress}.");
#endif
responseString = await httpClient.SendRequestLiteWithResultAsync(request);
if (responseString == null)
{
return(false); // no need to handle the error because already done
}
#if UNITY_2018_2_OR_NEWER
UnityEngine.Debug.Log($"!!! Connected to {serverAddress}.");
#else
System.Diagnostics.Debug.WriteLine($"!!! Connected to {serverAddress}.");
#endif
}
//userId, clientToken, clientUrl, serverTimeString, turnServersAuthorization
JArray paramArray = JArray.Parse(responseString);
UserId = paramArray[0].ToString();
ClientToken = paramArray[1].ToString();
ClientUrl = paramArray[2].ToString();
var serverTimeString = paramArray[3].ToString();
ClientServerTimeDiff = DateTime.UtcNow - UnixEpoch.AddSeconds(long.Parse(serverTimeString));
if (paramArray.Count > 4)
{
TurnServersAuthorization = paramArray[4].ToString();
}
#if UNITY_2018_2_OR_NEWER
UnityEngine.Debug.Log($"Initializing SignalR connection {ClientUrl}.");
#else
System.Diagnostics.Debug.WriteLine($"Initializing SignalR connection {ClientUrl}.");
#endif
connection = new HubConnectionBuilder()
.WithUrl(ClientUrl,
option =>
{
option.AccessTokenProvider = () =>
{
return(Task.FromResult(ClientToken));
};
})
#if !UNITY_2018_2_OR_NEWER
.AddMessagePackProtocol() // https://fogbugz.unity3d.com/default.asp?1091189_1sqkebcrot7vvv9b
#endif
.Build();
#if UNITY_2018_2_OR_NEWER
UnityEngine.Debug.Log($"Connecting to SignalR...");
#else
System.Diagnostics.Debug.WriteLine($"Connecting to SignalR...");
#endif
await connection.StartAsync();
bool bRes = (connection.State == HubConnectionState.Connected);
if (bRes)
{
Me = new SignalNowPeer(UserId, PeerStatus.Online, StatusTimeout);
connection.Closed += (Exception why) =>
{
#if UNITY_2018_2_OR_NEWER
UnityEngine.Debug.LogWarning($"SignalR disconnected");
#else
System.Diagnostics.Debug.WriteLine($"SignalR disconnected");
#endif
connection = null;
if (!disconnecting)
{
return(DisconnectInternal(why));
}
else
{
return(Task.Delay(0));
}
};
#if UNITY_2018_2_OR_NEWER
UnityEngine.Debug.Log($"Getting a message token.");
#else
System.Diagnostics.Debug.WriteLine($"Getting a message token.");
#endif
bRes = await EnsureMessageToken();
#if UNITY_2018_2_OR_NEWER
UnityEngine.Debug.Log($"Message token is {(bRes ? "good" : "empty")}");
#else
System.Diagnostics.Debug.WriteLine($"Message token is {(bRes ? "good" : "empty")}");
#endif
if (bRes)
{
connection.On <string, string, string>("SIGNAL",
(string senderId, string messageType, string messagePayload) =>
{
if (senderId != UserId)
{
OnMessageIn(senderId, messageType, messagePayload);
}
});
ConnectionChanged?.Invoke(this, true, null);
bRes = await SendImportantMessage(GetEveryoneRecipient(), true, "I_AM_HERE",
((int)StatusTimeout.TotalSeconds).ToString(), true);
}
}
else
{
#if UNITY_2018_2_OR_NEWER
UnityEngine.Debug.Log($"Couldn't connect to SignalR.");
#else
System.Diagnostics.Debug.WriteLine($"Couldn't connect to SignalR.");
#endif
}
return(bRes);
}
