aboutsummaryrefslogtreecommitdiff
path: root/src/dht
diff options
context:
space:
mode:
authorChristian Grothoff <christian@grothoff.org>2011-09-27 21:07:58 +0000
committerChristian Grothoff <christian@grothoff.org>2011-09-27 21:07:58 +0000
commita9c2c9e208c23b3923744e854aa7aa32355b1bb1 (patch)
treeb5fee811be37150a70f3d5e1879926a45bf7b28a /src/dht
parent65b243be0941da4896afd842deda48cd0ce488e2 (diff)
downloadgnunet-a9c2c9e208c23b3923744e854aa7aa32355b1bb1.tar.gz
gnunet-a9c2c9e208c23b3923744e854aa7aa32355b1bb1.zip
DCE
Diffstat (limited to 'src/dht')
-rw-r--r--src/dht/plugin_dhtlog_mysql_dump_load.c944
-rw-r--r--src/dht/test_dhtlog.c256
2 files changed, 0 insertions, 1200 deletions
diff --git a/src/dht/plugin_dhtlog_mysql_dump_load.c b/src/dht/plugin_dhtlog_mysql_dump_load.c
deleted file mode 100644
index fada2029e..000000000
--- a/src/dht/plugin_dhtlog_mysql_dump_load.c
+++ /dev/null
@@ -1,944 +0,0 @@
1/*
2 This file is part of GNUnet.
3 (C) 2006 - 2009 Christian Grothoff (and other contributing authors)
4
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 2, or (at your
8 option) any later version.
9
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
19*/
20
21/**
22 * @file src/dht/plugin_dhtlog_mysql_dump_load.c
23 * @brief MySQL logging plugin to record DHT operations to MySQL server,
24 * but write all queries to file instead of the actual server
25 * so that they can be imported later. Since the first attempt
26 * (writing out SQL queries) seemed rather time consuming on insert,
27 * this plugin writes out tab separated values instead.
28 *
29 * @author Nathan Evans
30 *
31 * Database: MySQL
32 */
33
34#include "platform.h"
35#include "gnunet_util_lib.h"
36#include "dhtlog.h"
37
38
39#define DEBUG_DHTLOG GNUNET_YES
40
41/**
42 * Maximum number of supported parameters for a prepared
43 * statement. Increase if needed.
44 */
45#define MAX_PARAM 32
46
47
48static unsigned long max_varchar_len;
49
50/**
51 * The configuration the DHT service is running with
52 */
53static const struct GNUNET_CONFIGURATION_Handle *cfg;
54
55#define DATE_STR_SIZE 50
56
57static unsigned int topology_count;
58
59/**
60 * File(s) to dump all sql statements to.
61 */
62FILE *outfile;
63FILE *generic_stat_outfile;
64FILE *stat_outfile;
65FILE *node_outfile;
66FILE *query_outfile;
67FILE *route_outfile;
68FILE *dhtkey_outfile;
69FILE *extended_topology_outfile;
70
71static char *
72get_sql_time ()
73{
74 static char date[DATE_STR_SIZE];
75 time_t timetmp;
76 struct tm *tmptr;
77
78 time (&timetmp);
79 memset (date, 0, DATE_STR_SIZE);
80 tmptr = localtime (&timetmp);
81 if (NULL != tmptr)
82 strftime (date, DATE_STR_SIZE, "%Y-%m-%d %H:%M:%S", tmptr);
83 else
84 strcpy (date, "");
85
86 return date;
87}
88
89/*
90 * Records the current topology (number of connections, time, trial)
91 *
92 * @param num_connections how many connections are in the topology
93 *
94 * @return GNUNET_OK on success, GNUNET_SYSERR on failure
95 */
96int
97add_topology (int num_connections)
98{
99 int ret;
100
101 if (outfile == NULL)
102 return GNUNET_SYSERR;
103
104 ret =
105 fprintf (outfile,
106 "insert into topology (trialuid, date, connections) values (@temp_trial, \"%s\", %d);\n",
107 get_sql_time (), num_connections);
108 if (ret < 0)
109 return GNUNET_SYSERR;
110 ret =
111 fprintf (outfile,
112 "select max(topology_uid) from topology into @temp_topology;\n");
113 if (ret >= 0)
114 return GNUNET_OK;
115 return GNUNET_SYSERR;
116}
117
118/*
119 * Inserts the specified round into the dhttests.rounds table
120 *
121 * @param round_type the type of round that is being started
122 * @param round_count counter for the round (if applicable)
123 *
124 * @return GNUNET_OK on success, GNUNET_SYSERR on failure
125 */
126int
127add_round (unsigned int round_type, unsigned int round_count)
128{
129 int ret;
130
131 if (outfile == NULL)
132 return GNUNET_SYSERR;
133
134 ret =
135 fprintf (outfile,
136 "insert into rounds (trialuid, round_type, round_count, starttime) values (@temp_trial, \"%u\", \"%u\", \"%s\");\n",
137 round_type, round_count, get_sql_time ());
138
139 if (ret >= 0)
140 return GNUNET_OK;
141 return GNUNET_SYSERR;
142
143}
144
145/*
146 * Inserts the specified round results into the
147 * dhttests.processed_round_details table
148 *
149 * @param round_type the type of round that is being started
150 * @param round_count counter for the round (if applicable)
151 * @param num_messages the total number of messages initiated
152 * @param num_messages_succeeded the number of messages that succeeded
153 *
154 * @return GNUNET_OK on success, GNUNET_SYSERR on failure
155 */
156int
157add_round_details (unsigned int round_type, unsigned int round_count,
158 unsigned int num_messages,
159 unsigned int num_messages_succeeded)
160{
161 int ret;
162
163 if (outfile == NULL)
164 return GNUNET_SYSERR;
165
166 ret =
167 fprintf (outfile,
168 "insert into processed_trial_rounds (trialuid, round_type, round_count, starttime, endtime, num_messages, num_messages_succeeded) values (@temp_trial, \"%u\", \"%u\", \"%s\", \"%s\", \"%u\", \"%u\");\n",
169 round_type, round_count, get_sql_time (), get_sql_time (),
170 num_messages, num_messages_succeeded);
171
172 if (ret >= 0)
173 return GNUNET_OK;
174 return GNUNET_SYSERR;
175}
176
177/*
178 * Records a connection between two peers in the current topology
179 *
180 * @param first one side of the connection
181 * @param second other side of the connection
182 *
183 * @return GNUNET_OK on success, GNUNET_SYSERR on failure
184 */
185int
186add_extended_topology (const struct GNUNET_PeerIdentity *first,
187 const struct GNUNET_PeerIdentity *second)
188{
189 int ret;
190
191 if (outfile == NULL)
192 return GNUNET_SYSERR;
193
194 ret =
195 fprintf (extended_topology_outfile,
196 "insert into extended_topology (topology_uid, uid_first, uid_second) values (%u, %s,",
197 topology_count, GNUNET_h2s_full (&first->hashPubKey));
198 if (ret < 0)
199 return GNUNET_SYSERR;
200 ret =
201 fprintf (extended_topology_outfile, "%s);\n",
202 GNUNET_h2s_full (&second->hashPubKey));
203
204 if (ret >= 0)
205 return GNUNET_OK;
206 return GNUNET_SYSERR;
207}
208
209
210/*
211 * Inserts the specified trial into the dhttests.trials table
212 *
213 * @param trial_info struct containing the data to insert about this trial
214 *
215 * @return GNUNET_OK on success, GNUNET_SYSERR on failure
216 */
217int
218add_trial (struct GNUNET_DHTLOG_TrialInfo *trial_info)
219{
220 int ret;
221
222 if (outfile == NULL)
223 return GNUNET_SYSERR;
224
225 ret =
226 fprintf (outfile,
227 "INSERT INTO trials "
228 "(starttime, other_trial_identifier, numnodes, topology,"
229 "blacklist_topology, connect_topology, connect_topology_option,"
230 "connect_topology_option_modifier, topology_percentage, topology_probability,"
231 "puts, gets, "
232 "concurrent, settle_time, num_rounds, malicious_getters,"
233 "malicious_putters, malicious_droppers, malicious_get_frequency,"
234 "malicious_put_frequency, stop_closest, stop_found, strict_kademlia, "
235 "gets_succeeded, message) "
236 "VALUES (\"%s\", %u, %u, %u, %u, %u, %u, %f, %f, %f, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, \"%s\");\n",
237 get_sql_time (), trial_info->other_identifier,
238 trial_info->num_nodes, trial_info->topology,
239 trial_info->blacklist_topology, trial_info->connect_topology,
240 trial_info->connect_topology_option,
241 trial_info->connect_topology_option_modifier,
242 trial_info->topology_percentage,
243 trial_info->topology_probability, trial_info->puts,
244 trial_info->gets, trial_info->concurrent,
245 trial_info->settle_time, trial_info->num_rounds,
246 trial_info->malicious_getters, trial_info->malicious_putters,
247 trial_info->malicious_droppers,
248 trial_info->malicious_get_frequency,
249 trial_info->malicious_put_frequency, trial_info->stop_closest,
250 trial_info->stop_found, trial_info->strict_kademlia,
251 trial_info->gets_succeeded, trial_info->message);
252
253 if (ret < 0)
254 return GNUNET_SYSERR;
255
256 ret =
257 fprintf (outfile,
258 "SELECT MAX( trialuid ) FROM trials into @temp_trial;\n");
259
260 if (ret >= 0)
261 return GNUNET_OK;
262 else
263 return GNUNET_SYSERR;
264}
265
266
267/*
268 * Inserts the specified stats into the dhttests.generic_stats table
269 *
270 * @param peer the peer inserting the statistic
271 * @param name the name of the statistic
272 * @param section the section of the statistic
273 * @param value the value of the statistic
274 *
275 * @return GNUNET_OK on success, GNUNET_SYSERR on failure
276 */
277int
278add_generic_stat (const struct GNUNET_PeerIdentity *peer, const char *name,
279 const char *section, uint64_t value)
280{
281 if (outfile == NULL)
282 return GNUNET_SYSERR;
283
284 if (peer != NULL)
285 fprintf (generic_stat_outfile, "TRIALUID\t%s\t%s\t%s\t%llu\n",
286 GNUNET_h2s_full (&peer->hashPubKey), section, name,
287 (unsigned long long) value);
288
289 return GNUNET_OK;
290}
291
292
293/*
294 * Inserts the specified stats into the dhttests.node_statistics table
295 *
296 * @param peer the peer inserting the statistic
297 * @param route_requests route requests seen
298 * @param route_forwards route requests forwarded
299 * @param result_requests route result requests seen
300 * @param client_requests client requests initiated
301 * @param result_forwards route results forwarded
302 * @param gets get requests handled
303 * @param puts put requests handle
304 * @param data_inserts data inserted at this node
305 * @param find_peer_requests find peer requests seen
306 * @param find_peers_started find peer requests initiated at this node
307 * @param gets_started get requests initiated at this node
308 * @param puts_started put requests initiated at this node
309 * @param find_peer_responses_received find peer responses received locally
310 * @param get_responses_received get responses received locally
311 * @param find_peer_responses_sent find peer responses sent from this node
312 * @param get_responses_sent get responses sent from this node
313 *
314 * @return GNUNET_OK on success, GNUNET_SYSERR on failure
315 */
316int
317add_stat (const struct GNUNET_PeerIdentity *peer, unsigned int route_requests,
318 unsigned int route_forwards, unsigned int result_requests,
319 unsigned int client_requests, unsigned int result_forwards,
320 unsigned int gets, unsigned int puts, unsigned int data_inserts,
321 unsigned int find_peer_requests, unsigned int find_peers_started,
322 unsigned int gets_started, unsigned int puts_started,
323 unsigned int find_peer_responses_received,
324 unsigned int get_responses_received,
325 unsigned int find_peer_responses_sent,
326 unsigned int get_responses_sent)
327{
328 int ret;
329
330 if (outfile == NULL)
331 return GNUNET_SYSERR;
332
333 if (peer != NULL)
334 ret =
335 fprintf (stat_outfile,
336 "TRIALUID\t%s\t%u\t%u\t%u\t%u\t%u\t%u\t%u\t%u\t%u\t%u\t%u\t%u\t%u\t%u\t%u\t%u\n",
337 GNUNET_h2s_full (&peer->hashPubKey), route_requests,
338 route_forwards, result_requests, client_requests,
339 result_forwards, gets, puts, data_inserts, find_peer_requests,
340 find_peers_started, gets_started, puts_started,
341 find_peer_responses_received, get_responses_received,
342 find_peer_responses_sent, get_responses_sent);
343
344 else
345 return GNUNET_SYSERR;
346
347 if (ret >= 0)
348 return GNUNET_OK;
349 else
350 return GNUNET_SYSERR;
351}
352
353/*
354 * Inserts the specified dhtkey into the dhttests.dhtkeys table,
355 * stores return value of dhttests.dhtkeys.dhtkeyuid into dhtkeyuid
356 *
357 * @param dhtkeyuid return value
358 * @param dhtkey hashcode of key to insert
359 *
360 * @return GNUNET_OK on success, GNUNET_SYSERR on failure
361 */
362int
363add_dhtkey (unsigned long long *dhtkeyuid, const GNUNET_HashCode * dhtkey)
364{
365 int ret;
366
367 if (dhtkeyuid != NULL)
368 *dhtkeyuid = 0;
369
370 if ((dhtkey_outfile == NULL) || (dhtkey == NULL))
371 return GNUNET_SYSERR;
372
373 ret = fprintf (dhtkey_outfile, "TRIALUID\t%s\n", GNUNET_h2s_full (dhtkey));
374
375 if (ret >= 0)
376 return GNUNET_OK;
377 else
378 return GNUNET_SYSERR;
379}
380
381/*
382 * Inserts the specified node into the dhttests.nodes table
383 *
384 * @param nodeuid the inserted node uid
385 * @param node the node to insert
386 *
387 * @return GNUNET_OK on success, GNUNET_SYSERR on failure
388 */
389int
390add_node (unsigned long long *nodeuid, struct GNUNET_PeerIdentity *node)
391{
392 int ret;
393
394 if ((node == NULL) || (node_outfile == NULL))
395 return GNUNET_SYSERR;
396
397 ret =
398 fprintf (node_outfile, "TRIALUID\t%s\n",
399 GNUNET_h2s_full (&node->hashPubKey));
400 fflush (node_outfile);
401 if (ret >= 0)
402 return GNUNET_OK;
403 return GNUNET_SYSERR;
404}
405
406/*
407 * Update dhttests.trials table with current server time as end time
408 *
409 * @param gets_succeeded how many gets did the testcase report as successful
410 *
411 * @return GNUNET_OK on success, GNUNET_SYSERR on failure.
412 */
413int
414update_trials (unsigned int gets_succeeded)
415{
416 int ret;
417
418 if (outfile == NULL)
419 return GNUNET_SYSERR;
420
421 ret =
422 fprintf (outfile,
423 "update trials set endtime=\"%s\", gets_succeeded=%u where trialuid = @temp_trial;\n",
424 get_sql_time (), gets_succeeded);
425 fflush (node_outfile);
426 if (ret >= 0)
427 return GNUNET_OK;
428 else
429 return GNUNET_SYSERR;
430}
431
432
433/*
434 * Update dhttests.nodes table setting the identified
435 * node as a malicious dropper.
436 *
437 * @param peer the peer that was set to be malicious
438 *
439 * @return GNUNET_OK on success, GNUNET_SYSERR on failure.
440 */
441int
442set_malicious (struct GNUNET_PeerIdentity *peer)
443{
444 int ret;
445
446 if (outfile == NULL)
447 return GNUNET_SYSERR;
448
449 ret =
450 fprintf (outfile,
451 "update nodes set malicious_dropper = 1 where trialuid = @temp_trial and nodeid = \"%s\";\n",
452 GNUNET_h2s_full (&peer->hashPubKey));
453 fflush (node_outfile);
454 if (ret >= 0)
455 return GNUNET_OK;
456 else
457 return GNUNET_SYSERR;
458}
459
460
461/*
462 * Update dhttests.trials table with total connections information
463 *
464 * @param totalConnections the number of connections
465 *
466 * @return GNUNET_OK on success, GNUNET_SYSERR on failure.
467 */
468int
469add_connections (unsigned int totalConnections)
470{
471 int ret;
472
473 if (outfile == NULL)
474 return GNUNET_SYSERR;
475
476 ret =
477 fprintf (outfile,
478 "update trials set totalConnections = %u where trialuid = @temp_trial;\n",
479 totalConnections);
480 fflush (node_outfile);
481 if (ret >= 0)
482 return GNUNET_OK;
483 else
484 return GNUNET_SYSERR;
485}
486
487
488/*
489 * Update dhttests.topology table with total connections information
490 *
491 * @param connections the number of connections
492 *
493 * @return GNUNET_OK on success, GNUNET_SYSERR on failure.
494 */
495int
496update_topology (unsigned int connections)
497{
498 int ret;
499
500 if (outfile == NULL)
501 return GNUNET_SYSERR;
502
503 ret =
504 fprintf (outfile,
505 "update topology set connections = %u where topology_uid = @temp_topology;\n",
506 connections);
507 topology_count++;
508 if (ret >= 0)
509 return GNUNET_OK;
510 else
511 return GNUNET_SYSERR;
512}
513
514/*
515 * Inserts the specified query into the dhttests.queries table
516 *
517 * @param sqlqueruid inserted query uid
518 * @param queryid dht query id
519 * @param type type of the query
520 * @param hops number of hops query traveled
521 * @param succeeded whether or not query was successful
522 * @param node the node the query hit
523 * @param key the key of the query
524 *
525 * @return GNUNET_OK on success, GNUNET_SYSERR on failure.
526 */
527int
528add_query (unsigned long long *sqlqueryuid, unsigned long long queryid,
529 unsigned int type, unsigned int hops, int succeeded,
530 const struct GNUNET_PeerIdentity *node, const GNUNET_HashCode * key)
531{
532 int ret;
533
534 if ((outfile == NULL) || (node == NULL) || (key == NULL))
535 return GNUNET_SYSERR;
536
537 if (sqlqueryuid != NULL)
538 *sqlqueryuid = 0;
539
540 ret = fprintf (query_outfile, "TRIALUID\t%s\t", GNUNET_h2s_full (key));
541
542 if (ret < 0)
543 return GNUNET_SYSERR;
544
545 ret =
546 fprintf (query_outfile, "%s\t%llu\t%u\t%u\t%u\t%s\n",
547 GNUNET_h2s_full (&node->hashPubKey), queryid, type, hops,
548 succeeded, get_sql_time ());
549
550 if (ret >= 0)
551 return GNUNET_OK;
552 else
553 return GNUNET_SYSERR;
554}
555
556/*
557 * Inserts the specified route information into the dhttests.routes table
558 *
559 * @param sqlqueruid inserted query uid
560 * @param queryid dht query id
561 * @param type type of the query
562 * @param hops number of hops query traveled
563 * @param succeeded whether or not query was successful
564 * @param node the node the query hit
565 * @param key the key of the query
566 * @param from_node the node that sent the message to node
567 * @param to_node next node to forward message to
568 *
569 * @return GNUNET_OK on success, GNUNET_SYSERR on failure.
570 */
571int
572add_route (unsigned long long *sqlqueryuid, unsigned long long queryid,
573 unsigned int type, unsigned int hops, int succeeded,
574 const struct GNUNET_PeerIdentity *node, const GNUNET_HashCode * key,
575 const struct GNUNET_PeerIdentity *from_node,
576 const struct GNUNET_PeerIdentity *to_node)
577{
578 int ret;
579
580 if ((outfile == NULL) || (node == NULL) || (key == NULL))
581 return GNUNET_SYSERR;
582
583 if (sqlqueryuid != NULL)
584 *sqlqueryuid = 0;
585
586 ret = fprintf (route_outfile, "TRIALUID\t%s\t", GNUNET_h2s_full (key));
587 if (ret < 0)
588 return GNUNET_SYSERR;
589
590 ret = fprintf (route_outfile, "%s\t", GNUNET_h2s_full (&node->hashPubKey));
591 if (ret < 0)
592 return GNUNET_SYSERR;
593 if (from_node == NULL)
594 ret = fprintf (route_outfile, "0\t");
595 else
596 ret =
597 fprintf (route_outfile, "%s\t",
598 GNUNET_h2s_full (&from_node->hashPubKey));
599 if (ret < 0)
600 return GNUNET_SYSERR;
601
602 if (to_node == NULL)
603 ret =
604 fprintf (route_outfile, "0\t%llu\t%u\t%u\t%d\n", queryid, type, hops,
605 succeeded);
606 else
607 ret =
608 fprintf (route_outfile, "%s\t%llu\t%u\t%u\t%d\n",
609 GNUNET_h2s_full (&to_node->hashPubKey), queryid, type, hops,
610 succeeded);
611
612 if (ret >= 0)
613 return GNUNET_OK;
614 else
615 return GNUNET_SYSERR;
616}
617
618/*
619 * Provides the dhtlog api
620 *
621 * @param c the configuration to use to connect to a server
622 *
623 * @return the handle to the server, or NULL on error
624 */
625void *
626libgnunet_plugin_dhtlog_mysql_dump_load_init (void *cls)
627{
628 struct GNUNET_DHTLOG_Plugin *plugin = cls;
629 char *outfile_name;
630 char *outfile_path;
631 char *fn;
632 int dirwarn;
633
634 cfg = plugin->cfg;
635 max_varchar_len = 255;
636
637 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
638 "MySQL (DUMP) DHT Logger: initializing\n");
639
640 if (GNUNET_OK !=
641 GNUNET_CONFIGURATION_get_value_string (plugin->cfg, "MYSQLDUMP", "PATH",
642 &outfile_path))
643 {
644 outfile_path = GNUNET_strdup ("");
645 }
646
647 GNUNET_asprintf (&outfile_name, "%s%s-%d", outfile_path, "mysqldump",
648 getpid ());
649
650 fn = GNUNET_STRINGS_filename_expand (outfile_name);
651
652 if (fn == NULL)
653 {
654 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
655 _("Failed to get full path for `%s'\n"), outfile_name);
656 GNUNET_free (outfile_path);
657 GNUNET_free (outfile_name);
658 return NULL;
659 }
660
661 dirwarn = (GNUNET_OK != GNUNET_DISK_directory_create_for_file (fn));
662 outfile = FOPEN (fn, "w");
663
664 if (outfile == NULL)
665 {
666 GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "fopen", fn);
667 if (dirwarn)
668 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
669 _("Failed to create or access directory for log file `%s'\n"),
670 fn);
671 GNUNET_free (outfile_path);
672 GNUNET_free (outfile_name);
673 GNUNET_free (fn);
674 return NULL;
675 }
676
677 GNUNET_free (outfile_name);
678 GNUNET_asprintf (&outfile_name, "%s%s-%d", outfile_path, "mysqldump_nodes",
679 getpid ());
680 GNUNET_free (fn);
681 fn = GNUNET_STRINGS_filename_expand (outfile_name);
682
683 if (fn == NULL)
684 {
685 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
686 _("Failed to get full path for `%s'\n"), outfile_name);
687 GNUNET_free (outfile_path);
688 GNUNET_free (outfile_name);
689 return NULL;
690 }
691
692 dirwarn = (GNUNET_OK != GNUNET_DISK_directory_create_for_file (fn));
693 node_outfile = FOPEN (fn, "w");
694
695 if (node_outfile == NULL)
696 {
697 GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "fopen", fn);
698 if (dirwarn)
699 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
700 _("Failed to create or access directory for log file `%s'\n"),
701 fn);
702 GNUNET_free (outfile_path);
703 GNUNET_free (outfile_name);
704 GNUNET_free (fn);
705 return NULL;
706 }
707
708 GNUNET_free (outfile_name);
709 GNUNET_asprintf (&outfile_name, "%s%s-%d", outfile_path, "mysqldump_routes",
710 getpid ());
711
712 GNUNET_free (fn);
713 fn = GNUNET_STRINGS_filename_expand (outfile_name);
714
715 if (fn == NULL)
716 {
717 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
718 _("Failed to get full path for `%s'\n"), outfile_name);
719 GNUNET_free (outfile_path);
720 GNUNET_free (outfile_name);
721 return NULL;
722 }
723
724 dirwarn = (GNUNET_OK != GNUNET_DISK_directory_create_for_file (fn));
725 route_outfile = FOPEN (fn, "w");
726
727 if (route_outfile == NULL)
728 {
729 GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "fopen", fn);
730 if (dirwarn)
731 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
732 _("Failed to create or access directory for log file `%s'\n"),
733 fn);
734 GNUNET_free (outfile_path);
735 GNUNET_free (outfile_name);
736 GNUNET_free (fn);
737 return NULL;
738 }
739
740 GNUNET_free (outfile_name);
741 GNUNET_asprintf (&outfile_name, "%s%s-%d", outfile_path, "mysqldump_queries",
742 getpid ());
743
744 GNUNET_free (fn);
745 fn = GNUNET_STRINGS_filename_expand (outfile_name);
746
747 if (fn == NULL)
748 {
749 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
750 _("Failed to get full path for `%s'\n"), outfile_name);
751 GNUNET_free (outfile_path);
752 GNUNET_free (outfile_name);
753 return NULL;
754 }
755
756 dirwarn = (GNUNET_OK != GNUNET_DISK_directory_create_for_file (fn));
757 query_outfile = FOPEN (fn, "w");
758
759 if (query_outfile == NULL)
760 {
761 GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "fopen", fn);
762 if (dirwarn)
763 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
764 _("Failed to create or access directory for log file `%s'\n"),
765 fn);
766 GNUNET_free (outfile_path);
767 GNUNET_free (outfile_name);
768 GNUNET_free (fn);
769 return NULL;
770 }
771
772 GNUNET_free (outfile_name);
773 GNUNET_asprintf (&outfile_name, "%s%s-%d", outfile_path, "mysqldump_stats",
774 getpid ());
775
776 GNUNET_free (fn);
777 fn = GNUNET_STRINGS_filename_expand (outfile_name);
778
779 if (fn == NULL)
780 {
781 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
782 _("Failed to get full path for `%s'\n"), outfile_name);
783 GNUNET_free (outfile_path);
784 GNUNET_free (outfile_name);
785 return NULL;
786 }
787
788 dirwarn = (GNUNET_OK != GNUNET_DISK_directory_create_for_file (fn));
789 stat_outfile = FOPEN (fn, "w");
790
791 if (stat_outfile == NULL)
792 {
793 GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "fopen", fn);
794 if (dirwarn)
795 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
796 _("Failed to create or access directory for log file `%s'\n"),
797 fn);
798 GNUNET_free (outfile_path);
799 GNUNET_free (outfile_name);
800 GNUNET_free (fn);
801 return NULL;
802 }
803
804 GNUNET_free (outfile_name);
805 GNUNET_asprintf (&outfile_name, "%s%s-%d", outfile_path,
806 "mysqldump_generic_stats", getpid ());
807 GNUNET_free (fn);
808 fn = GNUNET_STRINGS_filename_expand (outfile_name);
809
810 if (fn == NULL)
811 {
812 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
813 _("Failed to get full path for `%s'\n"), outfile_name);
814 GNUNET_free (outfile_path);
815 GNUNET_free (outfile_name);
816 return NULL;
817 }
818
819 dirwarn = (GNUNET_OK != GNUNET_DISK_directory_create_for_file (fn));
820 generic_stat_outfile = FOPEN (fn, "w");
821
822 if (generic_stat_outfile == NULL)
823 {
824 GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "fopen", fn);
825 if (dirwarn)
826 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
827 _("Failed to create or access directory for log file `%s'\n"),
828 fn);
829 GNUNET_free (outfile_path);
830 GNUNET_free (outfile_name);
831 GNUNET_free (fn);
832 return NULL;
833 }
834
835 GNUNET_free (outfile_name);
836 GNUNET_asprintf (&outfile_name, "%s%s-%d", outfile_path, "mysqldump_dhtkey",
837 getpid ());
838 GNUNET_free (fn);
839 fn = GNUNET_STRINGS_filename_expand (outfile_name);
840
841 if (fn == NULL)
842 {
843 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
844 _("Failed to get full path for `%s'\n"), outfile_name);
845 GNUNET_free (outfile_path);
846 GNUNET_free (outfile_name);
847 return NULL;
848 }
849
850 dirwarn = (GNUNET_OK != GNUNET_DISK_directory_create_for_file (fn));
851 dhtkey_outfile = FOPEN (fn, "w");
852
853 if (dhtkey_outfile == NULL)
854 {
855 GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "fopen", fn);
856 if (dirwarn)
857 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
858 _("Failed to create or access directory for log file `%s'\n"),
859 fn);
860 GNUNET_free (outfile_path);
861 GNUNET_free (outfile_name);
862 GNUNET_free (fn);
863 return NULL;
864 }
865
866 GNUNET_free (outfile_name);
867 GNUNET_asprintf (&outfile_name, "%s%s-%d", outfile_path,
868 "mysqldump_extended_topology", getpid ());
869 GNUNET_free (fn);
870 fn = GNUNET_STRINGS_filename_expand (outfile_name);
871
872 if (fn == NULL)
873 {
874 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
875 _("Failed to get full path for `%s'\n"), outfile_name);
876 GNUNET_free (outfile_path);
877 GNUNET_free (outfile_name);
878 return NULL;
879 }
880
881 dirwarn = (GNUNET_OK != GNUNET_DISK_directory_create_for_file (fn));
882 extended_topology_outfile = FOPEN (fn, "w");
883
884 if (extended_topology_outfile == NULL)
885 {
886 GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "fopen", fn);
887 if (dirwarn)
888 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
889 _("Failed to create or access directory for log file `%s'\n"),
890 fn);
891 GNUNET_free (outfile_path);
892 GNUNET_free (outfile_name);
893 GNUNET_free (fn);
894 return NULL;
895 }
896
897 GNUNET_free (outfile_path);
898 GNUNET_free (outfile_name);
899 GNUNET_free (fn);
900
901 GNUNET_assert (plugin->dhtlog_api == NULL);
902 plugin->dhtlog_api = GNUNET_malloc (sizeof (struct GNUNET_DHTLOG_Handle));
903 plugin->dhtlog_api->insert_trial = &add_trial;
904 plugin->dhtlog_api->insert_stat = &add_stat;
905 plugin->dhtlog_api->insert_round = &add_round;
906 plugin->dhtlog_api->insert_round_details = &add_round_details;
907 plugin->dhtlog_api->insert_query = &add_query;
908 plugin->dhtlog_api->update_trial = &update_trials;
909 plugin->dhtlog_api->insert_route = &add_route;
910 plugin->dhtlog_api->insert_node = &add_node;
911 plugin->dhtlog_api->insert_dhtkey = &add_dhtkey;
912 plugin->dhtlog_api->update_connections = &add_connections;
913 plugin->dhtlog_api->insert_topology = &add_topology;
914 plugin->dhtlog_api->insert_extended_topology = &add_extended_topology;
915 plugin->dhtlog_api->update_topology = &update_topology;
916 plugin->dhtlog_api->set_malicious = &set_malicious;
917 plugin->dhtlog_api->add_generic_stat = &add_generic_stat;
918
919 return plugin;
920}
921
922/**
923 * Shutdown the plugin.
924 */
925void *
926libgnunet_plugin_dhtlog_mysql_dump_load_done (void *cls)
927{
928 struct GNUNET_DHTLOG_Handle *dhtlog_api = cls;
929
930 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MySQL DHT Logger: database shutdown\n");
931 GNUNET_assert (dhtlog_api != NULL);
932
933 fclose (outfile);
934 fclose (node_outfile);
935 fclose (query_outfile);
936 fclose (route_outfile);
937 fclose (stat_outfile);
938 fclose (generic_stat_outfile);
939 fclose (extended_topology_outfile);
940 GNUNET_free (dhtlog_api);
941 return NULL;
942}
943
944/* end of plugin_dhtlog_mysql_dump_load.c */
diff --git a/src/dht/test_dhtlog.c b/src/dht/test_dhtlog.c
deleted file mode 100644
index 89ec97d6c..000000000
--- a/src/dht/test_dhtlog.c
+++ /dev/null
@@ -1,256 +0,0 @@
1/*
2 This file is part of GNUnet.
3 (C) 2006, 2009 Christian Grothoff (and other contributing authors)
4
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 2, or (at your
8 option) any later version.
9
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
19*/
20/*
21 * @file src/dht/test_dhtlog.c
22 * @brief Test of the dhtlog service
23 * @author Nathan Evans
24 */
25
26#include "platform.h"
27#include "gnunet_util_lib.h"
28#include "gnunet_protocols.h"
29#include "dhtlog.h"
30
31#define VERBOSE GNUNET_NO
32
33static int ok;
34
35#define CHECK(a) if (a != GNUNET_OK) return a
36/**
37 * Actual test of the service operations
38 */
39static int
40test (struct GNUNET_DHTLOG_Handle *api)
41{
42 struct GNUNET_PeerIdentity p1;
43 struct GNUNET_PeerIdentity p2;
44 struct GNUNET_PeerIdentity p3;
45 struct GNUNET_PeerIdentity p4;
46 struct GNUNET_DHTLOG_TrialInfo trial_info;
47 GNUNET_HashCode k1;
48 GNUNET_HashCode k2;
49 int ret;
50 unsigned int i = 42;
51 unsigned long long sqlqueryuid;
52 unsigned long long sqlrouteuid = 0;
53 unsigned long long nodeuid = 0;
54 unsigned long long internaluid = 1010223344LL;
55 unsigned long long dhtkeyuid = 0;
56
57 memset (&p1.hashPubKey, 3, sizeof (GNUNET_HashCode));
58 memset (&p2.hashPubKey, 4, sizeof (GNUNET_HashCode));
59 memset (&p3.hashPubKey, 5, sizeof (GNUNET_HashCode));
60 memset (&p4.hashPubKey, 6, sizeof (GNUNET_HashCode));
61
62 memset (&k1, 0, sizeof (GNUNET_HashCode));
63 memset (&k2, 1, sizeof (GNUNET_HashCode));
64 memset (&trial_info, 0, sizeof (struct GNUNET_DHTLOG_TrialInfo));
65 trial_info.other_identifier = 777;
66 trial_info.num_nodes = i;
67 trial_info.topology = 5;
68 trial_info.blacklist_topology = 4;
69 trial_info.connect_topology = 3;
70 trial_info.connect_topology_option = 2;
71 trial_info.connect_topology_option_modifier = .75;
72 trial_info.topology_percentage = .25;
73 trial_info.topology_probability = .5;
74 trial_info.puts = 42;
75 trial_info.gets = 14;
76 trial_info.concurrent = 5;
77 trial_info.settle_time = 1;
78 trial_info.num_rounds = 12;
79 trial_info.malicious_getters = 0;
80 trial_info.malicious_putters = 0;
81 trial_info.malicious_droppers = 0;
82 trial_info.malicious_get_frequency = 1;
83 trial_info.malicious_put_frequency = 0;
84 trial_info.stop_closest = 1;
85 trial_info.stop_found = 0;
86 trial_info.strict_kademlia = 1;
87 trial_info.message = GNUNET_strdup ("TEST INSERT_TRIAL");
88 ret = api->insert_trial (&trial_info);
89 GNUNET_free (trial_info.message);
90 CHECK (ret);
91#if VERBOSE
92 fprintf (stderr, "Insert trial succeeded!\n");
93#endif
94 ret = api->insert_topology (500);
95 CHECK (ret);
96#if VERBOSE
97 fprintf (stderr, "Insert topology succeeded!\n");
98#endif
99 ret = api->insert_node (&nodeuid, &p1);
100 CHECK (ret);
101 ret = api->insert_node (&nodeuid, &p2);
102 CHECK (ret);
103 ret = api->insert_node (&nodeuid, &p3);
104 CHECK (ret);
105 ret = api->insert_node (&nodeuid, &p4);
106 CHECK (ret);
107#if VERBOSE
108 fprintf (stderr, "Insert node succeeded!\n");
109#endif
110 ret = api->set_malicious (&p1);
111 CHECK (ret);
112#if VERBOSE
113 fprintf (stderr, "Set malicious succeeded!\n");
114#endif
115 ret = api->insert_topology (0);
116 CHECK (ret);
117#if VERBOSE
118 fprintf (stderr, "Insert topology succeeded!\n");
119#endif
120 ret = api->insert_extended_topology (&p1, &p2);
121 CHECK (ret);
122 ret = api->insert_extended_topology (&p3, &p4);
123 CHECK (ret);
124#if VERBOSE
125 fprintf (stderr, "Insert extended topology succeeded!\n");
126#endif
127 ret = api->update_topology (101);
128 CHECK (ret);
129#if VERBOSE
130 fprintf (stderr, "Update topology succeeded!\n");
131#endif
132 ret = api->insert_dhtkey (&dhtkeyuid, &k1);
133 CHECK (ret);
134 ret = api->insert_dhtkey (&dhtkeyuid, &k2);
135 CHECK (ret);
136#if VERBOSE
137 fprintf (stderr, "Insert dhtkey succeeded!\n");
138#endif
139 ret = api->insert_query (&sqlqueryuid, internaluid, 2, 4, 0, &p2, &k1);
140 CHECK (ret);
141#if VERBOSE
142 fprintf (stderr, "Insert query succeeded!\n");
143#endif
144 ret =
145 api->insert_route (&sqlrouteuid, sqlqueryuid, 1, 1, DHTLOG_GET, &p1, &k2,
146 &p4, &p3);
147 CHECK (ret);
148 ret =
149 api->insert_route (&sqlrouteuid, sqlqueryuid, 2, 0, DHTLOG_PUT, &p3, &k1,
150 &p4, &p2);
151 CHECK (ret);
152 ret =
153 api->insert_route (&sqlrouteuid, sqlqueryuid, 3, 1, DHTLOG_ROUTE, &p3,
154 &k2, &p2, NULL);
155 CHECK (ret);
156 ret =
157 api->insert_route (&sqlrouteuid, sqlqueryuid, 4, 7, DHTLOG_ROUTE, &p3,
158 &k2, NULL, NULL);
159 CHECK (ret);
160#if VERBOSE
161 fprintf (stderr, "Insert route succeeded!\n");
162#endif
163 sleep (1);
164 ret =
165 api->insert_stat (&p1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
166 17);
167 CHECK (ret);
168 ret =
169 api->insert_stat (&p2, 12, 23, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
170 25, 26, 27);
171 CHECK (ret);
172#if VERBOSE
173 fprintf (stderr, "Insert stat succeeded!\n");
174#endif
175 ret = api->update_trial (787);
176 CHECK (ret);
177#if VERBOSE
178 fprintf (stderr, "Update trial succeeded!\n");
179#endif
180 ret = api->add_generic_stat (&p2, "nonsense", "section", 77765);
181 CHECK (ret);
182#if VERBOSE
183 fprintf (stderr, "Insert generic stat succeeded!\n");
184#endif
185 ret = api->insert_round (401, 507);
186 CHECK (ret);
187 ret = api->insert_round_details (402, 507, 1123, 985);
188 CHECK (ret);
189#if VERBOSE
190 fprintf (stderr, "Insert round succeeded!\n");
191#endif
192 return 0;
193}
194
195
196
197static void
198run (void *cls, char *const *args, const char *cfgfile,
199 const struct GNUNET_CONFIGURATION_Handle *cfg)
200{
201 struct GNUNET_DHTLOG_Handle *api;
202
203 ok = 0;
204 api = GNUNET_DHTLOG_connect (cfg);
205
206 if (api == NULL)
207 {
208 ok = 1;
209 return;
210 }
211 ok = test (api);
212
213 GNUNET_DHTLOG_disconnect (api);
214}
215
216
217static int
218check ()
219{
220 char *const argv[] = { "test-dhtlog-api",
221 "-c",
222 "test_dhtlog_data.conf",
223#if VERBOSE
224 "-L", "DEBUG",
225#endif
226 NULL
227 };
228 struct GNUNET_GETOPT_CommandLineOption options[] = {
229 GNUNET_GETOPT_OPTION_END
230 };
231 GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,
232 "test-dhtlog-api", "nohelp", options, &run, NULL);
233 if (ok != 0)
234 fprintf (stderr, "Test failed with error code: %d\n", ok);
235 return ok;
236}
237
238
239int
240main (int argc, char *argv[])
241{
242 int ret;
243
244 GNUNET_log_setup ("test-datacache-api",
245#if VERBOSE
246 "DEBUG",
247#else
248 "WARNING",
249#endif
250 NULL);
251 ret = check ();
252
253 return ret;
254}
255
256/* end of test_dhtlog.c */