/// <summary>
/// Appends the given load to the machine with the lowest load
/// </summary>
/// <param name="load">Load to append</param>
/// <param name="includeMaster">Can master receive this load</param>
/// <returns>The peer manager that received the load, null if master machine received it</returns>
public IPeerManager AppendLoad(float load, bool includeMaster)
{
IPeerManager lowestPeer = null;
foreach (var clientLoad in clientLoads)
{
if (lowestPeer == null || clientLoad.Value < clientLoads[lowestPeer])
{
lowestPeer = clientLoad.Key;
}
}
if (includeMaster && (lowestPeer == null || masterLoad < clientLoads[lowestPeer]))
{
masterLoad += load;
return(null);
}
if (lowestPeer == null)
{
Log.Error($"{nameof(NetworkLoadBalancer)} does not have any client registered. Load appended to the master machine.");
masterLoad += load;
return(null);
}
clientLoads[lowestPeer] = clientLoads[lowestPeer] + load;
return(lowestPeer);
}
/// <inheritdoc/>
public void ReceiveMessage(IPeerManager sender, DistributedMessage distributedMessage)
{
if (ParentObject.IsAuthoritative)
{
return;
}
DistributedMessage messageCopy = null;
if (ParentObject.ForwardMessages)
{
messageCopy = new DistributedMessage(distributedMessage);
if (string.IsNullOrEmpty(messageCopy.AddressKey))
{
Log.Error("Null before");
}
}
ParseMessage(distributedMessage);
if (ParentObject.ForwardMessages && messageCopy != null)
{
if (!string.IsNullOrEmpty(messageCopy.AddressKey))
{
BroadcastMessage(messageCopy);
}
else
{
Log.Error("Null after");
}
}
}
public void parity_netPeers_null_ActivePeers()
{
var logger = LimboLogs.Instance;
var specProvider = MainnetSpecProvider.Instance;
var ethereumEcdsa = new EthereumEcdsa(specProvider.ChainId, logger);
var txStorage = new InMemoryTxStorage();
IDb blockDb = new MemDb();
IDb headerDb = new MemDb();
IDb blockInfoDb = new MemDb();
IBlockTree blockTree = new BlockTree(blockDb, headerDb, blockInfoDb, new ChainLevelInfoRepository(blockInfoDb), specProvider, NullBloomStorage.Instance, LimboLogs.Instance);
var txPool = new TxPool.TxPool(txStorage, ethereumEcdsa, new ChainHeadSpecProvider(specProvider, blockTree), new TxPoolConfig(),
new StateProvider(new TrieStore(new MemDb(), LimboLogs.Instance), new MemDb(), LimboLogs.Instance), new TxValidator(specProvider.ChainId), LimboLogs.Instance);
new OnChainTxWatcher(blockTree, txPool, specProvider, LimboLogs.Instance);
IReceiptStorage receiptStorage = new InMemoryReceiptStorage();
IPeerManager peerManager = Substitute.For <IPeerManager>();
IParityModule parityModule = new ParityModule(ethereumEcdsa, txPool, blockTree, receiptStorage, new Enode(TestItem.PublicKeyA, IPAddress.Loopback, 8545),
_signerStore, new MemKeyStore(new[] { TestItem.PrivateKeyA }), logger, peerManager);
string serialized = RpcTest.TestSerializedRequest(parityModule, "parity_netPeers");
var expectedResult = "{\"jsonrpc\":\"2.0\",\"result\":{\"active\":0,\"connected\":0,\"max\":0,\"peers\":[]},\"id\":67}";
Assert.AreEqual(expectedResult, serialized);
}
/// <summary>
/// Method invoked when new peer connects
/// </summary>
/// <param name="peer">Peer that has connected</param>
public void OnPeerConnected(IPeerManager peer)
{
Debug.Assert(State == SimulationState.Initial);
MasterPeer = peer;
Log.Info($"Master {peer.PeerEndPoint} connected.");
var info = new Commands.Info()
{
Version = "todo",
UnityVersion = Application.unityVersion,
OperatingSystem = SystemInfo.operatingSystemFamily.ToString(),
};
State = SimulationState.Connected;
if (Loader.Instance.LoaderUI != null)
{
Loader.Instance.LoaderUI.SetLoaderUIState(LoaderUI.LoaderUIStateType.PROGRESS);
}
var infoData = PacketsProcessor.Write(info);
var message = MessagesPool.Instance.GetMessage(infoData.Length);
message.AddressKey = Key;
message.Content.PushBytes(infoData);
message.Type = DistributedMessageType.ReliableOrdered;
UnicastMessage(peer.PeerEndPoint, message);
}
private async Task InitPeer()
{
/* rlpx */
var eciesCipher = new EciesCipher(_cryptoRandom);
var eip8Pad = new Eip8MessagePad(_cryptoRandom);
_messageSerializationService.Register(new AuthEip8MessageSerializer(eip8Pad));
_messageSerializationService.Register(new AckEip8MessageSerializer(eip8Pad));
_messageSerializationService.Register(Assembly.GetAssembly(typeof(HelloMessageSerializer)));
var encryptionHandshakeServiceA = new EncryptionHandshakeService(_messageSerializationService, eciesCipher,
_cryptoRandom, new Ecdsa(), _nodeKey, _logManager);
var networkConfig = _configProvider.GetConfig <INetworkConfig>();
_sessionMonitor = new SessionMonitor(networkConfig, _logManager);
_rlpxPeer = new RlpxPeer(
_nodeKey.PublicKey,
_initConfig.P2PPort,
encryptionHandshakeServiceA,
_logManager,
_sessionMonitor);
await _rlpxPeer.Init();
var peerStorage = new NetworkStorage(PeersDbPath, networkConfig, _logManager, _perfService);
ProtocolValidator protocolValidator = new ProtocolValidator(_nodeStatsManager, _blockTree, _logManager);
_protocolsManager = new ProtocolsManager(_syncPeerPool, _syncServer, _txPool, _discoveryApp, _messageSerializationService, _rlpxPeer, _nodeStatsManager, protocolValidator, peerStorage, _perfService, _logManager);
PeerLoader peerLoader = new PeerLoader(networkConfig, _nodeStatsManager, peerStorage, _logManager);
_peerManager = new PeerManager(_rlpxPeer, _discoveryApp, _nodeStatsManager, peerStorage, peerLoader, networkConfig, _logManager);
_peerManager.Init();
}
public void Initialize()
{
_logManager = new OneLoggerLogManager(new SimpleConsoleLogger());
_configurationProvider = new JsonConfigProvider();
((NetworkConfig)_configurationProvider.GetConfig <NetworkConfig>()).DbBasePath = Path.Combine(Path.GetTempPath(), "PeerManagerTests");
if (!Directory.Exists(_configurationProvider.GetConfig <NetworkConfig>().DbBasePath))
{
Directory.CreateDirectory(_configurationProvider.GetConfig <NetworkConfig>().DbBasePath);
}
_nodeFactory = new NodeFactory();
_localPeer = new TestRlpxPeer();
var keyProvider = new PrivateKeyProvider(new CryptoRandom());
var key = keyProvider.PrivateKey.PublicKey;
_synchronizationManager = Substitute.For <ISynchronizationManager>();
var nodeTable = new NodeTable(_nodeFactory, Substitute.For <IKeyStore>(), new NodeDistanceCalculator(_configurationProvider), _configurationProvider, _logManager);
nodeTable.Initialize(new NodeId(key));
_discoveryManager = new DiscoveryManager(new NodeLifecycleManagerFactory(_nodeFactory, nodeTable, new DiscoveryMessageFactory(_configurationProvider), Substitute.For <IEvictionManager>(), new NodeStatsProvider(_configurationProvider), _configurationProvider, _logManager), _nodeFactory, nodeTable, new DiscoveryStorage(_configurationProvider, _nodeFactory, _logManager, new PerfService(_logManager)), _configurationProvider, _logManager);
_discoveryManager.MessageSender = Substitute.For <IMessageSender>();
_peerManager = new PeerManager(_localPeer, _discoveryManager, _synchronizationManager, new NodeStatsProvider(_configurationProvider), new PeerStorage(_configurationProvider, _nodeFactory, _logManager, new PerfService(_logManager)), _nodeFactory, _configurationProvider, new PerfService(_logManager), _logManager);
}
/// <summary>
/// Method invoked when peer disconnects
/// </summary>
/// <param name="peer">Peer that has disconnected</param>
public void OnPeerDisconnected(IPeerManager peer)
{
MasterPeer = null;
OnStopCommand(new Commands.Stop());
MessagesManager.RevokeIdentifiers();
Debug.Log($"Peer {peer.PeerEndPoint} disconnected.");
}
void IMessageReceiver.ReceiveMessage(IPeerManager sender, DistributedMessage distributedMessage)
{
if (sensorsInstances.Any() || Loader.Instance.Network.IsMaster)
{
return;
}
var allSensorsString = distributedMessage.Content.PopString();
var allSensors = JsonConvert.DeserializeObject <SensorData[]>(allSensorsString);
var enabledSensorsString = distributedMessage.Content.PopString();
var enabledSensors = JsonConvert.DeserializeObject <List <string> >(enabledSensorsString);
InstantiateSensors(allSensors);
foreach (var instance in sensorsInstances)
{
if (enabledSensors.Contains(instance.Key))
{
instance.Value.Enable();
}
else
{
instance.Value.Disable();
}
}
SensorsChanged?.Invoke();
}
/// <inheritdoc/>
public void ReceiveMessage(IPeerManager sender, Message message)
{
var command =
(IdsRegisterCommandType)message.Content.PopInt(ByteCompression
.RequiredBytes <IdsRegisterCommandType>());
var key = message.Content.PopString();
var id = message.Content.PopInt(BytesPerId);
switch (command)
{
case IdsRegisterCommandType.BindIdAndKey:
if (AssignIds)
{
return;
}
BindReceiver(key, id);
break;
case IdsRegisterCommandType.UnbindIdAndKey:
if (AssignIds)
{
return;
}
UnbindKeyId(key, id);
break;
}
}
/// <inheritdoc/>
public void ReceiveMessage(IPeerManager sender, DistributedMessage distributedMessage)
{
var methodName = distributedMessage.Content.PopEnum <NPCControllerMethodName>();
switch (methodName)
{
case NPCControllerMethodName.SetLights:
SetLights(distributedMessage.Content.PopInt());
break;
case NPCControllerMethodName.SetBrakeLights:
SetBrakeLights(distributedMessage.Content.PopBool());
break;
case NPCControllerMethodName.SetNPCTurnSignal:
SetNPCTurnSignal(distributedMessage.Content.PopBool(), distributedMessage.Content.PopBool(), distributedMessage.Content.PopBool());
break;
case NPCControllerMethodName.SetNPCHazards:
SetNPCHazards(distributedMessage.Content.PopBool());
break;
case NPCControllerMethodName.SetIndicatorReverse:
SetIndicatorReverse(distributedMessage.Content.PopBool());
break;
case NPCControllerMethodName.ResetLights:
ResetLights();
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Method that sends initial messages to new peer after connecting to the connection manager
/// </summary>
/// <param name="peer">New connected peer</param>
private void ConnectionManagerOnPeerConnected(IPeerManager peer)
{
for (var i = 0; i < senders.Count; i++)
{
senders[i].UnicastInitialMessages(peer.PeerEndPoint);
}
}
/// <inheritdoc/>
public void ReceiveMessage(IPeerManager sender, DistributedMessage distributedMessage)
{
if (!ParentObject.IsAuthoritative)
{
ParseMessage(distributedMessage);
}
}
public EthStatsIntegration(
string name,
string node,
int port,
string network,
string protocol,
string api,
string client,
string contact,
bool canUpdateHistory,
string secret,
IEthStatsClient?ethStatsClient,
IMessageSender?sender,
ITxPool?txPool,
IBlockTree?blockTree,
IPeerManager?peerManager,
ILogManager?logManager)
{
_name = name;
_node = node;
_port = port;
_network = network;
_protocol = protocol;
_api = api;
_client = client;
_contact = contact;
_canUpdateHistory = canUpdateHistory;
_secret = secret;
_ethStatsClient = ethStatsClient ?? throw new ArgumentNullException(nameof(ethStatsClient));
_sender = sender ?? throw new ArgumentNullException(nameof(sender));
_txPool = txPool ?? throw new ArgumentNullException(nameof(txPool));
_blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_peerManager = peerManager ?? throw new ArgumentNullException(nameof(peerManager));
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
}
public ServerSocket(IPeerManager peerMgr)
{
sock = new Socket(AddressFamily.InterNetworkV6,
SocketType.Stream,
ProtocolType.Tcp);
listener = new TcpListener(IPAddress.Parse("127.0.0.1"), 1984);
peerManager = peerMgr;
}
private async Task InitPeer()
{
/* rlpx */
var eciesCipher = new EciesCipher(_cryptoRandom);
var eip8Pad = new Eip8MessagePad(_cryptoRandom);
_messageSerializationService.Register(new AuthEip8MessageSerializer(eip8Pad));
_messageSerializationService.Register(new AckEip8MessageSerializer(eip8Pad));
var encryptionHandshakeServiceA = new EncryptionHandshakeService(_messageSerializationService, eciesCipher,
_cryptoRandom, new Signer(), _nodeKey, _logManager);
/* p2p */
_messageSerializationService.Register(new HelloMessageSerializer());
_messageSerializationService.Register(new DisconnectMessageSerializer());
_messageSerializationService.Register(new PingMessageSerializer());
_messageSerializationService.Register(new PongMessageSerializer());
/* eth62 */
_messageSerializationService.Register(new StatusMessageSerializer());
_messageSerializationService.Register(new TransactionsMessageSerializer());
_messageSerializationService.Register(new GetBlockHeadersMessageSerializer());
_messageSerializationService.Register(new NewBlockHashesMessageSerializer());
_messageSerializationService.Register(new GetBlockBodiesMessageSerializer());
_messageSerializationService.Register(new BlockHeadersMessageSerializer());
_messageSerializationService.Register(new BlockBodiesMessageSerializer());
_messageSerializationService.Register(new NewBlockMessageSerializer());
/* eth63 */
_messageSerializationService.Register(new GetNodeDataMessageSerializer());
_messageSerializationService.Register(new NodeDataMessageSerializer());
_messageSerializationService.Register(new GetReceiptsMessageSerializer());
_messageSerializationService.Register(new ReceiptsMessageSerializer());
var networkConfig = _configProvider.GetConfig <INetworkConfig>();
ISessionMonitor sessionMonitor = new SessionMonitor(networkConfig, _logManager);
_rlpxPeer = new RlpxPeer(
_nodeKey.PublicKey,
_initConfig.P2PPort,
encryptionHandshakeServiceA,
_logManager,
_perfService,
sessionMonitor);
await _rlpxPeer.Init();
var peerStorage = new NetworkStorage(PeersDbPath, networkConfig, _logManager, _perfService);
ProtocolValidator protocolValidator = new ProtocolValidator(_nodeStatsManager, _blockTree, _logManager);
_protocolsManager = new ProtocolsManager(_syncManager, _transactionPool, _discoveryApp, _messageSerializationService, _rlpxPeer, _nodeStatsManager, protocolValidator, peerStorage, _perfService, _logManager);
PeerLoader peerLoader = new PeerLoader(networkConfig, _nodeStatsManager, peerStorage, _logManager);
_peerManager = new PeerManager(_rlpxPeer, _discoveryApp, _nodeStatsManager, peerStorage, peerLoader, networkConfig, _logManager);
_peerManager.Init();
}
/// <summary>
/// Method invoked when peer disconnects
/// </summary>
/// <param name="peer">Peer that has disconnected</param>
public void OnPeerDisconnected(IPeerManager peer)
{
if (peer != MasterPeer)
{
return;
}
MasterPeer = null;
Log.Info($"Peer {peer.PeerEndPoint} disconnected.");
}
/// <summary>
/// Method invoked when master manager connects to a new client
/// </summary>
/// <param name="peer">Peer manager of the connected client</param>
private void MasterManagerOnClientConnected(IPeerManager peer)
{
if (clientLoads.ContainsKey(peer))
{
Log.Error($"Client {peer.PeerEndPoint.Address} is already registered in the load balanced.");
return;
}
clientLoads.Add(peer, 0.0f);
}
public void ReceiveMessage(IPeerManager sender, DistributedMessage distributedMessage)
{
if (sensorsInstances.Any() || Loader.Instance.Network.IsMaster)
{
return;
}
var sensors = distributedMessage.Content.PopString();
InstantiateSensors(sensors);
}
/// <summary>
/// Release the load from given peer
/// </summary>
/// <param name="peer">Peer which should lower its load</param>
/// <param name="load">Load value</param>
public void ReleaseLoad(IPeerManager peer, float load)
{
if (peer == null)
{
masterLoad -= load;
return;
}
clientLoads[peer] = clientLoads[peer] - load;
}
public AdminModule(IBlockTree blockTree, INetworkConfig networkConfig, IPeerManager peerManager, IStaticNodesManager staticNodesManager, IEnode enode, string dataDir)
{
_blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree));
_networkConfig = networkConfig ?? throw new ArgumentNullException(nameof(networkConfig));
_peerManager = peerManager ?? throw new ArgumentNullException(nameof(peerManager));
_staticNodesManager = staticNodesManager ?? throw new ArgumentNullException(nameof(staticNodesManager));
_enode = enode ?? throw new ArgumentNullException(nameof(enode));
_dataDir = dataDir ?? throw new ArgumentNullException(nameof(dataDir));
BuildNodeInfo();
}
public BusBootstrapper(IAssemblyScanner assemblyScanner, ZmqTransportConfiguration zmqTransportConfiguration, IBusBootstrapperConfiguration bootstrapperConfiguration,
IMessageSender messageSender, IPeerManager peerManager, ISubscriptionManager subscriptionManager, IPeerConfiguration peerConfiguration)
{
_assemblyScanner = assemblyScanner;
_zmqTransportConfiguration = zmqTransportConfiguration;
_bootstrapperConfiguration = bootstrapperConfiguration;
_messageSender = messageSender;
_peerManager = peerManager;
_subscriptionManager = subscriptionManager;
_peerConfiguration = peerConfiguration;
}
public void ReceiveMessage(IPeerManager sender, DistributedMessage distributedMessage)
{
if (sensorsInstances.Any() || Loader.Instance.Network.IsMaster)
{
return;
}
var sensors = distributedMessage.Content.PopString();
var parsed = JsonConvert.DeserializeObject <SensorData[]>(sensors);
InstantiateSensors(parsed);
}
// And this for Autofac or real IoC
public ConversationManager(
ISignallingService signaller,
IPeerManager peerManager,
IMediaManager mediaManager,
IDispatcherProvider dispatcherProvider)
{
this.signaller = signaller;
this.peerManager = peerManager;
this.peerManager.OnIceCandidate += this.OnLocalIceCandidateDeterminedAsync;
this.mediaManager = mediaManager;
this.dispatcherProvider = dispatcherProvider;
}
/// <summary>
/// Method invoked when peer disconnects
/// </summary>
/// <param name="peer">Peer that has disconnected</param>
public void OnPeerDisconnected(IPeerManager peer)
{
if (peer != MasterPeer)
{
Log.Info($"Could not connect to the {peer.PeerEndPoint} endpoint.");
connectionRequests--;
return;
}
MasterPeer = null;
Log.Info($"Peer {peer.PeerEndPoint} disconnected.");
}
public ReliabilityCoordinator(IPeerManager peerManager, IPeerConfiguration peerConfiguration, IAssemblyScanner assemblyScanner)
{
_peerManager = peerManager;
_peerConfiguration = peerConfiguration;
_assemblyScanner = assemblyScanner;
_peerManager.PeerConnected += OnPeerChange;
var messageOptionses = _assemblyScanner.GetMessageOptions();
foreach (var messageOptionse in messageOptionses)
{
_messageOptions.Add(messageOptionse.MessageType.FullName, messageOptionse);
}
}
/// <summary>
/// Method invoked when new peer connects
/// </summary>
/// <param name="peer">Peer that has connected</param>
public void OnPeerConnected(IPeerManager peer)
{
Debug.Assert(State == SimulationState.Connecting);
Connection.DroppedAllConnections -= TryConnectToMasterEndPoints;
MasterPeer = peer;
Log.Info($"Peer {peer.PeerEndPoint} connected.");
State = SimulationState.Connected;
if (Loader.Instance.Network.IsSimulationReady)
{
SendReadyCommand();
}
}
public void ReceiveMessage(IPeerManager sender, DistributedMessage distributedMessage)
{
var sensorPath = distributedMessage.Content.PopString();
var sensorUid = distributedMessage.Content.PopString();
var sensorInPath = sensors.FirstOrDefault(metaData => metaData.HierarchyPath == sensorPath);
if (sensorInPath != null)
{
AppendUid(sensorInPath.Instance, sensorUid);
}
else
{
awaitingPathToUID.Add(sensorPath, sensorUid);
}
}
protected bool DisposedValue; // To detect redundant calls
public UDPNetworking(IPeerIdentification peerName, IPeerManager peerManager, ISerializer serializer, IPEndPoint ipEndPoint)
{
PeerName = peerName;
PeerManager = peerManager;
Serializer = serializer;
UDPClient = new UDPClient(ipEndPoint);
UDPClient.OnMessageReceived +=
(sender, udpResult) => RecieveMessageAsync(udpResult.Buffer, udpResult.RemoteEndPoint);
UDPClient.OnMessageReceivedFailure +=
(sender, exception) => OnMessageReceivedFailure?.Invoke(sender, exception);
UDPClient.OnMessageSendFailure +=
(sender, exception) => OnMessageSendFailure?.Invoke(sender, exception);
UDPClient.WaitForStartup();
}
/// <summary>
/// Method invoked when new peer connects
/// </summary>
/// <param name="peer">Peer that has connected</param>
public void OnPeerConnected(IPeerManager peer)
{
connectionRequests--;
Debug.Assert(State == SimulationState.Connecting);
StopCoroutine(masterEndpointsCouroutine);
MasterPeer = peer;
Log.Info($"Peer {peer.PeerEndPoint} connected.");
State = SimulationState.Connected;
if (Loader.Instance.Network.IsSimulationReady)
{
SendReadyCommand();
}
}
/// <inheritdoc/>
public void OnPeerConnected(NetPeer peer)
{
if (MasterPeer != null)
{
peers.Remove(peer.EndPoint);
return;
}
if (!peers.TryGetValue(peer.EndPoint, out masterPeer))
{
masterPeer = new LiteNetLibPeerManager(peer);
peers.Add(peer.EndPoint, MasterPeer);
}
Log.Info($"{GetType().Name} has connected to the master peer '{MasterPeer.PeerEndPoint}'.");
PeerConnected?.Invoke(MasterPeer);
}
public void Setup()
{
_blockTree = Build.A.BlockTree().OfChainLength(5).TestObject;
_networkConfig = new NetworkConfig();
IPeerManager peerManager = Substitute.For <IPeerManager>();
peerManager.ActivePeers.Returns(new List <Peer> {
new Peer(new Node("127.0.0.1", 30303, true))
});
IStaticNodesManager staticNodesManager = Substitute.For <IStaticNodesManager>();
Enode enode = new Enode(_enodeString);
_adminRpcModule = new AdminRpcModule(_blockTree, _networkConfig, peerManager, staticNodesManager, enode, _exampleDataDir);
_serializer = new EthereumJsonSerializer();
}
void IMessageReceiver.ReceiveMessage(IPeerManager sender, DistributedMessage distributedMessage)
{
var network = Loader.Instance.Network;
if (network.IsMaster)
{
var agentsString = distributedMessage.Content.PopString();
var agentsData = JArray.Parse(agentsString);
foreach (var agentDataToken in agentsData.Children())
{
var agentData = agentDataToken as JObject;
if (agentData == null)
{
continue;
}
var agentId = agentData["id"].Value <uint>();
var sensorsJson = agentData["Sensors"] as JObject;
if (sensorsJson == null)
{
continue;
}
if (ClientsSensorsData.TryGetValue(agentId, out var sensors))
{
foreach (var clientSensorData in sensorsJson.Properties())
{
sensors.Add(clientSensorData.Name, clientSensorData.Value);
}
}
else
{
ClientsSensorsData.Add(agentId, sensorsJson);
}
}
//Send approve response to the client
var message = MessagesPool.Instance.GetMessage();
message.AddressKey = Key;
message.Type = DistributedMessageType.ReliableOrdered;
UnicastMessage(sender.PeerEndPoint, message);
ReceivedResponses++;
}
else
{
//Register received response from the master
ReceivedResponses++;
}
}
