async def on_timeout(): await sleep(30) for definition in get_default_configuration()['overlays']: if definition['class'] not in RESULTS: RESULTS[definition['class']] = -1.0 print(definition['class'], "found no peers at all!", file=sys.stderr) get_event_loop().stop()
async def start_communities(): for i in [1, 2]: configuration = get_default_configuration() configuration['keys'] = [{ 'alias': "my peer", 'generation': u"medium", 'file': u"ec%d.pem" % i }] configuration['port'] = 12000 + randint(0, 10000) configuration['overlays'] = [{ 'class': 'MyCommunity', 'key': "my peer", 'walkers': [{ 'strategy': "RandomWalk", 'peers': 10, 'init': { 'timeout': 3.0 } }], 'bootstrappers': [DISPERSY_BOOTSTRAPPER], 'initialize': {}, 'on_start': [('started', )] }] ipv8 = IPv8(configuration) await ipv8.start() INSTANCES.append(ipv8)
async def start_ipv8(self, statistics, no_rest_api): """ Main method to startup IPv8. """ self.ipv8 = IPv8(get_default_configuration(), enable_statistics=statistics) await self.ipv8.start() async def signal_handler(sig): print("Received shut down signal %s" % sig) if not self._stopping: self._stopping = True if self.restapi: await self.restapi.stop() await self.ipv8.stop() await gather(*all_tasks()) get_event_loop().stop() signal.signal(signal.SIGINT, lambda sig, _: ensure_future(signal_handler(sig))) signal.signal(signal.SIGTERM, lambda sig, _: ensure_future(signal_handler(sig))) print("Starting IPv8") if not no_rest_api: self.restapi = RESTManager(self.ipv8) await self.restapi.start()
def setup_test(window=1, packet_size=1000, packets=10000): """ Create two nodes who will be sending packets to each other. :param window: the window size for packets (1 is synchronous) :param packet_size: the size of each packet :param packets: the number of packets to send in the experiment :return: the deferred that fires once the experiment is complete """ configuration = get_default_configuration() configuration['overlays'] = [] configuration['keys'] = [] master_peer = Peer(ECCrypto().generate_key(u"low")) peer_ipv8 = IPv8(configuration) peer_ipv8.keys = {'my_peer': Peer(ECCrypto().generate_key(u"low"))} peer_ipv8.overlays = [ LoadOverlay(master_peer, peer_ipv8.keys['my_peer'], peer_ipv8.endpoint, peer_ipv8.network, window, packet_size, packets) ] counterparty_ipv8 = IPv8(configuration) counterparty_ipv8.keys = {'my_peer': Peer(ECCrypto().generate_key(u"low"))} counterparty_ipv8.overlays = [ LoadOverlay(master_peer, counterparty_ipv8.keys['my_peer'], counterparty_ipv8.endpoint, counterparty_ipv8.network, 0, packet_size, packets) ] peer_ipv8.overlays[0].send(counterparty_ipv8.endpoint.get_address()) return DeferredList( [peer_ipv8.overlays[0].done, counterparty_ipv8.overlays[0].done])
def custom_intro_response_cb(self, peer, dist, payload): if (peer.address not in self.network.blacklist) and (self.__class__.__name__ not in RESULTS): RESULTS[self.__class__.__name__] = time.time() - START_TIME print(self.__class__.__name__, "found a peer!", file=sys.stderr) if len(get_default_configuration()['overlays']) == len(RESULTS): reactor.callFromThread(reactor.stop)
def on_timeout(): for definition in get_default_configuration()['overlays']: if definition['class'] not in RESULTS: RESULTS[definition['class']] = -1.0 print(definition['class'], "found no peers at all!", file=sys.stderr) reactor.callFromThread(reactor.stop)
def main(argv): parser = argparse.ArgumentParser(add_help=False, description=( 'Simple client for various types attestations')) parser.add_argument('--help', '-h', action='help', default=argparse.SUPPRESS, help='Show this help message and exit') parser.add_argument('--port', '-p', default=8124, type=int, help='Listen port for web service (8124 by default)') parser.add_argument('--ip', '-i', default='127.0.0.1', help='Listen IP for webservice (127.0.0.1 by default)') parser.add_argument('--reset', '-r', action='store_true', default=False, help='Resets the identity') args = parser.parse_args(argv) if os.path.exists("temp") and args.reset: shutil.rmtree("temp") if not os.path.exists("temp"): os.mkdir("temp") with open('temp/state.json', 'w') as outfile: data = { "attributes": [], "providers": {} } json.dump(data, outfile) # Start REST endpoints using Twisted vars = globals() configuration = get_default_configuration() configuration['logger']['level'] = "ERROR" configuration['keys'] = [ {'alias': "anonymous id", 'generation': u"curve25519", 'file': u"temp/ec_multichain.pem"}, {'alias': "my peer", 'generation': u"medium", 'file': u"temp/ec.pem"} ] # Only load the basic communities # requested_overlays = ['DiscoveryCommunity', 'AttestationCommunity', 'IdentityCommunity'] # configuration['overlays'] = [o for o in configuration['overlays'] if o['class'] in requested_overlays] # Give each peer a separate working directory working_directory_overlays = ['AttestationCommunity', 'IdentityCommunity'] for overlay in configuration['overlays']: if overlay['class'] in working_directory_overlays: overlay['initialize'] = {'working_directory': 'temp'} ipv8 = IPv8(configuration) config = { 'mid_b64': b64encode(ipv8.keys["anonymous id"].mid), } rest_manager = IPv8RESTManager(ipv8) rest_manager.start(args.port) rest_manager.root_endpoint.putChild(b'api', APIEndpoint(config)) rest_manager.root_endpoint.putChild( b'gui', File(os.path.join(BASE_DIR, 'webapp', 'dist'))) print('mid_b64: ' + str(config['mid_b64'])) reactor.run()
def __init__(self, path, port, interface='127.0.0.1', configuration=None): """ Create a test peer with a REST API interface. :param path: the for the working directory of this peer :param port: this peer's port :param interface: IP or alias of the peer. Defaults to '127.0.0.1' :param configuration: IPv8 configuration object. Defaults to None """ self._logger = logging.getLogger(self.__class__.__name__) self._logger.info("Peer starting-up.") self._rest_manager = None self._port = port self._interface = interface self._path = path self._configuration = configuration # Check to see if we've received a custom configuration if configuration is None: # Create a default configuration self._configuration = get_default_configuration() self._configuration['logger'] = {'level': "ERROR"} overlays = ['AttestationCommunity', 'IdentityCommunity'] self._configuration['overlays'] = [o for o in self._configuration['overlays'] if o['class'] in overlays] for o in self._configuration['overlays']: o['walkers'] = [{ 'strategy': "RandomWalk", 'peers': 20, 'init': { 'timeout': 60.0 } }] self._create_working_directory(self._path) self._logger.info("Created working directory.") os.chdir(self._path) self._ipv8 = IPv8(self._configuration) os.chdir(os.path.dirname(__file__)) # Change the master_peers of the IPv8 object's overlays, in order to avoid conflict with the live networks for idx, overlay in enumerate(self._ipv8.overlays): self._ipv8.overlays[idx].master_peer = Peer(COMMUNITY_TO_MASTER_PEER_KEY[type(overlay).__name__]) self._rest_manager = TestPeer.RestAPITestWrapper(self._ipv8, self._port, self._interface) self._rest_manager.start() self._logger.info("Peer started up.")
async def main(): configuration = get_default_configuration() configuration['keys'] = [{ 'alias': "my peer", 'generation': "curve25519", 'file': "ec.pem" }] configuration['port'] = 12000 + randint(0, 10000) configuration['overlays'] = [] ipv8 = IPv8(configuration) await ipv8.start() overlay = MyCommunity(ipv8.keys['my peer'], ipv8.endpoint, ipv8.network) introductions = {} ips = {} for _ in range(count): for dns_addr in DISPERSY_BOOTSTRAPPER['init']['dns_addresses']: if 'tribler.org' not in dns_addr[0] and 'ip-v8.org' not in dns_addr[0]: continue try: ip = ips.get(dns_addr[0], gethostbyname(dns_addr[0])) except OSError: continue try: response = await wait_for(overlay.send_intro_request((ip, dns_addr[1])), timeout=5) except AsyncTimeoutError: continue reachable = False try: if response.wan_introduction_address != ('0.0.0.0', 0): # Wait some time for puncture to be sent await sleep(.1) await wait_for(overlay.send_intro_request(response.wan_introduction_address), timeout=5) reachable = True except AsyncTimeoutError: pass introductions[dns_addr] = introductions.get(dns_addr, []) introductions[dns_addr].append([response.wan_introduction_address, response.lan_introduction_address, reachable]) await sleep(delay) with open('bootstrap_introductions.txt', 'w') as f: f.write('Address Peers Type') for dns_addr, responses in introductions.items(): f.write(f"\n{dns_addr[0]}:{dns_addr[1]} {len([wan for wan, _, _ in responses if wan != ('0.0.0.0', 0)])} 0") f.write(f"\n{dns_addr[0]}:{dns_addr[1]} {len({wan for wan, _, _ in responses if wan != ('0.0.0.0', 0)})} 1") f.write(f"\n{dns_addr[0]}:{dns_addr[1]} {len({lan for _, lan, _ in responses if lan != ('0.0.0.0', 0)})} 3") f.write(f"\n{dns_addr[0]}:{dns_addr[1]} {len({wan for wan, _, reachable in responses if reachable})} 2")
async def start_ipv8(self, statedir, listen_port, statistics, no_rest_api): """ Main method to startup IPv8. """ configuration = get_default_configuration() configuration['port'] = listen_port # Open the database self.tc_persistence = TrustChainDB(statedir, 'trustchain') if statedir: # If we use a custom state directory, update various variables for key in configuration["keys"]: key["file"] = os.path.join(statedir, key["file"]) for community in configuration["overlays"]: if community["class"] == "TrustChainCommunity": community["initialize"]["persistence"] = self.tc_persistence allowed_overlays = ['DHTDiscoveryCommunity', 'DiscoveryCommunity', 'HiddenTunnelCommunity', 'TrustChainCommunity'] configuration['overlays'] = [overlay for overlay in configuration['overlays'] if overlay['class'] in allowed_overlays] for overlay in configuration['overlays']: if overlay['class'] == 'HiddenTunnelCommunity': overlay['initialize']['settings']['min_circuits'] = 0 overlay['initialize']['settings']['max_circuits'] = 0 overlay['initialize']['settings']['max_relays_or_exits'] = 1000 overlay['initialize']['settings']['peer_flags'] = {PEER_FLAG_EXIT_IPV8} self.ipv8 = IPv8(configuration, enable_statistics=statistics) await self.ipv8.start() async def signal_handler(sig): print("Received shut down signal %s" % sig) if not self._stopping: self._stopping = True if self.restapi: await self.restapi.stop() await self.ipv8.stop() await gather(*all_tasks()) get_event_loop().stop() signal.signal(signal.SIGINT, lambda sig, _: ensure_future(signal_handler(sig))) signal.signal(signal.SIGTERM, lambda sig, _: ensure_future(signal_handler(sig))) print("Starting IPv8") if not no_rest_api: self.restapi = RESTManager(self.ipv8) await self.restapi.start()
async def start_ipv8(self, listen_port, statistics, no_rest_api): """ Main method to startup IPv8. """ configuration = get_default_configuration() configuration['port'] = listen_port allowed_overlays = [ 'DHTDiscoveryCommunity', 'DiscoveryCommunity', 'HiddenTunnelCommunity', 'TrustChainCommunity' ] configuration['overlays'] = [ overlay for overlay in configuration['overlays'] if overlay['class'] in allowed_overlays ] for overlay in configuration['overlays']: if overlay['class'] == 'HiddenTunnelCommunity': overlay['initialize']['settings']['min_circuits'] = 0 overlay['initialize']['settings']['max_circuits'] = 0 overlay['initialize']['settings']['max_relays_or_exits'] = 1000 overlay['initialize']['settings'][ 'peer_flags'] = PEER_FLAG_EXIT_IPV8 self.ipv8 = IPv8(configuration, enable_statistics=statistics) await self.ipv8.start() async def signal_handler(sig): print("Received shut down signal %s" % sig) if not self._stopping: self._stopping = True if self.restapi: await self.restapi.stop() await self.ipv8.stop() await gather(*all_tasks()) get_event_loop().stop() signal.signal(signal.SIGINT, lambda sig, _: ensure_future(signal_handler(sig))) signal.signal(signal.SIGTERM, lambda sig, _: ensure_future(signal_handler(sig))) print("Starting IPv8") if not no_rest_api: self.restapi = RESTManager(self.ipv8) await self.restapi.start()
async def start_communities(): configuration = get_default_configuration() configuration['keys'] = [{ 'alias': "my peer", 'generation': u"medium", 'file': u"ec1.pem" }] configuration['port'] = 12000 + randint(0, 10000) configuration['overlays'] = [{ 'class': 'MyCommunity', 'key': "my peer", 'walkers': [], 'initialize': {}, 'on_start': [('started', )] }] ipv8 = IPv8(configuration) await ipv8.start() INSTANCES.append(ipv8)
async def start_community(): for peer_id in [1, 2]: configuration = get_default_configuration() configuration['logger']['level'] = "ERROR" configuration['keys'] = [{'alias': "anonymous id", 'generation': u"curve25519", 'file': f"keyfile_{peer_id}.pem"}] configuration['working_directory'] = f"state_{peer_id}" configuration['overlays'] = [] # Start the IPv8 service ipv8 = IPv8(configuration) await ipv8.start() rest_manager = RESTManager(ipv8) await rest_manager.start(14410 + peer_id) # Print the peer for reference print("Starting peer", b64encode(ipv8.keys["anonymous id"].mid))
def start_ipv8(self, options): """ Main method to startup IPv8. """ configuration = get_default_configuration() configuration['port'] = options["listen_port"] allowed_overlays = [ 'DHTDiscoveryCommunity', 'DiscoveryCommunity', 'HiddenTunnelCommunity', 'TrustChainCommunity' ] configuration['overlays'] = [ overlay for overlay in configuration['overlays'] if overlay['class'] in allowed_overlays ] for overlay in configuration['overlays']: if overlay['class'] == 'HiddenTunnelCommunity': overlay['initialize']['settings']['min_circuits'] = 0 overlay['initialize']['settings']['max_circuits'] = 0 overlay['initialize']['settings']['max_relays_or_exits'] = 1000 overlay['initialize']['settings'][ 'peer_flags'] = PEER_FLAG_EXIT_IPV8 self.ipv8 = IPv8(configuration, enable_statistics=options['statistics']) def signal_handler(sig, _): msg("Received shut down signal %s" % sig) if not self._stopping: self._stopping = True if self.restapi: self.restapi.stop() self.ipv8.stop() signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) msg("Starting IPv8") if not options['no-rest-api']: self.restapi = RESTManager(self.ipv8) reactor.callLater(0.0, self.restapi.start)
def start_openwallet(self, options): """ Main method to startup OpenWallet. """ configuration = get_default_configuration() configuration['logger']['level'] = "ERROR" configuration['keys'] = [{ 'alias': "anonymous id", 'generation': u"curve25519", 'file': u"temp/ec_multichain.pem" }, { 'alias': "my peer", 'generation': u"medium", 'file': u"temp/ec.pem" }] working_directory_overlays = [ 'AttestationCommunity', 'IdentityCommunity' ] for overlay in configuration['overlays']: if overlay['class'] in working_directory_overlays: overlay['initialize'] = {'working_directory': 'temp'} self.ipv8 = IPv8(configuration) self.restapi = IPv8RESTManager(self.ipv8) self.port = options["port"] reactor.callLater(0.0, self.startApi) def signal_handler(sig, _): msg("Received shut down signal %s" % sig) if not self._stopping: self._stopping = True if self.restapi: self.restapi.stop() self.ipv8.stop() signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) msg("Starting OpenWallet and IPv8") msg("Python Version: " + sys.version)
async def start_communities(): # Override the Community master peers so we don't interfere with the live network # Also hook in our custom logic for introduction responses for community_cls in _COMMUNITIES.values(): community_cls.master_peer = Peer(ECCrypto().generate_key(u"medium")) community_cls.introduction_response_callback = custom_intro_response_cb # Create two peers with separate working directories previous_workdir = getcwd() for i in [1, 2]: configuration = get_default_configuration() configuration['port'] = 12000 + randint(0, 10000) configuration['logger']['level'] = "CRITICAL" for overlay in configuration['overlays']: overlay['walkers'] = [walker for walker in overlay['walkers'] if walker['strategy'] in _WALKERS] workdir = path.abspath(path.join(path.dirname(__file__), str(i))) if not path.exists(workdir): mkdir(workdir) chdir(workdir) await IPv8(configuration).start() chdir(previous_workdir)
async def start_ipv8(self, statistics, no_rest_api, api_key, cert_file): """ Main method to startup IPv8. """ self.ipv8 = IPv8(get_default_configuration(), enable_statistics=statistics) await self.ipv8.start() async def signal_handler(sig): print("Received shut down signal %s" % sig) if not self._stopping: self._stopping = True if self.restapi: await self.restapi.stop() await self.ipv8.stop() await gather(*all_tasks()) get_event_loop().stop() signal.signal(signal.SIGINT, lambda sig, _: ensure_future(signal_handler(sig))) signal.signal(signal.SIGTERM, lambda sig, _: ensure_future(signal_handler(sig))) print("Starting IPv8") if not no_rest_api: # Load the certificate/key file. A new one can be generated as follows: # openssl req \ # -newkey rsa:2048 -nodes -keyout private.key \ # -x509 -days 365 -out certfile.pem # cat private.key >> certfile.pem # rm private.key ssl_context = None if cert_file: ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) ssl_context.load_cert_chain(cert_file) self.restapi = RESTManager(self.ipv8) await self.restapi.start(api_key=api_key, ssl_context=ssl_context)
def start_ipv8(self, options): """ Main method to startup IPv8. """ self.ipv8 = IPv8(get_default_configuration()) def signal_handler(sig, _): msg("Received shut down signal %s" % sig) if not self._stopping: self._stopping = True if self.restapi: self.restapi.stop() self.ipv8.stop() signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) msg("Starting IPv8") if not options['no-rest-api']: self.restapi = RESTManager(self.ipv8) reactor.callLater(0.0, self.restapi.start)
lan_socket_address, socket_address, identifier, introduction=None): return super(MyCommunity, self).create_introduction_response( lan_socket_address, socket_address, identifier, introduction, b'1') def create_introduction_request(self, socket_address): return super(MyCommunity, self).create_introduction_request(socket_address, b'2') _COMMUNITIES['MyCommunity'] = MyCommunity for i in [1, 2]: configuration = get_default_configuration() configuration['keys'] = [{ 'alias': "my peer", 'generation': u"medium", 'file': u"ec%d.pem" % i }] configuration['port'] = 12000 + randint(0, 10000) configuration['overlays'] = [{ 'class': 'MyCommunity', 'key': "my peer", 'walkers': [{ 'strategy': "RandomWalk", 'peers': 10, 'init': {
async def start(self): """ Start a Tribler session by initializing the LaunchManyCore class, opening the database and running the upgrader. Returns a deferred that fires when the Tribler session is ready for use. :param config: a TriblerConfig object """ self._logger.info("Session is using state directory: %s", self.config.get_state_dir()) self.get_ports_in_config() self.create_state_directory_structure() self.init_keypair() # Start the REST API before the upgrader since we want to send interesting upgrader events over the socket if self.config.get_http_api_enabled(): self.api_manager = RESTManager(self) self.readable_status = STATE_START_API await self.api_manager.start() if self.upgrader_enabled: self.upgrader = TriblerUpgrader(self) self.readable_status = STATE_UPGRADING_READABLE try: await self.upgrader.run() except Exception as e: self._logger.error("Error in Upgrader callback chain: %s", e) self.tracker_manager = TrackerManager(self) # On Mac, we bundle the root certificate for the SSL validation since Twisted is not using the root # certificates provided by the system trust store. if sys.platform == 'darwin': os.environ['SSL_CERT_FILE'] = str( (get_lib_path() / 'root_certs_mac.pem')) if self.config.get_chant_enabled(): channels_dir = self.config.get_chant_channels_dir() metadata_db_name = 'metadata.db' if not self.config.get_testnet( ) else 'metadata_testnet.db' database_path = self.config.get_state_dir( ) / 'sqlite' / metadata_db_name self.mds = MetadataStore(database_path, channels_dir, self.trustchain_keypair) # IPv8 if self.config.get_ipv8_enabled(): from ipv8.configuration import get_default_configuration ipv8_config = get_default_configuration() ipv8_config['port'] = self.config.get_ipv8_port() ipv8_config['address'] = self.config.get_ipv8_address() ipv8_config['overlays'] = [] ipv8_config['keys'] = [] # We load the keys ourselves ipv8_config['working_directory'] = str(self.config.get_state_dir()) if self.config.get_ipv8_bootstrap_override(): import ipv8.community as community_file community_file._DEFAULT_ADDRESSES = [ self.config.get_ipv8_bootstrap_override() ] community_file._DNS_ADDRESSES = [] self.ipv8 = IPv8( ipv8_config, enable_statistics=self.config.get_ipv8_statistics()) await self.ipv8.start() self.config.set_anon_proxy_settings( 2, ("127.0.0.1", self.config.get_tunnel_community_socks5_listen_ports())) self.ipv8_start_time = timemod.time() self.load_ipv8_overlays() self.enable_ipv8_statistics() if self.api_manager: self.api_manager.set_ipv8_session(self.ipv8) if self.config.get_tunnel_community_enabled(): await self.tunnel_community.wait_for_socks_servers() # Note that currently we should only start libtorrent after the SOCKS5 servers have been started if self.config.get_libtorrent_enabled(): self.readable_status = STATE_START_LIBTORRENT from tribler_core.modules.libtorrent.download_manager import DownloadManager self.dlmgr = DownloadManager(self) self.dlmgr.initialize() self.readable_status = STATE_LOAD_CHECKPOINTS await self.dlmgr.load_checkpoints() self.readable_status = STATE_READABLE_STARTED if self.config.get_torrent_checking_enabled(): self.readable_status = STATE_START_TORRENT_CHECKER self.torrent_checker = TorrentChecker(self) await self.torrent_checker.initialize() if self.config.get_dummy_wallets_enabled(): # For debugging purposes, we create dummy wallets dummy_wallet1 = DummyWallet1() self.wallets[dummy_wallet1.get_identifier()] = dummy_wallet1 dummy_wallet2 = DummyWallet2() self.wallets[dummy_wallet2.get_identifier()] = dummy_wallet2 if self.config.get_watch_folder_enabled(): self.readable_status = STATE_START_WATCH_FOLDER self.watch_folder = WatchFolder(self) self.watch_folder.start() if self.config.get_resource_monitor_enabled(): self.resource_monitor = ResourceMonitor(self) self.resource_monitor.start() if self.config.get_version_checker_enabled(): self.version_check_manager = VersionCheckManager(self) self.version_check_manager.start() if self.config.get_ipv8_enabled( ) and self.config.get_trustchain_enabled(): self.payout_manager = PayoutManager(self.trustchain_community, self.dht_community) # GigaChannel Manager should be started *after* resuming the downloads, # because it depends on the states of torrent downloads if self.config.get_chant_enabled() and self.config.get_chant_manager_enabled()\ and self.config.get_libtorrent_enabled: self.gigachannel_manager = GigaChannelManager(self) self.gigachannel_manager.start() if self.config.get_bootstrap_enabled(): self.register_task('bootstrap_download', self.start_bootstrap_download) self.notifier.notify(NTFY.TRIBLER_STARTED)
async def start_communities(): # Launch two IPv8 services. # We run REST endpoints for these services on: # - http://localhost:14411/ # - http://localhost:14412/ # This script also prints the peer ids for reference with: # - http://localhost:1441*/attestation?type=peers for i in [1, 2]: configuration = get_default_configuration() configuration['logger']['level'] = "ERROR" configuration['keys'] = [{ 'alias': "anonymous id", 'generation': u"curve25519", 'file': u"ec%d_multichain.pem" % i }] # Only load the basic communities configuration['overlays'] = [{ 'class': 'IsolatedDiscoveryCommunity', 'key': "anonymous id", 'walkers': [{ 'strategy': "RandomWalk", 'peers': 20, 'init': { 'timeout': 3.0 } }, { 'strategy': "RandomChurn", 'peers': -1, 'init': { 'sample_size': 8, 'ping_interval': 10.0, 'inactive_time': 27.5, 'drop_time': 57.5 } }, { 'strategy': "PeriodicSimilarity", 'peers': -1, 'init': {} }], 'bootstrappers': [DISPERSY_BOOTSTRAPPER], 'initialize': {}, 'on_start': [] }, { 'class': 'IsolatedAttestationCommunity', 'key': "anonymous id", 'walkers': [{ 'strategy': "RandomWalk", 'peers': 20, 'init': { 'timeout': 3.0 } }], 'bootstrappers': [DISPERSY_BOOTSTRAPPER], 'initialize': { 'working_directory': 'state_%d' % i }, 'on_start': [] }, { 'class': 'IsolatedIdentityCommunity', 'key': "anonymous id", 'walkers': [{ 'strategy': "RandomWalk", 'peers': 20, 'init': { 'timeout': 3.0 } }], 'bootstrappers': [DISPERSY_BOOTSTRAPPER], 'initialize': { 'working_directory': 'state_%d' % i }, 'on_start': [] }] # Start the IPv8 service ipv8 = IPv8(configuration, extra_communities={ 'IsolatedDiscoveryCommunity': IsolatedDiscoveryCommunity, 'IsolatedAttestationCommunity': IsolatedAttestationCommunity, 'IsolatedIdentityCommunity': IsolatedIdentityCommunity }) await ipv8.start() rest_manager = RESTManager(ipv8) await rest_manager.start(14410 + i) # Print the peer for reference print("Starting peer", b64encode(ipv8.keys["anonymous id"].mid))
def start(self, options, service): """ Main method to startup the cli and add a signal handler. """ msg("Service: Starting") self.service = service # State directory state_directory = options['statedir'] util.create_directory_if_not_exists(state_directory) # port network_port = options['port'] # Initial configuration configuration = get_default_configuration() configuration['address'] = "0.0.0.0" configuration['port'] = network_port configuration['keys'] = [{ 'alias': 'my peer', 'generation': u"curve25519", 'file': os.path.join(state_directory, u"ec.pem") }] configuration['logger'] = {'level': "ERROR"} configuration['overlays'] = [{ 'class': 'DiscoveryCommunity', 'key': "my peer", 'walkers': [{ 'strategy': 'RandomWalk', 'peers': -1, 'init': { 'timeout': 3.0 } }, { 'strategy': 'RandomChurn', 'peers': -1, 'init': { 'sample_size': 64, 'ping_interval': 1.0, 'inactive_time': 1.0, 'drop_time': 3.0 } }], 'initialize': {}, 'on_start': [('resolve_dns_bootstrap_addresses', )] }] configuration['overlays'] = [] # IPv8 instance self.ipv8 = IPv8(configuration) # Network port actual_network_port = self.ipv8.endpoint.get_address()[1] # Peer self.my_peer = self.ipv8.keys.get('my peer') # Trustchain community self.trustchain_community = TrustChainTestnetCommunity( self.my_peer, self.ipv8.endpoint, self.ipv8.network, working_directory=state_directory) self.ipv8.overlays.append(self.trustchain_community) self.ipv8.strategies.append((EdgeWalk(self.trustchain_community), 10)) # Event bus self.bus = EventBus() # module community self.module_community = ModuleCommunity( self.my_peer, self.ipv8.endpoint, self.ipv8.network, trustchain=self.trustchain_community, bus=self.bus, working_directory=state_directory, ipv8=self.ipv8, service=self.service) self.ipv8.overlays.append(self.module_community) self.ipv8.strategies.append((RandomWalk(self.module_community), 10)) # CLI self.cli = CLI(self, self.ipv8, self.module_community) def signal_handler(sig, _): msg("Service: Received shut down signal %s" % sig) if not self._stopping: self.stop() signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) self.rest_api = RESTManager(self.ipv8) self.rest_api.start(actual_network_port + 1000) self.rest_api.root_endpoint.putChild('module', ModuleRootEndpoint(self.ipv8)) StandardIO(self.cli)