private async Task CommandAsync(PacketPayload payload, CancellationToken cancellationToken)
{
await _completionLock.WaitAsync(cancellationToken).ConfigureAwait(false);
_commandCompletionSource = new TaskCompletionSource <Packet>();
try
{
var packet = new Packet
{
Content = new PacketContent
{
Payload = payload
}
};
Send(packet);
var responsePacket = await _commandCompletionSource.Task.ConfigureAwait(false);
var messageId = responsePacket.Content.MessageId;
if (messageId != MessageId.ACK_ACK)
{
throw new InvalidOperationException($"Received {messageId}");
}
}
finally
{
_completionLock.Release();
}
}
public bool TryProcessPayload(PacketPayload payload, IMessageParameters parameters, INetPeer peer)
{
Logger.DebugFormat("Recieved Payload Type: {0} from Peer: {1}", payload?.GetType(), peer.PeerDetails.ConnectionID);
//Always return false for logging so we don't consume
return(false);
}
/// <summary>
/// Handles outgoing requests using the internal registered middlewares.
/// </summary>
/// <param name="request">Request to process.</param>
/// <param name="payload">Payload to process.</param>
private void ProcessRequestMiddlewares(IRestRequest request, PacketPayload payload)
{
//We move forward through the middlewares to give them a chance
//to process the requests.
for (int i = 0; i < restsharpMiddlewares.Count; i++)
restsharpMiddlewares[i].ProcessOutgoingRequest(request, payload);
}
public virtual async Task <IActionResult> Post([FromBody] RequestMessage gladNetRequest)
{
if (!ModelState.IsValid)
{
return(new BadRequestResult());
}
//This is an ASP server. We can ONLY send back to the original sender so we can enable routeback
//This works because if there is anything in the routing stack it wasn't from this ASP server so we can enable
//routeback and it'll be sent back through the system
TPayloadType payload = gladNetRequest?.Payload?.Data as TPayloadType;
if (payload == null)
{
return(new BadRequestResult());
}
PacketPayload responsePayload = await HandlePost(payload);
ResponseMessage responseMessage = new ResponseMessage(responsePayload);
//Now check routeback info
if (gladNetRequest.isMessageRoutable)
{
gladNetRequest.ExportRoutingDataTo(responseMessage);
responseMessage.isRoutingBack = true;
}
//Return an ASP result
return(new GladNetObjectResult(responseMessage));
}
public bool ProcessOutgoingRequest(IRestRequest request, PacketPayload payload)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
//If the payload requires authorization to handle on the server then we should
//send the JWT header with the request.
//Check if the payload requires authorizatation
if (!payload.GetType().HasAttribute <AuthorizationRequiredAttribute>())
{
return(true); //return true means the middleware didn't encounter a failure
}
//If an authorization required payload is being sent but we have no token we must
//throw an error
if (!tokenService.isTokenAvailable)
{
throw new InvalidOperationException($"{nameof(ITokenService)} indicated the token was unavailable. Service cannot send {payload.GetType().Name} as it requires the token to authenticate.");
}
request.AddHeader("Authorization", tokenService.FullTokenHeaderValue);
return(true);
}
/// <summary>
/// Process the outgoing <see cref="IRestRequest"/> and returning false to indicate a failure.
/// </summary>
/// <param name="request">The rest request.</param>
/// <param name="payload">The <see cref="PacketPayload"/> being sent.</param>
/// <returns>True if the middleware processed the request and false if there was an error.</returns>
public bool ProcessOutgoingRequest(IRestRequest request, PacketPayload payload)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
AuthenticationRequest requestPayload = payload as AuthenticationRequest;
//We return true to indicate the middleware functioned correctly
if (requestPayload == null)
{
return(true);
}
//Clear out the normal parameters
request.Parameters.Clear();
//the JWT service is expecting authentication to be query string in the body
//In this form: username=Admin&password=Test123$&grant_type=password
request.AddParameter("application/x-www-form-urlencoded", $"username={requestPayload.UserName}&password={requestPayload.Password}&grant_type=password", ParameterType.RequestBody);
return(true);
}
/// <summary>
/// Enqueues a webrequest to be handled with the provided serialized data.
/// This
/// </summary>
/// <param name="requestPayload">Request payload.</param>
/// <param name="requestName">String <see cref="Type"/> name of the <see cref="PacketPayload"/> type.</param>
/// <returns>Returns the result of the enqueued request.</returns>
public SendResult EnqueueRequest(PacketPayload requestPayload)
{
//Check param
if (requestPayload == null)
throw new ArgumentNullException(nameof(requestPayload), $"Provided parameter request payload {requestPayload} is null.");
return EnqueueRequest(new RequestMessage(requestPayload), requestPayload.GetType().Name, requestPayload);
}
public SendResult SendEvent(PacketPayload payload, DeliveryMethod deliveryMethod, bool encrypt = false, byte channel = 0)
{
//TODO: Get true broadcasting functionality
foreach (INetPeer p in peers)
{
p.TrySendMessage(OperationType.Event, payload, deliveryMethod, encrypt, channel);
}
//This is a 1 to N broadcast. Can't really respond with full details using a SendResult
return(SendResult.Sent);
}
/// <summary>
/// Attempts to send a message using the provided <see cref="PacketPayload"/>.
/// </summary>
/// <param name="opType">The outgoing <see cref="OperationType"/>.</param>
/// <param name="payload">The <see cref="PacketPayload"/> to send with the message.</param>
/// <param name="deliveryMethod">Delivery method to use for the message.</param>
/// <param name="encrypt">Indicates if the message should be encrypted.</param>
/// <param name="channel">Channel to send on.</param>
/// <returns>Indicates the status of the outgoing message attempt.</returns>
public SendResult TrySendMessage(OperationType opType, PacketPayload payload, DeliveryMethod deliveryMethod, bool encrypt = false, byte channel = 0)
{
if (opType == OperationType.Request)
{
return(messageSendingService.SendRequest(payload, deliveryMethod, encrypt, channel));
}
else
{
throw new ArgumentException($"Cannot send OperationType: {opType} from client peers.", nameof(opType));
}
}
private void Poll(PacketPayload packetPayload)
{
var packet = new Packet
{
Content = new PacketContent
{
Payload = packetPayload
}
};
Send(packet);
}
protected override void OnReceiveRequest(PacketPayload payload, IMessageParameters parameters)
{
//We're not interested in unencrypted messages on the ProxyLoadBalancing server
if (!parameters.Encrypted)
{
return;
}
else
{
Logger.WarnFormat("Client: {0} at IP {1} tried to send unencrypted payload Type: {2}", PeerDetails.ConnectionID, PeerDetails.RemoteIP.ToString(), payload.GetType());
}
}
public SendResult EnqueueRequest(byte[] serializedRequest, string payloadName, PacketPayload payload)
{
if (serializedRequest == null) throw new ArgumentNullException(nameof(serializedRequest));
if (payload == null) throw new ArgumentNullException(nameof(payload));
if (string.IsNullOrEmpty(payloadName)) throw new ArgumentException($"Failed to determine endpoint URL due to invalid or unavailable payload name.", nameof(payloadName));
//TODO: Cache non-generic name
//Create a new request that targets the API/RequestName controller
//on the ASP server.
RestRequest request = new RestRequest($"/api/{GetNameWithoutGenericArity(payloadName)}", Method.POST);
//TODO: Don't just assume serialization format
//sends the request with the protobuf content type header.
request.AddParameter("application/gladnet", serializedRequest, ParameterType.RequestBody);
//Below we process outgoing and then incoming middlewares
ProcessRequestMiddlewares(request, payload);
IRestResponse response = httpClient.Post(request);
ProcessResponseMiddlewares(response);
//We should check the bytes returned in a response
//We expect a NetworkMessage (in GladNet2 to preserve routing information)
if (response.RawBytes != null && response.RawBytes.Count() > 0)
{
//With GladNet we expect to get back a NetworkMessage so we should attempt to deserialize one.
ResponseMessage responseMessage = deserializer.Deserialize<ResponseMessage>(response.RawBytes);
#if !ENDUSER
//If the message is routing back we don't need it to hit the user.
//We can routeback now
if(responseMessage.isRoutingBack)
{
//This is a difficult decision but we should indicate Sent after routing back as the message definitely was sent
messageRoutebackService.Route(responseMessage, DefaultWebMessageParameters.Default); //TODO: Deal with message parameters
return SendResult.Sent; //return, don't let the message be dispatched
}
//For GladNet2 2.x routing we have to push the AUID into the response message if it's not routing back
responseMessage.Push(pairedConnectionAUID);
#endif
//Must deserialize the payload before it reaches the user.
responseMessage.Payload.Deserialize(deserializer);
responseMessage.Dispatch(responseMessageRecieverService, DefaultWebMessageParameters.Default); //TODO: Add message parameters.
}
return SendResult.Sent;
}
public SendResult SendRequest(PacketPayload payload, DeliveryMethod deliveryMethod, bool encrypt = false, byte channel = 0)
{
if (payload == null)
{
throw new ArgumentNullException(nameof(payload), $"Payload parameter {payload} must not be null.");
}
//Right now we just ignore the payload args
//TODO: Implement support for args
//Requests are sent to ASP controlls based on the payload type names.
return(requestEnqueueStrat.EnqueueRequest(payload));
}
/// <summary>
/// Sends a Photon response message with the provided parameters
/// </summary>
/// <param name="payload">Payload to send with the message.</param>
/// <param name="unreliable">Indicates if the message should be sent unreliabily.</param>
/// <param name="encrypt">Indicates if the message should be encrypted.</param>
/// <param name="channel">Channel to send the message on.</param>
/// <returns>Indicates the result of sending the message.</returns>
private Photon.SocketServer.SendResult SendResponse(PacketPayload payload, bool unreliable, bool encrypt, byte channel)
{
//Builds the message in a context that Photon understands (dictionary of objects)
OperationResponse data = new OperationResponse(1, new Dictionary <byte, object>(1)
{
{ 0, SerializePayload(payload) }
});
//Sends the event through Photon's transport layer.
return(photonPeer.SendOperationResponse(data, new SendParameters()
{
ChannelId = channel, Encrypted = encrypt, Unreliable = unreliable
}));
}
/// <summary>
/// Attempts to send a message using the provided <see cref="PacketPayload"/>.
/// </summary>
/// <param name="opType">The outgoing <see cref="OperationType"/>.</param>
/// <param name="payload">The <see cref="PacketPayload"/> to send with the message.</param>
/// <param name="deliveryMethod">Delivery method to use for the message.</param>
/// <param name="encrypt">Indicates if the message should be encrypted.</param>
/// <param name="channel">Channel to send on.</param>
/// <returns>Indicates the status of the outgoing message attempt.</returns>
public GladNet.Common.SendResult TrySendMessage(OperationType opType, PacketPayload payload, DeliveryMethod deliveryMethod, bool encrypt = false, byte channel = 0)
{
Photon.SocketServer.SendResult result;
//Depending on the operation type we'll need to call different methods on the peer to send
switch (opType)
{
case OperationType.Event:
result = SendEvent(payload, deliveryMethod.isReliable(), encrypt, channel);
break;
case OperationType.Response:
result = SendResponse(payload, deliveryMethod.isReliable(), encrypt, channel);
break;
default:
return(GladNet.Common.SendResult.Invalid);
}
//Map the send result
switch (result)
{
case Photon.SocketServer.SendResult.Ok:
return(GladNet.Common.SendResult.Sent);
case Photon.SocketServer.SendResult.Disconnected:
return(GladNet.Common.SendResult.FailedNotConnected);
case Photon.SocketServer.SendResult.SendBufferFull:
return(GladNet.Common.SendResult.Invalid);
case Photon.SocketServer.SendResult.MessageToBig:
return(GladNet.Common.SendResult.Invalid);
case Photon.SocketServer.SendResult.InvalidChannel:
return(GladNet.Common.SendResult.Invalid);
case Photon.SocketServer.SendResult.Failed:
return(GladNet.Common.SendResult.Invalid);
case Photon.SocketServer.SendResult.InvalidContentType:
return(GladNet.Common.SendResult.Invalid);
case Photon.SocketServer.SendResult.EncryptionNotSupported:
return(GladNet.Common.SendResult.Invalid);
default:
return(GladNet.Common.SendResult.Invalid);
}
}
protected override void OnReceiveRequest(PacketPayload payload, IMessageParameters parameters)
{
//We're not interested in unencrypted messages on the ProxyLoadBalancing server
/*if (!parameters.Encrypted)
* return;
* else
* Logger.WarnFormat("AuthService: {0} at IP {1} tried to send unencrypted payload Type: {2}", PeerDetails.ConnectionID, PeerDetails.RemoteIP.ToString(), payload.GetType());*/
Logger.Debug("Recieved a message.");
//Pass this message to the handlers
requestHandler.TryProcessPayload(payload, parameters, this);
}
//ProgressEvent m_progressEvents = new ProgressEvent();
//public ProgressEvent progressEvents { get { return m_progressEvents; }}
public async Task UDPing(){
bool isError = false;
int nr = profile.pps * profile.duration;
m_isAbort = false;
profile.BenchStart(PRE_WARM_PACKET_NR);
var startMicroSec = profile.now * 1000;
var body = new PacketPayload();
if(profile.pktPayloadSize > 10){ body.msg = new string('X', profile.pktPayloadSize - 10); }
var payload = JsonSerializer.Serialize(body);
var preWarmCnt = PRE_WARM_PACKET_NR;
profile.currentSeq = -preWarmCnt;
for(;profile.currentSeq < nr; ++profile.currentSeq){
if(m_isAbort){ break; }
if(preWarmCnt > 0){
SendTestPacket(MSG_TYPE_ECHO, System.Int32.MaxValue + profile.currentSeq, payload, payload.Length);
--preWarmCnt;
if(preWarmCnt == 0){ startMicroSec = profile.now * 1000; }
var waitByMSec = (int)(1000 / profile.pps);
if(waitByMSec > 0){ await Task.Delay(waitByMSec); }
}
else {
SendTestPacket(MSG_TYPE_ECHO, profile.currentSeq, payload, payload.Length);
profile.SendHandler(profile.currentSeq);
var deltaMicroSec = 1000000 * (profile.currentSeq + 1) / profile.pps;
var waitByMSec = (int)(((startMicroSec + deltaMicroSec) / 1000) - profile.now);
//UnityEngine.Debug.Log(profile.currentSeq.ToString() + " : " + waitByMSec.ToString());
if(waitByMSec > 0){ await Task.Delay(waitByMSec); }
}
}
// 最終PacketのTimeoutを待つためにWait
await Task.Delay(TIMEOUT_MSEC);
profile.BenchEnd();
if (m_isAbort){ profile.status = Status.E_INTR; }
else if(isError) { profile.status = Status.E_CRITICAL; }
else { profile.status = Status.E_OK; }
}
public SendResult SendRequest(PacketPayload payload, DeliveryMethod deliveryMethod, bool encrypt = false, byte channel = 0)
{
//We send messages now and not payloads
RequestMessage message = new RequestMessage(payload);
//Serialize the internal payload
//We need to do this manually
message.Payload.Serialize(serializer);
//WARNING: Make sure to send encrypted parameter. There was a fault where we didn't. We cannot unit test it as it's within a MonoBehaviour
return(peer.OpCustom(1, new Dictionary <byte, object>()
{
{ 1, serializer.Serialize(message) }
}, deliveryMethod.isReliable(), channel, encrypt) ? SendResult.Sent : SendResult.Invalid);
}
public SendResult TrySendMessage(OperationType opType, PacketPayload payload, DeliveryMethod deliveryMethod, bool encrypt = false, byte channel = 0)
{
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
if (!CanSend(opType))
{
throw new InvalidOperationException($"Cannot send {opType} with the {this.GetType().Name} because the service cannot handle that {nameof(OperationType)}.");
}
INetworkMessage message = networkMessageFactory.Create(opType, payload);
return(SendValidMessage(message, deliveryMethod, encrypt, channel));
}
protected void Serialize(PacketPayload packetPayload, byte[] expected)
{
var stream = new MemoryStream();
var packet = new Packet
{
//SyncCharacters = Constants.SyncCharacters,
Content = new PacketContent
{
Payload = packetPayload
}
};
Serializer.Serialize(stream, packet);
AssertEqual(expected, stream.ToArray());
}
/// <summary>
/// Creates a new <see cref="INetworkMessage"/>
/// </summary>
/// <param name="opType">Operation type of the message.</param>
/// <param name="payload">Payload for the <see cref="INetworkMessage"/>.</param>
/// <returns>A new non-null <see cref="INetworkMessage"/>.</returns>
public INetworkMessage Create(OperationType opType, PacketPayload payload)
{
switch (opType)
{
case OperationType.Event:
return(new EventMessage(payload));
case OperationType.Request:
return(new RequestMessage(payload));
case OperationType.Response:
return(new ResponseMessage(payload));
default:
throw new InvalidOperationException($"Cannot create a {nameof(INetworkMessage)} instance for {nameof(OperationType)}: {opType}.");
}
}
public SendResult EnqueueRequest(RequestMessage requestMessage)
{
if (requestMessage == null) throw new ArgumentNullException(nameof(requestMessage));
PacketPayload payload = requestMessage.Payload.Data; //reference to save the payload
requestMessage.Payload.Serialize(serializer); //have to serialize payload first
byte[] serializedData = serializer.Serialize(requestMessage);
//This shouldn't happen but if it does we'll want some information on which type failed.
if (serializedData == null)
throw new InvalidOperationException($"Payload failed to serialize {requestMessage} of Type: {requestMessage?.Payload?.Data?.GetType()?.Name}.");
string payloadName = requestMessage.Payload?.Data?.GetType().Name;
if (payloadName == null)
throw new InvalidOperationException($"Failed to determine endpoint URL due to invalid or unavailable payload name.");
return EnqueueRequest(serializedData, payloadName, payload);
}
public SendResult SendRequest(PacketPayload payload, DeliveryMethod deliveryMethod, bool encrypt = false, byte channel = 0)
{
return(NetworkSendService.TrySendMessage(OperationType.Request, payload, deliveryMethod, encrypt, channel));
}
public TestSerialization(PacketPayload payload)
{
netsendable = new NetSendable <PacketPayload>(payload);
}
public SendResult TrySendMessage(OperationType opType, PacketPayload payload, DeliveryMethod deliveryMethod, bool encrypt = false, byte channel = 0)
{
return(CanSend(opType) ? SendRequest(payload, deliveryMethod, encrypt, channel) : SendResult.Invalid);
}
internal RawPacketHandlerEventArgs(MessageId messageId, PacketPayload packetPayload)
{
MessageId = messageId;
PacketPayload = packetPayload;
}
/// <summary>
/// Serializes the <see cref="PacketPayload"/> provided.
/// </summary>
/// <param name="payload">Payload to serialize.</param>
/// <returns>The serialized packet payload.</returns>
private byte[] SerializePayload(PacketPayload payload)
{
return(serializerStrategy.Serialize(payload));
}
