/// <summary>
/// Initializes parts of the object that are common for both inbound and outbound peers.
/// </summary>
/// <param name="inbound"><c>true</c> for inbound peers, <c>false</c> for outbound peers.</param>
/// <param name="peerEndPoint">IP address and port on the side of the peer.</param>
/// <param name="network">Specification of the network the node runs on - regtest/testnet/mainnet.</param>
/// <param name="parameters">Various settings and requirements related to how the connections with peers are going to be established, or <c>null</c> to use default parameters.</param>
/// <param name="dateTimeProvider">Provider of time functions.</param>
/// <param name="loggerFactory">Factory for creating loggers.</param>
/// <param name="selfEndpointTracker">Tracker for endpoints known to be self.</param>
/// <param name="onDisconnected">Callback that is invoked when peer has finished disconnecting, or <c>null</c> when no notification after the disconnection is required.</param>
private NetworkPeer(bool inbound,
IPEndPoint peerEndPoint,
Network network,
NetworkPeerConnectionParameters parameters,
IDateTimeProvider dateTimeProvider,
ILoggerFactory loggerFactory,
ISelfEndpointTracker selfEndpointTracker,
Action <INetworkPeer> onDisconnected = null)
{
this.loggerFactory = loggerFactory;
this.dateTimeProvider = dateTimeProvider;
this.preferredTransactionOptions = network.NetworkOptions;
this.SupportedTransactionOptions = network.NetworkOptions & ~NetworkOptions.All;
this.State = inbound ? NetworkPeerState.Connected : NetworkPeerState.Created;
this.Inbound = inbound;
this.PeerEndPoint = peerEndPoint;
this.RemoteSocketEndpoint = this.PeerEndPoint;
this.RemoteSocketAddress = this.RemoteSocketEndpoint.Address;
this.RemoteSocketPort = this.RemoteSocketEndpoint.Port;
this.Network = network;
this.Behaviors = new NetworkPeerBehaviorsCollection(this);
this.selfEndpointTracker = selfEndpointTracker;
this.onDisconnectedAsyncContext = new AsyncLocal <DisconnectedExecutionAsyncContext>();
this.ConnectionParameters = parameters ?? new NetworkPeerConnectionParameters();
this.MyVersion = this.ConnectionParameters.CreateVersion(this.PeerEndPoint, network, this.dateTimeProvider.GetTimeOffset());
this.MessageReceived = new AsyncExecutionEvent <INetworkPeer, IncomingMessage>();
this.StateChanged = new AsyncExecutionEvent <INetworkPeer, NetworkPeerState>();
this.onDisconnected = onDisconnected;
}
public PeerInvalidTransactionProvider(IOptionsSnapshot <NetworkOptions> networkOptions)
{
_networkOptions = networkOptions.Value;
_invalidTransactionCache = new ConcurrentDictionary <string, ConcurrentQueue <InvalidTransaction> >();
_hostInvalidTransactionIdCache = new ConcurrentDictionary <string, int>();
Logger = NullLogger <PeerInvalidTransactionProvider> .Instance;
}
private Block GenerateBlockWithWeight(int weight, NetworkOptions options)
{
var block = new Block();
var transaction = new Transaction();
transaction.Outputs.Add(new TxOut(new Money(10000000000), new Script()));
block.Transactions.Add(transaction);
int blockWeight = this.CalculateBlockWeight(block, options);
var requiredScriptWeight = weight - blockWeight - 4;
block.Transactions[0].Outputs.Clear();
// generate nonsense script with required bytes to reach required weight.
var script = Script.FromBytesUnsafe(new string('A', requiredScriptWeight).Select(c => (byte)c).ToArray());
transaction.Outputs.Add(new TxOut(new Money(10000000000), script));
blockWeight = this.CalculateBlockWeight(block, options);
if (blockWeight == weight)
{
return(block);
}
return(null);
}
public static NetServer CreateServer(NetworkOptions options)
{
var config = new NetPeerConfiguration(options.Identifier);
config.AcceptIncomingConnections = true;
config.UseMessageRecycling = true;
config.SetMessageTypeEnabled(NetIncomingMessageType.DiscoveryRequest, true);
config.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval, true);
config.MaximumConnections = options.ClientLimit;
config.ConnectionTimeout = 5;
if (options.PingInterval > 0)
{
config.PingInterval = options.PingInterval / 1000f;
}
if (options.RetryInterval > 0)
{
config.ResendHandshakeInterval = config.ResendHandshakeInterval / 1000f;
}
if (options.Host != null && options.Host.Trim().Length > 0)
{
config.LocalAddress = IPAddress.Parse(options.Host);
}
config.Port = options.Port;
return(new NetServer(config));
}
public ProudNetServerService(ILogger <ProudNetServerService> logger, IServiceProvider serviceProvider,
IOptions <NetworkOptions> networkOptions, IOptions <ThreadingOptions> threadingOptions,
P2PGroupManager groupManager, UdpSocketManager udpSocketManager, ISchedulerService schedulerService,
ISessionManagerFactory sessionManagerFactory, Microsoft.Extensions.Logging.ILoggerFactory loggerFactory)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_logger = logger;
_serviceProvider = serviceProvider;
_networkOptions = networkOptions.Value;
_threadingOptions = threadingOptions.Value;
_groupManager = groupManager;
_udpSocketManager = udpSocketManager;
_schedulerService = schedulerService;
_magicNumberSessionManager = sessionManagerFactory.GetSessionManager <Guid>(SessionManagerType.MagicNumber);
_udpSessionManager = sessionManagerFactory.GetSessionManager <uint>(SessionManagerType.UdpId);
InternalLoggerFactory.DefaultFactory = loggerFactory;
var sessionManager = _serviceProvider.GetRequiredService <ISessionManager>();
sessionManager.Added += SessionManager_OnAdded;
sessionManager.Removed += SessionManager_OnRemoved;
}
/// <summary>
/// Clones the NetworkOptions object.
/// </summary>
/// <returns>The cloned NetworkOptions object.</returns>
public virtual NetworkOptions Clone()
{
var clone = new NetworkOptions();
clone.flags = this.flags;
return(clone);
}
public NetworkParameters(double learningRate, double dropoutRate, double momentum, bool doBiases, int numIterations = 0)
{
Options = NetworkOptions.None;
if (learningRate > 0 && learningRate != 1)
{
LearningRate = learningRate;
Options |= NetworkOptions.LearningRate;
}
if (dropoutRate > 0)
{
DropoutRate = dropoutRate;
DropoutMultiplier = 1.0 / (1 - DropoutRate);
Options |= NetworkOptions.Dropout;
}
if (momentum > 0)
{
Momentum = momentum;
Options |= NetworkOptions.Momentum;
}
if (doBiases)
{
Options |= NetworkOptions.Biases;
}
NumIterations = numIterations;
}
public NodeManager(IOptionsSnapshot <NetworkOptions> networkOptions)
{
_nodes = new ConcurrentDictionary <string, NodeInfo>();
_networkOptions = networkOptions.Value;
Logger = NullLogger <NodeManager> .Instance;
}
public byte[] Send(byte[] data, NetworkOptions options)
{
SocketError err;
_socket.SendTimeout = (int)options.SendTimeout.TotalMilliseconds;
_socket.Send(data, 0, data.Length, SocketFlags.None, out err);
_logger.Debug("Send Completed with status: " + err);
_socket.ReceiveTimeout = (int)options.ReceiveTimeout.TotalMilliseconds;
try
{
int readBytes = _socket.Receive(state.buffer, 0, bufSize, SocketFlags.None, out err);
_logger.Debug("Receive Completed with status: " + err);
if (err == SocketError.Success)
{
//_packet.Raw = state.buffer.Take(readBytes).ToArray();
return(state.buffer.Take(readBytes).ToArray());
}
}
catch (SocketException ex)
{
if (ex.SocketErrorCode == SocketError.TimedOut)
{
// tid ut
}
else
{
throw;
}
}
return(null);
}
/// <summary>
/// Gets serialized size of <paramref name="data"/> in bytes.
/// </summary>
/// <param name="data">Data that we calculate serialized size of.</param>
/// <param name="options">Serialization options.</param>
/// <returns>Serialized size of <paramref name="data"/> in bytes.</returns>
private int GetSize(IBitcoinSerializable data, NetworkOptions options)
{
var bms = new BitcoinStream(Stream.Null, true);
bms.TransactionOptions = options;
data.ReadWrite(bms);
return((int)bms.Counter.WrittenBytes);
}
public PeerDiscoveryJobProcessorTests()
{
_peerDiscoveryJobProcessor = GetRequiredService <IPeerDiscoveryJobProcessor>();
_peerPool = GetRequiredService <IPeerPool>();
_nodeManager = GetRequiredService <INodeManager>();
_discoveredNodeCacheProvider = GetRequiredService <IDiscoveredNodeCacheProvider>();
_networkOptions = GetRequiredService <IOptionsSnapshot <NetworkOptions> >().Value;
}
public P2PGroupManager(ILogger <P2PGroupManager> logger, ILoggerFactory loggerFactory,
IOptions <NetworkOptions> options, IHostIdFactory hostIdFactory, ISessionManager sessionManager)
{
_logger = logger;
_loggerFactory = loggerFactory;
_options = options.Value;
_hostIdFactory = hostIdFactory;
_sessionManager = sessionManager;
}
internal P2PGroup(ILogger <P2PGroup> logger, uint hostId, NetworkOptions options,
ISessionManager sessionManager, bool allowDirectP2P)
{
_log = logger;
_options = options;
_sessionManager = sessionManager;
HostId = hostId;
AllowDirectP2P = allowDirectP2P;
}
public AuthenticationHandler(
ISessionManagerFactory sessionManagerFactory,
IOptions <NetworkOptions> networkOptions,
RSACryptoServiceProvider rsa)
{
_sessionManager = sessionManagerFactory.GetSessionManager <uint>(SessionManagerType.HostId);
_networkOptions = networkOptions.Value;
_rsa = rsa;
}
/// <summary>
/// Gets serialized size of <paramref name="data"/> in bytes.
/// </summary>
/// <param name="network">The blockchain network.</param>
/// <param name="data">Data that we calculate serialized size of.</param>
/// <param name="options">Serialization options.</param>
/// <returns>Serialized size of <paramref name="data"/> in bytes.</returns>
public static int GetSize(Network network, IBitcoinSerializable data, NetworkOptions options)
{
var bms = new BitcoinStream(Stream.Null, true);
bms.TransactionOptions = options;
bms.ConsensusFactory = network.Consensus.ConsensusFactory;
data.ReadWrite(bms);
return((int)bms.Counter.WrittenBytes);
}
public NetworkParameters(NetworkParameters parameters)
{
Options = parameters.Options;
LearningRate = parameters.LearningRate;
DropoutRate = parameters.DropoutRate;
DropoutMultiplier = parameters.DropoutMultiplier;
Momentum = parameters.Momentum;
NumIterations = parameters.NumIterations;
}
public HandshakeProvider(IAccountService accountService, IBlockchainService blockchainService,
IOptionsSnapshot <NetworkOptions> networkOptions)
{
_accountService = accountService;
_blockchainService = blockchainService;
_networkOptions = networkOptions.Value;
Logger = NullLogger <HandshakeProvider> .Instance;
}
private int CalculateBlockWeight(Transaction transaction, NetworkOptions options)
{
using (var stream = new MemoryStream())
{
var bms = new BitcoinStream(stream, true);
bms.TransactionOptions = options;
transaction.ReadWrite(bms);
return((int)bms.Counter.WrittenBytes);
}
}
public ServerlistService(ILogger <ServerlistService> logger, ISessionManager sessionManager, ISchedulerService scheduler,
IMessageBus messageBus, IOptions <NetworkOptions> networkOptions, IOptions <ServerListOptions> serverOptions)
{
_logger = logger;
_sessionManager = sessionManager;
_scheduler = scheduler;
_messageBus = messageBus;
_networkOptions = networkOptions.Value;
_serverOptions = serverOptions.Value;
}
public GrpcServerService(IOptionsSnapshot <NetworkOptions> netOpts, IPeerPool peerPool, IBlockchainService blockChainService, IAccountService accountService)
{
_netOpts = netOpts.Value;
_peerPool = peerPool;
_blockChainService = blockChainService;
_accountService = accountService;
EventBus = NullLocalEventBus.Instance;
Logger = NullLogger <GrpcServerService> .Instance;
}
/// <summary>
/// Provides the '&' (and) operator between two NetworkOptions objects.
/// </summary>
/// <param name="left">The left NetworkOptions object.</param>
/// <param name="right">The right NetworkOptions object.</param>
/// <returns>A NetworkOptions object that represents the intersection of the input object.</returns>
public static NetworkOptions operator &(NetworkOptions left, NetworkOptions right)
{
if (ReferenceEquals(null, left))
{
return(right?.Clone());
}
NetworkOptions clone = left.Clone();
clone.flags &= (right?.flags ?? All);
return(clone);
}
public GrpcNetworkServer(IOptionsSnapshot <NetworkOptions> options, PeerService.PeerServiceBase serverService,
IPeerPool peerPool, AuthInterceptor authInterceptor)
{
_serverService = serverService;
_authInterceptor = authInterceptor;
_peerPool = peerPool;
_networkOptions = options.Value;
Logger = NullLogger <GrpcNetworkServer> .Instance;
EventBus = NullLocalEventBus.Instance;
}
public ActionPolicy(NetworkOptions networkOptions)
{
Condition.Requires(networkOptions, "networkOptions").IsNotNull();
Condition.Requires(networkOptions.RetryAttempts, "networkOptions.RetryAttempts").IsGreaterThan(0);
Condition.Requires(networkOptions.DelayBetweenFailedRequestsInSec, "networkOptions.DelayBetweenFailedRequestsInSec").IsGreaterOrEqual(0);
Condition.Requires(networkOptions.DelayFailedRequestRate, "networkOptions.DelayFailRequestRate").IsGreaterOrEqual(0);
this._retryAttempts = networkOptions.RetryAttempts;
this._delay = networkOptions.DelayBetweenFailedRequestsInSec;
this._delayRate = networkOptions.DelayFailedRequestRate;
}
public PeerReconnectionWorker(AbpTimer timer, IOptionsSnapshot <NetworkOptions> networkOptions,
INetworkService networkService, IPeerPool peerPool, IReconnectionService reconnectionService)
: base(timer)
{
_peerPool = peerPool;
_reconnectionService = reconnectionService;
_networkService = networkService;
_networkOptions = networkOptions.Value;
timer.Period = _networkOptions.PeerReconnectionPeriod;
}
public Startup(IHostingEnvironment env)
{
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
.AddEnvironmentVariables();
Configuration = builder.Build();
NetworkOptions = Configuration.GetSection("Network").Get <NetworkOptions>();
}
public GrpcPeerPool(IOptionsSnapshot <NetworkOptions> networkOptions, IAccountService accountService,
IBlockchainService blockChainService)
{
_networkOptions = networkOptions.Value;
_accountService = accountService;
_blockchainService = blockChainService;
_authenticatedPeers = new ConcurrentDictionary <string, GrpcPeer>();
Logger = NullLogger <GrpcPeerPool> .Instance;
}
public void ResetVariables()
{
NetworkOptions = new NetworkOptions();
// Session
InsertedTokens.Clear();
SelectedTokens.Clear();
SelectedMap = "empty";
// Restore latest settings
LoadMainMenu();
}
/// <inheritdoc />
public InventoryType AddSupportedOptions(InventoryType inventoryType)
{
// Transaction options we prefer and which are also supported by peer.
NetworkOptions actualTransactionOptions = this.preferredTransactionOptions & this.SupportedTransactionOptions;
if ((actualTransactionOptions & NetworkOptions.Witness) != 0)
{
inventoryType |= InventoryType.MSG_WITNESS_FLAG;
}
return(inventoryType);
}
public AuthenticationHandler(ILogger <AuthenticationHandler> logger, IOptions <NetworkOptions> networkOptions,
IMessageBus messageBus, ISessionManager sessionManager, DatabaseService databaseService,
IServiceProvider serviceProvider, PlayerManager playerManager)
{
_logger = logger;
_networkOptions = networkOptions.Value;
_messageBus = messageBus;
_sessionManager = sessionManager;
_databaseService = databaseService;
_serviceProvider = serviceProvider;
_playerManager = playerManager;
}
public SessionHandler(ILogger <SessionHandler> logger, IOptions <NetworkOptions> networkOptions,
RSACryptoServiceProvider rsa, IHostIdFactory hostIdFactory,
ISessionFactory sessionFactory, ISessionManagerFactory sessionManagerFactory,
ILoggerFactory loggerFactory)
{
_logger = logger;
_networkOptions = networkOptions.Value;
_rsa = rsa;
_hostIdFactory = hostIdFactory;
_sessionFactory = sessionFactory;
_sessionManager = sessionManagerFactory.GetSessionManager <uint>(SessionManagerType.HostId);
_loggerFactory = loggerFactory;
}
