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])
async def run(self):
await super().run()
config = self.session.config
self._task_manager = TaskManager()
port = config.ipv8.port
address = config.ipv8.address
self.logger.info('Starting ipv8')
self.logger.info(f'Port: {port}. Address: {address}')
ipv8_config_builder = (
ConfigBuilder().set_port(port).set_address(address).clear_overlays(
).clear_keys() # We load the keys ourselves
.set_working_directory(str(config.state_dir)).set_walker_interval(
config.ipv8.walk_interval))
if config.gui_test_mode:
endpoint = DispatcherEndpoint([])
else:
# IPv8 includes IPv6 support by default.
# We only load IPv4 to not kill all Tribler overlays (currently, it would instantly crash all users).
# If you want to test IPv6 in Tribler you can set ``endpoint = None`` here.
endpoint = DispatcherEndpoint(["UDPIPv4"],
UDPIPv4={
'port': port,
'ip': address
})
ipv8 = IPv8(ipv8_config_builder.finalize(),
enable_statistics=config.ipv8.statistics
and not config.gui_test_mode,
endpoint_override=endpoint)
await ipv8.start()
self.ipv8 = ipv8
key_component = await self.require_component(KeyComponent)
self.peer = Peer(key_component.primary_key)
if config.ipv8.statistics and not config.gui_test_mode:
# Enable gathering IPv8 statistics
for overlay in ipv8.overlays:
ipv8.endpoint.enable_community_statistics(
overlay.get_prefix(), True)
if config.ipv8.walk_scaling_enabled and not config.gui_test_mode:
from tribler_core.components.ipv8.ipv8_health_monitor import IPv8Monitor
IPv8Monitor(ipv8, config.ipv8.walk_interval,
config.ipv8.walk_scaling_upper_limit).start(
self._task_manager)
if config.dht.enabled:
self._init_dht_discovery_community()
if not config.gui_test_mode:
if config.discovery_community.enabled:
self._init_peer_discovery_community()
else:
if config.dht.enabled:
self.dht_discovery_community.routing_tables[
UDPv4Address] = RoutingTable('\x00' * 20)
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 start_crawler(self, options):
"""
Main method to startup the TrustChain crawler.
"""
root = logging.getLogger()
root.setLevel(logging.INFO)
stderr_handler = logging.StreamHandler(sys.stderr)
stderr_handler.setLevel(logging.INFO)
stderr_handler.setFormatter(
logging.Formatter("%(asctime)s:%(levelname)s:%(message)s"))
root.addHandler(stderr_handler)
if options["statedir"]:
# If we use a custom state directory, update various variables
for key in crawler_config["keys"]:
key["file"] = os.path.join(options["statedir"], key["file"])
for community in crawler_config["overlays"]:
if community["class"] == "TrustChainCommunity":
community["initialize"]["working_directory"] = options[
"statedir"]
if 'testnet' in options and options['testnet']:
for community in crawler_config["overlays"]:
if community["class"] == "TrustChainCommunity":
community["class"] = "TrustChainTestnetCommunity"
self.ipv8 = IPv8(crawler_config)
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()
if options['yappi']:
yappi.stop()
msg("Yappi has shutdown")
yappi_stats = yappi.get_func_stats()
yappi_stats.sort("tsub")
out_file = 'yappi'
if options["statedir"]:
out_file = os.path.join(options["statedir"], out_file)
yappi_stats.save(out_file, type='callgrind')
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
msg("Starting TrustChain crawler")
if not options['no-rest-api']:
self.restapi = RESTManager(self.ipv8)
reactor.callLater(0.0, self.restapi.start, options["apiport"])
if options['yappi']:
yappi.start(builtins=True)
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_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)
def start_trust(self, options):
"""
Main method to startup the trust.
"""
root = logging.getLogger()
root.setLevel(logging.INFO)
stderr_handler = logging.StreamHandler(sys.stderr)
stderr_handler.setLevel(logging.INFO)
stderr_handler.setFormatter(
logging.Formatter("%(asctime)s:%(levelname)s:%(message)s"))
root.addHandler(stderr_handler)
self.ipv8 = IPv8(configuration)
# Peer
my_peer = self.ipv8.keys.get('my peer')
# trust community
trust_community = TrustCommunity(my_peer, self.ipv8.endpoint,
self.ipv8.network)
self.ipv8.overlays.append(trust_community)
self.ipv8.strategies.append((RandomWalk(trust_community), 10))
def signal_handler(sig, _):
msg("Received shut down signal %s" % sig)
if not self._stopping:
self._stopping = True
self.restapi.stop()
self.ipv8.stop()
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
self.restapi = RESTManager(self.ipv8)
reactor.callLater(0.0, self.restapi.start, 8001)
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))
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_anydex(self, options):
"""
Main method to startup AnyDex.
"""
config = get_anydex_configuration()
if options.statedir:
# If we use a custom state directory, update various variables
for key in config["keys"]:
key["file"] = os.path.join(options.statedir, key["file"])
for community in config["overlays"]:
if community["class"] == "TrustChainCommunity":
community["initialize"]["working_directory"] = options.statedir
if options.testnet:
for community in config["overlays"]:
if community["class"] == "TrustChainCommunity":
community["class"] = "TrustChainTestnetCommunity"
self.ipv8 = IPv8(config, enable_statistics=options.statistics)
await self.ipv8.start()
print("Starting AnyDex")
if not options.no_rest_api:
self.restapi = RESTManager(self.ipv8)
await self.restapi.start(options.apiport)
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()
self.restapi = None
await self.ipv8.stop()
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)))
# Get Trustchain + DHT overlays
for overlay in self.ipv8.overlays:
# Logger level required by bitcoinlib import
overlay.logger.setLevel('INFO')
if isinstance(overlay, (TrustChainCommunity, TrustChainTestnetCommunity)):
self.trustchain = overlay
elif isinstance(overlay, DHTDiscoveryCommunity):
self.dht = overlay
# Initialize dummy wallets
dummy_wallet1 = DummyWallet1()
self.wallets[dummy_wallet1.get_identifier()] = dummy_wallet1
dummy_wallet2 = DummyWallet2()
self.wallets[dummy_wallet2.get_identifier()] = dummy_wallet2
# Bitcoinlib imports required to be later due to logger overlap
from anydex.wallet.bitcoinlib.bitcoinlib_wallets import BitcoinTestnetWallet, BitcoinWallet, LitecoinWallet, \
LitecoinTestnetWallet, DashWallet, DashTestnetWallet
# Initialize bitcoin wallets
btc_wallet = BitcoinWallet(os.path.join(options.statedir, 'sqlite'))
btc_wallet.create_wallet()
self.wallets[btc_wallet.get_identifier()] = btc_wallet
btc_testnet_wallet = BitcoinTestnetWallet(os.path.join(options.statedir, 'sqlite'))
btc_testnet_wallet.create_wallet()
self.wallets[btc_testnet_wallet.get_identifier()] = btc_testnet_wallet
# Initialize litecoin wallets
ltc_wallet = LitecoinWallet(os.path.join(options.statedir, 'sqlite'))
ltc_wallet.create_wallet()
self.wallets[ltc_wallet.get_identifier()] = ltc_wallet
ltc_testnet_wallet = LitecoinTestnetWallet(os.path.join(options.statedir, 'sqlite'))
ltc_testnet_wallet.create_wallet()
self.wallets[ltc_testnet_wallet.get_identifier()] = ltc_testnet_wallet
# Initialize dash wallets
dash_wallet = DashWallet(os.path.join(options.statedir, 'sqlite'))
dash_wallet.create_wallet()
self.wallets[dash_wallet.get_identifier()] = dash_wallet
# DASH TESTNET HAS NO PROVIDERS IN BITCOINLIB
# dash_testnet_wallet = DashTestnetWallet(os.path.join(options.statedir, 'sqlite'))
# dash_testnet_wallet.create_wallet()
# self.wallets[dash_testnet_wallet.get_identifier()] = dash_testnet_wallet
# Initialize ethereum wallets
eth_wallet = EthereumWallet(os.path.join(options.statedir, 'sqlite'))
eth_wallet.create_wallet()
self.wallets[eth_wallet.get_identifier()] = eth_wallet
eth_testnet_wallet = EthereumTestnetWallet(os.path.join(options.statedir, 'sqlite'))
eth_testnet_wallet.create_wallet()
self.wallets[eth_testnet_wallet.get_identifier()] = eth_testnet_wallet
# Initialize iota wallets
iota_wallet = IotaWallet(os.path.join(options.statedir, 'sqlite'))
iota_wallet.create_wallet()
self.wallets[iota_wallet.get_identifier()] = iota_wallet
iota_testnet_wallet = IotaTestnetWallet(os.path.join(options.statedir, 'sqlite'))
iota_testnet_wallet.create_wallet()
self.wallets[iota_testnet_wallet.get_identifier()] = iota_testnet_wallet
# Initialize monero wallets
# xmr_wallet = MoneroWallet(os.path.join(options.statedir, 'sqlite'))
# xmr_wallet.create_wallet()
# self.wallets[xmr_wallet.get_identifier()] = xmr_wallet
# xmr_testnet_wallet = MoneroTestnetWallet(os.path.join(options.statedir, 'sqlite'))
# xmr_testnet_wallet.create_wallet()
# self.wallets[xmr_testnet_wallet.get_identifier()] = xmr_testnet_wallet
# Initialize stellar wallets
xlm_wallet = StellarWallet(os.path.join(options.statedir, 'sqlite'))
xlm_wallet.create_wallet()
self.wallets[xlm_wallet.get_identifier()] = xlm_wallet
xlm_testnet_wallet = StellarTestnetWallet(os.path.join(options.statedir, 'sqlite'))
xlm_testnet_wallet.create_wallet()
self.wallets[xlm_testnet_wallet.get_identifier()] = xlm_testnet_wallet
# Load market community
self.market = MarketTestnetCommunity(self.trustchain.my_peer, self.ipv8.endpoint, self.ipv8.network,
trustchain=self.trustchain,
dht=self.dht,
wallets=self.wallets,
working_directory=options.statedir,
record_transactions=False,
is_matchmaker=not options.no_matchmaker)
self.ipv8.overlays.append(self.market)
self.ipv8.strategies.append((RandomWalk(self.market), 20))
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/state_%d' % i}
# Start the IPv8 service
ipv8 = IPv8(configuration)
rest_manager = RESTManager(ipv8)
rest_manager.start(14410 + i)
# Print the peer for reference
print("Starting peer", i)
print("port", (14410 + i))
print("mid_b64", b64encode(ipv8.keys["anonymous id"].mid))
print("mid_hex", hexlify(ipv8.keys["anonymous id"].mid))
data[names[i - 1]] = {
'port': 14410 + i,
'mid_b64': b64encode(ipv8.keys["anonymous id"].mid),
'mid_hex': hexlify(ipv8.keys["anonymous id"].mid)
}
def start_anydex(self, options):
"""
Main method to startup AnyDex.
"""
config = get_anydex_configuration()
if options["statedir"]:
# If we use a custom state directory, update various variables
for key in config["keys"]:
key["file"] = os.path.join(options["statedir"], key["file"])
for community in config["overlays"]:
if community["class"] == "TrustChainCommunity":
community["initialize"]["working_directory"] = options["statedir"]
if 'testnet' in options and options['testnet']:
for community in config["overlays"]:
if community["class"] == "TrustChainCommunity":
community["class"] = "TrustChainTestnetCommunity"
self.ipv8 = IPv8(config, 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 AnyDex")
if not options['no-rest-api']:
self.restapi = RESTManager(self.ipv8)
reactor.callLater(0.0, self.restapi.start)
factory = WebSocketServerFactory(u"ws://127.0.0.1:9000")
factory.protocol = AnyDexWebsocketProtocol
reactor.listenTCP(9000, factory)
# Get Trustchain + DHT overlays
for overlay in self.ipv8.overlays:
if isinstance(overlay, TrustChainTestnetCommunity):
self.trustchain = overlay
elif isinstance(overlay, DHTDiscoveryCommunity):
self.dht = overlay
# Initialize wallets
dummy_wallet1 = DummyWallet1()
self.wallets[dummy_wallet1.get_identifier()] = dummy_wallet1
dummy_wallet2 = DummyWallet2()
self.wallets[dummy_wallet2.get_identifier()] = dummy_wallet2
# Load market community
self.market = MarketTestnetCommunity(self.trustchain.my_peer, self.ipv8.endpoint, self.ipv8.network,
trustchain=self.trustchain,
dht=self.dht,
wallets=self.wallets,
working_directory=options["statedir"],
record_transactions=False)
self.ipv8.overlays.append(self.market)
self.ipv8.strategies.append((RandomWalk(self.market), 20))
async def start_anydex(self, options):
"""
Main method to startup AnyDex.
"""
config = get_anydex_configuration()
if options.statedir:
# If we use a custom state directory, update various variables
for key in config["keys"]:
key["file"] = os.path.join(options.statedir, key["file"])
for community in config["overlays"]:
if community["class"] == "TrustChainCommunity":
community["initialize"][
"working_directory"] = options.statedir
if options.testnet:
for community in config["overlays"]:
if community["class"] == "TrustChainCommunity":
community["class"] = "TrustChainTestnetCommunity"
self.ipv8 = IPv8(config, enable_statistics=options.statistics)
await self.ipv8.start()
print("Starting AnyDex")
if not options.no_rest_api:
self.restapi = RESTManager(self.ipv8)
await self.restapi.start(options.apiport)
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()
self.restapi = None
await self.ipv8.stop()
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)))
# Get Trustchain + DHT overlays
for overlay in self.ipv8.overlays:
if isinstance(overlay,
(TrustChainCommunity, TrustChainTestnetCommunity)):
self.trustchain = overlay
elif isinstance(overlay, DHTDiscoveryCommunity):
self.dht = overlay
# Initialize wallets
dummy_wallet1 = DummyWallet1()
self.wallets[dummy_wallet1.get_identifier()] = dummy_wallet1
dummy_wallet2 = DummyWallet2()
self.wallets[dummy_wallet2.get_identifier()] = dummy_wallet2
# Load market community
self.market = MarketTestnetCommunity(
self.trustchain.my_peer,
self.ipv8.endpoint,
self.ipv8.network,
trustchain=self.trustchain,
dht=self.dht,
wallets=self.wallets,
working_directory=options.statedir,
record_transactions=False,
is_matchmaker=not options.no_matchmaker)
self.ipv8.overlays.append(self.market)
self.ipv8.strategies.append((RandomWalk(self.market), 20))
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)
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()
# we have to represent `user_id` as a string to make it equal to the
# `user_id` on the GUI side
user_id_str = hexlify(self.trustchain_keypair.key.pk).encode('utf-8')
SentryReporter.set_user(user_id_str)
# Start the REST API before the upgrader since we want to send interesting upgrader events over the socket
if self.config.get_api_http_enabled() or self.config.get_api_https_enabled():
from tribler_core.restapi.rest_manager import RESTManager
self.api_manager = RESTManager(self)
self.readable_status = STATE_START_API
await self.api_manager.start()
if self.upgrader_enabled and not self.core_test_mode:
from tribler_core.upgrade.upgrade import TriblerUpgrader
self.upgrader = TriblerUpgrader(self)
self.readable_status = STATE_UPGRADING_READABLE
await self.upgrader.run()
self.tracker_manager = TrackerManager(self)
# Start torrent checker before Popularity community is loaded
if self.config.get_torrent_checking_enabled() and not self.core_test_mode:
from tribler_core.modules.torrent_checker.torrent_checker import TorrentChecker
self.readable_status = STATE_START_TORRENT_CHECKER
self.torrent_checker = TorrentChecker(self)
await self.torrent_checker.initialize()
# 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():
from tribler_core.modules.metadata_store.store import MetadataStore
channels_dir = self.config.get_chant_channels_dir()
metadata_db_name = 'metadata.db' if not self.config.get_chant_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,
notifier=self.notifier,
disable_sync=self.core_test_mode)
if self.core_test_mode:
generate_test_channels(self.mds)
# IPv8
if self.config.get_ipv8_enabled():
from ipv8.configuration import ConfigBuilder
from ipv8.messaging.interfaces.dispatcher.endpoint import DispatcherEndpoint
ipv8_config_builder = (ConfigBuilder()
.set_port(self.config.get_ipv8_port())
.set_address(self.config.get_ipv8_address())
.clear_overlays()
.clear_keys() # We load the keys ourselves
.set_working_directory(str(self.config.get_state_dir()))
.set_walker_interval(self.config.get_ipv8_walk_interval()))
if self.core_test_mode:
endpoint = DispatcherEndpoint([])
else:
# IPv8 includes IPv6 support by default.
# We only load IPv4 to not kill all Tribler overlays (currently, it would instantly crash all users).
# If you want to test IPv6 in Tribler you can set ``endpoint = None`` here.
endpoint = DispatcherEndpoint(["UDPIPv4"], UDPIPv4={'port': self.config.get_ipv8_port(),
'ip': self.config.get_ipv8_address()})
self.ipv8 = IPv8(ipv8_config_builder.finalize(),
enable_statistics=self.config.get_ipv8_statistics() and not self.core_test_mode,
endpoint_override=endpoint)
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()
if not self.core_test_mode:
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()
if self.config.get_ipv8_walk_scaling_enabled():
from tribler_core.modules.ipv8_health_monitor import IPv8Monitor
IPv8Monitor(self.ipv8,
self.config.get_ipv8_walk_interval(),
self.config.get_ipv8_walk_scaling_upper_limit()).start(self)
# 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, dummy_mode=self.core_test_mode)
self.dlmgr.initialize()
self.readable_status = STATE_LOAD_CHECKPOINTS
await self.dlmgr.load_checkpoints()
if self.core_test_mode:
await self.dlmgr.start_download_from_uri("magnet:?xt=urn:btih:0000000000000000000000000000000000000000")
self.readable_status = STATE_READABLE_STARTED
if self.config.get_watch_folder_enabled():
from tribler_core.modules.watch_folder import WatchFolder
self.readable_status = STATE_START_WATCH_FOLDER
self.watch_folder = WatchFolder(self)
self.watch_folder.start()
if self.config.get_resource_monitor_enabled() and not self.core_test_mode:
from tribler_core.modules.resource_monitor.core import CoreResourceMonitor
self.resource_monitor = CoreResourceMonitor(self)
self.resource_monitor.start()
if self.config.get_version_checker_enabled() and not self.core_test_mode:
from tribler_core.modules.versioncheck_manager import VersionCheckManager
self.version_check_manager = VersionCheckManager(self)
self.version_check_manager.start()
if self.config.get_ipv8_enabled():
from tribler_core.modules.payout_manager import PayoutManager
self.payout_manager = PayoutManager(self.bandwidth_community, self.dht_community)
if self.core_test_mode:
from ipv8.messaging.interfaces.udp.endpoint import UDPv4Address
from ipv8.dht.routing import RoutingTable
self.dht_community.routing_tables[UDPv4Address] = RoutingTable('\x00' * 20)
# 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:
from tribler_core.modules.metadata_store.gigachannel_manager import GigaChannelManager
self.gigachannel_manager = GigaChannelManager(self)
if not self.core_test_mode:
self.gigachannel_manager.start()
if self.config.get_bootstrap_enabled() and not self.core_test_mode:
self.register_task('bootstrap_download', self.start_bootstrap_download)
self.notifier.notify(NTFY.TRIBLER_STARTED, self.trustchain_keypair.key.pk)
# If there is a config error, report to the user via GUI notifier
if self.config.config_error:
self.notifier.notify(NTFY.REPORT_CONFIG_ERROR, self.config.config_error)
async def start_crawler(self, statedir, apiport, no_rest_api, testnet,
yappi):
"""
Main method to startup the TrustChain crawler.
"""
# Open the database
self.tc_persistence = TrustChainDB(statedir, 'trustchain')
if statedir:
# If we use a custom state directory, update various variables
for key in crawler_config["keys"]:
key["file"] = os.path.join(statedir, key["file"])
for community in crawler_config["overlays"]:
if community[
"class"] == "TrustChainCrawlerCommunity" or community[
"class"] == "TrustChainBackwardsCrawlerCommunity":
community["initialize"][
"persistence"] = self.tc_persistence
if testnet:
for community in crawler_config["overlays"]:
if community["class"] == "TrustChainCommunity":
community["class"] = "TrustChainTestnetCommunity"
extra_communities = {
"TrustChainCrawlerCommunity":
TrustChainCrawlerCommunity,
"TrustChainBackwardsCrawlerCommunity":
TrustChainBackwardsCrawlerCommunity
}
self.ipv8 = IPv8(crawler_config, extra_communities=extra_communities)
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()
if yappi:
yappi.stop()
print("Yappi has shutdown")
yappi_stats = yappi.get_func_stats()
yappi_stats.sort("tsub")
out_file = 'yappi'
if statedir:
out_file = os.path.join(statedir, out_file)
yappi_stats.save(out_file, type='callgrind')
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 TrustChain crawler")
if not no_rest_api:
self.restapi = RESTManager(self.ipv8)
await self.restapi.start(apiport)
if yappi:
yappi.start(builtins=True)
_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': {
'timeout': 3.0
}
}],
'initialize': {},
'on_start': [('started', )]
}]
INSTANCES.append(IPv8(configuration))
reactor.run()
# 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__), "%d" % i))
if not path.exists(workdir):
mkdir(workdir)
chdir(workdir)
IPv8(configuration)
chdir(previous_workdir)
# Actually start running everything, this blocks until the experiment finishes
reactor.callLater(30.0, on_timeout)
reactor.run()
# Print the introduction times for all default Communities, sorted alphabetically.
print(','.join(['%.4f' % RESULTS[key] for key in sorted(RESULTS)]))
