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)
