protected override void CopyInto(IMessageCloak msg)
{
base.CopyInto(msg);
this.Reset();
IBytesMessageCloak bmsg = msg as IBytesMessageCloak;
bmsg.Content = this.Content;
}
private bool IsMessageRedeliveryExceeded(IMessageDelivery delivery)
{
Message.Message message = delivery.Message;
IRedeliveryPolicy policy = this.Session.Connection.RedeliveryPolicy;
if (policy != null && policy.MaximumRedeliveries >= 0)
{
IMessageCloak msgCloak = message.GetMessageCloak();
return(msgCloak.RedeliveryCount > policy.MaximumRedeliveries);
}
return(false);
}
protected override void CopyInto(IMessageCloak msg)
{
base.CopyInto(msg);
if (msg is IStreamMessageCloak)
{
IStreamMessageCloak copy = (msg as IStreamMessageCloak);
foreach (object o in list)
{
copy.Put(o);
}
}
}
private void AckReceived(IMessageDelivery delivery)
{
IMessageCloak cloak = delivery.Message.GetMessageCloak();
if (cloak.AckHandler != null)
{
delivered.AddLast(delivery);
}
else
{
AckConsumed(delivery);
}
}
protected override void CopyInto(IMessageCloak msg)
{
base.CopyInto(msg);
if (msg is IObjectMessageCloak)
{
IObjectMessageCloak copy = msg as IObjectMessageCloak;
if (copy is AMQPObjectMessageCloak)
{
this.objectSerializer.CopyInto((copy as AMQPObjectMessageCloak).objectSerializer);
}
else
{
this.objectSerializer.SetObject(copy.Body);
}
}
}
internal void Recover()
{
Tracer.DebugFormat("Session recover for consumer: {0}", Id);
IMessageCloak cloak = null;
IMessageDelivery delivery = null;
lock (messageQueue.SyncRoot)
{
while ((delivery = delivered.Last?.Value) != null)
{
cloak = delivery.Message.GetMessageCloak();
cloak.DeliveryCount = cloak.DeliveryCount + 1;
(delivery as MessageDelivery).EnqueueFirst = true;
delivered.RemoveLast();
SendForDelivery(delivery);
}
delivered.Clear();
}
}
protected override void CopyInto(IMessageCloak msg)
{
base.CopyInto(msg);
IPrimitiveMap copy = (msg as IMapMessageCloak).Map;
foreach (string key in this.map.Keys)
{
object value = map[key];
if (value != null)
{
Type valType = value.GetType();
if (valType.IsPrimitive)
{
// value copy primitive value
copy[key] = value;
}
else if (valType.IsArray && valType.Equals(typeof(byte[])))
{
// use IPrimitive map SetBytes for most common implementation this is a deep copy.
byte[] original = value as byte[];
copy.SetBytes(key, original);
}
else if (valType.Equals(typeof(IDictionary)) || valType.Equals(typeof(Amqp.Types.Map)))
{
// reference copy
copy.SetDictionary(key, value as IDictionary);
}
else if (valType.Equals(typeof(IList)) || valType.Equals(typeof(Amqp.Types.List)))
{
// reference copy
copy.SetList(key, value as IList);
}
else
{
copy[key] = value;
}
}
else
{
copy[key] = value;
}
}
}
public virtual IMessageCloak Copy()
{
IMessageCloak copy = null;
switch (JMSMessageType)
{
case MessageSupport.JMS_TYPE_MSG:
copy = new AMQPMessageCloak(connection);
break;
case MessageSupport.JMS_TYPE_BYTE:
copy = new AMQPBytesMessageCloak(connection);
break;
case MessageSupport.JMS_TYPE_TXT:
copy = new AMQPTextMessageCloak(connection);
break;
case MessageSupport.JMS_TYPE_MAP:
copy = new AMQPMapMessageCloak(connection);
break;
case MessageSupport.JMS_TYPE_STRM:
copy = new AMQPStreamMessageCloak(connection);
break;
case MessageSupport.JMS_TYPE_OBJ:
copy = new AMQPObjectMessageCloak(connection, (this as AMQPObjectMessageCloak).Type);
break;
default:
throw new NMSException("Fatal error Invalid JMS type.");
}
CopyInto(copy);
return(copy);
}
protected override void CopyInto(IMessageCloak msg)
{
base.CopyInto(msg);
(msg as ITextMessageCloak).Text = Text;
}
internal Message(IMessageCloak message)
{
this.cloak = message;
}
protected virtual void CopyInto(IMessageCloak msg)
{
MessageTransformation.CopyNMSMessageProperties(this, msg);
msg.AckHandler = this.AckHandler;
}
protected void DoSend(IDestination destination, IMessage message, MsgDeliveryMode deliveryMode, MsgPriority priority, TimeSpan timeToLive)
{
this.Attach();
bool sendSync = deliveryMode.Equals(MsgDeliveryMode.Persistent);
if (destination.IsTemporary && (destination as TemporaryDestination).IsDeleted)
{
throw new InvalidDestinationException("Can not send message on deleted temporary topic.");
}
message.NMSDestination = destination;
message.NMSDeliveryMode = deliveryMode;
message.NMSPriority = priority;
// If there is timeToLive, set it before setting NMSTimestamp as timeToLive
// is required to calculate absolute expiry time.
// TBD: If the messageProducer has a non-default timeToLive and the message
// already has a timeToLive set by application, which should take precedence, this
// code overwrites the message TimeToLive in this case but not if the producer TimeToLive
// is the default ...
if (timeToLive != NMSConstants.defaultTimeToLive)
{
message.NMSTimeToLive = timeToLive;
}
if (!DisableMessageTimestamp)
{
message.NMSTimestamp = DateTime.UtcNow;
}
if (!DisableMessageID)
{
message.NMSMessageId = MessageIdGenerator.GenerateId().ToString();
}
Amqp.Message amqpmsg = null;
if (message is Message.Message)
{
Message.Message copy = (message as Message.Message).Copy();
copy.NMSDestination = DestinationTransformation.Transform(Session.Connection, destination);
PrepareMessageForSend(copy);
IMessageCloak cloak = copy.GetMessageCloak();
if (cloak is AMQPMessageCloak)
{
amqpmsg = (cloak as AMQPMessageCloak).AMQPMessage;
}
}
else
{
Message.Message nmsmsg = this.Session.Connection.TransformFactory.TransformMessage <Message.Message>(message);
PrepareMessageForSend(nmsmsg);
IMessageCloak cloak = nmsmsg.GetMessageCloak().Copy();
if (cloak is AMQPMessageCloak)
{
amqpmsg = (cloak as AMQPMessageCloak).AMQPMessage;
}
}
if (amqpmsg != null)
{
if (Tracer.IsDebugEnabled)
{
Tracer.DebugFormat("Sending message : {0}", message.ToString());
}
if (sendSync)
{
DoAMQPSendSync(amqpmsg, this.RequestTimeout);
}
else
{
DoAMQPSendAsync(amqpmsg, HandleAsyncAMQPMessageOutcome);
}
}
}
