internal Task Open()
{
var tcs = new TaskCompletionSource <bool>();
var writer = AmqpChannelLevelFrameWriter.ChannelOpen();
_connectionIo.SendCommand(_channelNum, 20, 10,
writer,
reply: (channel, classMethodId, error) =>
{
if (classMethodId == AmqpClassMethodChannelLevelConstants.ChannelOpenOk)
{
_connectionIo._frameReader.Read_ChannelOpenOk((reserved) =>
{
tcs.SetResult(true);
});
}
else
{
AmqpIOBase.SetException(tcs, error, classMethodId);
}
}, expectsReply: true);
return(tcs.Task);
}
internal Task __ExchangeDelete(string exchange, bool waitConfirmation)
{
var tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
var writer = AmqpChannelLevelFrameWriter.ExchangeDelete(exchange, waitConfirmation);
_connectionIo.SendCommand(_channelNum, Amqp.Channel.Exchange.ClassId, Amqp.Channel.Exchange.Methods.ExchangeDelete,
writer,
reply: (channel, classMethodId, error) =>
{
if (!waitConfirmation || classMethodId == AmqpClassMethodChannelLevelConstants.ExchangeDeleteOk)
{
if (LogAdapter.ProtocolLevelLogEnabled)
{
LogAdapter.LogDebug(LogSource, "< ExchangeDeleteOk " + exchange);
}
tcs.SetResult(true);
}
else
{
AmqpIOBase.SetException(tcs, error, classMethodId);
}
},
expectsReply: waitConfirmation);
return(tcs.Task);
}
internal Task __QueueUnbind(string queue, string exchange, string routingKey,
IDictionary <string, object> arguments)
{
var tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
var writer = AmqpChannelLevelFrameWriter.QueueUnbind(queue, exchange, routingKey, arguments);
_connectionIo.SendCommand(_channelNum,
Amqp.Channel.Queue.ClassId, Amqp.Channel.Queue.Methods.QueueUnbind,
writer,
reply: (channel, classMethodId, error) =>
{
if (classMethodId == AmqpClassMethodChannelLevelConstants.QueueUnbindOk)
{
if (LogAdapter.ProtocolLevelLogEnabled)
{
LogAdapter.LogDebug(LogSource, "< QueueUnbindOk " + queue);
}
tcs.SetResult(true);
}
else
{
AmqpIOBase.SetException(tcs, error, classMethodId);
}
},
expectsReply: true);
return(tcs.Task);
}
internal Task __BasicCancel(string consumerTag, bool waitConfirmation)
{
var tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
_connectionIo.SendCommand(_channelNum, 60, 30,
AmqpChannelLevelFrameWriter.BasicCancel(consumerTag, waitConfirmation),
reply: (channel, classMethodId, error) =>
{
if (waitConfirmation && classMethodId == AmqpClassMethodChannelLevelConstants.CancelOk)
{
_connectionIo._frameReader.Read_CancelOk(_ =>
{
tcs.SetResult(true);
});
}
else if (!waitConfirmation)
{
tcs.SetResult(true);
}
else
{
AmqpIOBase.SetException(tcs, error, classMethodId);
}
},
expectsReply: waitConfirmation);
return(tcs.Task);
}
internal Task __ExchangeDeclare(string exchange, string type, bool durable, bool autoDelete,
IDictionary <string, object> arguments, bool waitConfirmation)
{
var tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
var writer = AmqpChannelLevelFrameWriter.ExchangeDeclare(exchange, type, durable, autoDelete,
arguments, false, false, waitConfirmation);
_connectionIo.SendCommand(_channelNum, 40, 10,
writer,
reply: (channel, classMethodId, error) =>
{
if (!waitConfirmation || classMethodId == AmqpClassMethodChannelLevelConstants.ExchangeDeclareOk)
{
Console.WriteLine("< ExchangeDeclareOk " + exchange);
tcs.SetResult(true);
}
else
{
AmqpIOBase.SetException(tcs, error, classMethodId);
}
return(Task.CompletedTask);
},
expectsReply: waitConfirmation);
return(tcs.Task);
}
internal void __SendChannelFlowOk(bool isActive)
{
_connectionIo.SendCommand(_channelNum, 20, 21,
AmqpChannelLevelFrameWriter.ChannelFlowOk(isActive),
reply: null, expectsReply: false, tcs: null,
immediately: true);
}
public Task __ExchangeUnbind(string source, string destination, string routingKey, IDictionary <string, object> arguments, bool waitConfirmation)
{
var tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
var writer = AmqpChannelLevelFrameWriter.ExchangeUnbind(source, destination, routingKey, arguments, waitConfirmation);
_connectionIo.SendCommand(_channelNum,
Amqp.Channel.Exchange.ClassId, Amqp.Channel.Exchange.Methods.ExchangeUnBind,
writer,
reply: (channel, classMethodId, error) =>
{
if (!waitConfirmation || classMethodId == AmqpClassMethodChannelLevelConstants.ExchangeUnbindOk)
{
if (LogAdapter.ProtocolLevelLogEnabled)
{
LogAdapter.LogDebug(LogSource, "< ExchangeUnbindOk " + source);
}
tcs.SetResult(true);
}
else
{
AmqpIOBase.SetException(tcs, error, classMethodId);
}
},
expectsReply: waitConfirmation);
return(tcs.Task);
}
internal Task <string> __BasicConsume(ConsumeMode mode, string queue, string consumerTag, bool withoutAcks,
bool exclusive, IDictionary <string, object> arguments, bool waitConfirmation, Action <string> confirmConsumerTag)
{
var tcs = new TaskCompletionSource <string>( // TaskCreationOptions.AttachedToParent |
mode == ConsumeMode.ParallelWithBufferCopy || mode == ConsumeMode.SerializedWithBufferCopy
? TaskCreationOptions.RunContinuationsAsynchronously : TaskCreationOptions.None);
var writer = AmqpChannelLevelFrameWriter.BasicConsume(
queue, consumerTag, withoutAcks, exclusive, arguments, waitConfirmation);
_connectionIo.SendCommand(_channelNum, 60, 20,
writer,
reply: (channel, classMethodId, error) =>
{
if (LogAdapter.ProtocolLevelLogEnabled)
{
LogAdapter.LogDebug("ChannelIO", "< BasicConsumeOk for queue " + queue);
}
if (waitConfirmation && classMethodId == AmqpClassMethodChannelLevelConstants.BasicConsumeOk)
{
_connectionIo._frameReader.Read_BasicConsumeOk((consumerTag2) =>
{
if (string.IsNullOrEmpty(consumerTag))
{
if (LogAdapter.ProtocolLevelLogEnabled)
{
LogAdapter.LogDebug("ChannelIO", "< BasicConsumeOk consumerTag " + consumerTag);
}
confirmConsumerTag(consumerTag2);
}
tcs.SetResult(consumerTag2);
});
}
else if (!waitConfirmation)
{
tcs.SetResult(consumerTag);
}
else
{
AmqpIOBase.SetException(tcs, error, classMethodId);
}
return(Task.CompletedTask);
}, expectsReply: waitConfirmation);
return(tcs.Task);
}
internal Task <AmqpQueueInfo> __QueueDeclare(string queue, bool passive, bool durable, bool exclusive, bool autoDelete,
IDictionary <string, object> arguments, bool waitConfirmation)
{
var tcs = new TaskCompletionSource <AmqpQueueInfo>(TaskCreationOptions.RunContinuationsAsynchronously);
var writer = AmqpChannelLevelFrameWriter.QueueDeclare(queue, passive, durable,
exclusive, autoDelete, arguments, waitConfirmation);
_connectionIo.SendCommand(_channelNum, 50, 10,
writer,
reply: async(channel, classMethodId, error) =>
{
if (waitConfirmation && classMethodId == AmqpClassMethodChannelLevelConstants.QueueDeclareOk)
{
await _connectionIo._frameReader.Read_QueueDeclareOk((queueName, messageCount, consumerCount) =>
{
tcs.SetResult(new AmqpQueueInfo()
{
Name = queueName,
Consumers = consumerCount,
Messages = messageCount
});
return(Task.CompletedTask);
});
}
else if (!waitConfirmation)
{
tcs.SetResult(new AmqpQueueInfo {
Name = queue
});
}
else
{
AmqpIOBase.SetException(tcs, error, classMethodId);
}
}, expectsReply: waitConfirmation);
return(tcs.Task);
}
internal Task __BasicRecover(bool requeue)
{
var tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
_connectionIo.SendCommand(_channelNum, 60, 110,
AmqpChannelLevelFrameWriter.Recover(requeue),
reply: (channel, classMethodId, error) =>
{
if (classMethodId == AmqpClassMethodChannelLevelConstants.RecoverOk)
{
tcs.SetResult(true);
}
else
{
AmqpIOBase.SetException(tcs, error, classMethodId);
}
},
expectsReply: true,
tcs: tcs);
return(tcs.Task);
}
internal Task __QueueBind(string queue, string exchange, string routingKey, IDictionary <string, object> arguments, bool waitConfirmation)
{
var tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
var writer = AmqpChannelLevelFrameWriter.QueueBind(queue, exchange, routingKey, arguments, waitConfirmation);
_connectionIo.SendCommand(_channelNum, 50, 20,
writer,
reply: (channel, classMethodId, error) =>
{
if (!waitConfirmation || (classMethodId == AmqpClassMethodChannelLevelConstants.QueueBindOk))
{
tcs.SetResult(true);
}
else
{
AmqpIOBase.SetException(tcs, error, classMethodId);
}
}, expectsReply: waitConfirmation);
return(tcs.Task);
}
internal Task __BasicQos(uint prefetchSize, ushort prefetchCount, bool global)
{
var tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
var writer = AmqpChannelLevelFrameWriter.BasicQos(prefetchSize, prefetchCount, global);
_connectionIo.SendCommand(_channelNum, 60, 10,
writer,
reply: (channel, classMethodId, error) =>
{
if (classMethodId == AmqpClassMethodChannelLevelConstants.BasicQosOk)
{
tcs.SetResult(true);
}
else
{
AmqpIOBase.SetException(tcs, error, classMethodId);
}
}, expectsReply: true);
return(tcs.Task);
}
public Task __SendConfirmSelect(bool noWait)
{
var tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
_connectionIo.SendCommand(_channelNum, 85, 10,
AmqpChannelLevelFrameWriter.ConfirmSelect(noWait),
reply: (channel, classMethodId, error) =>
{
if (classMethodId == AmqpClassMethodChannelLevelConstants.ConfirmSelectOk)
{
tcs.SetResult(true);
}
else
{
AmqpIOBase.SetException(tcs, error, classMethodId);
}
},
expectsReply: true,
tcs: tcs);
return(tcs.Task);
}
internal Task <uint> __QueuePurge(string queue, bool waitConfirmation)
{
var tcs = new TaskCompletionSource <uint>(TaskCreationOptions.RunContinuationsAsynchronously);
var writer = AmqpChannelLevelFrameWriter.QueuePurge(queue, waitConfirmation);
_connectionIo.SendCommand(_channelNum,
Amqp.Channel.Queue.ClassId, Amqp.Channel.Queue.Methods.QueuePurge,
writer,
reply: async(channel, classMethodId, error) =>
{
if (waitConfirmation && classMethodId == AmqpClassMethodChannelLevelConstants.QueuePurgeOk)
{
await _connectionIo._frameReader.Read_GenericMessageCount(count =>
{
if (LogAdapter.ProtocolLevelLogEnabled)
{
LogAdapter.LogDebug("ChannelIO", "< QueuePurgeOk " + queue);
}
tcs.SetResult(count);
return(Task.CompletedTask);
}).ConfigureAwait(false);
}
else if (!waitConfirmation)
{
tcs.SetResult(0);
}
else
{
AmqpIOBase.SetException(tcs, error, classMethodId);
}
},
expectsReply: waitConfirmation);
return(tcs.Task);
}