/// <inheritdoc/>
public void SendEmptyMessage(Exchange exchange, EmptyMessage message)
{
if (message.Type == MessageType.RST && exchange != null)
{
// We have rejected the request or response
exchange.Complete = true;
}
}
/// <summary>
/// Reject this exchange and therefore the request.
/// Sends an RST back to the client.
/// </summary>
public void SendReject()
{
System.Diagnostics.Debug.Assert(_origin == Origin.Remote);
_request.IsRejected = true;
EmptyMessage rst = EmptyMessage.NewRST(_request);
_endpoint.SendEmptyMessage(this, rst);
}
public void AccessingNoneTest()
{
var accessor = new DefaultMessageAccessor();
var message = new EmptyMessage();
Assert.IsFalse(accessor.TryGetEntityId(message, out _));
Assert.IsFalse(accessor.TryGetConcurrencyToken(message, out _));
}
/// <summary>
/// Create a new acknowledgment for the specified message.
/// </summary>
/// <param name="message">the message to acknowledge</param>
/// <returns>the acknowledgment</returns>
public static EmptyMessage NewACK(Message message)
{
EmptyMessage ack = new EmptyMessage(MessageType.ACK);
ack.ID = message.ID;
ack.Token = CoapConstants.EmptyToken;
ack.Destination = message.Source;
return(ack);
}
/// <summary>
/// Create a new reset message for the specified message.
/// </summary>
/// <param name="message">the message to reject</param>
/// <returns>the reset</returns>
public static EmptyMessage NewRST(Message message)
{
EmptyMessage rst = new EmptyMessage(MessageType.RST);
rst.ID = message.ID;
rst.Token = CoapConstants.EmptyToken;
rst.Destination = message.Source;
return(rst);
}
public void CloneTest()
{
var message1 = new EmptyMessage();
var clone1 = message1.Clone();
Assert.IsTrue(clone1 is EmptyMessage);
//string message1Json = message1.ToString();
//Debug.Log(message1Json);
Game.Initialize();
Game.SetTestMode();
var card = new Card00001(Game.Player);
var targets = new List <Card>()
{
card
};
var message2 = new MoveMessage()
{
Targets = targets,
Reason = card.sk1
};
var clone2 = message2.Clone() as MoveMessage;
Assert.IsTrue(clone2 is MoveMessage);
Assert.IsTrue(clone2.Reason == card.sk1);
Assert.IsFalse(clone2.Targets == targets);
Assert.IsTrue(clone2.Targets.SequenceEqual(targets));
//string message2Json = message2.ToString();
//Debug.Log(message2Json);
DeployMessage message3 = new DeployMessage()
{
Targets = targets,
ActionedList = new List <bool>()
{
true
},
ToFrontFieldList = new List <bool>()
{
false
},
Reason = null
};
DeployMessage clone3 = message3.Clone() as DeployMessage;
Assert.IsTrue(clone3 is DeployMessage);
Assert.IsTrue(clone3.Reason == null);
Assert.IsFalse(clone3.Targets == targets);
Assert.IsTrue(clone3.Targets.SequenceEqual(targets));
Assert.IsTrue(clone3.ActionedList[0]);
Assert.IsFalse(clone3.ToFrontFieldList[0]);
clone3.ActionedList[0] = false;
Assert.IsFalse(clone3.ActionedList[0]);
Assert.IsTrue(message3.ActionedList[0]);
//string message3Json = message3.ToString();
//Debug.Log(message2Json);
}
public void Should_be_able_to_serialize_single_message_with_default_namespaces()
{
var serializer = SerializerFactory.Create <EmptyMessage>();
var msg = new EmptyMessage();
var expected = @"<EmptyMessage xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns=""http://tempuri.net/NServiceBus.Serializers.XML.Test""></EmptyMessage>";
AssertSerializedEquals(serializer, msg, expected);
}
void IOutbox.SendEmptyMessage(Exchange exchange, EmptyMessage message)
{
_matcher.SendEmptyMessage(exchange, message);
if (!message.IsCancelled)
{
_channel.Send(Serialize(message), message.Destination);
}
}
/// <summary>
/// When we receive a duplicate of a request, we stop it here and do not
/// forward it to the upper layer. If the server has already sent a response,
/// we send it again. If the request has only been acknowledged (but the ACK
/// has gone lost or not reached the client yet), we resent the ACK. If the
/// request has neither been responded, acknowledged or rejected yet, the
/// server has not yet decided what to do with the request and we cannot do
/// anything.
/// </summary>
public override void ReceiveRequest(INextLayer nextLayer, Exchange exchange, Request request)
{
if (request.Duplicate)
{
// Request is a duplicate, so resend ACK, RST or response
if (exchange.CurrentResponse != null)
{
if (log.IsDebugEnabled)
{
log.Debug("Respond with the current response to the duplicate request");
}
base.SendResponse(nextLayer, exchange, exchange.CurrentResponse);
}
else if (exchange.CurrentRequest != null)
{
if (exchange.CurrentRequest.IsAcknowledged)
{
if (log.IsDebugEnabled)
{
log.Debug("The duplicate request was acknowledged but no response computed yet. Retransmit ACK.");
}
EmptyMessage ack = EmptyMessage.NewACK(request);
SendEmptyMessage(nextLayer, exchange, ack);
}
else if (exchange.CurrentRequest.IsRejected)
{
if (log.IsDebugEnabled)
{
log.Debug("The duplicate request was rejected. Reject again.");
}
EmptyMessage rst = EmptyMessage.NewRST(request);
SendEmptyMessage(nextLayer, exchange, rst);
}
else
{
if (log.IsDebugEnabled)
{
log.Debug("The server has not yet decided what to do with the request. We ignore the duplicate.");
}
// The server has not yet decided, whether to acknowledge or
// reject the request. We know for sure that the server has
// received the request though and can drop this duplicate here.
}
}
else
{
// Lost the current request. The server has not yet decided what to do.
}
}
else
{
// Request is not a duplicate
exchange.CurrentRequest = request;
base.ReceiveRequest(nextLayer, exchange, request);
}
}
/// <inheritdoc/>
public EmptyMessage DecodeEmptyMessage()
{
System.Diagnostics.Debug.Assert(!IsRequest && !IsResponse);
EmptyMessage message = new EmptyMessage(m_type);
message.Type = m_type;
message.ID = m_id;
ParseMessage(message);
return(message);
}
private Byte[] Serialize(EmptyMessage message)
{
Byte[] bytes = message.Bytes;
if (bytes == null)
{
bytes = Spec.NewMessageEncoder().Encode(message);
message.Bytes = bytes;
}
return(bytes);
}
/// <summary>
/// Accept this exchange and therefore the request. Only if the request's
/// type was a <code>CON</code> and the request has not been acknowledged
/// yet, it sends an ACK to the client.
/// </summary>
public virtual void SendAccept()
{
System.Diagnostics.Debug.Assert(_origin == Origin.Remote);
if (_request.Type == MessageType.CON && !_request.IsAcknowledged)
{
_request.IsAcknowledged = true;
EmptyMessage ack = EmptyMessage.NewACK(_request);
_endpoint.SendEmptyMessage(this, ack);
}
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
case PacketOpcode.Evt_Combat__CancelAttack_ID:
case PacketOpcode.Evt_Combat__CommenceAttack_ID: {
EmptyMessage message = new EmptyMessage(opcode);
message.contributeToTreeView(outputTreeView);
break;
}
// TODO: Evt_Combat__UntargetedMeleeAttack_ID
case PacketOpcode.Evt_Combat__TargetedMeleeAttack_ID: {
TargetedMeleeAttack message = TargetedMeleeAttack.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Combat__TargetedMissileAttack_ID: {
TargetedMissileAttack message = TargetedMissileAttack.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
// TODO: Evt_Combat__UntargetedMissileAttack_ID
case PacketOpcode.Evt_Combat__ChangeCombatMode_ID: {
ChangeCombatMode message = ChangeCombatMode.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Combat__QueryHealth_ID: {
QueryHealth message = QueryHealth.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Combat__QueryHealthResponse_ID: {
QueryHealthResponse message = QueryHealthResponse.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
default: {
handled = false;
break;
}
}
return(handled);
}
public bool SendReturnToLobby()
{
if ((base.client == null) || !base.client.isConnected)
{
return(false);
}
EmptyMessage msg = new EmptyMessage();
base.client.Send(0x2e, msg);
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="TransferTransaction"/> class.
/// </summary>
/// <param name="networkType">Type of the network.</param>
/// <param name="version">The version.</param>
/// <param name="deadline">The deadline.</param>
/// <param name="fee">The fee.</param>
/// <param name="recipient">The recipient.</param>
/// <param name="mosaics">The mosaics.</param>
/// <param name="message">The message.</param>
/// <exception cref="System.ArgumentNullException">recipient</exception>
internal TransferTransaction(NetworkType.Types networkType, byte version, Deadline deadline, ulong fee, Address recipient, List <Mosaic> mosaics, IMessage message)
{
Address = recipient ?? throw new ArgumentNullException(nameof(recipient));
TransactionType = TransactionTypes.Types.Transfer;
Version = version;
Deadline = deadline;
Message = message ?? EmptyMessage.Create();
Mosaics = mosaics ?? new List <Mosaic>();;
NetworkType = networkType;
Fee = fee == 0 ? CalculateFee() : fee;
}
public void Should_be_able_to_serialize_single_message_with_specified_namespace_with_trailing_forward_slashes()
{
var serializer = SerializerFactory.Create <EmptyMessage>();
serializer.Namespace = "http://super.com///";
var msg = new EmptyMessage();
var expected = @"<EmptyMessage xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns=""http://super.com/NServiceBus.Serializers.XML.Test""></EmptyMessage>";
AssertSerializedEquals(serializer, msg, expected);
}
public override void OnServerAddPlayer(NetworkConnection conn, short playerControllerId)
{
// check MaxPlayersPerConnection
int numPlayersForConnection = 0;
foreach (var player in conn.playerControllers)
{
if (player.IsValid)
{
numPlayersForConnection += 1;
}
}
if (numPlayersForConnection >= maxPlayersPerConnection)
{
if (LogFilter.logWarn)
{
Debug.LogWarning("NetworkLobbyManager no more players for this connection.");
}
var errorMsg = new EmptyMessage();
conn.Send(MsgType.LobbyAddPlayerFailed, errorMsg);
return;
}
byte slot = FindSlot();
if (slot == Byte.MaxValue)
{
if (LogFilter.logWarn)
{
Debug.LogWarning("NetworkLobbyManager no space for more players");
}
var errorMsg = new EmptyMessage();
conn.Send(MsgType.LobbyAddPlayerFailed, errorMsg);
return;
}
var newLobbyGameObject = OnLobbyServerCreateLobbyPlayer(conn, playerControllerId);
if (newLobbyGameObject == null)
{
Debug.Log("Instantiate");
newLobbyGameObject = (GameObject)Instantiate(playerPrefab.gameObject, Vector3.zero, Quaternion.identity);
}
var newLobbyPlayer = newLobbyGameObject.GetComponent <CaptainsMessPlayer>();
newLobbyPlayer.slot = slot;
lobbySlots[slot] = newLobbyPlayer;
NetworkServer.AddPlayerForConnection(conn, newLobbyGameObject, playerControllerId);
}
public override async Task GetAllGauges(EmptyMessage request, IServerStreamWriter <GaugeResponse> responseStream, ServerCallContext context)
{
long qps = GetQpsAndReset();
var response = new GaugeResponse
{
Name = GaugeName,
LongValue = qps
};
await responseStream.WriteAsync(response);
}
private void Reject(Message message)
{
EmptyMessage rst = EmptyMessage.NewRST(message);
Fire(SendingEmptyMessage, rst);
if (!rst.IsCancelled)
{
_channel.Send(Serialize(rst), rst.Destination);
}
}
public bool SendReturnToLobby()
{
if (this.client == null || !this.client.isConnected)
{
return(false);
}
EmptyMessage msg = new EmptyMessage();
this.client.Send(46, msg);
return(true);
}
void IOutbox.SendEmptyMessage(Exchange exchange, EmptyMessage message)
{
Matcher.SendEmptyMessage(exchange, message);
if (!message.IsCancelled)
{
MockQueueItem item = new MockQueueItem(MockQueueItem.QueueType.ClientSendEmptyMessageNetwork, message);
item.Destination = message.Destination;
item.Source = MyAddress;
Pump.Queue.Enqueue(item);
}
}
private void Reject(Message message)
{
EmptyMessage rst = EmptyMessage.NewRST(message);
if (!rst.IsCancelled)
{
MockQueueItem item = new MockQueueItem(MockQueueItem.QueueType.ClientSendEmptyMessageNetwork, rst);
item.Destination = message.Destination;
item.Source = MyAddress;
Pump.Queue.Enqueue(item);
}
}
public override bool Try(Message message, ref Message substitute)
{
if (message is AvoidMessage)
{
if ((message as AvoidMessage).AttackingUnit == Owner)
{
substitute = new EmptyMessage();
return(false);
}
}
return(true);
}
public async Task <StringMessage> ClientTest(EmptyMessage request, ServerCallContext context)
{
var result = await _greeterClient.SayHelloAsync(new Helloworld.HelloRequest()
{
Name = "yilei"
});
return(new StringMessage()
{
Value = $"{result.Message},guid {_testScope.Id} "
});
}
public void Should_be_able_to_serialize_single_message_with_specified_namespaces()
{
var serializer = SerializerFactory.Create <EmptyMessage>();
serializer.SkipWrappingElementForSingleMessages = true;
serializer.Namespace = "http://super.com";
var msg = new EmptyMessage();
var expected = @"<EmptyMessage xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns=""http://super.com/NServiceBus.Serializers.XML.Test"">";
AssertSerializedEquals(serializer, msg, expected);
}
public bool SendReturnToLobby()
{
if (client == null || !client.isConnected)
{
return(false);
}
var msg = new EmptyMessage();
client.Send(MsgType.LobbyReturnToLobby, msg);
return(true);
}
public override void OnServerAddPlayer(NetworkConnection conn, short playerControllerId)
{
if (SceneManager.GetSceneAt(0).name != this.m_LobbyScene)
{
return;
}
int num = 0;
using (List <PlayerController> .Enumerator enumerator = conn.playerControllers.GetEnumerator())
{
while (enumerator.MoveNext())
{
if (enumerator.Current.IsValid)
{
++num;
}
}
}
if (num >= this.maxPlayersPerConnection)
{
if (LogFilter.logWarn)
{
Debug.LogWarning((object)"NetworkLobbyManager no more players for this connection.");
}
EmptyMessage emptyMessage = new EmptyMessage();
conn.Send((short)45, (MessageBase)emptyMessage);
}
else
{
byte slot = this.FindSlot();
if ((int)slot == (int)byte.MaxValue)
{
if (LogFilter.logWarn)
{
Debug.LogWarning((object)"NetworkLobbyManager no space for more players");
}
EmptyMessage emptyMessage = new EmptyMessage();
conn.Send((short)45, (MessageBase)emptyMessage);
}
else
{
GameObject player = this.OnLobbyServerCreateLobbyPlayer(conn, playerControllerId);
if ((Object)player == (Object)null)
{
player = (GameObject)Object.Instantiate((Object)this.lobbyPlayerPrefab.gameObject, Vector3.zero, Quaternion.identity);
}
NetworkLobbyPlayer component = player.GetComponent <NetworkLobbyPlayer>();
component.slot = slot;
this.lobbySlots[(int)slot] = component;
NetworkServer.AddPlayerForConnection(conn, player, playerControllerId);
}
}
}
public override void OnServerAddPlayer(NetworkConnection conn, short playerControllerId)
{
string name = SceneManager.GetSceneAt(0).name;
if (name != m_LobbyScene)
{
return;
}
int num = 0;
for (int i = 0; i < conn.playerControllers.Count; i++)
{
if (conn.playerControllers[i].IsValid)
{
num++;
}
}
if (num >= maxPlayersPerConnection)
{
if (LogFilter.logWarn)
{
Debug.LogWarning("NetworkLobbyManager no more players for this connection.");
}
EmptyMessage msg = new EmptyMessage();
conn.Send(45, msg);
return;
}
byte b = FindSlot();
if (b == byte.MaxValue)
{
if (LogFilter.logWarn)
{
Debug.LogWarning("NetworkLobbyManager no space for more players");
}
EmptyMessage msg2 = new EmptyMessage();
conn.Send(45, msg2);
return;
}
GameObject gameObject = OnLobbyServerCreateLobbyPlayer(conn, playerControllerId);
if (gameObject == null)
{
gameObject = Object.Instantiate(lobbyPlayerPrefab.gameObject, Vector3.zero, Quaternion.identity);
}
NetworkLobbyPlayer component = gameObject.GetComponent <NetworkLobbyPlayer>();
component.slot = b;
lobbySlots[b] = component;
NetworkServer.AddPlayerForConnection(conn, gameObject, playerControllerId);
}
public void ReadMessages()
{
try
{
bool connected = true;
do
{
int recebimento = stream.ReadByte();
switch (recebimento)
{
case MessageType.SERVER_INFORMATION:
serverInformation = Serializer.DeserializeWithLengthPrefix <ServerInformation>(stream, PrefixStyle.Base128);
LoginReturn();
break;
case MessageType.MAP_RESPONSE:
UpdateMap(Serializer.DeserializeWithLengthPrefix <MapResponse>(stream, PrefixStyle.Base128));
break;
case MessageType.MAP_UPDATE:
UpdateMap(Serializer.DeserializeWithLengthPrefix <MapUpdate>(stream, PrefixStyle.Base128));
break;
case 1:
connected = false;
break;
case -1:
connected = false;
break;
default:
Messages.AddLogMessage("Mensagem não tratada. Código =" + recebimento);
EmptyMessage message = Serializer.DeserializeWithLengthPrefix <EmptyMessage>(stream, PrefixStyle.Base128);
break;
}
} while (connected);
}
catch (IOException ex)
{
editor.timerConnect.Enabled = false;
editor.CloseMap();
MessageBox.Show("Você foi desconectado, seu mapa foi fechado!");
}
catch (Exception ex)
{
editor.timerConnect.Enabled = false;
MessageBox.Show("ReadMessages: " + ex.Message);
editor.CloseMap();
}
}
public override bool acceptMessageData(BinaryReader messageDataReader, TreeView outputTreeView)
{
bool handled = true;
PacketOpcode opcode = Util.readOpcode(messageDataReader);
switch (opcode)
{
case PacketOpcode.Evt_Game__Join_ID:
{
Join message = Join.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Game__Quit_ID:
{
EmptyMessage message = new EmptyMessage(opcode);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Game__Stalemate_ID:
{
Stalemate message = Stalemate.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Game__Recv_JoinGameResponse_ID:
{
Recv_JoinGameResponse message = Recv_JoinGameResponse.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
case PacketOpcode.Evt_Game__Recv_GameOver_ID:
{
Recv_GameOver message = Recv_GameOver.read(messageDataReader);
message.contributeToTreeView(outputTreeView);
break;
}
default: {
handled = false;
break;
}
}
return(handled);
}
/// <inheritdoc/>
public EmptyMessage DecodeEmptyMessage()
{
System.Diagnostics.Debug.Assert(!IsRequest && !IsResponse);
EmptyMessage message = new EmptyMessage(_type);
message.Type = _type;
message.ID = _id;
ParseMessage(message);
return message;
}
/// <summary>
/// If we receive an ACK or RST, we mark the outgoing request or response
/// as acknowledged or rejected respectively and cancel its retransmission.
/// </summary>
public override void ReceiveEmptyMessage(INextLayer nextLayer, Exchange exchange, EmptyMessage message)
{
switch (message.Type)
{
case MessageType.ACK:
if (exchange.Origin == Origin.Local)
exchange.CurrentRequest.IsAcknowledged = true;
else
exchange.CurrentResponse.IsAcknowledged = true;
break;
case MessageType.RST:
if (exchange.Origin == Origin.Local)
exchange.CurrentRequest.IsRejected = true;
else
exchange.CurrentResponse.IsRejected = true;
break;
default:
if (log.IsWarnEnabled)
log.Warn("Empty messgae was not ACK nor RST: " + message);
break;
}
TransmissionContext ctx = (TransmissionContext)exchange.Remove(TransmissionContextKey);
if (ctx != null)
ctx.Cancel();
base.ReceiveEmptyMessage(nextLayer, exchange, message);
}
/// <inheritdoc/>
public void SendEmptyMessage(Exchange exchange, EmptyMessage message)
{
_executor.Start(() => _coapStack.SendEmptyMessage(exchange, message));
}
private void ReceiveData(DataReceivedEventArgs e)
{
IMessageDecoder decoder = Spec.NewMessageDecoder(e.Data);
if (decoder.IsRequest)
{
Request request;
try
{
request = decoder.DecodeRequest();
}
catch (Exception)
{
if (decoder.IsReply)
{
if (log.IsWarnEnabled)
log.Warn("Message format error caused by " + e.EndPoint);
}
else
{
// manually build RST from raw information
EmptyMessage rst = new EmptyMessage(MessageType.RST);
rst.Destination = e.EndPoint;
rst.ID = decoder.ID;
_channel.Send(Serialize(rst), rst.Destination);
if (log.IsWarnEnabled)
log.Warn("Message format error caused by " + e.EndPoint + " and reseted.");
}
return;
}
request.Source = e.EndPoint;
Exchange exchange = _matcher.ReceiveRequest(request);
if (exchange != null)
{
exchange.EndPoint = this;
_coapStack.ReceiveRequest(exchange, request);
}
}
else if (decoder.IsResponse)
{
Response response = decoder.DecodeResponse();
response.Source = e.EndPoint;
Exchange exchange = _matcher.ReceiveResponse(response);
if (exchange != null)
{
response.RTT = (DateTime.Now - exchange.Timestamp).TotalMilliseconds;
exchange.EndPoint = this;
_coapStack.ReceiveResponse(exchange, response);
}
else if (response.Type != MessageType.ACK)
{
if (log.IsDebugEnabled)
log.Debug("Rejecting unmatchable response from " + e.EndPoint);
Reject(response);
}
}
else if (decoder.IsEmpty)
{
EmptyMessage message = decoder.DecodeEmptyMessage();
message.Source = e.EndPoint;
// CoAP Ping
if (message.Type == MessageType.CON || message.Type == MessageType.NON)
{
if (log.IsDebugEnabled)
log.Debug("Responding to ping by " + e.EndPoint);
Reject(message);
}
else
{
Exchange exchange = _matcher.ReceiveEmptyMessage(message);
if (exchange != null)
{
exchange.EndPoint = this;
_coapStack.ReceiveEmptyMessage(exchange, message);
}
}
}
else if (log.IsDebugEnabled)
{
log.Debug("Silently ignoring non-CoAP message from " + e.EndPoint);
}
}
private Byte[] Serialize(EmptyMessage message)
{
Byte[] bytes = message.Bytes;
if (bytes == null)
{
bytes = Spec.NewMessageEncoder().Encode(message);
message.Bytes = bytes;
}
return bytes;
}
void IOutbox.SendEmptyMessage(Exchange exchange, EmptyMessage message)
{
_matcher.SendEmptyMessage(exchange, message);
if (!message.IsCancelled)
_channel.Send(Serialize(message), message.Destination);
}
/// <inheritdoc/>
public void SendEmptyMessage(Exchange exchange, EmptyMessage message)
{
if (message.Type == MessageType.RST && exchange != null)
{
// We have rejected the request or response
exchange.Complete = true;
}
/*
* We do not expect any response for an empty message
*/
if (message.ID == Message.None && log.IsWarnEnabled)
log.Warn("Empy message " + message + " has no ID // debugging");
}
/// <inheritdoc/>
public void SendEmptyMessage(Exchange exchange, EmptyMessage message)
{
if (message.Type == MessageType.RST && exchange != null)
{
// We have rejected the request or response
exchange.Complete = true;
}
}
public void SendEmptyMessage(Exchange exchange, EmptyMessage message)
{
throw new NotImplementedException();
}
public override async Task GetAllGauges(EmptyMessage request, IServerStreamWriter<GaugeResponse> responseStream, ServerCallContext context)
{
long qps = GetQpsAndReset();
var response = new GaugeResponse
{
Name = GaugeName,
LongValue = qps
};
await responseStream.WriteAsync(response);
}
/// <inheritdoc/>
public Byte[] Encode(EmptyMessage message)
{
DatagramWriter writer = new DatagramWriter();
Serialize(writer, message, Code.Empty);
return writer.ToByteArray();
}
/// <inheritdoc/>
public Exchange ReceiveEmptyMessage(EmptyMessage message)
{
Exchange.KeyID keyID = new Exchange.KeyID(message.ID, message.Source);
Exchange exchange;
if (_exchangesByID.TryGetValue(keyID, out exchange))
{
if (log.IsDebugEnabled)
log.Debug("Exchange got reply: Cleaning up " + keyID);
_exchangesByID.Remove(keyID);
return exchange;
}
else
{
if (log.IsInfoEnabled)
log.Info("Matcher received empty message that does not match any exchange: " + message);
// ignore message;
return null;
} // else, this is an ACK for an unknown exchange and we ignore it
}
/// <inheritdoc/>
public Exchange ReceiveEmptyMessage(EmptyMessage message)
{
// local namespace
Exchange.KeyID keyID = new Exchange.KeyID(message.ID, null);
Exchange exchange;
if (_exchangesByID.TryGetValue(keyID, out exchange))
{
if (log.IsDebugEnabled)
log.Debug("Exchange got reply: Cleaning up " + keyID);
_exchangesByID.Remove(keyID);
return exchange;
}
else
{
if (log.IsInfoEnabled)
log.Info("Ignoring unmatchable empty message from " + message.Source + ": " + message);
return null;
}
}
/// <inheritdoc/>
public override void ReceiveEmptyMessage(INextLayer nextLayer, Exchange exchange, EmptyMessage message)
{
// NOTE: We could also move this into the MessageObserverAdapter from
// sendResponse into the method rejected().
if (message.Type == MessageType.RST && exchange.Origin == Origin.Remote)
{
// The response has been rejected
ObserveRelation relation = exchange.Relation;
if (relation != null)
{
relation.Cancel();
} // else there was no observe relation ship and this layer ignores the rst
}
base.ReceiveEmptyMessage(nextLayer, exchange, message);
}
