/// <summary>
/// 失败的微讯消息事务，提供了相关的基本操作
/// </summary>
/// <param name="channel">消息通信信道</param>
public FailMobiSageMessageTransaction(IMessageTransportChannel <BaseMessage> channel)
: base(channel)
{
Identity = new TransactionIdentity {
EndPoint = new IPEndPoint(IPAddress.Parse("0.0.0.0"), 1000)
};
}
/// <summary>
/// 失败的微讯消息事务，提供了相关的基本操作
/// </summary>
public FailMobiSageMetadataTransaction(string iep)
{
_iep = iep;
Identity = new TransactionIdentity {
EndPoint = new IPEndPoint(IPAddress.Parse("0.0.0.0"), 1000)
};
}
/// <summary>
/// 失败的微讯消息事务，提供了相关的基本操作
/// </summary>
/// <param name="lease">事务生命租期租约</param>
/// <param name="channel">消息通信信道</param>
public FailMobiSageMetadataTransaction(ILease lease, IMessageTransportChannel <MetadataContainer> channel)
: base(lease, channel)
{
Identity = new TransactionIdentity {
EndPoint = new IPEndPoint(IPAddress.Parse("0.0.0.0"), 1000)
};
}
public Task WaitAsync(TransactionIdentity transactionIdentity, TimeSpan timeout)
{
Contract.Requires(transactionIdentity != null);
Contract.Ensures(Contract.Result <Task>() != null);
throw new NotImplementedException();
}
private async Task CheckChanges()
{
var client = new QBitNinjaClient(settings.ApiUrl, Network.Main);
OnNewCheckCycleStarted?.Invoke(this, EventArgs.Empty);
foreach (var monitoringElement in monitoringList.ToList())
{
var from = new BlockFeature(SpecialFeature.Last);
var until = new BlockFeature(monitoringElement.Until.BlockHeight);
var balance =
await client.GetBalanceBetween(new BalanceSelector(monitoringElement.Address), from, until).ConfigureAwait(false);
if (balance == null)
{
throw new PaymentMonitorException($"Can't get {monitoringElement.Address} balance");
}
var monitorUntilTxid = monitoringElement.Until.TransactionId;
var oldToNewOperations = balance.Operations.Where(t => t.ReceivedCoins != null).ToList();
if (oldToNewOperations.Count == 0)
{
continue;
}
oldToNewOperations.Reverse();
if (monitorUntilTxid != uint256.Zero && oldToNewOperations.Exists(x => x.TransactionId == monitorUntilTxid))
{
oldToNewOperations = oldToNewOperations.SkipWhile(x => x.TransactionId != monitorUntilTxid).ToList();
oldToNewOperations.RemoveAll(x => x.TransactionId == monitorUntilTxid);
}
foreach (var operation in oldToNewOperations)
{
if (operation.Confirmations < settings.MinConfirmations)
{
continue;
}
var lku = new TransactionIdentity
{
BlockHeight = operation.Height,
TransactionId = operation.TransactionId,
};
var info = new MoneyEventInfo(monitoringElement.Address, lku,
operation.ReceivedCoins.Cast <Coin>().Select(x => x.Amount).ToList());
OnAmountChanged?.Invoke(this, info);
UpdateElementIdentity(monitoringElement, lku);
}
}
}
private void UpdateElementIdentity(MonitoringBlock element, TransactionIdentity identity)
{
var u = monitoringList.FirstOrDefault(t => t.Address == element.Address);
if (u != null)
{
u.Until = identity;
}
}
/// <summary>
/// 激活一个事务，并尝试处理该事务的响应消息流程
/// </summary>
/// <param name="identity">网络事务唯一标识</param>
/// <param name="response">应答消息</param>
public void Active(TransactionIdentity identity, ThriftMessage response)
{
ThriftMessageTransaction transaction;
if (!_transactions.TryRemove(identity, out transaction))
{
return;
}
transaction.SetResponse(response);
}
/// <summary>
/// 激活一个事务，并尝试处理该事务的响应消息流程
/// </summary>
/// <param name="identity">事务唯一标示</param>
/// <param name="response">响应消息</param>
public void Active(TransactionIdentity identity, TMessage response)
{
IMessageTransaction <TMessage> transaction = GetRemove(identity);
if (transaction == null)
{
return;
}
transaction.SetResponse(response);
}
/// <summary>
/// 为一个管理中的事务进行续约操作
/// </summary>
/// <param name="key">事务唯一键值</param>
/// <param name="timeSpan">续约时间</param>
/// <returns>
/// 返回续约后的时间
/// <para>* 如果返回值 = MIN(DateTime), 则表示续约失败</para>
/// </returns>
public virtual DateTime Renew(TransactionIdentity key, TimeSpan timeSpan)
{
IMessageTransaction <TMessage> transaction = GetTransaction(key);
if (transaction == null)
{
return(DateTime.MinValue);
}
return(transaction.GetLease().Renew(timeSpan));
}
public MoneyEventInfo(BitcoinAddress address, TransactionIdentity transactionIdentity, IList <Money> money)
{
Address = address;
TransactionIdentity = transactionIdentity;
Money = money;
if (Money != null)
{
TotalSatoshi = Money.Sum(x => x.Satoshi);
}
}
/// <summary>
/// 获取一个正在管理中的事务
/// </summary>
/// <param name="key">事务唯一键值</param>
/// <returns>事务</returns>
public virtual IMessageTransaction <TMessage> GetTransaction(TransactionIdentity key)
{
lock (_lockObj)
{
IMessageTransaction <TMessage> transaction;
if (_transactions.TryGetValue(key, out transaction))
{
return(transaction);
}
return(default(IMessageTransaction <TMessage>));
}
}
/// <summary>
/// 创建一个新的消息事务，并将其加入到当前的事务列表中
/// <para>* 事务超时时间被设置为KJFramework.Message节点的配置。</para>
/// <para>* 默认为: 30S</para>
/// </summary>
/// <param name="identity">事务唯一标示</param>
/// <param name="channel">消息通信信道</param>
/// <returns>返回一个新的消息事务</returns>
/// <exception cref="ArgumentNullException">通信信道不能为空</exception>
public BusinessMessageTransaction Create(TransactionIdentity identity, IMessageTransportChannel <BaseMessage> channel)
{
if (channel == null)
{
throw new ArgumentNullException(nameof(channel));
}
BusinessMessageTransaction transaction = new BusinessMessageTransaction(new Lease(DateTime.Now.Add(TransactionGlobal.TransactionTimeout)), channel)
{
TransactionManager = this, Identity = identity
};
return(Add(identity, transaction) ? transaction : null);
}
/// <summary>
/// 尝试获取一个具有指定唯一标示的事务，并且在获取该事务后进行移除操作
/// </summary>
/// <param name="key">事务唯一键值</param>
/// <returns>返回获取到的事务</returns>
public virtual IMessageTransaction <TMessage> GetRemove(TransactionIdentity key)
{
lock (_lockObj)
{
IMessageTransaction <TMessage> transaction;
if (!_transactions.TryGetValue(key, out transaction))
{
return(null);
}
_transactions.Remove(key);
return(transaction);
}
}
/// <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);
}
public void Wait(TransactionIdentity transactionIdentity, TimeSpan timeout)
{
var stopwatch = Stopwatch.StartNew();
while (_projectionDispatcher.Processed(transactionIdentity) == false)
{
if (stopwatch.Elapsed > timeout)
{
throw new TimeoutException(ProjectionTimeoutMessage);
}
Thread.Sleep(10);
}
}
public async Task WaitAsync(TransactionIdentity transactionIdentity, TimeSpan timeout)
{
var stopwatch = Stopwatch.StartNew();
while (_projectionDispatcher.Processed(transactionIdentity) == false)
{
if (stopwatch.Elapsed > timeout)
{
throw new TimeoutException(ProjectionTimeoutMessage);
}
await Task.Delay(10);
}
}
/// <summary>
/// 创建一个新的消息事务，并将其加入到当前的事务列表中
/// </summary>
/// <param name="sequenceId">本次新事务的唯一编号</param>
/// <param name="channel">消息通信信道</param>
/// <returns>返回一个新的消息事务</returns>
/// <exception cref="ArgumentNullException">通信信道不能为空</exception>
public ThriftMessageTransaction Create(int sequenceId, IMessageTransportChannel <ThriftMessage> channel)
{
if (channel == null)
{
throw new ArgumentNullException("channel");
}
ThriftMessageTransaction transaction = new ThriftMessageTransaction(new Lease(DateTime.MaxValue), channel)
{
TransactionManager = this, SequenceId = sequenceId
};
TransactionIdentity identity = IdentityHelper.Create((IPEndPoint)channel.LocalEndPoint, sequenceId, false);
transaction.Identity = identity;
return(Add(transaction) ? transaction : null);
}
public ProjectionContext(IEventProvider eventProvider, TransactionIdentity transactionIdentity, ICommand command, IReadOnlyCollection <Meta> metadata, EventProviderVersion version, object data)
{
Contract.Requires(eventProvider != null);
Contract.Requires(transactionIdentity != null);
Contract.Requires(command != null);
Contract.Requires(metadata != null);
Contract.Requires(version != null);
Contract.Requires(data != null);
EventProvider = eventProvider;
TransactionIdentity = transactionIdentity;
Command = command;
Metadata = metadata;
Version = version;
Data = data;
}
//new message arrived.
void ChannelReceivedMessage(object sender, LightSingleArgEventArgs <System.Collections.Generic.List <ThriftMessage> > e)
{
IMessageTransportChannel <ThriftMessage> msgChannel = (IMessageTransportChannel <ThriftMessage>)sender;
foreach (ThriftMessage message in e.Target)
{
if (message == null)
{
continue;
}
_tracing.Info("L: {0}\r\nR: {1}\r\n{2}", msgChannel.LocalEndPoint, msgChannel.RemoteEndPoint, message.ToString());
//rebuilds corresponding TransactionIdentity for current RSP message.
TransactionIdentity identity = IdentityHelper.Create((IPEndPoint)msgChannel.LocalEndPoint, (int)message.Identity.SequenceId, false);
_transactionManager.Active(identity, message);
}
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="attribute">字段属性</param>
/// <param name="analyseResult">分析结果</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, IntellectPropertyAttribute attribute, ToBytesAnalyseResult analyseResult, object target, bool isArrayElement = false, bool isNullable = false)
{
TransactionIdentity identity = analyseResult.GetValue <TransactionIdentity>(target);
if (identity == null)
{
return;
}
if (identity.IdentityType == TransactionIdentityTypes.TCP)
{
TCPTransactionIdentity.Serialize((byte)attribute.Id, IdentitySerializationTypes.IntellectObject, (TCPTransactionIdentity)identity, proxy);
}
else if (identity.IdentityType == TransactionIdentityTypes.NamedPipe)
{
NamedPipeTransactionIdentity.Serialize((byte)attribute.Id, IdentitySerializationTypes.IntellectObject, (NamedPipeTransactionIdentity)identity, proxy);
}
else
{
throw new NotSupportedException(string.Format("#We were not support current type of Transaction-Identity yet! {0}", identity.IdentityType));
}
}
/// <summary>
/// 管理一个事务
/// </summary>
/// <param name="key">事务唯一键值</param>
/// <param name="transaction">事务</param>
/// <exception cref="T:System.ArgumentNullException">参数错误</exception>
/// <returns>
/// 返回添加操作的状态
/// </returns>
public bool Add(TransactionIdentity key, IMessageTransaction <TMessage> transaction)
{
if (transaction == null)
{
throw new ArgumentNullException(nameof(transaction));
}
IMessageTransaction <TMessage> temp;
if ((temp = GetTransaction(key)) != null)
{
_tracing.Error(
"#Cannot add MessageTransaction to current TransactionManager, because the target identity has been dup. \r\nDetails below:\r\nIdentity: {0}\r\nCreate Time: {1}\r\nRequest: {2}\r\nResponse: {3}",
key,
temp.CreateTime,
(temp.Request == null ? "" : temp.Request.ToString()),
(temp.Response == null ? "" : temp.Response.ToString()));
return(false);
}
lock (_lockObj) _transactions.Add(key, transaction);
return(true);
}
/// <summary>
/// 从第三方客户数据转换为元数据
/// <para>* 此方法将会被轻量级的DataHelper所使用，并且写入的数据将不会拥有编号(Id)</para>
/// </summary>
/// <param name="proxy">内存片段代理器</param>
/// <param name="target">目标对象实例</param>
/// <param name="isArrayElement">当前写入的值是否为数组元素标示</param>
/// <param name="isNullable">是否为可空字段标示</param>
public override void Process(IMemorySegmentProxy proxy, object target, bool isArrayElement = false, bool isNullable = false)
{
TransactionIdentity identity = (TransactionIdentity)target;
if (identity == null)
{
return;
}
if (identity.IdentityType == TransactionIdentityTypes.TCP)
{
TCPTransactionIdentity.Serialize(0, IdentitySerializationTypes.IntellectObject, (TCPTransactionIdentity)identity, proxy);
}
else if (identity.IdentityType == TransactionIdentityTypes.NamedPipe)
{
NamedPipeTransactionIdentity.Serialize(0, IdentitySerializationTypes.IntellectObject, (NamedPipeTransactionIdentity)identity, proxy);
}
else
{
throw new NotSupportedException(string.Format("#We were not support current type of Transaction-Identity yet! {0}", identity.IdentityType));
}
}
static void MetadataNewTransaction(object sender, LightSingleArgEventArgs <IMessageTransaction <MetadataContainer> > e)
{
MetadataConnectionAgent agent = (MetadataConnectionAgent)sender;
IMessageTransaction <MetadataContainer> transaction = e.Target;
MetadataContainer reqMsg = transaction.Request;
Tuple <KAENetworkResource, ApplicationLevel> tag = new Tuple <KAENetworkResource, ApplicationLevel>((KAENetworkResource)agent.Tag, (reqMsg.IsAttibuteExsits(0x05) ? (ApplicationLevel)reqMsg.GetAttributeAsType <byte>(0x05) : ApplicationLevel.Stable));
MessageIdentity reqMsgIdentity = reqMsg.GetAttributeAsType <MessageIdentity>(0x00);
TransactionIdentity transactionIdentity = reqMsg.GetAttributeAsType <TransactionIdentity>(0x01);
Guid uniqueId = reqMsg.GetAttributeAsType <Guid>(0x03);
/*
* We always makes a checking on the Metadata protocol network communication.
* Because all of ours internal system communications are constructed by this kind of MSG protocol.
*/
if (reqMsgIdentity.ProtocolId >= 0xFC)
{
HandleSystemCommand(transaction);
}
//sends it to the appropriate application.
else
{
HandleBusiness(tag, (MetadataMessageTransaction)transaction, reqMsgIdentity, reqMsg, uniqueId, transactionIdentity);
}
}
/// <summary>
/// TransactionIdentity类型存储的静态构造器
/// </summary>
static TransactionIdentityValueStored()
{
_instance = ValueStoredHelper.BuildMethod <TransactionIdentity>();
_toBytesDelegate = delegate(IMemorySegmentProxy proxy, BaseValueStored messageIdentityValueStored)
{
TransactionIdentity identity = messageIdentityValueStored.GetValue <TransactionIdentity>();
if (identity.IdentityType == TransactionIdentityTypes.TCP)
{
TCPTransactionIdentity.Serialize(0, IdentitySerializationTypes.Metadata, (TCPTransactionIdentity)identity, proxy);
}
else if (identity.IdentityType == TransactionIdentityTypes.NamedPipe)
{
NamedPipeTransactionIdentity.Serialize(0, IdentitySerializationTypes.Metadata, (NamedPipeTransactionIdentity)identity, proxy);
}
else
{
throw new NotSupportedException(string.Format("#We were not support current type of Transaction-Identity yet! {0}", identity.IdentityType));
}
};
_toDataDelegate = delegate(ResourceBlock metadataObject, byte id, byte[] byteData, int offsetStart, uint offsetLength)
{
TransactionIdentityTypes identityType = (TransactionIdentityTypes)byteData[offsetStart];
if (identityType == TransactionIdentityTypes.TCP)
{
metadataObject.SetAttribute(id, new TransactionIdentityValueStored(TCPTransactionIdentity.Deserialize(byteData, offsetStart, (int)offsetLength)));
}
else if (identityType == TransactionIdentityTypes.NamedPipe)
{
metadataObject.SetAttribute(id, new TransactionIdentityValueStored(NamedPipeTransactionIdentity.Deserialize(byteData, offsetStart, (int)offsetLength)));
}
else
{
throw new NotSupportedException(string.Format("#We were not support current type of Transaction-Identity yet! {0}", identityType));
}
};
}
/// <summary>
/// 移除一个不需要管理的事务
/// </summary>
/// <param name="key">事务唯一键值</param>
public virtual void Remove(TransactionIdentity key)
{
ThriftMessageTransaction v;
_transactions.TryRemove(key, out v);
}
/// <summary>
/// 激活一个事务，并尝试处理该事务的响应消息流程
/// </summary>
/// <param name="identity">网络事务唯一标识</param>
/// <param name="response">应答消息</param>
public void Active(TransactionIdentity identity, ThriftMessage response)
{
ThriftMessageTransaction transaction;
if (!_transactions.TryRemove(identity, out transaction)) return;
transaction.SetResponse(response);
}
/*
* 处理外部请求的总入口
*
* [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);
}
/// <summary>
/// 移除一个不需要管理的事务
/// </summary>
/// <param name="key">事务唯一键值</param>
public virtual void Remove(TransactionIdentity key)
{
lock (_lockObj) _transactions.Remove(key);
}
public bool Processed(TransactionIdentity transactionIdentity)
{
Contract.Requires(transactionIdentity != null);
throw new NotImplementedException();
}
public bool Processed(TransactionIdentity transactionIdentity)
{
return(_processedTransactions.Contains(transactionIdentity));
}
public bool Processed(TransactionIdentity transactionIdentity)
{
return(_projectionDispatcher.Processed(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);
}
}
