c-ipfs/test/routing/test_routing.h

782 lines
25 KiB
C
Raw Normal View History

2017-07-26 14:48:04 +00:00
#pragma once
#include <pthread.h>
#include <fcntl.h>
2017-07-26 14:48:04 +00:00
#include <sys/stat.h>
#include "libp2p/os/utils.h"
#include "libp2p/utils/logger.h"
#include "multiaddr/multiaddr.h"
#include "ipfs/cmd/cli.h"
#include "ipfs/core/daemon.h"
#include "ipfs/core/ipfs_node.h"
#include "ipfs/routing/routing.h"
2017-07-26 14:48:04 +00:00
#include "ipfs/importer/importer.h"
#include "ipfs/importer/exporter.h"
#include "../test_helper.h"
2017-09-14 17:13:07 +00:00
/***
* "publish" a hash to the datastore (for ipns)
*/
int test_routing_put_value() {
2017-09-28 18:21:34 +00:00
int retVal = 0;
char* ipfs_path_publisher = "/tmp/ipfs_1";
char* peer_id_publisher = NULL;
struct MultiAddress* ma_publisher = NULL;
pthread_t thread_publisher;
int publisher_thread_started = 0;
struct CliArguments* arguments = NULL;
libp2p_logger_add_class("test_routing");
2017-09-28 19:44:55 +00:00
libp2p_logger_add_class("api");
2017-09-28 18:21:34 +00:00
// fire up the "publisher"
if (!drop_and_build_repository(ipfs_path_publisher, 4001, NULL, &peer_id_publisher)) {
libp2p_logger_error("test_routing", "Unable to drop and build repository.\n");
goto exit;
}
char multiaddress_string[255];
sprintf(multiaddress_string, "/ip4/127.0.0.1/tcp/4001/ipfs/%s", peer_id_publisher);
ma_publisher = multiaddress_new_from_string(multiaddress_string);
if (pthread_create(&thread_publisher, NULL, test_daemon_start, (void*)ipfs_path_publisher) < 0) {
libp2p_logger_error("test_routing", "Unable to start first daemon.\n");
goto exit;
}
publisher_thread_started = 1;
sleep(3);
// import the file into the "publisher"
char* args[] = { "ipfs", "--config", ipfs_path_publisher, "add", "-r", "~/site"};
arguments = cli_arguments_new(6, args);
ipfs_import_files(arguments);
cli_arguments_free(arguments);
// now "publish" to publisher
libp2p_logger_debug("test_routing", "About to publish to publisher.\n");
char* args2[] = {"ipfs", "--config", ipfs_path_publisher, "name", "publish", "QmZtAEqmnXMZkwVPKdyMGxUoo35cQMzNhmq6CN3DvgRwAD" };
arguments = cli_arguments_new(6, args2);
if (!ipfs_name(arguments))
goto exit;
cli_arguments_free(arguments);
arguments = NULL;
// see if we have what we should...
libp2p_logger_debug("test_routing", "About to ask for the server to resolve the publisher.\n");
2017-09-28 19:44:55 +00:00
char ipns[126];
sprintf(ipns, "/ipns/%s", peer_id_publisher);
char* args3[] = {"ipfs", "--config", ipfs_path_publisher, "name", "resolve", ipns};
2017-09-28 18:48:57 +00:00
arguments = cli_arguments_new(6, args3);
2017-09-28 18:21:34 +00:00
if (!ipfs_name(arguments))
goto exit;
retVal = 1;
exit:
ipfs_daemon_stop();
if (publisher_thread_started) {
pthread_join(thread_publisher, NULL);
}
multiaddress_free(ma_publisher);
cli_arguments_free(arguments);
return retVal;
}
/***
* "publish" a hash to the datastore (for ipns)
*/
int test_routing_put_value_and_resolve() {
2017-09-14 17:13:07 +00:00
int retVal = 0;
2017-09-25 11:57:17 +00:00
char* ipfs_path_publisher = "/tmp/ipfs_1";
2017-09-14 17:13:07 +00:00
char* peer_id_publisher = NULL;
struct MultiAddress* ma_publisher = NULL;
pthread_t thread_publisher;
int publisher_thread_started = 0;
pthread_t thread_consumer;
char* ipfs_path_consumer = "/tmp/ipfs_2";
char* peer_id_consumer = NULL;
int consumer_thread_started = 0;
struct Libp2pVector* ma_vector = NULL;
struct CliArguments* arguments = NULL;
2017-09-14 17:13:07 +00:00
2017-09-28 18:21:34 +00:00
libp2p_logger_add_class("test_routing");
2017-09-14 17:13:07 +00:00
// fire up the "publisher"
2017-09-28 18:21:34 +00:00
if (!drop_and_build_repository(ipfs_path_publisher, 4001, NULL, &peer_id_publisher)) {
libp2p_logger_error("test_routing", "Unable to drop and build repository.\n");
goto exit;
}
2017-09-14 17:13:07 +00:00
char multiaddress_string[255];
sprintf(multiaddress_string, "/ip4/127.0.0.1/tcp/4001/ipfs/%s", peer_id_publisher);
ma_publisher = multiaddress_new_from_string(multiaddress_string);
2017-09-28 18:21:34 +00:00
if (pthread_create(&thread_publisher, NULL, test_daemon_start, (void*)ipfs_path_publisher) < 0) {
libp2p_logger_error("test_routing", "Unable to start first daemon.\n");
2017-09-14 17:13:07 +00:00
goto exit;
}
publisher_thread_started = 1;
2017-09-28 18:21:34 +00:00
sleep(3);
// import the file into the "publisher"
char* args[] = { "ipfs", "--config", ipfs_path_publisher, "add", "-r", "~/site"};
arguments = cli_arguments_new(6, args);
ipfs_import_files(arguments);
cli_arguments_free(arguments);
2017-09-14 17:13:07 +00:00
// fire up the "consumer"
ma_vector = libp2p_utils_vector_new(1);
libp2p_utils_vector_add(ma_vector, ma_publisher);
drop_and_build_repository(ipfs_path_consumer, 4002, ma_vector, &peer_id_consumer);
2017-09-19 00:04:52 +00:00
if (pthread_create(&thread_consumer, NULL, test_daemon_start, (void*)ipfs_path_consumer) < 0)
2017-09-14 17:13:07 +00:00
goto exit;
consumer_thread_started = 1;
// wait for everything to fire up
sleep(3);
2017-09-28 18:21:34 +00:00
// now "publish" to publisher
libp2p_logger_debug("test_routing", "About to publish to publisher.\n");
char* args2[] = {"ipfs", "--config", ipfs_path_publisher, "name", "publish", "QmZtAEqmnXMZkwVPKdyMGxUoo35cQMzNhmq6CN3DvgRwAD" };
arguments = cli_arguments_new(6, args2);
if (!ipfs_name(arguments))
goto exit;
cli_arguments_free(arguments);
arguments = NULL;
2017-09-14 17:13:07 +00:00
// see if we have what we should...
2017-09-28 18:21:34 +00:00
libp2p_logger_debug("test_routing", "About to ask for the server to resolve the publisher.\n");
2017-09-14 17:13:07 +00:00
char* args3[] = {"ipfs", "--config", ipfs_path_consumer, "resolve", peer_id_publisher};
2017-09-28 18:21:34 +00:00
//char* results = NULL;
arguments = cli_arguments_new(5, args3);
if (!ipfs_name(arguments))
goto exit;
2017-09-14 17:13:07 +00:00
retVal = 1;
exit:
ipfs_daemon_stop();
if (publisher_thread_started) {
2017-09-14 19:58:53 +00:00
pthread_join(thread_publisher, NULL);
2017-09-14 17:13:07 +00:00
}
if (consumer_thread_started) {
2017-09-14 19:58:53 +00:00
pthread_join(thread_consumer, NULL);
2017-09-14 17:13:07 +00:00
}
multiaddress_free(ma_publisher);
cli_arguments_free(arguments);
2017-09-14 17:13:07 +00:00
return retVal;
}
int test_routing_find_peer() {
2017-04-27 16:35:26 +00:00
int retVal = 0;
2017-09-28 18:21:34 +00:00
char* ipfs_path1 = "/tmp/ipfs_1";
char* ipfs_path2 = "/tmp/ipfs_2";
char* ipfs_path3 = "/tmp/ipfs_3";
pthread_t thread1;
pthread_t thread2;
2017-09-28 18:21:34 +00:00
pthread_t thread3;
int thread1_started = 0, thread2_started = 0, thread3_started = 0;
2017-04-27 16:35:26 +00:00
char* peer_id_1 = NULL;
char* peer_id_2 = NULL;
char* peer_id_3 = NULL;
2017-09-28 18:21:34 +00:00
struct IpfsNode* local_node = NULL;
struct IpfsNode* local_node2 = NULL;
struct IpfsNode* local_node3 = NULL;
2017-04-27 16:35:26 +00:00
struct FSRepo* fs_repo = NULL;
struct MultiAddress* ma_peer1;
2017-04-27 16:35:26 +00:00
struct Libp2pVector *ma_vector = NULL;
struct Libp2pPeer* result = NULL;
struct HashtableNode *node = NULL;
2017-09-28 18:21:34 +00:00
struct Libp2pVector* peers = NULL;
2017-05-11 18:53:52 +00:00
//libp2p_logger_add_class("online");
//libp2p_logger_add_class("null");
//libp2p_logger_add_class("daemon");
//libp2p_logger_add_class("dht_protocol");
//libp2p_logger_add_class("peerstore");
// create peer 1
2017-09-28 18:21:34 +00:00
drop_and_build_repository(ipfs_path1, 4001, NULL, &peer_id_1);
char multiaddress_string[255];
sprintf(multiaddress_string, "/ip4/127.0.0.1/tcp/4001/ipfs/%s", peer_id_1);
ma_peer1 = multiaddress_new_from_string(multiaddress_string);
// start the daemon in a separate thread
2017-09-28 18:21:34 +00:00
if (pthread_create(&thread1, NULL, test_daemon_start, (void*)ipfs_path2) < 0)
2017-04-27 16:35:26 +00:00
goto exit;
thread1_started = 1;
2017-05-11 18:53:52 +00:00
sleep(3);
// create peer 2
2017-04-27 16:35:26 +00:00
ma_vector = libp2p_utils_vector_new(1);
libp2p_utils_vector_add(ma_vector, ma_peer1);
2017-09-28 18:21:34 +00:00
drop_and_build_repository(ipfs_path2, 4002, ma_vector, &peer_id_2);
// start the daemon in a separate thread
2017-09-28 18:21:34 +00:00
if (pthread_create(&thread2, NULL, test_daemon_start, (void*)ipfs_path2) < 0)
2017-04-27 16:35:26 +00:00
goto exit;
thread2_started = 1;
2017-09-28 18:21:34 +00:00
// JMJ wait for everything to start up
2017-05-11 18:53:52 +00:00
sleep(3);
2017-09-28 18:21:34 +00:00
// add a file to peer 2
char* hello_text = "Hello, World!";
create_file("/tmp/hello.txt", (uint8_t*)hello_text, strlen(hello_text));
2017-09-28 18:21:34 +00:00
size_t bytes_written = 0;
ipfs_node_offline_new(ipfs_path2, &local_node2);
ipfs_import_file(NULL, "/tmp/hello.txt", &node, local_node2, &bytes_written, 0);
2017-09-28 18:21:34 +00:00
ipfs_node_free(local_node2);
2017-05-11 18:53:52 +00:00
// create my peer, peer 3
2017-04-27 16:35:26 +00:00
libp2p_utils_vector_add(ma_vector, ma_peer1);
2017-09-28 18:21:34 +00:00
drop_and_build_repository(ipfs_path3, 4003, ma_vector, &peer_id_3);
// start the daemon in a separate thread
if (pthread_create(&thread3, NULL, test_daemon_start, (void*)ipfs_path3) < 0)
goto exit;
thread3_started = 1;
2017-09-28 18:21:34 +00:00
sleep(3);
2017-09-28 18:21:34 +00:00
ipfs_node_offline_new(ipfs_path3, &local_node3);
int peer2_len = strlen(peer_id_2);
if (!local_node3->routing->FindProviders(local_node3->routing, (unsigned char*)peer_id_2, peer2_len, &peers)) {
2017-09-28 18:21:34 +00:00
fprintf(stderr, "Unable to find peer %s by asking %s\n", peer_id_2, peer_id_1);
goto exit;
2017-05-11 18:53:52 +00:00
}
if (result == NULL) {
2017-05-11 18:53:52 +00:00
fprintf(stderr, "Result was NULL\n");
2017-04-27 16:35:26 +00:00
goto exit;
}
struct MultiAddress *remote_address = result->addr_head->item;
fprintf(stderr, "Remote address is: %s\n", remote_address->string);
2017-04-27 16:35:26 +00:00
retVal = 1;
exit:
ipfs_daemon_stop();
if (thread1_started)
pthread_join(thread1, NULL);
if (thread2_started)
pthread_join(thread2, NULL);
2017-09-28 20:43:03 +00:00
if (thread3_started)
pthread_join(thread3, NULL);
2017-04-27 16:35:26 +00:00
if (peer_id_1 != NULL)
free(peer_id_1);
if (peer_id_2 != NULL)
free(peer_id_2);
if (peer_id_3 != NULL)
free(peer_id_3);
if (fs_repo != NULL)
ipfs_repo_fsrepo_free(fs_repo);
if (ma_peer1 != NULL)
multiaddress_free(ma_peer1);
if (ma_vector != NULL)
libp2p_utils_vector_free(ma_vector);
if (node != NULL)
ipfs_hashtable_node_free(node);
2017-09-28 18:21:34 +00:00
if (local_node != NULL)
ipfs_node_free(local_node);
2017-05-11 18:53:52 +00:00
if (result != NULL)
libp2p_peer_free(result);
2017-04-27 16:35:26 +00:00
return retVal;
}
int test_routing_find_providers() {
int retVal = 0;
2017-09-28 18:21:34 +00:00
char* ipfs_path1 = "/tmp/ipfs_1";
char* ipfs_path2 = "/tmp/ipfs_2";
char* ipfs_path3 = "/tmp/ipfs_3";
char* peer_id_1 = NULL;
char* peer_id_2 = NULL;
char* peer_id_3 = NULL;
2017-09-28 18:21:34 +00:00
//struct IpfsNode *local_node1 = NULL;
struct IpfsNode *local_node2 = NULL;
struct IpfsNode *local_node3 = NULL;
char* remote_peer_id = NULL;
pthread_t thread1, thread2;
int thread1_started = 0, thread2_started = 0;
struct MultiAddress* ma_peer1 = NULL;
struct Libp2pVector* ma_vector2 = NULL, *ma_vector3 = NULL;
struct FSRepo* fs_repo = NULL;
2017-07-17 21:14:40 +00:00
struct HashtableNode* node = NULL;
struct Libp2pVector* result = NULL;
// create peer 1
2017-09-28 18:21:34 +00:00
drop_and_build_repository(ipfs_path1, 4001, NULL, &peer_id_1);
char multiaddress_string[255];
sprintf(multiaddress_string, "/ip4/127.0.0.1/tcp/4001/ipfs/%s", peer_id_1);
ma_peer1 = multiaddress_new_from_string(multiaddress_string);
// start the daemon in a separate thread
2017-09-28 18:21:34 +00:00
if (pthread_create(&thread1, NULL, test_daemon_start, (void*)ipfs_path1) < 0) {
fprintf(stderr, "Unable to start thread 1\n");
goto exit;
}
thread1_started = 1;
2017-09-28 18:21:34 +00:00
sleep(3);
// create peer 2
// create a vector to hold peer1's multiaddress so we can connect as a peer
ma_vector2 = libp2p_utils_vector_new(1);
libp2p_utils_vector_add(ma_vector2, ma_peer1);
2017-04-27 16:35:26 +00:00
// note: this destroys some things, as it frees the fs_repo:
2017-09-28 18:21:34 +00:00
drop_and_build_repository(ipfs_path2, 4002, ma_vector2, &peer_id_2);
// start the daemon in a separate thread
2017-09-28 18:21:34 +00:00
if (pthread_create(&thread2, NULL, test_daemon_start, (void*)ipfs_path2) < 0) {
fprintf(stderr, "Unable to start thread 2\n");
goto exit;
}
thread2_started = 1;
// wait for everything to start up
// JMJ debugging =
sleep(3);
2017-09-28 18:21:34 +00:00
// add a file, to prime the connection to peer 1
size_t bytes_written = 0;
ipfs_node_offline_new(ipfs_path2, &local_node2);
ipfs_import_file(NULL, "/home/parallels/ipfstest/hello_world.txt", &node, local_node2, &bytes_written, 0);
ipfs_node_free(local_node2);
// create my peer, peer 3
ma_peer1 = multiaddress_new_from_string(multiaddress_string);
ma_vector3 = libp2p_utils_vector_new(1);
libp2p_utils_vector_add(ma_vector3, ma_peer1);
2017-09-28 18:21:34 +00:00
drop_and_build_repository(ipfs_path3, 4003, ma_vector3, &peer_id_3);
2017-09-28 18:21:34 +00:00
ipfs_node_offline_new(ipfs_path3, &local_node3);
2017-09-28 18:21:34 +00:00
if (!local_node3->routing->FindProviders(local_node3->routing, node->hash, node->hash_size, &result)) {
fprintf(stderr, "Unable to find a provider\n");
goto exit;
}
if (result == NULL) {
fprintf(stderr, "Provider array is NULL\n");
goto exit;
}
// connect to peer 2
struct Libp2pPeer *remote_peer = NULL;
for(int i = 0; i < result->total; i++) {
remote_peer = (struct Libp2pPeer*)libp2p_utils_vector_get(result, i);
2017-09-28 18:21:34 +00:00
if (remote_peer->connection_type == CONNECTION_TYPE_CONNECTED
|| libp2p_peer_connect(&local_node3->identity->private_key, remote_peer, local_node3->peerstore, local_node3->repo->config->datastore, 5)) {
break;
}
remote_peer = NULL;
}
if (remote_peer == NULL) {
fprintf(stderr, "Remote Peer is NULL\n");
goto exit;
}
remote_peer_id = malloc(remote_peer->id_size + 1);
memcpy(remote_peer_id, remote_peer->id, remote_peer->id_size);
remote_peer_id[remote_peer->id_size] = 0;
fprintf(stderr, "Remote address is: %s\n", remote_peer_id);
free(remote_peer_id);
remote_peer_id = NULL;
retVal = 1;
exit:
ipfs_daemon_stop();
if (fs_repo != NULL)
ipfs_repo_fsrepo_free(fs_repo);
if (peer_id_1 != NULL)
free(peer_id_1);
if (peer_id_2 != NULL)
free(peer_id_2);
if (peer_id_3 != NULL)
free(peer_id_3);
if (thread1_started)
pthread_join(thread1, NULL);
if (thread2_started)
pthread_join(thread2, NULL);
if (ma_vector2 != NULL) {
libp2p_utils_vector_free(ma_vector2);
}
if (ma_vector3 != NULL) {
libp2p_utils_vector_free(ma_vector3);
}
2017-09-28 18:21:34 +00:00
if (local_node3 != NULL) {
ipfs_node_free(local_node3);
}
if (node != NULL)
ipfs_hashtable_node_free(node);
if (result != NULL) {
// we have a vector of peers. Clean 'em up:
2017-05-11 18:53:52 +00:00
/* free the vector, not the peers.
for(int i = 0; i < result->total; i++) {
struct Libp2pPeer* p = (struct Libp2pPeer*)libp2p_utils_vector_get(result, i);
libp2p_peer_free(p);
}
2017-05-11 18:53:52 +00:00
*/
libp2p_utils_vector_free(result);
}
return retVal;
}
/***
* Fire up a "client" and "server" and let the client tell the server he's providing a file
*/
int test_routing_provide() {
int retVal = 0;
// clean out repository
char* ipfs_path = "/tmp/test1";
os_utils_setenv("IPFS_PATH", ipfs_path, 1);
char* peer_id_1 = NULL;
char* peer_id_2 = NULL;
struct IpfsNode *local_node2 = NULL;
pthread_t thread1, thread2;
int thread1_started = 0, thread2_started = 0;
struct MultiAddress* ma_peer1 = NULL;
struct Libp2pVector* ma_vector2 = NULL;
2017-07-17 21:14:40 +00:00
struct HashtableNode* node = NULL;
2017-07-27 19:33:19 +00:00
libp2p_logger_add_class("daemon");
libp2p_logger_add_class("null");
// create peer 1
drop_and_build_repository(ipfs_path, 4001, NULL, &peer_id_1);
char multiaddress_string[255];
sprintf(multiaddress_string, "/ip4/127.0.0.1/tcp/4001/ipfs/%s", peer_id_1);
ma_peer1 = multiaddress_new_from_string(multiaddress_string);
// start the daemon in a separate thread
2017-09-19 00:04:52 +00:00
if (pthread_create(&thread1, NULL, test_daemon_start, (void*)ipfs_path) < 0) {
fprintf(stderr, "Unable to start thread 1\n");
goto exit;
}
thread1_started = 1;
// create peer 2
ipfs_path = "/tmp/test2";
os_utils_setenv("IPFS_PATH", ipfs_path, 1);
// create a vector to hold peer1's multiaddress so we can connect as a peer
ma_vector2 = libp2p_utils_vector_new(1);
libp2p_utils_vector_add(ma_vector2, ma_peer1);
// note: this distroys some things, as it frees the fs_repo:
drop_and_build_repository(ipfs_path, 4002, ma_vector2, &peer_id_2);
// add a file, to prime the connection to peer 1
//TODO: Find a better way to do this...
size_t bytes_written = 0;
ipfs_node_offline_new(ipfs_path, &local_node2);
uint8_t *bytes = (unsigned char*)"hello, world!\n";
char* filename = "test1.txt";
create_file(filename, bytes, strlen((char*)bytes));
ipfs_import_file(NULL, filename, &node, local_node2, &bytes_written, 0);
2017-09-25 13:55:42 +00:00
ipfs_node_free(local_node2);
// start the daemon in a separate thread
2017-09-19 00:04:52 +00:00
if (pthread_create(&thread2, NULL, test_daemon_start, (void*)ipfs_path) < 0) {
fprintf(stderr, "Unable to start thread 2\n");
goto exit;
}
thread2_started = 1;
// wait for everything to start up
sleep(3);
retVal = 1;
exit:
ipfs_daemon_stop();
if (peer_id_1 != NULL)
free(peer_id_1);
if (peer_id_2 != NULL)
free(peer_id_2);
if (thread1_started)
pthread_join(thread1, NULL);
if (thread2_started)
pthread_join(thread2, NULL);
if (ma_vector2 != NULL) {
libp2p_utils_vector_free(ma_vector2);
}
if (node != NULL)
ipfs_hashtable_node_free(node);
2017-07-27 19:33:19 +00:00
if (ma_peer1 != NULL)
multiaddress_free(ma_peer1);
return retVal;
}
/***
* Attempt to retrieve a file from a previously unknown node
*/
int test_routing_retrieve_file_third_party() {
int retVal = 0;
char* ipfs_path_1 = "/tmp/ipfs_1", *ipfs_path_2 = "/tmp/ipfs_2", *ipfs_path_3 = "/tmp/ipfs_3";
char* peer_id_1 = NULL, *peer_id_2 = NULL, *peer_id_3 = NULL;
struct IpfsNode* ipfs_node2 = NULL, *ipfs_node3 = NULL;
pthread_t thread1, thread2, thread3;
int thread1_started = 0, thread2_started = 0, thread3_started = 0;
struct MultiAddress* ma_peer1 = NULL;
struct Libp2pVector* ma_vector2 = NULL, *ma_vector3 = NULL;
struct HashtableNode* node = NULL, *result_node = NULL;
char multiaddress_string[255] = "";
char hash[256] = "";
2017-09-28 19:44:55 +00:00
/*
libp2p_logger_add_class("online");
2017-09-28 12:58:51 +00:00
libp2p_logger_add_class("offline");
libp2p_logger_add_class("multistream");
libp2p_logger_add_class("null");
libp2p_logger_add_class("dht_protocol");
libp2p_logger_add_class("providerstore");
libp2p_logger_add_class("peerstore");
libp2p_logger_add_class("exporter");
libp2p_logger_add_class("peer");
libp2p_logger_add_class("test_routing");
2017-09-28 12:58:51 +00:00
libp2p_logger_add_class("api");
2017-09-28 18:21:34 +00:00
libp2p_logger_add_class("secio");
2017-09-28 19:44:55 +00:00
*/
// clean out repository
// create peer 1
if (!drop_and_build_repository(ipfs_path_1, 4001, NULL, &peer_id_1))
goto exit;
sprintf(multiaddress_string, "/ip4/127.0.0.1/tcp/4001/ipfs/%s", peer_id_1);
ma_peer1 = multiaddress_new_from_string(multiaddress_string);
// start the daemon in a separate thread
2017-09-28 18:21:34 +00:00
libp2p_logger_debug("test_routing", "Firing up daemon 1, our central server. Named: %s.\n", peer_id_1);
if (pthread_create(&thread1, NULL, test_daemon_start, (void*)ipfs_path_1) < 0) {
libp2p_logger_error("test_routing", "Unable to start thread 1\n");
goto exit;
}
thread1_started = 1;
// create peer 2, that will host the file
// create a vector to hold peer1's multiaddress so we can connect as a peer
ma_vector2 = libp2p_utils_vector_new(1);
libp2p_utils_vector_add(ma_vector2, ma_peer1);
// note: this destroys some things, as it frees the fs_repo:
drop_and_build_repository(ipfs_path_2, 4002, ma_vector2, &peer_id_2);
2017-05-11 18:53:52 +00:00
multiaddress_free(ma_peer1);
// start the daemon in a separate thread
2017-09-28 18:21:34 +00:00
libp2p_logger_debug("test_routing", "Firing up daemon 2, which will host the file. Named %s.\n", peer_id_2);
if (pthread_create(&thread2, NULL, test_daemon_start, (void*)ipfs_path_2) < 0) {
libp2p_logger_error("test_routing", "Unable to start thread 2.\n");
goto exit;
}
thread2_started = 1;
2017-09-28 12:58:51 +00:00
// wait for everything to start up
sleep(3);
//TODO: add a file to server 2
uint8_t *bytes = (unsigned char*)"hello, world!\n";
char* filename = "test1.txt";
create_file(filename, bytes, strlen((char*)bytes));
size_t bytes_written;
ipfs_node_offline_new(ipfs_path_2, &ipfs_node2);
ipfs_import_file(NULL, filename, &node, ipfs_node2, &bytes_written, 0);
memset(hash, 0, 256);
ipfs_cid_hash_to_base58(node->hash, node->hash_size, (unsigned char*)hash, 256);
2017-09-28 18:21:34 +00:00
libp2p_logger_debug("test_routing", "Inserted file with hash %s into server %s.\n", hash, peer_id_2);
ipfs_node_free(ipfs_node2);
// wait for everything to start up
sleep(3);
// create my peer, peer 3
ma_peer1 = multiaddress_new_from_string(multiaddress_string);
ma_vector3 = libp2p_utils_vector_new(1);
libp2p_utils_vector_add(ma_vector3, ma_peer1);
drop_and_build_repository(ipfs_path_3, 4003, ma_vector3, &peer_id_3);
2017-05-11 18:53:52 +00:00
multiaddress_free(ma_peer1);
2017-09-28 18:21:34 +00:00
libp2p_logger_debug("test_routing", "Firing up daemon 3, which is our leech. Named: %s.\n", peer_id_3);
if (pthread_create(&thread3, NULL, test_daemon_start, (void*)ipfs_path_3) < 0) {
libp2p_logger_error("test_routing", "Unable to start thread 3.\n");
goto exit;
}
thread3_started = 1;
2017-09-28 12:58:51 +00:00
sleep(3);
//now have peer 3 ask for a file that is on peer 2, but peer 3 only knows of peer 1
ipfs_node_offline_new(ipfs_path_3, &ipfs_node3);
2017-09-28 18:21:34 +00:00
libp2p_logger_debug("test_routing", "Client of daemon 3 will now attempt to look for %s.\n", hash);
2017-09-28 12:58:51 +00:00
if (!ipfs_exporter_get_node(ipfs_node3, node->hash, node->hash_size, &result_node)) {
2017-09-28 12:58:51 +00:00
libp2p_logger_error("test_routing", "Get_Node returned false\n");
goto exit;
}
if (node->hash_size != result_node->hash_size) {
fprintf(stderr, "Node hash sizes do not match. Should be %lu but is %lu\n", node->hash_size, result_node->hash_size);
goto exit;
}
if (node->data_size != result_node->data_size) {
fprintf(stderr, "Result sizes do not match. Should be %lu but is %lu\n", node->data_size, result_node->data_size);
goto exit;
}
retVal = 1;
exit:
ipfs_daemon_stop();
if (thread1_started)
pthread_join(thread1, NULL);
if (thread2_started)
pthread_join(thread2, NULL);
if (thread3_started)
pthread_join(thread3, NULL);
if (ipfs_node3 != NULL)
2017-09-25 13:55:42 +00:00
ipfs_node_free(ipfs_node3);
if (peer_id_1 != NULL)
free(peer_id_1);
if (peer_id_2 != NULL)
free(peer_id_2);
if (peer_id_3 != NULL)
free(peer_id_3);
if (ma_vector2 != NULL)
libp2p_utils_vector_free(ma_vector2);
if (ma_vector3 != NULL)
libp2p_utils_vector_free(ma_vector3);
if (node != NULL)
ipfs_hashtable_node_free(node);
if (result_node != NULL)
ipfs_hashtable_node_free(result_node);
return retVal;
}
/***
* Attempt to retrieve a large file from a previously unknown node
*/
int test_routing_retrieve_large_file() {
int retVal = 0;
/*
libp2p_logger_add_class("multistream");
libp2p_logger_add_class("null");
libp2p_logger_add_class("dht_protocol");
libp2p_logger_add_class("providerstore");
libp2p_logger_add_class("peerstore");
libp2p_logger_add_class("peer");
libp2p_logger_add_class("test_routing");
*/
libp2p_logger_add_class("exporter");
libp2p_logger_add_class("online");
// clean out repository
char* ipfs_path = "/tmp/test1";
char* peer_id_1 = NULL, *peer_id_2 = NULL, *peer_id_3 = NULL;
struct IpfsNode* ipfs_node2 = NULL, *ipfs_node3 = NULL;
pthread_t thread1, thread2;
int thread1_started = 0, thread2_started = 0;
struct MultiAddress* ma_peer1 = NULL;
struct Libp2pVector* ma_vector2 = NULL, *ma_vector3 = NULL;
struct HashtableNode* node = NULL, *result_node = NULL;
FILE *fd;
char* temp_file_name = "/tmp/largefile.tmp";
unlink(temp_file_name);
// create peer 1
drop_and_build_repository(ipfs_path, 4001, NULL, &peer_id_1);
char multiaddress_string[255];
sprintf(multiaddress_string, "/ip4/127.0.0.1/tcp/4001/ipfs/%s", peer_id_1);
ma_peer1 = multiaddress_new_from_string(multiaddress_string);
// start the daemon in a separate thread
libp2p_logger_debug("test_routing", "Firing up daemon 1.\n");
2017-09-19 00:04:52 +00:00
if (pthread_create(&thread1, NULL, test_daemon_start, (void*)ipfs_path) < 0) {
fprintf(stderr, "Unable to start thread 1\n");
goto exit;
}
thread1_started = 1;
// wait for everything to start up
// JMJ debugging =
sleep(3);
// create peer 2
ipfs_path = "/tmp/test2";
// create a vector to hold peer1's multiaddress so we can connect as a peer
ma_vector2 = libp2p_utils_vector_new(1);
libp2p_utils_vector_add(ma_vector2, ma_peer1);
// note: this distroys some things, as it frees the fs_repo_3:
drop_and_build_repository(ipfs_path, 4002, ma_vector2, &peer_id_2);
2017-05-11 18:53:52 +00:00
multiaddress_free(ma_peer1);
// add a file, to prime the connection to peer 1
//TODO: Find a better way to do this...
size_t bytes_written = 0;
2017-09-25 13:55:42 +00:00
if (!ipfs_node_online_new(ipfs_path, &ipfs_node2))
goto exit;
ipfs_node2->routing->Bootstrap(ipfs_node2->routing);
ipfs_import_file(NULL, "/home/parallels/ipfstest/test_import_large.tmp", &node, ipfs_node2, &bytes_written, 0);
2017-09-25 13:55:42 +00:00
ipfs_node_free(ipfs_node2);
// start the daemon in a separate thread
libp2p_logger_debug("test_routing", "Firing up daemon 2.\n");
2017-09-19 00:04:52 +00:00
if (pthread_create(&thread2, NULL, test_daemon_start, (void*)ipfs_path) < 0) {
fprintf(stderr, "Unable to start thread 2\n");
goto exit;
}
thread2_started = 1;
// wait for everything to start up
// JMJ debugging =
sleep(3);
// see if we get the entire file
libp2p_logger_debug("test_routing", "Firing up the 3rd client\n");
// create my peer, peer 3
ipfs_path = "/tmp/test3";
ma_peer1 = multiaddress_new_from_string(multiaddress_string);
ma_vector3 = libp2p_utils_vector_new(1);
libp2p_utils_vector_add(ma_vector3, ma_peer1);
drop_and_build_repository(ipfs_path, 4003, ma_vector3, &peer_id_3);
2017-05-11 18:53:52 +00:00
multiaddress_free(ma_peer1);
2017-09-25 13:55:42 +00:00
ipfs_node_online_new(ipfs_path, &ipfs_node3);
ipfs_node3->routing->Bootstrap(ipfs_node3->routing);
fd = fopen(temp_file_name, "w+");
ipfs_exporter_object_cat_to_file(ipfs_node3, node->hash, node->hash_size, fd);
fclose(fd);
struct stat buf;
stat(temp_file_name, &buf);
if (buf.st_size != 1000000) {
2017-08-02 13:53:34 +00:00
fprintf(stderr, "File size should be 1000000, but is %lu\n", (unsigned long)buf.st_size);
goto exit;
}
retVal = 1;
exit:
ipfs_daemon_stop();
if (thread1_started)
pthread_join(thread1, NULL);
if (thread2_started)
pthread_join(thread2, NULL);
if (ipfs_node3 != NULL)
2017-09-25 13:55:42 +00:00
ipfs_node_free(ipfs_node3);
if (peer_id_1 != NULL)
free(peer_id_1);
if (peer_id_2 != NULL)
free(peer_id_2);
if (peer_id_3 != NULL)
free(peer_id_3);
if (ma_vector2 != NULL) {
libp2p_utils_vector_free(ma_vector2);
}
if (ma_vector3 != NULL) {
libp2p_utils_vector_free(ma_vector3);
}
if (node != NULL)
ipfs_hashtable_node_free(node);
if (result_node != NULL)
ipfs_hashtable_node_free(result_node);
return retVal;
}