public TcpConnectionFactory(IProtocol protocol, IProtocolHandler protocolHandler,
int chunkSize = 25, int chunkDelay = 250, bool closeConnectionAfterResponse = false)
{
if (protocol == null)
{
throw new ArgumentNullException(nameof(protocol));
}
if (protocolHandler == null)
{
throw new ArgumentNullException(nameof(protocolHandler));
}
if (chunkSize <= 0)
{
throw new ArgumentOutOfRangeException(nameof(chunkSize));
}
if (chunkDelay <= 0)
{
throw new ArgumentOutOfRangeException(nameof(chunkDelay));
}
m_protocol = protocol;
m_protocolHandler = protocolHandler;
m_chunkSize = chunkSize;
m_chunkDelay = chunkDelay;
m_closeConnectionAfterResponse = closeConnectionAfterResponse;
}
public WebSocketHandler(
IConnectionManager webSocketConnectionManager,
IProtocolHandler protocolHandler)
{
this._wsConnectionManager = webSocketConnectionManager;
this._protocolHandler = protocolHandler;
}
public static string Inspect(this IProtocolHandler message)
{
if (message == null)
{
return("null");
}
var type = message.GetType();
string result = type.FullName + Environment.NewLine;
var properties = type.GetProperties();
foreach (var property in properties)
{
if (!property.IsDefined(typeof(ProtoBuf.ProtoMemberAttribute), false))
{
continue;
}
var specified = properties.FirstOrDefault(p => p.Name == property.Name + "Specified");
bool?hasField = null;
if (specified != null)
{
hasField = specified.GetValue(message, null) as bool?;
}
result += " " + property.Name + ": " + FormatValue(hasField, property.GetValue(message, null)) + Environment.NewLine;
}
return(result);
}
public TestZoneImpl(String zoneId, String zoneUrl, Agent agent, AgentProperties props,
MessageDispatcher dispatcher, IProtocolHandler proto)
: base(zoneId, zoneUrl, agent, props)
{
this.Dispatcher = dispatcher;
fProtocolHandler = proto;
}
public async Task Adding_protocols_when_disconnecting_will_not_cause_trouble()
{
bool shouldStop = false;
int i = 0;
Session session = new(30312, new Node(TestItem.PublicKeyA, "127.0.0.1", 8545), _channel, NullDisconnectsAnalyzer.Instance, LimboLogs.Instance);
Action addProtocol = () =>
{
IProtocolHandler required = Substitute.For<IProtocolHandler>();
required.ProtocolCode.Returns("p2p");
required.MessageIdSpaceSize.Returns(16);
session.AddProtocolHandler(required);
while (!shouldStop)
{
IProtocolHandler protocolHandler = Substitute.For<IProtocolHandler>();
protocolHandler.ProtocolCode.Returns("aa" + i++);
protocolHandler.MessageIdSpaceSize.Returns(10);
session.AddProtocolHandler(protocolHandler);
}
};
session.Handshake(TestItem.PublicKeyA);
session.Init(5, _channelHandlerContext, _packetSender);
Task task = new(addProtocol);
task.Start();
await Task.Delay(20);
session.InitiateDisconnect(DisconnectReason.Other, "test");
await Task.Delay(10);
shouldStop = true;
}
/// <summary>
/// The accept.
/// </summary>
/// <param name="visitor">
/// The visitor.
/// </param>
public void ExecuteOperation(IProtocolHandler visitor)
{
foreach (IExecuteOperation acc in this.accounts)
{
acc.ExecuteOperation(visitor);
}
}
public static void RegisterProtocolHandler(string name, IProtocolHandler handler)
{
if (!_protocolHandlerMap.TryAdd(name, handler))
{
throw new MornException(MornErrorType.MornException, "已经注册过同名的协议处理接口");
}
}
private IProtocolHandler BuildHandler(string code, int spaceSize)
{
IProtocolHandler handler = Substitute.For<IProtocolHandler>();
handler.ProtocolCode.Returns(code);
handler.MessageIdSpaceSize.Returns(spaceSize);
return handler;
}
public IProtocolHandler Create(ISession session)
{
IProtocolHandler handler = _subprotocolFactory.Create(session);
handler.ProtocolInitialized += (sender, args) =>
{
var ndmEventArgs = (NdmProtocolInitializedEventArgs)args;
_protocolValidator.DisconnectOnInvalid(Protocol.Ndm, session, ndmEventArgs);
if (_logger.IsTrace)
{
_logger.Trace($"NDM version {handler.ProtocolVersion}: {session.RemoteNodeId}, host: {session.Node.Host}");
}
if (string.IsNullOrWhiteSpace(_ethRequestService.FaucetHost) ||
!session.Node.Host.Contains(_ethRequestService.FaucetHost))
{
return;
}
INdmPeer?peer = handler as INdmPeer;
if (peer != null)
{
_ethRequestService.UpdateFaucet(peer);
}
else
{
_logger.Warn($"NDM handler cannot serve as faucet since it is not implementing {nameof(INdmPeer)}");
}
};
return(handler);
}
public void Factory2()
{
_facility.AddTypedFactoryEntry(
new FactoryEntry(
"protocolHandlerFactory", typeof(IProtocolHandlerFactory2), "Create", "Release"));
_container.AddComponent("miranda", typeof(IProtocolHandler), typeof(MirandaProtocolHandler));
_container.AddComponent("messenger", typeof(IProtocolHandler), typeof(MessengerProtocolHandler));
IProtocolHandlerFactory2 factory =
(IProtocolHandlerFactory2)_container["protocolHandlerFactory"];
Assert.IsNotNull(factory);
IProtocolHandler handler = factory.Create("miranda");
Assert.IsNotNull(handler);
Assert.IsTrue(handler is MirandaProtocolHandler);
factory.Release(handler);
handler = factory.Create("messenger");
Assert.IsNotNull(handler);
Assert.IsTrue(handler is MessengerProtocolHandler);
factory.Release(handler);
}
public void Can_receive_messages()
{
Metrics.P2PBytesReceived = 0;
Session session = new(30312, new Node(TestItem.PublicKeyA, "127.0.0.1", 8545), _channel, NullDisconnectsAnalyzer.Instance, LimboLogs.Instance);
session.Handshake(TestItem.PublicKeyA);
session.Init(5, _channelHandlerContext, _packetSender);
IProtocolHandler p2p = BuildHandler("p2p", 10);
IProtocolHandler aaa = BuildHandler("aaa", 10);
IProtocolHandler bbb = BuildHandler("bbb", 5);
IProtocolHandler ccc = BuildHandler("ccc", 1);
session.AddProtocolHandler(p2p);
session.AddProtocolHandler(aaa);
session.AddProtocolHandler(bbb);
session.AddProtocolHandler(ccc);
byte[] data = new byte[10];
session.ReceiveMessage(new Packet("---", 3, data));
p2p.Received().HandleMessage(Arg.Is<Packet>(p => p.Protocol == "p2p" && p.PacketType == 3));
session.ReceiveMessage(new Packet("---", 11, data));
aaa.Received().HandleMessage(Arg.Is<Packet>(p => p.Protocol == "aaa" && p.PacketType == 1));
session.ReceiveMessage(new Packet("---", 21, data));
bbb.Received().HandleMessage(Arg.Is<Packet>(p => p.Protocol == "bbb" && p.PacketType == 1));
session.ReceiveMessage(new Packet("---", 25, data));
ccc.Received().HandleMessage(Arg.Is<Packet>(p => p.Protocol == "ccc" && p.PacketType == 0));
session.ReceiveMessage(new Packet("---", 100, data));
Metrics.P2PBytesReceived.Should().Be(data.Length * 5);
}
public TestZoneImpl(String zoneId, String zoneUrl, Agent agent, AgentProperties props,
MessageDispatcher dispatcher, IProtocolHandler proto)
: base(zoneId, zoneUrl, agent, props)
{
this.Dispatcher = dispatcher;
fProtocolHandler = proto;
}
public void Updates_local_and_remote_metrics_on_disconnects()
{
Session session = new(30312, new Node(TestItem.PublicKeyA, "127.0.0.1", 8545), _channel, new MetricsDisconnectsAnalyzer(), LimboLogs.Instance);
session.Handshake(TestItem.PublicKeyA);
session.Init(5, _channelHandlerContext, _packetSender);
IProtocolHandler p2p = BuildHandler("p2p", 10);
session.AddProtocolHandler(p2p);
long beforeLocal = Network.Metrics.LocalOtherDisconnects;
long beforeRemote = Network.Metrics.OtherDisconnects;
session.MarkDisconnected(DisconnectReason.Other, DisconnectType.Local, string.Empty);
long afterLocal = Network.Metrics.LocalOtherDisconnects;
long afterRemote = Network.Metrics.OtherDisconnects;
Assert.AreEqual(beforeLocal + 1, afterLocal);
Assert.AreEqual(beforeRemote, afterRemote);
session = new Session(30312, new Node(TestItem.PublicKeyA, "127.0.0.1", 8545), _channel, new MetricsDisconnectsAnalyzer(), LimboLogs.Instance);
session.Handshake(TestItem.PublicKeyA);
session.Init(5, _channelHandlerContext, _packetSender);
p2p = BuildHandler("p2p", 10);
session.AddProtocolHandler(p2p);
beforeLocal = Network.Metrics.LocalOtherDisconnects;
beforeRemote = Network.Metrics.OtherDisconnects;
session.MarkDisconnected(DisconnectReason.Other, DisconnectType.Remote, string.Empty);
afterLocal = Network.Metrics.LocalOtherDisconnects;
afterRemote = Network.Metrics.OtherDisconnects;
Assert.AreEqual(beforeLocal, afterLocal);
Assert.AreEqual(beforeRemote + 1, afterRemote);
}
private void InitProtocol(ISession session, string protocolCode, int version, bool addCapabilities = false)
{
if (session.State < SessionState.Initialized)
{
throw new InvalidOperationException($"{nameof(InitProtocol)} called on {session}");
}
if (session.State != SessionState.Initialized)
{
return;
}
string code = protocolCode.ToLowerInvariant();
if (!_protocolFactories.TryGetValue(code, out Func <ISession, int, IProtocolHandler> protocolFactory))
{
throw new NotSupportedException($"Protocol {code} {version} is not supported");
}
IProtocolHandler protocolHandler = protocolFactory(session, version);
protocolHandler.SubprotocolRequested += (s, e) => InitProtocol(session, e.ProtocolCode, e.Version);
session.AddProtocolHandler(protocolHandler);
if (addCapabilities)
{
foreach (Capability capability in _capabilities)
{
session.AddSupportedCapability(capability);
}
}
protocolHandler.Init();
}
public void ExternalConfigurationUsage()
{
WindsorContainer container = new WindsorContainer("../aop_castle_config.xml");
container.AddFacility("aspectsharp", new AspectSharpFacility());
// Logger implementation
container.AddComponent("logger", typeof(ILogger), typeof(MemoryLogger));
// AopAlliance interceptors
container.AddComponent("log4netinterceptor", typeof(LoggerTraceInterceptor));
// Protocol handlers
container.AddComponent("protocolhandler.miranda",
typeof(IProtocolHandler), typeof(MirandaProtocolHandler));
container.AddComponent("protocolhandler.messenger",
typeof(IProtocolHandler), typeof(MessengerProtocolHandler));
// using...
ILogger logger = (ILogger)container[typeof(ILogger)];
Assert.AreEqual(0, logger.Contents.Length);
IProtocolHandler handler = (IProtocolHandler)
container["protocolhandler.miranda"];
handler.Handle("contents");
handler = (IProtocolHandler)container["protocolhandler.messenger"];
handler.Handle("contents");
Assert.AreEqual("Entering Handle Leaving Handle Entering Handle Leaving Handle ",
logger.Contents);
}
public void Cannot_dispose_unless_disconnected()
{
Session session = new Session(30312, LimboLogs.Instance, _channel, new Node("127.0.0.1", 8545));
session.Handshake(TestItem.PublicKeyA);
Assert.Throws <InvalidOperationException>(() => session.Dispose());
session.Init(5, _channelHandlerContext, _packetSender);
Assert.Throws <InvalidOperationException>(() => session.Dispose());
IProtocolHandler p2p = BuildHandler("p2p", 10);
IProtocolHandler aaa = BuildHandler("aaa", 10);
IProtocolHandler bbb = BuildHandler("bbb", 5);
IProtocolHandler ccc = BuildHandler("ccc", 1);
session.AddProtocolHandler(p2p);
session.AddProtocolHandler(aaa);
session.AddProtocolHandler(bbb);
session.AddProtocolHandler(ccc);
session.InitiateDisconnect(DisconnectReason.ClientQuitting);
session.Dispose();
aaa.Received().InitiateDisconnect(DisconnectReason.ClientQuitting, "test");
bbb.Received().InitiateDisconnect(DisconnectReason.ClientQuitting, "test");
ccc.Received().InitiateDisconnect(DisconnectReason.ClientQuitting, "test");
aaa.Received().Dispose();
bbb.Received().Dispose();
ccc.Received().Dispose();
}
public void Can_receive_messages()
{
Session session = new Session(30312, LimboLogs.Instance, _channel, new Node("127.0.0.1", 8545));
session.Handshake(TestItem.PublicKeyA);
session.Init(5, _channelHandlerContext, _packetSender);
IProtocolHandler p2p = BuildHandler("p2p", 10);
IProtocolHandler aaa = BuildHandler("aaa", 10);
IProtocolHandler bbb = BuildHandler("bbb", 5);
IProtocolHandler ccc = BuildHandler("ccc", 1);
session.AddProtocolHandler(p2p);
session.AddProtocolHandler(aaa);
session.AddProtocolHandler(bbb);
session.AddProtocolHandler(ccc);
session.ReceiveMessage(new Packet("---", 3, Bytes.Empty));
p2p.Received().HandleMessage(Arg.Is <Packet>(p => p.Protocol == "p2p" && p.PacketType == 3));
session.ReceiveMessage(new Packet("---", 11, Bytes.Empty));
aaa.Received().HandleMessage(Arg.Is <Packet>(p => p.Protocol == "aaa" && p.PacketType == 1));
session.ReceiveMessage(new Packet("---", 21, Bytes.Empty));
bbb.Received().HandleMessage(Arg.Is <Packet>(p => p.Protocol == "bbb" && p.PacketType == 1));
session.ReceiveMessage(new Packet("---", 25, Bytes.Empty));
ccc.Received().HandleMessage(Arg.Is <Packet>(p => p.Protocol == "ccc" && p.PacketType == 0));
session.ReceiveMessage(new Packet("---", 100, Bytes.Empty));
}
public void Cannot_add_handlers_before_p2p()
{
Session session = new(30312, new Node(TestItem.PublicKeyA, "127.0.0.1", 8545), _channel, NullDisconnectsAnalyzer.Instance, LimboLogs.Instance);
session.Handshake(TestItem.PublicKeyA);
session.Init(5, _channelHandlerContext, _packetSender);
IProtocolHandler aaa = BuildHandler("aaa", 10);
Assert.Throws<InvalidOperationException>(() => session.AddProtocolHandler(aaa));
}
/// <summary>
/// Sends a <see cref="IProtocolException"/> message for an invalid object X.
/// </summary>
/// <param name="handler">The protocol handler.</param>
/// <param name="ex">The exception.</param>
/// <param name="uri">The URI.</param>
/// <param name="messageId">The message identifier.</param>
/// <returns>The <see cref="IProtocolException"/> message identifier.</returns>
public static long InvalidObjectX(this IProtocolHandler handler, Exception ex, string uri, long messageId = 0)
{
if (ex != null)
{
(handler as EtpProtocolHandler)?.Logger?.Debug($"Invalid Object XML: {uri}", ex);
}
return(handler.ProtocolException((int)EtpErrorCodes.InvalidObjectX, "Invalid Object. URI: " + uri, messageId));
}
/// <exception cref="ArgumentNullException">The value of '' cannot be null. </exception>
public Protocol(IProtocolHandler handler)
{
if (handler == null)
{
throw new ArgumentNullException();
}
_handler = handler;
}
/// <summary>
/// Sends a <see cref="IProtocolException"/> message for an unsupported object.
/// </summary>
/// <param name="handler">The protocol handler.</param>
/// <param name="ex">The exception.</param>
/// <param name="uri">The URI.</param>
/// <param name="messageId">The message identifier.</param>
/// <returns>The <see cref="IProtocolException"/> message identifier.</returns>
public static long UnsupportedObject(this IProtocolHandler handler, Exception ex, string uri, long messageId = 0)
{
if (ex != null)
{
(handler as EtpProtocolHandler)?.Logger?.Debug($"Unsupported Object: {uri}", ex);
}
return(handler.ProtocolException((int)EtpErrorCodes.UnsupportedObject, "Data object not supported. URI: " + uri, messageId));
}
private Guid GetSessionId(IProtocolHandler handler)
{
var guid = handler.EtpVersion == EtpVersion.v11
? GuidUtility.Create(handler.Session.SessionId, v11.ProtocolNames.GetProtocolName(handler.Protocol))
: GuidUtility.Create(handler.Session.SessionId, v12.ProtocolNames.GetProtocolName(handler.Protocol));
SessionIds[guid] = guid;
return(guid);
}
/// <summary>
/// Validates URI Object Type.
/// </summary>
/// <param name="handler">The handler.</param>
/// <param name="etpUri">The ETP URI.</param>
/// <param name="messageId">The message identifier.</param>
/// <returns></returns>
public static bool ValidateUriObjectType(this IProtocolHandler handler, EtpUri etpUri, long messageId = 0)
{
if (!string.IsNullOrWhiteSpace(etpUri.ObjectType))
{
return(true);
}
handler.UnsupportedObject(null, $"{etpUri.Uri}", messageId);
return(false);
}
public void Cannot_receive_before_initialized()
{
Session session = new(30312, new Node(TestItem.PublicKeyA, "127.0.0.1", 8545), _channel, NullDisconnectsAnalyzer.Instance, LimboLogs.Instance);
Assert.Throws<InvalidOperationException>(() => session.ReceiveMessage(new Packet("p2p", 1, Array.Empty<byte>())));
session.Handshake(TestItem.PublicKeyA);
Assert.Throws<InvalidOperationException>(() => session.ReceiveMessage(new Packet("p2p", 1, Array.Empty<byte>())));
session.Init(5, _channelHandlerContext, _packetSender);
IProtocolHandler p2p = BuildHandler("p2p", 10);
session.AddProtocolHandler(p2p);
}
/// <summary>
/// Validates URI Parent Hierarchy.
/// </summary>
/// <param name="handler">The handler.</param>
/// <param name="etpUri">The ETP URI.</param>
/// <param name="messageId">The message identifier.</param>
/// <returns></returns>
public static bool ValidateUriParentHierarchy(this IProtocolHandler handler, EtpUri etpUri, long messageId = 0)
{
if (etpUri.ValidateUriParentHierarchy())
{
return(true);
}
handler.InvalidUri($"{etpUri} is missing the objectId of a parent.", messageId);
return(false);
}
/// <summary>
/// Creates and validates the specified URI.
/// </summary>
/// <param name="handler">The protocol handler.</param>
/// <param name="uri">The URI.</param>
/// <param name="messageId">The message identifier.</param>
/// <returns>A new <see cref="EtpUri" /> instance.</returns>
public static EtpUri CreateAndValidateUri(this IProtocolHandler handler, string uri, long messageId = 0)
{
var etpUri = new EtpUri(uri);
if (!etpUri.IsValid)
{
handler.InvalidUri(uri, messageId);
}
return(etpUri);
}
public void Connect()
{
CheckAuthenticated();
CheckNotConnected();
protocolHandler = protocolHandlerFactory.Create();
protocolHandler.Dispatcher = messageBroker;
protocolHandler.Connect(config.GameServerAddress, sessionId, sessionCookie);
this.state = GameClientState.Connected;
}
private void RegisterHandler(IProtocolHandler handler)
{
var type = handler.GetType();
foreach (var scheme in handler.Scheme)
{
if (!this.handlers.ContainsKey(scheme))
{
this.handlers.Add(scheme.ToLower(), type);
}
}
}
public void Cannot_deliver_before_initialized()
{
Session session = new Session(30312, LimboLogs.Instance, _channel, new Node("127.0.0.1", 8545));
Assert.Throws <InvalidOperationException>(() => session.DeliverMessage(new Packet("p2p", 1, Bytes.Empty)));
session.Handshake(TestItem.PublicKeyA);
Assert.Throws <InvalidOperationException>(() => session.DeliverMessage(new Packet("p2p", 1, Bytes.Empty)));
session.Init(5, _channelHandlerContext, _packetSender);
IProtocolHandler p2p = BuildHandler("p2p", 10);
session.AddProtocolHandler(p2p);
}
public void Cannot_add_handler_twice()
{
Session session = new Session(30312, LimboLogs.Instance, _channel, new Node("127.0.0.1", 8545));
session.Handshake(TestItem.PublicKeyA);
session.Init(5, _channelHandlerContext, _packetSender);
IProtocolHandler p2p = BuildHandler("p2p", 10);
IProtocolHandler p2pAgain = BuildHandler("p2p", 10);
session.AddProtocolHandler(p2p);
Assert.Throws <InvalidOperationException>(() => session.AddProtocolHandler(p2pAgain));
}
public SocketProtocolHandler(IResolverSession session, IPacketStream packetStream, IProtocolConverter protocolConverter, IProtocolHandler protocolHandler)
{
this.ResolverSession = session;
this.packetStream = packetStream ?? throw new ArgumentNullException(nameof(packetStream));
this.protocolHandler = protocolHandler ?? throw new ArgumentNullException(nameof(protocolHandler));
this.protocolConverter = protocolConverter ?? throw new ArgumentNullException(nameof(protocolConverter));
this.ConverterHeader = new ConverterHeader()
{
VersionMajor = 1
};
}
protected void SetProto(IProtocolHandler proto)
{
fProtocolHandler = this.fProtocolHandler;
}