/// <summary>
/// 根据指定编号异步获取Ticker对象的操作
/// </summary>
/// <param name="coinType">币种编号</param>
/// <param name="platformType">平台编号</param>
/// <returns>返回执行结果</returns>
public async Task <IExecuteResult> GetTickerAsync(CoinTypes coinType, PlatformTypes platformType)
{
MetadataMessageTransaction transaction = SystemWorker.Instance.CreateMetadataTransaction("CoinAPI");
MetadataContainer reqMsg = new MetadataContainer();
reqMsg.SetAttribute(0x00, new MessageIdentityValueStored(new MessageIdentity
{
ProtocolId = 1,
ServiceId = 0,
DetailsId = 0
}));
reqMsg.SetAttribute(0x0F, new ByteValueStored((byte)coinType));
reqMsg.SetAttribute(0x10, new ByteValueStored((byte)platformType));
TaskCompletionSource <IExecuteResult> completionSource = new TaskCompletionSource <IExecuteResult>();
Task <IExecuteResult> task = completionSource.Task;
transaction.ResponseArrived += delegate(object sender, LightSingleArgEventArgs <MetadataContainer> e)
{
MetadataContainer rspMsg = e.Target;
completionSource.SetResult((!rspMsg.IsAttibuteExsits(0x0A))
? (rspMsg.GetAttribute(0x0F).GetValue <ResourceBlock>() == null
? ExecuteResult.Succeed(null)
: ExecuteResult.Succeed(ConverterFactory.GetTickerConverter().ConvertToDomainObject(rspMsg.GetAttribute(0x0F).GetValue <ResourceBlock>())))
: ExecuteResult.Fail(rspMsg.GetAttribute(0x0A).GetValue <byte>(), rspMsg.GetAttribute(0x0B).GetValue <string>()));
};
transaction.Timeout += delegate { completionSource.SetResult(ExecuteResult.Fail(SystemErrors.Timeout, string.Format("[Async Handle] Transaction: {0} execute timeout!", transaction.Identity))); };
transaction.Failed += delegate { completionSource.SetResult(ExecuteResult.Fail(SystemErrors.Unknown, string.Format("[Async Handle] Transaction: {0} execute failed!", transaction.Identity))); };
transaction.SendRequest(reqMsg);
return(await task);
}
void NewTransaction(object sender, KJFramework.EventArgs.LightSingleArgEventArgs <IMessageTransaction <MetadataContainer> > e)
{
NewProcessorObject obj;
MetadataMessageTransaction transaction = (MetadataMessageTransaction)e.Target;
if (!transaction.Request.IsAttibuteExsits(0x00))
{
throw new KeyHasNullException();
}
MessageIdentity identity = transaction.Request.GetAttribute(0x00).GetValue <MessageIdentity>();
lock (_processorLockObj)
{
if (!_processors.TryGetValue(new Protocols {
ProtocolId = identity.ProtocolId, ServiceId = identity.ServiceId, DetailsId = identity.DetailsId
}, out obj))
{
_tracing.Error("#Schedule message failed, because cannot find processor. #P:{0}, S{1}, D{2}", identity.ProtocolId, identity.ServiceId, identity.DetailsId);
return;
}
}
try
{
obj.Processor.Process(transaction);
}
catch (System.Exception ex) { _tracing.Error(ex, null); }
}
internal static void HandleSucceedSituation(MetadataMessageTransaction transaction, MetadataContainer rspMessage)
{
_rspRemainningCounter.Decrement();
MessageIdentity msgIdentity = transaction.Request.GetAttributeAsType <MessageIdentity>(0x00);
msgIdentity.DetailsId += 1;
rspMessage.SetAttribute(0x00, new MessageIdentityValueStored(msgIdentity));
transaction.SendResponse(rspMessage);
}
/// <summary>
/// 创建一个新的消息事务，并将其加入到当前的事务列表中
/// </summary>
/// <param name="identity">事务唯一标示</param>
/// <param name="channel">消息通信信道</param>
/// <param name="timeout">事务超时时间</param>
/// <returns>返回一个新的消息事务</returns>
/// <exception cref="ArgumentNullException">通信信道不能为空</exception>
public MetadataMessageTransaction Create(TransactionIdentity identity, IMessageTransportChannel <MetadataContainer> channel, TimeSpan timeout)
{
if (channel == null)
{
throw new ArgumentNullException(nameof(channel));
}
MetadataMessageTransaction transaction = new MetadataMessageTransaction(new Lease(DateTime.Now.Add(timeout)), channel)
{
TransactionManager = this, Identity = identity
};
return(Add(identity, transaction) ? transaction : null);
}
internal static void HandleErrorSituation(MetadataMessageTransaction transaction, KAEErrorCodes errorCode, string reason)
{
_rspRemainningCounter.Decrement();
_errorRspCounter.Increment();
MessageIdentity msgIdentity = transaction.Request.GetAttributeAsType <MessageIdentity>(0x00);
msgIdentity.DetailsId += 1;
MetadataContainer rspMsg = new MetadataContainer();
rspMsg.SetAttribute(0x00, new MessageIdentityValueStored(msgIdentity));
rspMsg.SetAttribute(0x0A, new ByteValueStored((byte)errorCode));
rspMsg.SetAttribute(0x0B, new StringValueStored(reason ?? string.Empty));
transaction.SendResponse(rspMsg);
}
protected override void DoBussiness(MetadataContainer reqMsg, MetadataMessageTransaction transaction)
{
CoinTypes coinType = (CoinTypes)reqMsg.GetAttribute(0x0F).GetValue <byte>();
PlatformTypes platformType = (PlatformTypes)reqMsg.GetAttribute(0x10).GetValue <byte>();
IExecuteResult executeResult = CacheManager.Instance.GetValue(coinType, platformType);
if (executeResult.State != ExecuteResults.Succeed)
{
transaction.SendResponse(GetErrorResponseMessage(SystemErrors.Unknown, executeResult.Error));
}
else
{
ResourceBlock rspCampaignData = ConverterFactory.GetTickerConverter().ConvertToNetworkObject(executeResult.GetResult <Ticker>());
transaction.SendResponse(GetSucceedResponseMessage(rspCampaignData));
}
}
//new message arrived.
void ChannelReceivedMessage(object sender, LightSingleArgEventArgs <List <MetadataContainer> > e)
{
IMessageTransportChannel <MetadataContainer> msgChannel = (IMessageTransportChannel <MetadataContainer>)sender;
foreach (MetadataContainer message in e.Target)
{
if (message == null)
{
continue;
}
_tracing.Info("L: {0}\r\nR: {1}\r\n{2}", msgChannel.LocalEndPoint, msgChannel.RemoteEndPoint, message.ToString());
TransactionIdentity identity;
if (!message.IsAttibuteExsits(0x01))
{
identity = msgChannel.GenerateRequestIdentity(0U);
}
else
{
identity = message.GetAttribute(0x01).GetValue <TransactionIdentity>();
}
//response.
if (!identity.IsRequest)
{
_transactionManager.Active(identity, message);
continue;
}
//create transaction by IsOneway flag.
IMessageTransaction <MetadataContainer> transaction = new MetadataMessageTransaction(_channel)
{
NeedResponse = !identity.IsOneway,
TransactionManager = _transactionManager,
Identity = identity,
Request = message
};
transaction.GetLease().Change(message.GetAttributeAsType <DateTime>(0x02));
NewTransactionHandler(new LightSingleArgEventArgs <IMessageTransaction <MetadataContainer> >(transaction));
}
}
/*
* 处理外部请求的总入口
*
* [RSP MESSAGE]
* ===========================================
* 0x00 - Message Identity
* 0x01 - Transaction Identity
* 0x02 - Requested Targeting APP Level (REQUIRED)
* ...
* Other Business Fields
*/
private static void HandleBusiness(Tuple <KAENetworkResource, ApplicationLevel> tag, MetadataMessageTransaction transaction, MessageIdentity reqMsgIdentity, object reqMsg, Guid kppUniqueId, TransactionIdentity transactionIdentity)
{
_rspRemainningCounter.Increment();
Application.HandleBusiness(tag, transaction, reqMsgIdentity, reqMsg, transactionIdentity);
}
internal void HandleBusiness(Tuple <KAENetworkResource, ApplicationLevel> tag, MetadataMessageTransaction transaction, MessageIdentity reqMsgIdentity, object reqMsg, TransactionIdentity transactionIdentity)
{
MetadataKAEProcessor processor;
//Targeted MessageIdentity CANNOT be support.
if (!_processors.TryGetValue(reqMsgIdentity, out processor))
{
_handleErrorSituation(transaction, KAEErrorCodes.NotSupportedMessageIdentity, "#We'd not supported current business protocol yet!");
return;
}
MetadataContainer rsp = processor.Process(transaction.Request);
if (!transaction.NeedResponse)
{
return;
}
if (rsp == null)
{
_handleErrorSituation(transaction, KAEErrorCodes.UnhandledExceptionOccured, string.Empty);
}
else
{
_handleSucceedSituation(transaction, rsp);
}
}
