public async Task Subscribe_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
{
var args = new SubscribeArgs();
await args.ReadAsync(iprot, cancellationToken);
await iprot.ReadMessageEndAsync(cancellationToken);
var result = new SubscribeResult();
try
{
result.Success = await _iAsync.SubscribeAsync(args.Message, cancellationToken);
await oprot.WriteMessageBeginAsync(new TMessage("Subscribe", TMessageType.Reply, seqid), cancellationToken);
await result.WriteAsync(oprot, cancellationToken);
}
catch (TTransportException)
{
throw;
}
catch (Exception ex)
{
Console.Error.WriteLine("Error occurred in processor:");
Console.Error.WriteLine(ex.ToString());
var x = new TApplicationException(TApplicationException.ExceptionType.InternalError, " Internal error.");
await oprot.WriteMessageBeginAsync(new TMessage("Subscribe", TMessageType.Exception, seqid), cancellationToken);
await x.WriteAsync(oprot, cancellationToken);
}
await oprot.WriteMessageEndAsync(cancellationToken);
await oprot.Transport.FlushAsync(cancellationToken);
}
/**
* Creates the print format of the subscribe result value.
* @param resultArray
* @return
*/
public static String createMessage(SubscribeResult result)
{
String resultString = null;
if (result != null)
{
if (result.Success)
{
resultString = resultString + "<b>Subscribe Result: Success</b>";
resultString = resultString + "<br> Account Id: " + result.AccountId;
resultString = resultString + "<br> Account Number: " + result.AccountNumber;
resultString = resultString + "<br> Subscription Id: " + result.SubscriptionId;
resultString = resultString + "<br> Subscription Number: " + result.SubscriptionNumber;
resultString = resultString + "<br> Invoice Number: " + result.InvoiceNumber;
resultString = resultString + "<br> Payment Transaction: " + result.PaymentTransactionNumber;
}
else
{
resultString = resultString + "<b>Subscribe Result: Failed</b>";
Error[] errors = result.Errors;
if (errors != null)
{
foreach (Error error in errors)
{
resultString = resultString + "<br> Error Code: " + error.Code;
resultString = resultString + "<br> Error Message: " + error.Message;
}
}
}
}
return resultString;
}
public EzSubscribeResult(
SubscribeResult result
)
{
if (result.item != null)
{
Item = new EzSubscribeUser(result.item);
}
}
public void Subscibe(CallMessage call, SubscribeResult handler)
{
lock (this)
call.Id = lastId++;
sendToServer(call.ToString());
var tcs = new TaskCompletionSource <ResultMessage>();
lock (this)
subscribes[call.Id] = handler;
}
public SubscribeResult SubscribeTopic(SubscribeRequest subscribeRequest)
{
var subscribeResult = new SubscribeResult();;
using (var connection = Factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.BasicQos(0, 1, false);
var result = channel.BasicGet(queue: "topic.bombay.queue", autoAck: false);
if (result != null)
{
subscribeResult.Body = Encoding.UTF8.GetString(result.Body);
}
}
return(subscribeResult);
}
public SubscribeResult SubscribeDirect(SubscribeRequest subscribeRequest)
{
var subscribeResult = new SubscribeResult();;
using (var connection = Factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue: subscribeRequest.Queue, durable: true, exclusive: false, autoDelete: false, arguments: null);
var result = channel.BasicGet(queue: subscribeRequest.Queue, autoAck: false);
if (result != null)
{
subscribeResult.Body = Encoding.UTF8.GetString(result.Body);
}
}
return(subscribeResult);
}
public virtual bool onReceive(MessageEnvelope message, ITransport transport)
{
if (message.Body.isSubscribeRequestSelected())
{
MessageEnvelope resultMsg = new MessageEnvelope();
MessageBody body = new MessageBody();
SubscribeResult subscribeResult = new SubscribeResult();
SubscribeResultCode subscribeResultCode = new SubscribeResultCode();
body.selectSubscribeResult(subscribeResult);
resultMsg.Body = (body);
resultMsg.Id = message.Id;
subscribeResultCode.Value = SubscribeResultCode.EnumType.unknownQueue;
subscribeResult.Code = subscribeResultCode;
try
{
transport.sendAsync(resultMsg);
}
catch (System.Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
else if (message.Body.isUnsubscribeRequestSelected())
{
MessageEnvelope resultMsg = new MessageEnvelope();
MessageBody body = new MessageBody();
UnsubscribeResult unsubscribeResult = new UnsubscribeResult();
UnsubscribeResultCode unsubscribeResultCode = new UnsubscribeResultCode();
body.selectUnsubscribeResult(unsubscribeResult);
resultMsg.Body = (body);
resultMsg.Id = message.Id;
unsubscribeResultCode.Value = (UnsubscribeResultCode.EnumType.unknownQueue);
unsubscribeResult.Code = (unsubscribeResultCode);
try
{
transport.sendAsync(resultMsg);
}
catch (System.Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
return(true);
}
private void onReceiveSubscribeRequest(MessageEnvelope message, ITransport transport)
{
RemoteConsumer <T> remoteConsumer = new RemoteConsumer <T>(
message.Body.SubscribeRequest.ConsumerId, transport
);
MessageEnvelope resultMsg = new MessageEnvelope();
MessageBody body = new MessageBody();
SubscribeResult subscribeResult = new SubscribeResult();
SubscribeResultCode subscribeResultCode = new SubscribeResultCode();
body.selectSubscribeResult(subscribeResult);
resultMsg.Body = body;
resultMsg.Id = message.Id;
try
{
addConsumer(remoteConsumer, message.Body.SubscribeRequest.Persistence, message.Body.SubscribeRequest.Filter);
subscribeResultCode.Value = SubscribeResultCode.EnumType.success;
}
catch (System.Exception e)
{
subscribeResultCode.Value = SubscribeResultCode.EnumType.alreadySubscription;
subscribeResult.Details = (e.ToString());
}
subscribeResult.Code = subscribeResultCode;
try
{
transport.sendAsync(resultMsg);
if (subscribeResult.Code.Value == SubscribeResultCode.EnumType.success &&
message.Body.SubscribeRequest.Persistence)
{
IList <IMessage <T> > messages = persistStorage.getMessagesToSend(remoteConsumer);
lock (queue)
{
queue.push(messages);
}
awaitMessageEvent.Set();
}
}
catch (System.Exception e)
{
Console.WriteLine(e);
}
}
public ISubscribeResult Subscribe(CancellationToken unsubscribe)
{
var subscription = new SubscribeResult();
_subscriptions[unsubscribe] = subscription;
unsubscribe.Register(() =>
{
if (_subscriptions.TryRemove(unsubscribe, out var sub))
{
OnUnsubscribing(sub);
sub.TryComplete();
}
});
OnSubscribed(subscription);
return(subscription);
}
public MqttSubAckPacket Create(MqttSubscribePacket subscribePacket, SubscribeResult subscribeResult)
{
if (subscribePacket == null)
{
throw new ArgumentNullException(nameof(subscribePacket));
}
if (subscribeResult == null)
{
throw new ArgumentNullException(nameof(subscribeResult));
}
var subAckPacket = new MqttSubAckPacket
{
PacketIdentifier = subscribePacket.PacketIdentifier,
ReasonCodes = subscribeResult.ReasonCodes,
ReasonString = subscribeResult.ReasonString,
UserProperties = subscribeResult.UserProperties
};
return(subAckPacket);
}
public async Task <Ruyi.SDK.Http.SubscribeReply> SubscribeAsync(Ruyi.SDK.Http.SubscribeRequest message, CancellationToken cancellationToken)
{
await OutputProtocol.WriteMessageBeginAsync(new TMessage("Subscribe", TMessageType.Call, SeqId), cancellationToken);
var args = new SubscribeArgs();
args.Message = message;
await args.WriteAsync(OutputProtocol, cancellationToken);
await OutputProtocol.WriteMessageEndAsync(cancellationToken);
await OutputProtocol.Transport.FlushAsync(cancellationToken);
var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
if (msg.Type == TMessageType.Exception)
{
var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
await InputProtocol.ReadMessageEndAsync(cancellationToken);
throw x;
}
var result = new SubscribeResult();
await result.ReadAsync(InputProtocol, cancellationToken);
await InputProtocol.ReadMessageEndAsync(cancellationToken);
if (result.__isset.success)
{
return(result.Success);
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "Subscribe failed: unknown result");
}
/**
* Creates the print format of the subscribe result value.
* @param resultArray
* @return
*/
private String createMessage(SubscribeResult[] resultArray)
{
string resultString = "SusbscribeResult :\n";
if (resultArray != null)
{
SubscribeResult result = resultArray[0];
if (result.Success)
{
resultString = resultString + "\nSubscribe Result: \n";
resultString = resultString + "\n\tAccount Id: " + result.AccountId;
resultString = resultString + "\n\tAccount Number: " + result.AccountNumber;
resultString = resultString + "\n\tSubscription Id: " + result.SubscriptionId;
resultString = resultString + "\n\tSubscription Number: " + result.SubscriptionNumber;
resultString = resultString + "\n\tInvoice Number: " + result.InvoiceNumber;
resultString = resultString + "\n\tPayment Transaction: " + result.PaymentTransactionNumber;
}
else
{
resultString = resultString + "\nSubscribe Failure Result: \n";
Error[] errors = result.Errors;
if (errors != null)
{
foreach (Error error in errors)
{
resultString = resultString + "\n\tError Code: " + error.Code;
resultString = resultString + "\n\tError Message: " + error.Message;
}
}
}
}
return resultString;
}
public virtual void OnUnsubscribing(SubscribeResult subscription)
{
}
public override void OnSubscribed(SubscribeResult subscription)
{
subscription.WriteAsync(_welcomeItem);
}
public override void OnUnsubscribing(SubscribeResult subscription)
{
if (!_byeItem.Equals(default))
public virtual void OnSubscribed(SubscribeResult subscription)
{
}
public MqttSubAckPacket CreateSubAckPacket(MqttSubscribePacket subscribePacket, SubscribeResult subscribeResult)
{
if (subscribePacket == null)
{
throw new ArgumentNullException(nameof(subscribePacket));
}
if (subscribeResult == null)
{
throw new ArgumentNullException(nameof(subscribeResult));
}
var subackPacket = new MqttSubAckPacket
{
PacketIdentifier = subscribePacket.PacketIdentifier
};
subackPacket.ReasonCodes.AddRange(subscribeResult.ReasonCodes);
return(subackPacket);
}
public override void OnSubscribed(SubscribeResult subscription)
{
subscription.WriteAsync("value").AsTask().Wait();
}
public List<SubscribeResponseHolder> Subscribe(List<SubscribeRequest> input)
{
List<SubscribeResponseHolder> results = new List<SubscribeResponseHolder>();
SubscribeResult[] res = new SubscribeResult[]{};
bool done = false;
int subscribeNum = 50;
while (!done)
{
List<SubscribeRequest> doWork = new List<SubscribeRequest>() { };
if (input.Count > subscribeNum)
{
List<SubscribeRequest> subList = input.GetRange(0, subscribeNum);
for (int i = 0; i < subscribeNum; i++)
{
SubscribeRequest temp = subList[i];
doWork.Add(temp);
input.Remove(temp);
}
}
else
{
done = true;
doWork = input;
}
CheckTime();
try
{
res = svc.subscribe(sh, doWork.ToArray());
}
catch (FaultException e)
{
SubscribeResponseHolder error = new SubscribeResponseHolder();
error.Message = e.Message;
error.Success = false;
results.Add(error);
return results;
}
foreach (SubscribeResult sr in res)
{
SubscribeResponseHolder temp = new SubscribeResponseHolder();
if (sr.Success)
{
temp.Success = true;
temp.SubRes = sr;
}
else
{
temp.Success = false;
temp.Message = sr.Errors[0].Message;
}
results.Add(temp);
}
}
return results;
}
