/// <summary>
/// 单方向信道抽象父类，提供了相关的基本操作
/// </summary>
/// <param name="channel">基于流的通讯信道</param>
/// <param name="protocolStack">协议栈</param>
protected OnewayChannel(IRawTransportChannel channel, IProtocolStack protocolStack)
{
if (channel == null)
{
throw new ArgumentNullException(nameof(channel));
}
if (!channel.IsConnected)
{
throw new ArgumentException("Current raw transport channel hsa been disconnected!");
}
if (protocolStack == null)
{
throw new ArgumentNullException(nameof(protocolStack));
}
if (!protocolStack.Initialize())
{
throw new ArgumentException("Cannot initialize current protocol stack!");
}
_channel = channel;
if (_channel.Buffer == null)
{
_channel.Buffer = new ReceiveBuffer(102400);
}
_logicalAddress = _channel.LogicalAddress;
_address = _channel.Address;
_channel.Disconnected += RawChannelDisconnected;
_channel.ReceivedData += RawChannelReceivedData;
_protocolStack = protocolStack;
}
/// <summary>
/// 创建一个新的连接代理器
/// </summary>
/// <param name="iep">远程终结点地址</param>
/// <param name="protocolStack">协议栈</param>
/// <param name="transactionManager">事务管理器</param>
/// <returns>如果无法连接到远程地址，则返回null.</returns>
public static IThriftConnectionAgent Create(IPEndPoint iep, IProtocolStack <ThriftMessage> protocolStack, ThriftMessageTransactionManager transactionManager)
{
if (iep == null)
{
throw new ArgumentNullException("iep");
}
if (protocolStack == null)
{
throw new ArgumentNullException("protocolStack");
}
if (transactionManager == null)
{
throw new ArgumentNullException("transactionManager");
}
ITransportChannel transportChannel = new TcpTransportChannel(iep);
transportChannel.Connect();
if (!transportChannel.IsConnected)
{
return(null);
}
IMessageTransportChannel <ThriftMessage> msgChannel = new MessageTransportChannel <ThriftMessage>((IRawTransportChannel)transportChannel, protocolStack, new ThriftProtocolSegmentDataParser((ThriftProtocolStack)protocolStack));
return(new ThriftConnectionAgent(msgChannel, transactionManager));
}
/// <summary>
/// 创建一个新的连接代理器
/// </summary>
/// <param name="iep">远程终结点地址</param>
/// <param name="protocolStack">协议栈</param>
/// <param name="transactionManager">事务管理器</param>
/// <returns>如果无法连接到远程地址，则返回null.</returns>
/// <exception cref="System.ArgumentNullException">非法参数</exception>
public static IServerConnectionAgent <BaseMessage> Create(IPEndPoint iep, IProtocolStack protocolStack, MessageTransactionManager transactionManager)
{
if (iep == null)
{
throw new ArgumentNullException(nameof(iep));
}
if (protocolStack == null)
{
throw new ArgumentNullException(nameof(protocolStack));
}
if (transactionManager == null)
{
throw new ArgumentNullException(nameof(transactionManager));
}
ITransportChannel transportChannel = new TcpTransportChannel(iep);
transportChannel.Connect();
if (!transportChannel.IsConnected)
{
return(null);
}
IMessageTransportChannel <BaseMessage> msgChannel = new MessageTransportChannel <BaseMessage>((IRawTransportChannel)transportChannel, protocolStack);
return(new IntellectObjectConnectionAgent(msgChannel, transactionManager));
}
/// <summary>
/// 数据段解析器元接口
/// </summary>
/// <param name="protocolStack">协议栈</param>
public SegmentDataParser(IProtocolStack protocolStack)
{
if (protocolStack == null)
{
throw new ArgumentNullException(nameof(protocolStack));
}
_protocolStack = protocolStack;
}
/// <summary>
/// 注册指定服务角色的协议栈
/// </summary>
/// <param name="role">角色名称</param>
/// <param name="protocolStack">协议栈</param>
public void Regist(string role, IProtocolStack protocolStack)
{
if (string.IsNullOrEmpty(role))
{
throw new ArgumentNullException("role");
}
_protocolStacks[role] = protocolStack;
}
/// <summary>
/// 注册指定服务角色的协议栈
/// </summary>
/// <param name="role">服务角色</param>
/// <param name="protocolStack">协议栈</param>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
public static void Regist(string role, IProtocolStack protocolStack)
{
if (string.IsNullOrEmpty(role))
{
throw new ArgumentNullException(nameof(role));
}
if (protocolStack == null)
{
throw new ArgumentNullException(nameof(protocolStack));
}
_protocolStackContainer.Regist(role, protocolStack);
}
/// <summary>
/// 单方向信道抽象父类，提供了相关的基本操作
/// </summary>
/// <param name="protocolStack">协议栈</param>
protected OnewayChannel(IProtocolStack protocolStack)
{
if (protocolStack == null)
{
throw new ArgumentNullException(nameof(protocolStack));
}
if (!protocolStack.Initialize())
{
throw new ArgumentException("Cannot initialize current protocol stack!");
}
_protocolStack = protocolStack;
}
/// <summary>
/// 注册指定服务角色的协议栈
/// </summary>
/// <param name="role">服务角色</param>
/// <param name="protocolStack">协议栈</param>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
public void Regist(string role, IProtocolStack <BaseMessage> protocolStack)
{
if (string.IsNullOrEmpty(role))
{
throw new ArgumentNullException("role");
}
if (protocolStack == null)
{
throw new ArgumentNullException("protocolStack");
}
_protocolStacks[role] = protocolStack;
}
/// <summary>
/// 消息传输信道
/// </summary>
/// <param name="rawChannel">数据流信道</param>
/// <param name="protocolStack">协议栈</param>
/// <param name="parser">解析器</param>
/// <exception cref="ArgumentNullException">参数错误</exception>
public MessageTransportChannel(IRawTransportChannel rawChannel, IProtocolStack protocolStack, ISegmentDataParser <T> parser)
{
if (rawChannel == null)
{
throw new ArgumentNullException("rawChannel");
}
if (protocolStack == null)
{
throw new ArgumentNullException("protocolStack");
}
if (rawChannel.SupportSegment && parser == null)
{
throw new ArgumentNullException("parser");
}
_rawChannel = rawChannel;
_channelType = _rawChannel.ChannelType;
//initialize segment data parser, if current channel support segment data recv.
if (_rawChannel.SupportSegment)
{
_parser = parser;
_parser.ParseSucceed += SegmentParseSucceed;
_rawChannel.ReceivedDataSegment += ReceivedDataSegment;
}
else
{
_rawChannel.ReceivedData += RawReceivedData;
if (_rawChannel.Buffer == null)
{
_rawChannel.Buffer = new ReceiveBuffer(ChannelConst.RecvBufferSize);
}
}
_protocolStack = protocolStack;
_rawChannel.Opened += Opened;
_rawChannel.Opening += Opening;
_rawChannel.Closed += Closed;
_rawChannel.Closing += Closing;
_rawChannel.Faulted += Faulted;
_rawChannel.Disconnected += RawChannelDisconnected;
_rawChannel.Connected += Connected;
_key = _rawChannel.Key;
_localIep = _rawChannel.LocalEndPoint;
_remoteIep = _rawChannel.RemoteEndPoint;
//open this channel at last.
_rawChannel.Open();
}
/// <summary>
/// 获取具有指定唯一标示的消息通信信道
/// </summary>
/// <param name="iep">远程终结点地址，如果给予的目标key在当前连接池中并不存在任何连接，则会使用此参数来创建一个连接</param>
/// <param name="key">连接标示</param>
/// <param name="protocolStack">协议栈</param>
/// <param name="transactionManager">网络事务管理器</param>
/// <returns>返回一个消息通信信道</returns>
public virtual IThriftConnectionAgent GetChannel(IPEndPoint iep, string key, IProtocolStack <ThriftMessage> protocolStack, object transactionManager)
{
try
{
lock (_lockObj)
{
ConnectionSet <ThriftMessage> connectionSet;
if (!_connections.TryGetValue(key, out connectionSet))
{
connectionSet = new SequentialConnectionSet <ThriftMessage>(_min, _max, new Tuple <IPEndPoint, IProtocolStack <ThriftMessage>, object>(iep, protocolStack, transactionManager), CreateAgent);
connectionSet.Tag = key;
_connections.Add(key, connectionSet);
}
return(connectionSet.GetConnection());
}
}
catch (Exception ex)
{
_tracing.Error(ex, null);
return(null);
}
}
/// <summary>
/// 获取具有指定唯一标示的消息通信信道
/// </summary>
/// <param name="iep">远程终结点地址，如果给予的目标key在当前连接池中并不存在任何连接，则会使用此参数来创建一个连接</param>
/// <param name="key">连接标示</param>
/// <param name="protocolStack">协议栈</param>
/// <param name="transactionManager">网络事务管理器</param>
/// <returns>返回一个消息通信信道</returns>
public virtual IThriftConnectionAgent GetChannel(IPEndPoint iep, string key, IProtocolStack<ThriftMessage> protocolStack, object transactionManager)
{
try
{
lock (_lockObj)
{
ConnectionSet<ThriftMessage> connectionSet;
if (!_connections.TryGetValue(key, out connectionSet))
{
connectionSet = new SequentialConnectionSet<ThriftMessage>(_min, _max, new Tuple<IPEndPoint, IProtocolStack<ThriftMessage>, object>(iep, protocolStack, transactionManager), CreateAgent);
connectionSet.Tag = key;
_connections.Add(key, connectionSet);
}
return connectionSet.GetConnection();
}
}
catch (Exception ex)
{
_tracing.Error(ex, null);
return null;
}
}
/// <summary>
/// 输出通道元接口，提供了相关的基本操作。
/// </summary>
/// <param name="channel">基于流的通讯信道</param>
/// <param name="protocolStack">协议栈</param>
public OutputChannel(IRawTransportChannel channel, IProtocolStack protocolStack)
: base(channel, protocolStack)
{
}
/// <summary>
/// 根据当前负载器规则获取一个通信信道
/// </summary>
/// <param name="target">标示网络终点接的协议簇组合</param>
/// <param name="level">KAE应用等级</param>
/// <param name="protocolStack">协议栈</param>
/// <param name="errMsg">错误信息</param>
/// <param name="selectedRingNode">已选中的一致性HASH圆环节点</param>
/// <returns>如果指定条件的通信信道不存在，则会创建它并返回</returns>
/// <exception cref="ArgumentNullException">参数不能为空</exception>
public IServerConnectionAgent <TMessage> GetChannel(Protocols target, ApplicationLevel level, IProtocolStack protocolStack, out string errMsg, out KAERingNode selectedRingNode)
{
lock (_lockObj)
{
IDictionary <ApplicationLevel, IDictionary <ProtocolTypes, KetamaRing> > firstLevel;
if (_addresses.TryGetValue(target, out firstLevel))
{
IDictionary <ProtocolTypes, KetamaRing> secondLevel;
if (firstLevel.TryGetValue(level, out secondLevel))
{
KetamaRing ring;
if (secondLevel.TryGetValue(_protocolType, out ring))
{
if (ring == null)
{
errMsg = string.Format("#Sadly, We have no more network information about what you gave of protocol: {0}-{1}-{2}, Maybe it was been removed or there wasn't any available network resources.", target.ProtocolId, target.ServiceId, target.DetailsId);
selectedRingNode = null;
return(null);
}
KAERingNode node = ring.GetWorkerNode();
IServerConnectionAgent <TMessage> agent = _connectionPool.GetChannel(node.EndPoint, node.RawAddress, protocolStack, _transactionManager);
errMsg = (agent != null ? string.Empty : "#Sadly, We cannot connect to remote endpoint: " + node.RawAddress);
selectedRingNode = node;
return(agent);
}
}
}
errMsg = string.Format("#Couldn't find any remoting address which it can access it. #Protocol: {0}, #Level: {1}", target, level);
selectedRingNode = null;
return(null);
}
}
/// <summary>
/// 获取具有指定标示的连接代理器，如果具有该条件的代理器不存在，则会创建一个新的代理器
/// </summary>
/// <param name="key">连接标示</param>
/// <param name="roleId">服务角色编号</param>
/// <param name="protocolStack">连接所承载的协议栈</param>
/// <param name="transactionManager">事务管理器</param>
/// <returns>如果返回null, 则表示当前无法连接到目标远程终结点地址</returns>
public IThriftConnectionAgent GetChannel(string key, string roleId, IProtocolStack <ThriftMessage> protocolStack, ThriftMessageTransactionManager transactionManager)
{
string fullKey = string.Format("{0}#{1}", roleId, key);
return(base.GetChannel(key, fullKey, protocolStack, transactionManager));
}
/// <summary>
/// 输出通道元接口，提供了相关的基本操作。
/// </summary>
/// <param name="protocolStack">协议栈</param>
public OutputChannel(IProtocolStack protocolStack)
: base(protocolStack)
{
}
/// <summary> /// 创建一个新的服务器端连接代理器，并将其注册到当前的连接池中 /// </summary> /// <param name="iep">要创建连接的远程终结点地址</param> /// <param name="protocolStack">协议栈</param> /// <param name="transactionManager">网络事务管理器</param> /// <returns>返回已经创建好的服务器端连接代理器</returns> protected abstract IThriftConnectionAgent CreateAgent(IPEndPoint iep, IProtocolStack <ThriftMessage> protocolStack, object transactionManager);
/// <summary>
/// 创建一个新的服务器端连接代理器，并将其注册到当前的连接池中
/// </summary>
/// <param name="iep">要创建连接的远程终结点地址</param>
/// <param name="protocolStack">协议栈</param>
/// <param name="transactionManager">网络事务管理器</param>
/// <returns>返回已经创建好的服务器端连接代理器</returns>
protected override IThriftConnectionAgent CreateAgent(IPEndPoint iep, IProtocolStack <ThriftMessage> protocolStack, object transactionManager)
{
return(ThriftConnectionAgent.Create(iep, protocolStack, (ThriftMessageTransactionManager)transactionManager));
}
/// <summary>
/// ����һ���µ����Ӵ�����
/// </summary>
/// <param name="iep">Զ���ս���ַ</param>
/// <param name="protocolStack">Э��ջ</param>
/// <param name="transactionManager">���������</param>
/// <returns>��������ӵ�Զ�̵�ַ����null.</returns>
public static IThriftConnectionAgent Create(IPEndPoint iep, IProtocolStack<ThriftMessage> protocolStack, ThriftMessageTransactionManager transactionManager)
{
if (iep == null) throw new ArgumentNullException("iep");
if (protocolStack == null) throw new ArgumentNullException("protocolStack");
if (transactionManager == null) throw new ArgumentNullException("transactionManager");
ITransportChannel transportChannel = new TcpTransportChannel(iep);
transportChannel.Connect();
if (!transportChannel.IsConnected) return null;
IMessageTransportChannel<ThriftMessage> msgChannel = new MessageTransportChannel<ThriftMessage>((IRawTransportChannel)transportChannel, protocolStack, new ThriftProtocolSegmentDataParser((ThriftProtocolStack) protocolStack));
return new ThriftConnectionAgent(msgChannel, transactionManager);
}
/// <summary>
/// 创建一个新的服务器端连接代理器，并将其注册到当前的连接池中
/// </summary>
/// <param name="iep">要创建连接的远程终结点地址</param>
/// <param name="protocolStack">协议栈</param>
/// <param name="transactionManager">网络事务管理器</param>
/// <returns>返回已经创建好的服务器端连接代理器</returns>
protected override IServerConnectionAgent <BaseMessage> CreateAgent(IPEndPoint iep, IProtocolStack protocolStack, object transactionManager)
{
return(IntellectObjectConnectionAgent.Create(iep, protocolStack, (MessageTransactionManager)transactionManager));
}
/// <summary>
/// 获取具有指定标示的连接代理器，如果具有该条件的代理器不存在，则会创建一个新的代理器
/// </summary>
/// <param name="key">连接标示</param>
/// <param name="roleId">服务角色编号</param>
/// <param name="protocolStack">连接所承载的协议栈</param>
/// <param name="transactionManager">事务管理器</param>
/// <returns>如果返回null, 则表示当前无法连接到目标远程终结点地址</returns>
public IThriftConnectionAgent GetChannel(string key, string roleId, IProtocolStack<ThriftMessage> protocolStack, ThriftMessageTransactionManager transactionManager)
{
string fullKey = string.Format("{0}#{1}", roleId, key);
return base.GetChannel(key, fullKey, protocolStack, transactionManager);
}
/// <summary>
/// 创建一个新的服务器端连接代理器，并将其注册到当前的连接池中
/// </summary>
/// <param name="iep">要创建连接的远程终结点地址</param>
/// <param name="protocolStack">协议栈</param>
/// <param name="transactionManager">网络事务管理器</param>
/// <returns>返回已经创建好的服务器端连接代理器</returns>
protected override IThriftConnectionAgent CreateAgent(IPEndPoint iep, IProtocolStack<ThriftMessage> protocolStack, object transactionManager)
{
return ThriftConnectionAgent.Create(iep, protocolStack, (ThriftMessageTransactionManager)transactionManager);
}
/// <summary>
/// 获取具有指定标示的连接代理器，如果具有该条件的代理器不存在，则会创建一个新的代理器
/// </summary>
/// <param name="key">连接标示</param>
/// <param name="roleId">服务角色编号</param>
/// <param name="protocolStack">连接所承载的协议栈</param>
/// <param name="transactionManager">事务管理器</param>
/// <returns>如果返回null, 则表示当前无法连接到目标远程终结点地址</returns>
public IServerConnectionAgent <MetadataContainer> GetChannel(string key, string roleId, IProtocolStack protocolStack, MetadataTransactionManager transactionManager)
{
string fullKey = string.Format("{0}#{1}", roleId, key);
return(base.GetChannel(key, fullKey, protocolStack, transactionManager));
}
/// <summary>
/// 创建一个新的服务器端连接代理器，并将其注册到当前的连接池中
/// </summary>
/// <param name="iep">要创建连接的远程终结点地址</param>
/// <param name="protocolStack">协议栈</param>
/// <param name="transactionManager">网络事务管理器</param>
/// <returns>返回已经创建好的服务器端连接代理器</returns>
protected override IServerConnectionAgent <MetadataContainer> CreateAgent(IPEndPoint iep, IProtocolStack protocolStack, object transactionManager)
{
return(MetadataConnectionAgent.Create(iep, protocolStack, (MetadataTransactionManager)transactionManager));
}
/// <summary> /// 创建一个新的服务器端连接代理器，并将其注册到当前的连接池中 /// </summary> /// <param name="iep">要创建连接的远程终结点地址</param> /// <param name="protocolStack">协议栈</param> /// <param name="transactionManager">网络事务管理器</param> /// <returns>返回已经创建好的服务器端连接代理器</returns> protected abstract IServerConnectionAgent <TMessage> CreateAgent(IPEndPoint iep, IProtocolStack protocolStack, object transactionManager);
/// <summary>
/// 获取具有指定唯一标示的消息通信信道
/// </summary>
/// <param name="iep">远程终结点地址，如果给予的目标key在当前连接池中并不存在任何连接，则会使用此参数来创建一个连接</param>
/// <param name="key">连接标示</param>
/// <param name="protocolStack">协议栈</param>
/// <param name="transactionManager">网络事务管理器</param>
/// <returns>返回一个消息通信信道</returns>
public virtual IThriftConnectionAgent GetChannel(string iep, string key, IProtocolStack<ThriftMessage> protocolStack, object transactionManager)
{
return GetChannel(iep.ConvertToIPEndPoint(), key, protocolStack, transactionManager);
}
/// <summary> /// 创建一个新的服务器端连接代理器，并将其注册到当前的连接池中 /// </summary> /// <param name="iep">要创建连接的远程终结点地址</param> /// <param name="protocolStack">协议栈</param> /// <param name="transactionManager">网络事务管理器</param> /// <returns>返回已经创建好的服务器端连接代理器</returns> protected abstract IThriftConnectionAgent CreateAgent(IPEndPoint iep, IProtocolStack<ThriftMessage> protocolStack, object transactionManager);
/// <summary>
/// 获取具有指定唯一标示的消息通信信道
/// </summary>
/// <param name="iep">远程终结点地址，如果给予的目标key在当前连接池中并不存在任何连接，则会使用此参数来创建一个连接</param>
/// <param name="key">连接标示</param>
/// <param name="protocolStack">协议栈</param>
/// <param name="transactionManager">网络事务管理器</param>
/// <returns>返回一个消息通信信道</returns>
public virtual IServerConnectionAgent <TMessage> GetChannel(string iep, string key, IProtocolStack protocolStack, object transactionManager)
{
return(GetChannel(iep.ConvertToIPEndPoint(), key, protocolStack, transactionManager));
}
/// <summary>
/// 消息传输信道
/// </summary>
/// <param name="rawChannel">数据流信道</param>
/// <param name="protocolStack">协议栈</param>
/// <exception cref="ArgumentNullException">参数错误</exception>
public MessageTransportChannel(IRawTransportChannel rawChannel, IProtocolStack protocolStack)
: this(rawChannel, protocolStack, new SegmentDataParser <T>(protocolStack))
{
}
