/// <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; }