/// <summary>
/// Constructor
/// </summary>
/// <param name="config">Network configuration</param>
/// <param name="aclLoader">ACL loader to define access</param>
/// <param name="peerFactory">Factory to create peers from endpoints</param>
/// <param name="peerListener">Listener to accept peer connections</param>
/// <param name="peerMessageListener">PeerMessageListener</param>
/// <param name="serverContext">Server context</param>
/// <param name="serverProcesses">Server processes</param>
/// <param name="logger">Logger</param>
public Server(
NetworkConfig config,
INetworkAclLoader aclLoader,
IPeerFactory peerFactory,
IPeerListener peerListener,
IPeerMessageListener peerMessageListener,
IServerContext serverContext,
IEnumerable <IServerProcess> serverProcesses,
ILogger <Server> logger)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
_peerFactory = peerFactory ?? throw new ArgumentNullException(nameof(peerFactory));
_peerListener = peerListener ?? throw new ArgumentNullException(nameof(peerListener));
if (aclLoader == null)
{
throw new ArgumentNullException(nameof(aclLoader));
}
_acl = aclLoader.Load(config.AclConfig) ?? NetworkAcl.Default;
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_peerMessageListener = peerMessageListener ?? throw new ArgumentNullException(nameof(peerMessageListener));
_serverContext = serverContext ?? throw new ArgumentNullException(nameof(serverContext));
_serverProcesses = serverProcesses ?? throw new ArgumentNullException(nameof(serverProcesses));
_peerListener.OnPeerConnected += PeerConnected;
// TODO #364: Change after port forwarding implementation
_peerEndPoints = config.PeerEndPoints;
}
public Server(
NetworkConfig config,
IPeerFactory peerFactory,
IPeerListener peerListener,
IMessageHandler <Message> messageHandler,
ILogger <Server> logger)
{
_config = config ?? throw new ArgumentNullException(nameof(config));
_peerFactory = peerFactory ?? throw new ArgumentNullException(nameof(peerFactory));
_peerListener = peerListener ?? throw new ArgumentNullException(nameof(peerListener));
_messageHandler = messageHandler;
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_peerListener.OnPeerConnected += PeerConnected;
_connectedPeers = new ConcurrentBag <IPeer>();
_failedPeers = new List <IPEndPoint>();
// TODO: Change after port forwarding implementation
_port = _config.Port;
Version = 2;
var r = new Random(Environment.TickCount);
Nonce = (uint)r.Next();
_userAgent = $"/NEO:{Assembly.GetExecutingAssembly().GetName().Version.ToString(3)}/";
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="config">Network configuration</param>
/// <param name="aclLoader">ACL loader to define access</param>
/// <param name="peerFactory">Factory to create peers from endpoints</param>
/// <param name="peerListener">Listener to accept peer connections</param>
/// <param name="peerMessageListener">PeerMessageListener</param>
/// <param name="logger">Logger</param>
public Server(
NetworkConfig config,
INetworkAclLoader aclLoader,
IPeerFactory peerFactory,
IPeerListener peerListener,
IPeerMessageListener peerMessageListener,
ILogger <Server> logger)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
_peerFactory = peerFactory ?? throw new ArgumentNullException(nameof(peerFactory));
_peerListener = peerListener ?? throw new ArgumentNullException(nameof(peerListener));
if (aclLoader == null)
{
throw new ArgumentNullException(nameof(aclLoader));
}
_acl = aclLoader.Load(config.AclConfig) ?? NetworkAcl.Default;
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_peerMessageListener = peerMessageListener ?? throw new ArgumentNullException(nameof(peerMessageListener));
_peerListener.OnPeerConnected += PeerConnected;
_connectedPeers = new ConcurrentBag <IPeer>();
_failedPeers = new List <IPEndPoint>();
// TODO: Change after port forwarding implementation
_peerEndPoints = config.PeerEndPoints;
}
public PeerBase(IPeerListener peerListener, bool batch)
{
m_batch = batch;
m_peerListener = peerListener;
m_peerSession = null;
m_sendBufferQueue = new Queue <StreamBuffer>();
m_sendBufferLenght = 0;
}
/// <summary>Create a local peer and start connecting to an active remote host.</summary>
/// <param name="remote">Remote address to connect to.</param>
/// <param name="config">Peer configuration values. If null, default is used.</param>
/// <param name="listener">Peer listener to use. If null, <see cref="PeerEvents"/> is used.</param>
/// <param name="message">Connect message to use.</param>
/// <returns>Local peer that attempts to connect.</returns>
public Peer Connect(IPEndPoint remote, PeerConfig config, IPeerListener listener, IWritable message = null)
{
// Validate
if (Disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
else if (remote == null)
{
throw new ArgumentNullException(nameof(remote), "Remote connect address is null");
}
// Map address
if (remote.AddressFamily != Socket.AddressFamily)
{
if (remote.AddressFamily == AddressFamily.InterNetwork)
{
remote = new IPEndPoint(remote.Address.MapToIPv6(), remote.Port);
}
else if (remote.Address.IsIPv4MappedToIPv6)
{
remote = new IPEndPoint(remote.Address.MapToIPv4(), remote.Port);
}
else
{
throw new ArgumentException(string.Format("Bad peer address {0}", remote), nameof(remote));
}
}
// Create peer
Peer peer = null;
try {
PeersLock.EnterWriteLock();
Peers.TryGetValue(remote, out peer);
if (peer == null || peer.Disposed)
{
peer = new Peer(this, remote, config, listener);
Peers[remote] = peer;
}
else
{
// Peer already exists
}
} finally {
PeersLock.ExitWriteLock();
}
// Start connecting
peer.Connect(message);
// Return peer
return(peer);
}
public TPeer(IPeerListener peerListener, bool batch = false)
: base(peerListener, batch)
{
this.m_sendPingTime = System.DateTime.Now;
this.m_recPingTime = System.DateTime.Now;
this.m_sendPingTimeout = 0.0f;
this.m_recPingTimeout = 0.0f;
this.m_bHeartBeat = false;
this.m_connected = false;
this.m_csHeartBeat = 0x50a0005;
this.m_scHeartBeat = 0x70a0005;
}
public PeerBase(IPeerListener listener, string address, int port)
{
lastPingResult = Environment.TickCount;
EnqueueLock = new object();
this.listener = listener;
outgoingStream = new List <byte[]>();
incomingList = new Queue <byte[]>();
ActionQueue = new Queue <Action>();
this.ServerAddress = address;
this.ServerPort = port;
this.sock = new SocketTcp(this);
}
public ClientEngine(EngineSettings settings, IPeerListener listener, IPieceWriter writer)
{
Check.Settings(settings);
Check.Listener(listener);
Check.Writer(writer);
// This is just a sanity check to make sure the ReusableTasks.dll assembly is
// loadable.
GC.KeepAlive(ReusableTasks.ReusableTask.CompletedTask);
PeerId = GeneratePeerId();
Listener = listener ?? throw new ArgumentNullException(nameof(listener));
Settings = settings ?? throw new ArgumentNullException(nameof(settings));
allTorrents = new List <TorrentManager> ();
publicTorrents = new List <TorrentManager> ();
Torrents = new ReadOnlyCollection <TorrentManager> (publicTorrents);
DiskManager = new DiskManager(Settings, writer);
ConnectionManager = new ConnectionManager(PeerId, Settings, DiskManager);
DhtEngine = new NullDhtEngine();
listenManager = new ListenManager(this);
PortForwarder = new MonoNatPortForwarder();
MainLoop.QueueTimeout(TimeSpan.FromMilliseconds(TickLength), delegate {
if (IsRunning && !Disposed)
{
LogicTick();
}
return(!Disposed);
});
downloadLimiter = new RateLimiter();
downloadLimiters = new RateLimiterGroup {
new DiskWriterLimiter(DiskManager),
downloadLimiter,
};
uploadLimiter = new RateLimiter();
uploadLimiters = new RateLimiterGroup {
uploadLimiter
};
listenManager.Register(listener);
if (SupportsLocalPeerDiscovery)
{
RegisterLocalPeerDiscovery(new LocalPeerDiscovery(Settings));
}
}
public Server(
IBlockchain blockchain,
NetworkConfig config,
IPeerFactory peerFactory,
IPeerListener peerListener,
IMessageHandler <Message> messageHandler,
ILogger <Server> logger,
NetworkACLFactory aclFactory)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
this._blockchain = blockchain ?? throw new ArgumentNullException(nameof(blockchain));
this._peerFactory = peerFactory ?? throw new ArgumentNullException(nameof(peerFactory));
this._peerListener = peerListener ?? throw new ArgumentNullException(nameof(peerListener));
this._logger = logger ?? throw new ArgumentNullException(nameof(logger));
if (aclFactory == null)
{
throw new ArgumentNullException(nameof(aclFactory));
}
this._messageHandler = messageHandler;
this._acl = aclFactory.CreateNew();
this._acl?.Load(config?.ACL);
this._peerListener.OnPeerConnected += PeerConnected;
this._connectedPeers = new ConcurrentBag <IPeer>();
this._failedPeers = new List <IPEndPoint>();
// TODO: Change after port forwarding implementation
this._port = config.Port;
ProtocolVersion = 2;
var r = new Random(Environment.TickCount);
Nonce = (uint)r.Next();
this._peerEndPoints = config.PeerEndPoints;
this._userAgent = $"/NEO:{Assembly.GetExecutingAssembly().GetName().Version.ToString(3)}/";
}
public ClientEngine(EngineSettings settings, IPeerListener listener, IPieceWriter writer)
{
Check.Settings(settings);
Check.Listener(listener);
Check.Writer(writer);
PeerId = GeneratePeerId();
Listener = listener ?? throw new ArgumentNullException(nameof(listener));
Settings = settings ?? throw new ArgumentNullException(nameof(settings));
torrents = new List <TorrentManager>();
Torrents = new ReadOnlyCollection <TorrentManager> (torrents);
DiskManager = new DiskManager(Settings, writer);
ConnectionManager = new ConnectionManager(PeerId, Settings, DiskManager);
DhtEngine = new NullDhtEngine();
listenManager = new ListenManager(this);
MainLoop.QueueTimeout(TimeSpan.FromMilliseconds(TickLength), delegate {
if (IsRunning && !Disposed)
{
LogicTick();
}
return(!Disposed);
});
downloadLimiter = new RateLimiter();
downloadLimiters = new RateLimiterGroup {
new DiskWriterLimiter(DiskManager),
downloadLimiter,
};
uploadLimiter = new RateLimiter();
uploadLimiters = new RateLimiterGroup {
uploadLimiter
};
listenManager.Register(listener);
if (SupportsLocalPeerDiscovery)
{
RegisterLocalPeerDiscovery(new LocalPeerDiscovery(Settings));
}
}
public ClientEngine(EngineSettings settings, IPeerListener listener, PieceWriter writer)
{
Check.Settings(settings);
Check.Listener(listener);
Check.Writer(writer);
this.Listener = listener;
this.Settings = settings;
this.ConnectionManager = new ConnectionManager(this);
DhtEngine = new NullDhtEngine();
this.DiskManager = new DiskManager(this, writer);
this.listenManager = new ListenManager(this);
MainLoop.QueueTimeout(TimeSpan.FromMilliseconds(TickLength), delegate {
if (IsRunning && !Disposed)
{
LogicTick();
}
return(!Disposed);
});
this.torrents = new List <TorrentManager>();
this.torrentsReadonly = new ReadOnlyCollection <TorrentManager> (torrents);
downloadLimiter = new RateLimiterGroup {
new DiskWriterLimiter(DiskManager),
new RateLimiter()
};
uploadLimiter = new RateLimiter();
this.PeerId = GeneratePeerId();
localPeerListener = new LocalPeerListener();
localPeerListener.PeerFound += HandleLocalPeerFound;
localPeerManager = new LocalPeerManager();
LocalPeerSearchEnabled = SupportsLocalPeerDiscovery;
listenManager.Register(listener);
}
public void Unregister(IPeerListener listener)
{
listener.ConnectionReceived -= ConnectionReceived;
Listeners.Remove(listener);
}
public void Register(IPeerListener listener)
{
Listeners.Add(listener);
listener.ConnectionReceived += ConnectionReceived;
}
public void SetPeerListener(IPeerListener listener)
{
m_listener = listener != null ? listener : s_nullPeerListener;
}
public ReliableOrderServerPeer(IGameSession iSession, IPeerListener peerListener)
: base(iSession, peerListener)
{
}
/// <summary>Accept the request, create a new peer and establish a connection.</summary>
/// <param name="config">Peer configuration values. If null, default is used.</param>
/// <param name="listener">Peer listener. If null, event based listener is created.</param>
/// <returns>The created peer.</returns>
public Peer Accept(PeerConfig config, IPeerListener listener)
{
return(Host.Accept(this, config, listener));
}
/// <summary>Accept a connection request and return a connected local peer.</summary>
/// <param name="request">Connection request to accept.</param>
/// <param name="config">Peer configuration values. If null, default is used.</param>
/// <param name="listener">Peer listener to use. If null, event based listener is created.</param>
/// <returns>Connected local peer.</returns>
public Peer Accept(ConnectionRequest request, PeerConfig config, IPeerListener listener)
{
// Validate request
if (Disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
else if (request == null)
{
throw new ArgumentNullException(nameof(request), "Connection request is null");
}
else if (request.Host != this)
{
throw new ArgumentException("Connection request host mismatch", nameof(request));
}
else if (request.Disposed)
{
throw new InvalidOperationException(string.Format(
"Connection request from {0} is disposed", request.Remote
));
}
else if (config.RemotePublicKey != null)
{
throw new ArgumentException(string.Format(
"Connection request from {0} cannot be authenticated", request.Remote
), nameof(config));
}
else if (request.Key.Count > 0 && request.Key.Count != ExchangerKeyLength)
{
throw new InvalidOperationException(string.Format(
"Connection request from {0} has {1} exchanger bytes", request.Remote, request.Key.Count
));
}
else if (request.Random.Count > 0 && request.Random.Count != Authenticator.SignatureLength)
{
throw new InvalidOperationException(string.Format(
"Connection request from {0} has {1} random bytes", request.Remote, request.Random.Count
));
}
else if (request.Random.Count > 0 && Config.PrivateKey == null)
{
throw new InvalidOperationException(string.Format(
"Connection request from {0} has authentication", request.Remote
));
}
// Create peer
Peer peer = null;
try {
PeersLock.EnterWriteLock();
Peers.TryGetValue(request.Remote, out peer);
if (peer == null || peer.Disposed)
{
peer = new Peer(this, request.Remote, config, listener);
Peers[request.Remote] = peer;
}
else
{
// Peer already exists
}
} finally {
PeersLock.ExitWriteLock();
}
// Accept the request
peer.Accept(request);
// Return peer
return(peer);
}
protected void SetPeerListener(IPeerListener peerListener)
{
m_peerListener = peerListener;
}
public ReliableOrderPeer(IPeerListener peerListener, bool batch = false)
: base(peerListener, batch)
{
InitPeer(null);
}
public void Setup()
{
listener = new PeerListener(endpoint);
listener.Start();
}
public void SetPeerListener(IPeerListener listener)
{
m_listener = listener != null ? listener : s_nullPeerListener;
}
protected ReliableOrderPeer(IGameSession iSession, IPeerListener peerListener, bool batch = false)
: base(peerListener, batch)
{
InitPeer(iSession);
}
public ClientEngine(EngineSettings settings, IPeerListener listener)
: this(settings, listener, new DiskWriter())
{
}
public void StartServerPeer(IPeerListener peerListener)
{
SetPeerListener(peerListener);
((ServerSession)m_peerSession).SessionReceive(this);
}
public void SetListener(IPeerListener listener)
{
Listener.ConnectionReceived -= ConnectionReceived;
Listener = listener ?? new NullPeerListener();
Listener.ConnectionReceived += ConnectionReceived;
}
public ClientPeer(IPeerListener listener, ConnectionProtocol protocolType = ConnectionProtocol.Tcp)
{
PeerListener = listener;
UsedProtocol = protocolType;
}
