private void OnNewConnection(IConnection connection)
{
connection.OnPacketReceived = packet =>
{
Task.Run(async() =>
{
RequestCall call = protocol.DeserializeRequest(packet, packet.Length, this.protocolVersion);
RequestResponse response;
switch (call.Request.RequestType)
{
case RingMasterRequestType.Init:
{
RequestInit initRequest = (RequestInit)call.Request;
response = new RequestResponse();
response.Content = new string[] { string.Empty + initRequest.SessionId, Guid.NewGuid().ToString() };
response.ResultCode = (int)RingMasterException.Code.Ok;
break;
}
default:
{
response = await this.requestHandler.Request(call.Request);
break;
}
}
response.CallId = call.CallId;
connection.Send(this.protocol.SerializeResponse(response, this.protocolVersion));
});
};
connection.OnConnectionLost = () => { };
}
public async Task <UnityWebRequest> IRequestSend(RequestCall data)
{
UnityWebRequest request;//= data();
//do
//{
request = data();
// loadingScreen.SetActive(true);
await request.SendWebRequest();
// loadingScreen.SetActive(false);
Debug.Log(request.isNetworkError);
//if (request.responseCode==403)
//{
// AppManager.Instance.SwitchScreen(0);
// //AppManager.Instance.bottomBar.SetActive(false);
// //PlayerPrefs.DeleteAll();
// // AppManager.Instance.userInfo = new UserInfo();
// SceneManager.LoadScene(0);
// //break;
//}
if (request.error != null)
{
print(request.error);
print(request.downloadHandler.text);
// noInternet.SetActive(true);
await new WaitWhile(() => { return(noInternet.activeSelf == true); });
}
// }
//while (request.error != null);
Debug.Log(request.downloadHandler.text);
return(request);
}
/// <summary>
/// Serialize a <see cref="RequestCall"/>.
/// </summary>
/// <param name="request">Request to serialize</param>
/// <param name="version">Serialization protocol version to use</param>
/// <returns>Serialized representation of the given request</returns>
public byte[] SerializeRequest(RequestCall request, uint version)
{
using (var serializer = new Serializer(version))
{
serializer.SerializeRequest(request);
return(serializer.GetBytes());
}
}
/// <summary>
/// Serialize a <see cref="RequestCall"/>.
/// </summary>
/// <param name="request">Request to serialize</param>
public void SerializeRequest(RequestCall request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
this.binaryWriter.Write((uint)RequestType.RequestCall);
this.binaryWriter.Write((ulong)request.CallId);
this.SerializeRingmasterRequest(request.Request);
}
/// <summary>
/// Send a request through the given connection.
/// </summary>
/// <param name="connection">Connection through which the request must be sent</param>
/// <param name="request">Request to send</param>
/// <returns>A <see cref="Task"/> that tracks execution of this method</returns>
private async Task SendRequest(IConnection connection, RequestWrapper request)
{
switch (request.WrappedRequest.RequestType)
{
case RingMasterRequestType.Exists:
{
var existsRequest = (RequestExists)request.WrappedRequest;
request.AssociatedWatcher = this.RegisterWatcher(existsRequest.Watcher, existsRequest.Path);
existsRequest.Watcher = request.AssociatedWatcher;
break;
}
case RingMasterRequestType.GetData:
{
var getDataRequest = (RequestGetData)request.WrappedRequest;
request.AssociatedWatcher = this.RegisterWatcher(getDataRequest.Watcher, getDataRequest.Path);
getDataRequest.Watcher = request.AssociatedWatcher;
break;
}
case RingMasterRequestType.GetChildren:
{
var getChildrenRequest = (RequestGetChildren)request.WrappedRequest;
request.AssociatedWatcher = this.RegisterWatcher(getChildrenRequest.Watcher, getChildrenRequest.Path);
getChildrenRequest.Watcher = request.AssociatedWatcher;
break;
}
}
RequestCall call = new RequestCall
{
CallId = request.CallId,
Request = request.WrappedRequest,
};
try
{
this.cancellationTokenSource.Token.ThrowIfCancellationRequested();
byte[] requestPacket = this.communicationProtocol.SerializeRequest(call, connection.ProtocolVersion);
RingMasterClientEventSource.Log.Send(connection.Id, call.CallId, requestPacket.Length);
await connection.SendAsync(requestPacket);
this.instrumentation.RequestSent(call.CallId, call.Request.RequestType, requestPacket.Length);
}
catch (Exception ex)
{
RingMasterClientEventSource.Log.RequestSendFailed(connection.Id, request.CallId, ex.ToString());
this.instrumentation.RequestSendFailed(request.CallId, request.WrappedRequest.RequestType);
throw;
}
}
public async Task <UnityWebRequest> IRequestSend(RequestCall data)
{
UnityWebRequest request;//= data();
request = data();
await request.SendWebRequest();
Debug.Log(request.isNetworkError);
return(request);
}
/// <summary>
/// Callback to be used by Connection.OnPacketReceived in secure transport
/// </summary>
/// <param name="packet">Packet received from the TCP connection</param>
public void OnPacketReceived(byte[] packet)
{
var connection = this.Connection;
var timer = Stopwatch.StartNew();
RequestCall call = this.protocol.DeserializeRequest(packet, packet.Length, connection.ProtocolVersion);
try
{
RingMasterServerEventSource.Log.ProcessRequest(
this.Id,
call.CallId,
(int)call.Request.RequestType,
call.Request.Path,
packet.Length,
connection.ProtocolVersion);
// Wait until the previous request is started then let this one go.
this.requestOrdering.Wait();
this.ProcessRequest(
call.Request,
(response, exception) =>
{
if (exception == null)
{
response.CallId = call.CallId;
}
else
{
RingMasterServerEventSource.Log.ProcessRequestFailed(this.Id, call.CallId, exception.ToString());
response = new RequestResponse
{
CallId = call.CallId,
ResultCode = (int)RingMasterException.Code.Systemerror,
};
}
byte[] responsePacket = this.protocol.SerializeResponse(response, connection.ProtocolVersion);
connection.Send(responsePacket);
timer.Stop();
RingMasterServerEventSource.Log.ProcessRequestCompleted(this.Id, call.CallId, timer.ElapsedMilliseconds);
this.instrumentation?.OnRequestCompleted(call.Request.RequestType, timer.Elapsed);
});
}
catch (Exception ex)
{
RingMasterServerEventSource.Log.ProcessRequestFailed(this.Id, call.CallId, ex.ToString());
}
}
public async Task <UnityWebRequest> IRequestSend(RequestCall data, bool showLoading = true)
{
UnityWebRequest request;
do
{
request = data();
if (showLoading)
{
await request.SendWebRequest();
}
if (request.error != null)
{
print(request.error);
print(request.downloadHandler.text);
if (request.error != null)
{
if (request.isHttpError)
{
if (request.downloadHandler.text.Contains("wrong phone or code"))
{
//TODO BAD IMPLEMENTATION FOR SPECIAL CASE
break;
}
else if (request.responseCode == 403)
{
AppManager.Instance.userInfo = new UserInfo();
AppManager.Instance.userInfo.user = new User();
PlayerPrefs.DeleteAll();
AppManager.Instance.SwitchScreen(0);
break;
}
else
{
}
}
else
{
}
}
}
}while (request.error != null);
//Debug.Log(request.downloadHandler.text);
return(request);
}
/**
* MNasod wrap smart contract call functionality.
* @see {@link https://github.com/nebulasio/wiki/blob/master/rpc.md#call}
*
* @param {TransactionOptions} options
*
* @return [Transcation hash]{@link https://github.com/nebulasio/wiki/blob/master/rpc.md#call}
*
* @example
* var api = new Neb().api;
* api.call({
* chainID: 1,
* from: "n1QZMXSZtW7BUerroSms4axNfyBGyFGkrh5",
* to: "n1SAeQRVn33bamxN4ehWUT7JGdxipwn8b17",
* value: 10,
* nonce: 12,
* gasPrice: 1000000,
* gasLimit: 2000000,
* contract: {
* function: "save",
* args: "[0]"
* }
* }).then(function(tx) {
* //code
* });
*/
public async Task <dynamic> CallAsync(string from, string to, string value, string nonce, int gasPrice, int gasLimit, string function, string args)
{
RequestCall callRequest = new RequestCall()
{
From = from,
To = to,
Value = value,
Nonce = nonce,
GasPrice = Convert.ToString(gasPrice),
GasLimit = Convert.ToString(gasLimit),
Contract = new RequestContract()
{
Function = function,
Args = args
}
};
string json = Newtonsoft.Json.JsonConvert.SerializeObject(callRequest, Formatting.Indented, CamelCaseSetting);
return(await sendRequestAsync <dynamic>("post", "/call", json));
}
public async Task <UnityWebRequest> IRequestSend(RequestCall data)
{
UnityWebRequest request;//= data();
request = data();
// loadingScreen.SetActive(true);
await request.SendWebRequest();
// loadingScreen.SetActive(false);
//Debug.Log(request.isNetworkError);
//if (request.responseCode == 403)
//{
// SceneManager.LoadScene(0);
//}
if (request.error != null)
{
print(request.error);
print(request.downloadHandler.text);
// noInternet.SetActive(true);
await new WaitWhile(() => { return(noInternet.activeSelf == true); });
}
Debug.Log(request.downloadHandler.text);
return(request);
}
