public CatalystNodePoa(IKeySigner keySigner,
IPeerService peer,
IConsensus consensus,
IDfsService dfsService,
ILedger ledger,
ILogger logger,
IPeerClient peerClient,
IPeerSettings peerSettings,
IMempool <PublicEntryDao> memPool,
ISynchroniser synchronizer,
IPeerRepository peerRepository,
IContract contract = null)
{
Guard.Argument(peerRepository, nameof(peerRepository)).NotNull();
_peer = peer;
_peerClient = peerClient;
_peerSettings = peerSettings;
Consensus = consensus;
_dfsService = dfsService;
_ledger = ledger;
_keySigner = keySigner;
_logger = logger;
_memPool = memPool;
_contract = contract;
_synchronizer = synchronizer;
_peerRepository = peerRepository;
var privateKey = keySigner.KeyStore.KeyStoreDecrypt(KeyRegistryTypes.DefaultKey);
_publicKey = keySigner.CryptoContext.GetPublicKeyFromPrivateKey(privateKey);
}
private async Task Setup()
{
_peerChallenger = ContainerProvider.Container.Resolve <IPeerChallenger>();
var eventLoopGroupFactoryConfiguration = new EventLoopGroupFactoryConfiguration
{
TcpClientHandlerWorkerThreads = 2,
TcpServerHandlerWorkerThreads = 3,
UdpServerHandlerWorkerThreads = 4,
UdpClientHandlerWorkerThreads = 5
};
var keySigner = Substitute.For <IKeySigner>();
keySigner.Verify(Arg.Any <ISignature>(), Arg.Any <byte[]>(), default).ReturnsForAnyArgs(true);
var signature = Substitute.For <ISignature>();
keySigner.Sign(Arg.Any <byte[]>(), default).ReturnsForAnyArgs(signature);
_peerService = new PeerService(new UdpServerEventLoopGroupFactory(eventLoopGroupFactoryConfiguration),
new PeerServerChannelFactory(ContainerProvider.Container.Resolve <IPeerMessageCorrelationManager>(),
ContainerProvider.Container.Resolve <IBroadcastManager>(),
keySigner,
ContainerProvider.Container.Resolve <IPeerIdValidator>(),
ContainerProvider.Container.Resolve <IPeerSettings>()),
new DiscoveryHelper.DevDiscover(),
ContainerProvider.Container.Resolve <IEnumerable <IP2PMessageObserver> >(),
_peerSettings,
ContainerProvider.Container.Resolve <ILogger>(),
ContainerProvider.Container.Resolve <IHealthChecker>());
await _peerService.StartAsync();
}
public CatalystNodePoa(IKeySigner keySigner,
IPeerService peer,
IConsensus consensus,
IDfs dfs,
ILedger ledger,
ILogger logger,
IPeerClient peerClient,
IPeerSettings peerSettings,
IMempool <PublicEntryDao> memPool,
IContract contract = null)
{
_peer = peer;
_peerClient = peerClient;
_peerSettings = peerSettings;
Consensus = consensus;
_dfs = dfs;
_ledger = ledger;
_keySigner = keySigner;
_logger = logger;
_memPool = memPool;
_contract = contract;
var privateKey = keySigner.KeyStore.KeyStoreDecrypt(KeyRegistryTypes.DefaultKey);
_publicKey = keySigner.CryptoContext.GetPublicKeyFromPrivateKey(privateKey);
}
public AdminController(
IWebHostEnvironment environment,
ILogger <AdminController> logger,
SignInManager <UserProfileModel> signInManager,
UserManager <UserProfileModel> userManager,
IPostService posts,
IUserProfileService localProfiles,
IPublicProfileService publicProfiles,
IDebugService debugService,
RoleManager <UserGroupModel> roleManager,
IReactionService reactions,
ITagService tags,
INotificationService notifications,
IPeerService peers,
IAuthService auth,
ISettingsService settings,
IInvitationService invitationService,
IActivityStreamRepository activityStreams
) :
base(environment, signInManager, userManager, posts, localProfiles, publicProfiles, reactions, tags, notifications, peers, auth, settings, activityStreams)
{
_logger = logger;
_debugService = debugService;
_roleManager = roleManager;
_invitationService = invitationService;
}
private async Task Setup()
{
_peerChallengeRequest = ContainerProvider.Container.Resolve <IPeerChallengeRequest>();
var eventLoopGroupFactoryConfiguration = new EventLoopGroupFactoryConfiguration
{
TcpClientHandlerWorkerThreads = 2,
TcpServerHandlerWorkerThreads = 3,
UdpServerHandlerWorkerThreads = 4,
UdpClientHandlerWorkerThreads = 5
};
var keySigner = ContainerProvider.Container.Resolve <IKeySigner>(); // @@
_peerService = new PeerService(
new UdpServerEventLoopGroupFactory(eventLoopGroupFactoryConfiguration),
new PeerServerChannelFactory(ContainerProvider.Container.Resolve <IPeerMessageCorrelationManager>(),
ContainerProvider.Container.Resolve <IBroadcastManager>(),
keySigner,
ContainerProvider.Container.Resolve <IPeerIdValidator>(),
ContainerProvider.Container.Resolve <IPeerSettings>()),
new DiscoveryHelper.DevDiscover(),
ContainerProvider.Container.Resolve <IEnumerable <IP2PMessageObserver> >(),
_peerSettings,
ContainerProvider.Container.Resolve <ILogger>(),
ContainerProvider.Container.Resolve <IHealthChecker>());
await _peerService.StartAsync();
}
public ChannelMessageLoggingService(IServiceScopeFactory scopeFactory, IPeerService peerService,
IChannelService channelService, IConfiguration configuration)
{
_localPersistenceContext = scopeFactory.CreateScopedService <LocalPersistenceContext>();
_peerService = peerService;
_channelService = channelService;
_persist = configuration.GetConfiguration <ChannelConfiguration>().PersistChannelLogs;
}
public SystemController(IAuthService auth, SimpleDbContext db, IPeerService peers, IApiDescriptionGroupCollectionProvider apiExplorer, IActivityStreamRepository activityStreams)
{
_auth = auth;
_db = db;
_peers = peers;
_apiExplorer = apiExplorer;
_activityStreams = activityStreams;
}
//todo add unit tests
public PeerSyncManagerUnitTests()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_peerService = Substitute.For <IPeerService>();
_peerClient = Substitute.For <IPeerClient>();
_peerRepository = new PeerRepository(new InMemoryRepository <Peer, string>());
_deltaHeightReplaySubject = new ReplaySubject <IObserverDto <ProtocolMessage> >(1);
_peerService.MessageStream.Returns(_deltaHeightReplaySubject.AsObservable());
}
public void Init()
{
Setup(TestContext.CurrentContext);
var logger = Substitute.For <ILogger>();
var keyRegistry = TestKeyRegistry.MockKeyRegistry();
ContainerProvider.ContainerBuilder.RegisterInstance(keyRegistry).As <IKeyRegistry>();
ContainerProvider.ContainerBuilder.RegisterModule(new KeystoreModule());
ContainerProvider.ContainerBuilder.RegisterModule(new KeySignerModule());
ContainerProvider.ContainerBuilder.RegisterModule(new HashingModule());
ContainerProvider.ContainerBuilder.RegisterModule(new BulletProofsModule());
_peerSettings = new PeerSettings(ContainerProvider.ConfigurationRoot);
var peerSettings =
PeerIdHelper.GetPeerId("sender", _peerSettings.BindAddress, _peerSettings.Port)
.ToSubstitutedPeerSettings();
ContainerProvider.ContainerBuilder.Register(c =>
{
var peerClient = c.Resolve <IPeerClient>();
peerClient.StartAsync().ConfigureAwait(false).GetAwaiter().GetResult();
return(new PeerChallengeRequest(logger, peerClient, peerSettings, 10));
}).As <IPeerChallengeRequest>().SingleInstance();
_peerChallengeRequest = ContainerProvider.Container.Resolve <IPeerChallengeRequest>();
var eventLoopGroupFactoryConfiguration = new EventLoopGroupFactoryConfiguration
{
TcpClientHandlerWorkerThreads = 2,
TcpServerHandlerWorkerThreads = 3,
UdpServerHandlerWorkerThreads = 4,
UdpClientHandlerWorkerThreads = 5
};
var keySigner = ContainerProvider.Container.Resolve <IKeySigner>(); // @@
_peerService = new PeerService(
new UdpServerEventLoopGroupFactory(eventLoopGroupFactoryConfiguration),
new PeerServerChannelFactory(ContainerProvider.Container.Resolve <IPeerMessageCorrelationManager>(),
ContainerProvider.Container.Resolve <IBroadcastManager>(),
keySigner,
ContainerProvider.Container.Resolve <IPeerIdValidator>(),
ContainerProvider.Container.Resolve <IPeerSettings>()),
new DiscoveryHelper.DevDiscover(),
ContainerProvider.Container.Resolve <IEnumerable <IP2PMessageObserver> >(),
_peerSettings,
ContainerProvider.Container.Resolve <ILogger>(),
ContainerProvider.Container.Resolve <IHealthChecker>());
_peerService.StartAsync().Wait();
}
private IPeerService CreatePeerService(IPEndPoint peer)
{
EndpointAddress ep = new EndpointAddress(string.Format(Config.P2PUri, peer.Address, peer.Port));
NetTcpBinding binding = new NetTcpBinding();
binding.Security.Mode = SecurityMode.None;
var factory = new ChannelFactory <IPeerService>(binding);
IPeerService peerService = factory.CreateChannel(ep);
return(peerService);
}
public ChannelCloseService(ILoggerFactory loggerFactory, IChannelService channelService, IPeerService peerService,
IWalletService walletService, IConfiguration configuration, IBlockchainClientService blockchainClientService,
IChannelLoggingService channelLoggingService)
{
_channelService = channelService;
_peerService = peerService;
_walletService = walletService;
_blockchainClientService = blockchainClientService;
_channelLoggingService = channelLoggingService;
_configuration = configuration.GetConfiguration <ChannelConfiguration>();
_logger = loggerFactory.CreateLogger(GetType());
}
public ChannelStateService(ILoggerFactory loggerFactory, IChannelService channelService,
IPeerService peerService, IChannelLoggingService channelLoggingService,
IChannelEstablishmentService channelEstablishmentService,
IChannelReestablishmentService channelReestablishmentService,
IChannelCloseService channelCloseService)
{
_logger = loggerFactory.CreateLogger(GetType());
_channelService = channelService;
_peerService = peerService;
_channelLoggingService = channelLoggingService;
_channelEstablishmentService = channelEstablishmentService;
_channelReestablishmentService = channelReestablishmentService;
_channelCloseService = channelCloseService;
}
public DeltaHeightWatcher(IPeerClient peerClient,
IPeerRepository peerRepository,
IPeerService peerService,
double threshold = 0.5d,
int minimumPeers = 2)
{
_peerClient = peerClient;
DeltaHeightRanker = new DeltaHeightRanker(peerRepository, 100, threshold);
_peerRepository = peerRepository;
_peerService = peerService;
_manualResetEventSlim = new ManualResetEventSlim(false);
_threshold = threshold;
_minimumPeers = minimumPeers;
}
private async Task InitialisePeerServiceAndSendMessage(IP2PMessageObserver pingRequestHandler, ProtocolMessage message)
{
_p2PMessageHandlers.Add(pingRequestHandler);
_peerService = new PeerService(new UdpServerEventLoopGroupFactory(new EventLoopGroupFactoryConfiguration()),
_udpServerServerChannelFactory,
_peerDiscovery,
_p2PMessageHandlers,
_peerSettings,
_logger,
Substitute.For <IHealthChecker>());
await _peerService.StartAsync();
_serverChannel.SimulateReceivingMessagesAsync(message);
}
public PersonController(
IWebHostEnvironment environment,
ILogger <PersonController> logger,
SignInManager <UserProfileModel> signInManager,
UserManager <UserProfileModel> userManager,
IPostService posts,
IUserProfileService localProfiles,
IPublicProfileService publicProfiles,
IReactionService reactions,
ITagService tags,
INotificationService notifications,
IPeerService peers,
IAuthService auth,
ISettingsService settings,
IActivityStreamRepository activityStreams) :
base(environment, signInManager, userManager, posts, localProfiles, publicProfiles, reactions, tags, notifications, peers, auth, settings, activityStreams)
{
_logger = logger;
}
public PeerSyncManager(IPeerClient peerClient,
IPeerRepository peerRepository,
IPeerService peerService,
IUserOutput userOutput,
IDeltaHeightWatcher deltaHeightWatcher,
IDfsService dfsService,
double threshold = 0.5d,
int minimumPeers = 2,
IScheduler scheduler = null)
{
_peerClient = peerClient;
_peerRepository = peerRepository;
_peerService = peerService;
_userOutput = userOutput;
_deltaHeightWatcher = deltaHeightWatcher;
_dfsService = dfsService;
_scoredDeltaIndexRangeSubject =
new ReplaySubject <IEnumerable <DeltaIndex> >(1, scheduler ?? Scheduler.Default);
ScoredDeltaIndexRange = _scoredDeltaIndexRangeSubject.AsObservable();
_threshold = threshold;
_minimumPeers = minimumPeers;
}
public AccountController(
ILogger <AccountController> logger,
IWebHostEnvironment environment,
UserManager <UserProfileModel> userManager,
SignInManager <UserProfileModel> signInManager,
IPostService posts, IUserProfileService localProfiles, IPublicProfileService publicProfiles,
IReactionService reactions, ITagService tags,
INotificationService notifications,
IPeerService peers,
IAuthService auth,
ISettingsService settings,
IFido2 fido2,
IInvitationService invitationService,
IActivityStreamRepository activityStreams,
IRateLimitService rateLimitService
) :
base(environment, signInManager, userManager, posts, localProfiles, publicProfiles, reactions, tags, notifications, peers, auth, settings, activityStreams)
{
_logger = logger;
_fido2 = fido2;
_invitationService = invitationService;
_rateLimitService = rateLimitService;
}
public ActivityStreamController(
IWebHostEnvironment environment,
SignInManager <UserProfileModel> signInManager,
UserManager <UserProfileModel> userManager,
IPostService posts,
IUserProfileService localProfiles,
IPublicProfileService publicProfiles,
IReactionService reactions,
ITagService tags,
INotificationService notifications,
IPeerService peers,
IAuthService auth,
ISettingsService settings,
IActivityStreamRepository activityStreams
) : base(signInManager, userManager, localProfiles, publicProfiles, auth, settings)
{
_environment = environment;
_posts = posts;
_reactions = reactions;
_tags = tags;
_notifications = notifications;
_peers = peers;
_activityStreams = activityStreams;
}
public PeersController(IPeerService peerService)
{
this._peerService = peerService;
}
public void Init()
{
_cancellationToken = new CancellationToken();
_manualResetEventSlim = new ManualResetEventSlim(false);
_testScheduler = new TestScheduler();
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_peerSettings = Substitute.For <IPeerSettings>();
_peerSettings.PeerId.Returns(PeerIdHelper.GetPeerId());
_deltaDfsReader = Substitute.For <IDeltaDfsReader>();
_deltaDfsReader.TryReadDeltaFromDfs(Arg.Any <Cid>(), out Arg.Any <Delta>()).Returns(x => true);
_deltaCache = Substitute.For <IDeltaCache>();
_deltaCache.GenesisHash.Returns("bafk2bzacecji5gcdd6lxsoazgnbg46c3vttjwwkptiw27enachziizhhkir2w".ToCid());
_ledger = Substitute.For <ILedger>();
_peerService = Substitute.For <IPeerService>();
_deltaHashProvider = new DeltaHashProvider(_deltaCache, Substitute.For <IDeltaIndexService>(), Substitute.For <ILogger>());
_deltaIndexService = new DeltaIndexService(new InMemoryRepository <DeltaIndexDao, string>());
_deltaIndexService.Add(new DeltaIndexDao {
Cid = _hashProvider.ComputeUtf8MultiHash("0").ToCid(), Height = 0
});
_peerClient = Substitute.For <IPeerClient>();
ModifyPeerClient <LatestDeltaHashRequest>((request, senderPeerIdentifier) =>
{
var deltaHeightResponse = new LatestDeltaHashResponse
{
DeltaIndex = new DeltaIndex
{
Cid = _hashProvider.ComputeUtf8MultiHash(_syncTestHeight.ToString()).ToCid().ToArray()
.ToByteString(),
Height = (uint)_syncTestHeight
}
};
_deltaHeightReplaySubject.OnNext(new ObserverDto(Substitute.For <IChannelHandlerContext>(),
deltaHeightResponse.ToProtocolMessage(senderPeerIdentifier, CorrelationId.GenerateCorrelationId())));
});
ModifyPeerClient <DeltaHistoryRequest>((request, senderPeerIdentifier) =>
{
var data = GenerateSampleData((int)request.Height, (int)request.Range, (int)_syncTestHeight);
_deltaIndexService.Add(data.DeltaIndex.Select(x => DeltaIndexDao.ToDao <DeltaIndex>(x, _mapperProvider)));
_deltaHistoryReplaySubject.OnNext(new ObserverDto(Substitute.For <IChannelHandlerContext>(),
data
.ToProtocolMessage(senderPeerIdentifier, CorrelationId.GenerateCorrelationId())));
});
_peerRepository = new PeerRepository(new InMemoryRepository <Peer, string>());
Enumerable.Repeat(new Peer {
PeerId = PeerIdHelper.GetPeerId()
}, 5).ToList().ForEach(_peerRepository.Add);
_deltaHeightReplaySubject = new ReplaySubject <IObserverDto <ProtocolMessage> >(1);
_deltaHistoryReplaySubject = new ReplaySubject <IObserverDto <ProtocolMessage> >(1);
var mergeMessageStreams = _deltaHeightReplaySubject.AsObservable()
.Merge(_deltaHistoryReplaySubject.AsObservable());
_peerService.MessageStream.Returns(mergeMessageStreams);
_deltaHashProvider = Substitute.For <IDeltaHashProvider>();
_deltaHashProvider.TryUpdateLatestHash(Arg.Any <Cid>(), Arg.Any <Cid>()).Returns(true);
_mapperProvider = new TestMapperProvider();
_userOutput = Substitute.For <IUserOutput>();
_deltaHeightWatcher = new DeltaHeightWatcher(_peerClient, _peerRepository, _peerService, minimumPeers: 0);
var dfsService = Substitute.For <IDfsService>();
_peerSyncManager = new PeerSyncManager(_peerClient, _peerRepository,
_peerService, _userOutput, _deltaHeightWatcher, Substitute.For <IDfsService>(), 0.7, 0);
}
public PeersController(PeersEngine peersEngine, IPeerService peers)
{
this.peersEngine = peersEngine;
this.peers = peers;
}
public ClientPeer(IPeerService peerService)
{
this.peerService = peerService;
tcpClient = new TcpClient();
}
public PeerAutoConnectService(IPeerService peerService, IConfiguration configuration, ILoggerFactory loggerFactory)
{
_peerService = peerService;
_logger = loggerFactory.CreateLogger <PeerService>();
_configuration = configuration.GetConfiguration <PeerConfiguration>();
}
