public void SetObject(object o)
{
if (o == null)
{
amqpMessage.BodySection = MessageSupport.NULL_AMQP_VALUE_BODY;
}
else if (IsNMSObjectTypeSupported(o))
{
object value = null;
if (o is IList)
{
value = ConversionSupport.ListToAmqp(o as IList);
}
else if (o is IPrimitiveMap)
{
value = ConversionSupport.NMSMapToAmqp(o as IPrimitiveMap);
}
else
{
value = o;
}
// to copy the object being set encode a message then decode and take body
Amqp.Message copy = new Amqp.Message(value);
ByteBuffer buffer = copy.Encode();
copy = Message.Decode(buffer);
amqpMessage.BodySection = new AmqpValue {
Value = copy.Body
};
}
else
{
throw new ArgumentException("Encoding unexpected object type: " + o.GetType().Name);
}
}
void SendInternal(Message message, DeliveryState deliveryState, OutcomeCallback callback, object state, bool sync)
{
const int reservedBytes = 40;
#if NETFX || NETFX40 || DOTNET
var buffer = message.Encode(this.Session.Connection.BufferManager, reservedBytes);
#else
var buffer = message.Encode(reservedBytes);
#endif
if (buffer.Length < 1)
{
throw new ArgumentException("Cannot send an empty message.");
}
Delivery delivery = new Delivery()
{
Message = message,
Buffer = buffer,
ReservedBufferSize = reservedBytes,
State = deliveryState,
Link = this,
OnOutcome = callback,
UserToken = state,
Settled = this.settleMode == SenderSettleMode.Settled || callback == null,
Batchable = !sync
};
lock (this.ThisLock)
{
this.ThrowIfDetaching("Send");
if (this.credit <= 0 || this.writing)
{
this.outgoingList.Add(delivery);
return;
}
delivery.Tag = Delivery.GetDeliveryTag(this.deliveryCount);
this.credit--;
this.deliveryCount++;
this.writing = true;
}
this.WriteDelivery(delivery);
}
public void SendTransferToLastOpenedLinkOnLastOpenedSession(Amqp.Message message, uint nextIncomingId)
{
lock (matchersLock)
{
var lastMatcher = GetLastMatcher();
ByteBuffer payload = message.Encode();
lastMatcher.WithOnComplete(context =>
{
var transfer = new Transfer()
{
DeliveryId = nextIncomingId,
DeliveryTag = Encoding.UTF8.GetBytes("theDeliveryTag" + nextIncomingId),
MessageFormat = 0,
Settled = false,
Handle = lastInitiatedLinkHandle,
};
context.SendCommand(transfer, payload);
});
}
}
internal void Send(Message message, DeliveryState deliveryState, OutcomeCallback callback, object state)
{
var buffer = message.Encode();
if (buffer.Length < 1)
{
throw new ArgumentException("Cannot send an empty message.");
}
Delivery delivery = new Delivery()
{
Message = message,
Buffer = buffer,
State = deliveryState,
Link = this,
OnOutcome = callback,
UserToken = state,
Settled = this.settleMode == SenderSettleMode.Settled || callback == null
};
lock (this.ThisLock)
{
this.ThrowIfDetaching("Send");
if (this.credit <= 0 || this.writing)
{
this.outgoingList.Add(delivery);
return;
}
delivery.Tag = GetDeliveryTag(this.deliveryCount);
this.credit--;
this.deliveryCount++;
this.writing = true;
}
this.WriteDelivery(delivery);
}
public void ExpectLinkFlowRespondWithTransfer(
Amqp.Message message,
int count,
bool drain,
bool sendDrainFlowResponse,
bool sendSettled,
bool addMessageNumberProperty,
Action <uint> creditMatcher,
int?nextIncomingId)
{
if (nextIncomingId == null && count > 0)
{
Assert.Fail("The remote NextIncomingId must be specified if transfers have been requested");
}
FrameMatcher <Flow> flowMatcher = new FrameMatcher <Flow>()
.WithAssertion(flow => Assert.AreEqual(drain, flow.Drain))
.WithAssertion(flow => creditMatcher(flow.LinkCredit));
if (nextIncomingId != null)
{
flowMatcher.WithAssertion(flow => Assert.AreEqual(nextIncomingId.Value, flow.NextIncomingId));
}
else
{
flowMatcher.WithAssertion(flow => Assert.GreaterOrEqual(flow.NextIncomingId, 0));
}
for (int i = 0; i < count; i++)
{
int nextId = nextIncomingId + i ?? i;
byte[] deliveryTag = Encoding.UTF8.GetBytes("theDeliveryTag" + nextId);
if (addMessageNumberProperty)
{
if (message.ApplicationProperties == null)
{
message.ApplicationProperties = new ApplicationProperties();
}
message.ApplicationProperties[MESSAGE_NUMBER] = i;
}
if (message.Properties == null)
{
message.Properties = new Properties();
}
message.Properties.MessageId = $"ID:{i.ToString()}";
var messageId = message.Properties.MessageId;
ByteBuffer payload = message.Encode();
flowMatcher.WithOnComplete(context =>
{
Logger.Debug($"Sending message {messageId}");
var transfer = new Transfer()
{
DeliveryId = (uint)nextId,
DeliveryTag = deliveryTag,
MessageFormat = 0,
Settled = sendSettled,
Handle = context.Command.Handle,
};
try
{
context.SendCommand(transfer, payload);
}
catch (Exception e)
{
Logger.Error($"Sending message {messageId} failed.");
throw;
}
});
}
if (drain && sendDrainFlowResponse)
{
flowMatcher.WithOnComplete(context =>
{
var flow = new Flow()
{
OutgoingWindow = 0,
IncomingWindow = uint.MaxValue,
LinkCredit = 0,
Drain = true,
Handle = context.Command.Handle,
DeliveryCount = context.Command.DeliveryCount + context.Command.LinkCredit,
NextOutgoingId = context.Command.NextIncomingId + (uint)count,
NextIncomingId = context.Command.NextOutgoingId
};
context.SendCommand(flow);
});
}
AddMatcher(flowMatcher);
}
internal void Send(Message message, DeliveryState deliveryState, OutcomeCallback callback, object state)
{
const int reservedBytes = 40;
#if NETFX || NETFX40 || DOTNET
var buffer = message.Encode(this.Session.Connection.BufferManager, reservedBytes);
#else
var buffer = message.Encode(reservedBytes);
#endif
if (buffer.Length < 1)
{
throw new ArgumentException("Cannot send an empty message.");
}
Delivery delivery = new Delivery()
{
Message = message,
Buffer = buffer,
ReservedBufferSize = reservedBytes,
State = deliveryState,
Link = this,
OnOutcome = callback,
UserToken = state,
Settled = this.settleMode == SenderSettleMode.Settled || callback == null
};
lock (this.ThisLock)
{
this.ThrowIfDetaching("Send");
if (this.credit <= 0 || this.writing)
{
this.outgoingList.Add(delivery);
return;
}
delivery.Tag = Delivery.GetDeliveryTag(this.deliveryCount);
this.credit--;
this.deliveryCount++;
this.writing = true;
}
this.WriteDelivery(delivery);
}
public override void OnFlow(FlowContext flowContext)
{
for (int i = 0; i < flowContext.Messages; i++)
{
var message = new Message("test message");
flowContext.Link.SendMessage(message, message.Encode());
}
}
internal void Send(Message message, DeliveryState deliveryState, OutcomeCallback callback, object state)
{
var buffer = message.Encode();
if (buffer.Length < 1)
{
throw new ArgumentException("Cannot send an empty message.");
}
Delivery delivery = new Delivery()
{
Message = message,
Buffer = buffer,
State = deliveryState,
Link = this,
OnOutcome = callback,
UserToken = state,
Settled = this.settleMode == SenderSettleMode.Settled || callback == null
};
lock (this.ThisLock)
{
this.ThrowIfDetaching("Send");
if (this.credit <= 0 || this.writing)
{
this.outgoingList.Add(delivery);
return;
}
delivery.Tag = GetDeliveryTag(this.deliveryCount);
this.credit--;
this.deliveryCount++;
this.writing = true;
}
this.WriteDelivery(delivery);
}
internal uint Send(Sender sender, Message message, bool settled)
{
ByteBuffer buffer = new ByteBuffer(128, true);
buffer.AdjustPosition(TransferFramePrefixSize, 0); // reserve space for frame header and transfer
message.Encode(buffer);
while (buffer.Length > 0)
{
this.Wait(o => ((Client)o).outWindow == 0, this, 60000);
lock (this)
{
this.nextOutgoingId++;
if (this.outWindow < uint.MaxValue)
{
this.outWindow--;
}
}
int payload = this.WriteTransferFrame(sender.Handle, this.deliveryId, settled, buffer, this.maxFrameSize);
Fx.DebugPrint(true, 0, "transfer", new List { this.deliveryId, settled, payload }, "delivery-id", "settled", "payload");
}
return this.deliveryId++;
}
