public void Store(AMQPHeader message)
{
if (message.Code.Value == HeaderCodes.TRANSFER)
{
MessageResendTimer <AMQPHeader> timer = new MessageResendTimer <AMQPHeader>(message, _listener, this, false);
Boolean added = false;
if (!((AMQPTransfer)message).DeliveryId.HasValue)
{
Int32 packetID = _packetIDCounter;
while (!added)
{
packetID = Interlocked.Increment(ref _packetIDCounter) % MAX_VALUE;
try
{
_timersMap.Add(packetID, timer);
added = true;
}
catch (ArgumentException)
{
//already exists
}
}
AMQPTransfer countable = (AMQPTransfer)message;
countable.DeliveryId = packetID;
}
else
{
_timersMap.Add((int)((AMQPTransfer)message).DeliveryId.Value, timer);
}
timer.Execute(_resendPeriod);
}
}
public void ProcessConnack(ConnackCode code, Boolean sessionPresent)
{
// CANCEL CONNECT TIMER
MessageResendTimer <MQMessage> timer = _timers.ConnectTimer;
_timers.StopConnectTimer();
// CHECK CODE , IF OK THEN MOVE TO CONNECTED AND NOTIFY NETWORK SESSION
if (code == ConnackCode.ACCEPTED)
{
SetState(ConnectionState.CONNECTION_ESTABLISHED);
if (timer != null)
{
Connect connect = (Connect)timer.Message;
if (connect.CleanSession)
{
clearAccountTopics();
}
}
_timers.StartPingTimer();
}
else
{
_timers.StopAllTimers();
_client.Shutdown();
SetState(ConnectionState.CONNECTION_FAILED);
}
}
public void Store(CoapMessage message)
{
MessageResendTimer <CoapMessage> timer = new MessageResendTimer <CoapMessage>(message, _listener, this, false);
Boolean added = false;
if (message.Token == null)
{
Int32 packetID = _packetIDCounter;
byte[] token = BitConverter.GetBytes(packetID);
while (!added)
{
packetID = Interlocked.Increment(ref _packetIDCounter) % MAX_VALUE;
token = Encoding.UTF8.GetBytes(packetID.ToString());
try
{
_timersMap.Add(token, timer);
added = true;
}
catch (ArgumentException)
{
//already exists
}
}
message.Token = token;
}
else
{
_timersMap.Add(message.Token, timer);
}
timer.Execute(_resendPeriod);
}
public void Store(byte[] token, CoapMessage message)
{
MessageResendTimer <CoapMessage> timer = new MessageResendTimer <CoapMessage>(message, _listener, this, false);
_timersMap.Add(token, timer);
timer.Execute(_resendPeriod);
}
public void StoreConnectTimer(SNMessage message)
{
if (_connectTimer != null)
{
_connectTimer.Stop();
}
_connectTimer = new MessageResendTimer <SNMessage>(message, _listener, this, true);
_connectTimer.Execute(_resendPeriod);
}
public void StartPingTimer()
{
if (_pingTimer != null)
{
_pingTimer.Stop();
}
_pingTimer = new MessageResendTimer <MQMessage>(new Pingreq(), _client, this, false);
_pingTimer.Execute(_keepalivePeriod);
}
public void StoreConnectTimer(MQMessage message)
{
if (_connectTimer != null)
{
_connectTimer.Stop();
}
_connectTimer = new MessageResendTimer <MQMessage>(message, _client, this, true);
_connectTimer.Execute(_resendPeriod);
}
public void StartPingTimer()
{
if (_pingTimer != null)
{
_pingTimer.Stop();
}
_pingTimer = new MessageResendTimer <SNMessage>(new SNPingreq(), _listener, this, false);
_pingTimer.Execute(_keepalivePeriod);
}
public void StartPingTimer()
{
if (_pingTimer != null)
{
_pingTimer.Stop();
}
_pingTimer = new MessageResendTimer <AMQPHeader>(new AMQPPing(), _listener, this, false);
_pingTimer.Execute(_client.GetKeepalivePeriod());
}
public void RefreshTimer(MessageResendTimer <CoapMessage> timer)
{
if (timer.Message.Token == null || timer.Message.Token.Length == 0)
{
timer.Execute(_keepalivePeriod);
}
else
{
timer.Execute(_resendPeriod);
}
}
public SNMessage Remove(Int32 packetID)
{
MessageResendTimer <SNMessage> timer = _timersMap[packetID];
_timersMap.Remove(packetID);
if (timer != null)
{
timer.Stop();
return(timer.Message);
}
return(null);
}
public void RefreshTimer(MessageResendTimer <SNMessage> timer)
{
switch (timer.Message.getType())
{
case SNType.PINGREQ:
timer.Execute(_keepalivePeriod);
break;
default:
timer.Execute(_resendPeriod);
break;
}
}
public void RefreshTimer(MessageResendTimer <AMQPHeader> timer)
{
switch (timer.Message.Code.Value)
{
case HeaderCodes.PING:
timer.Execute(_client.GetKeepalivePeriod());
break;
default:
timer.Execute(_resendPeriod);
break;
}
}
public void Store(Int32 packetID, AMQPHeader message)
{
Boolean isConnect = false;
if (message.Code.Value == HeaderCodes.OPEN)
{
isConnect = true;
}
MessageResendTimer <AMQPHeader> timer = new MessageResendTimer <AMQPHeader>(message, _listener, this, isConnect);
_timersMap.Add(packetID, timer);
timer.Execute(_resendPeriod);
}
public void Store(Int32 packetID, MQMessage message)
{
Boolean isConnect = false;
if (message.MessageType == MessageType.CONNECT)
{
isConnect = true;
}
MessageResendTimer <MQMessage> timer = new MessageResendTimer <MQMessage>(message, _client, this, isConnect);
_timersMap.Add(packetID, timer);
timer.Execute(_resendPeriod);
}
public void Store(Int32 packetID, SNMessage message)
{
Boolean isConnect = false;
if (message.getType() == SNType.CONNECT)
{
isConnect = true;
}
MessageResendTimer <SNMessage> timer = new MessageResendTimer <SNMessage>(message, _listener, this, isConnect);
_timersMap.Add(packetID, timer);
timer.Execute(_resendPeriod);
}
public CoapMessage Remove(byte[] token)
{
if (_timersMap.ContainsKey(token))
{
MessageResendTimer <CoapMessage> timer = _timersMap[token];
_timersMap.Remove(token);
if (timer != null)
{
timer.Stop();
return(timer.Message);
}
}
return(null);
}
public AMQPHeader Remove(Int32 packetID)
{
MessageResendTimer <AMQPHeader> timer = null;
if (_timersMap.ContainsKey(packetID))
{
timer = _timersMap[packetID];
}
_timersMap.Remove(packetID);
if (timer != null)
{
timer.Stop();
return(timer.Message);
}
return(null);
}
public void Store(SNMessage message)
{
Boolean isConnect = false;
if (message.getType() == SNType.CONNECT)
{
isConnect = true;
}
MessageResendTimer <SNMessage> timer = new MessageResendTimer <SNMessage>(message, _listener, this, isConnect);
Boolean added = false;
if (!((CountableMessage)message).MessageID.HasValue)
{
Int32 packetID = _packetIDCounter;
while (!added)
{
packetID = Interlocked.Increment(ref _packetIDCounter) % MAX_VALUE;
try
{
_timersMap.Add(packetID, timer);
added = true;
}
catch (ArgumentException)
{
//already exists
}
}
CountableMessage countable = (CountableMessage)message;
countable.MessageID = packetID;
}
else
{
_timersMap.Add(((CountableMessage)message).MessageID.Value, timer);
}
timer.Execute(_resendPeriod);
}
protected override void fixMessage(Packer packer, byte[] message)
{
int toSendAccNum = this.sendAccNum++;
packer.Pack((byte)Protocol.Reliable);
packer.Pack(toSendAccNum);
packer.Pack(message);
MessageResendTimer timer = new MessageResendTimer();
timer.accnumber = toSendAccNum;
timer.message = packer.GetPackedData();
timer.stopWatch.Start();
connection.reliableTimer.addResender(timer);
}
private void ExecuteTimer(MessageResendTimer <AMQPHeader> timer)
{
}
private void ExecuteTimer(MessageResendTimer <SNMessage> timer)
{
}
public void addResender(MessageResendTimer resender)
{
resenders.Add(resender.accnumber, resender);
}
