mirror
/
opentracker
mirror of git://erdgeist.org/opentracker
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add a stat option the count bucket stalls

Browse Source 
Add an iterator for all torrents. It's slower but for stats it's okay.
Move some stats collection stuff to the new iterator. More to come.
Start a "report all stats" page.
Start fixing the code to identify "busy" networks.
Add the concept of hosts allowed to proxy.
Add a parser for the X-Forwarded-For: HTTP header.
Clean up HTTP Header handling code. (Remove some left overs of now vanished sync code).
dynamic-accesslists
erdgeist 16 years ago
parent 72a1564ca1
commit 9297967f85
9 changed files with 252 additions and 177 deletions
Show Stats Download Patch File Download Diff File

11
opentracker.c
Unescape Escape View File

@ -135,12 +135,10 @@ static ssize_t handle_read( const int64 sock, struct ot_workstruct *ws ) {
array_catb( &cookie->data.request, ws->inbuf, byte_count ); array_catb( &cookie->data.request, ws->inbuf, byte_count );
if( array_failed( &cookie->data.request ) ) if( array_failed( &cookie->data.request ) ||
array_bytes( &cookie->data.request ) > 8192 )
return http_issue_error( sock, ws, CODE_HTTPERROR_500 ); return http_issue_error( sock, ws, CODE_HTTPERROR_500 );
if( array_bytes( &cookie->data.request ) > 8192 )
return http_issue_error( sock, ws, CODE_HTTPERROR_500 );
if( !memchr( array_start( &cookie->data.request ), '\n', array_bytes( &cookie->data.request ) ) ) if( !memchr( array_start( &cookie->data.request ), '\n', array_bytes( &cookie->data.request ) ) )
return 0; return 0;
@ -369,6 +367,11 @@ int parse_configfile( char * config_filename ) {
} else if(!byte_diff(p, 12, "access.stats" ) && isspace(p[12])) { } else if(!byte_diff(p, 12, "access.stats" ) && isspace(p[12])) {
if( !scan_ip6( p+13, tmpip )) goto parse_error; if( !scan_ip6( p+13, tmpip )) goto parse_error;
accesslist_blessip( tmpip, OT_PERMISSION_MAY_STAT ); accesslist_blessip( tmpip, OT_PERMISSION_MAY_STAT );
#endif
#ifdef WANT_IP_FROM_PROXY
} else if(!byte_diff(p, 12, "access.proxy" ) && isspace(p[12])) {
if( !scan_ip6( p+13, tmpip )) goto parse_error;
accesslist_blessip( tmpip, OT_PERMISSION_MAY_PROXY );
#endif #endif
} else if(!byte_diff(p, 20, "tracker.redirect_url" ) && isspace(p[20])) { } else if(!byte_diff(p, 20, "tracker.redirect_url" ) && isspace(p[20])) {
set_config_option( &g_redirecturl, p+21 ); set_config_option( &g_redirecturl, p+21 );

1
ot_accesslist.c
Unescape Escape View File

@ -124,6 +124,7 @@ int accesslist_blessip( ot_ip6 ip, ot_permissions permissions ) {
if( permissions & OT_PERMISSION_MAY_STAT ) off += snprintf( _debug+off, 512-off, " may_fetch_stats" ); if( permissions & OT_PERMISSION_MAY_STAT ) off += snprintf( _debug+off, 512-off, " may_fetch_stats" );
if( permissions & OT_PERMISSION_MAY_LIVESYNC ) off += snprintf( _debug+off, 512-off, " may_sync_live" ); if( permissions & OT_PERMISSION_MAY_LIVESYNC ) off += snprintf( _debug+off, 512-off, " may_sync_live" );
if( permissions & OT_PERMISSION_MAY_FULLSCRAPE ) off += snprintf( _debug+off, 512-off, " may_fetch_fullscrapes" ); if( permissions & OT_PERMISSION_MAY_FULLSCRAPE ) off += snprintf( _debug+off, 512-off, " may_fetch_fullscrapes" );
if( permissions & OT_PERMISSION_MAY_PROXY ) off += snprintf( _debug+off, 512-off, " may_proxy" );
if( !permissions ) off += snprintf( _debug+off, sizeof(_debug)-off, " nothing\n" ); if( !permissions ) off += snprintf( _debug+off, sizeof(_debug)-off, " nothing\n" );
_debug[off++] = '.'; _debug[off++] = '.';
write( 2, _debug, off ); write( 2, _debug, off );

3
ot_accesslist.h
Unescape Escape View File

@ -27,7 +27,8 @@ extern char *g_accesslist_filename;
typedef enum { typedef enum {
OT_PERMISSION_MAY_FULLSCRAPE = 0x1, OT_PERMISSION_MAY_FULLSCRAPE = 0x1,
OT_PERMISSION_MAY_STAT = 0x2, OT_PERMISSION_MAY_STAT = 0x2,
OT_PERMISSION_MAY_LIVESYNC = 0x4 OT_PERMISSION_MAY_LIVESYNC = 0x4,
OT_PERMISSION_MAY_PROXY = 0x8
} ot_permissions; } ot_permissions;
int accesslist_blessip( ot_ip6 ip, ot_permissions permissions ); int accesslist_blessip( ot_ip6 ip, ot_permissions permissions );

43
ot_http.c
Unescape Escape View File

@ -306,13 +306,14 @@ static ot_keywords keywords_announce[] = { { "port", 1 }, { "left", 2 }, { "even
{ NULL, -3 } }; { NULL, -3 } };
static ot_keywords keywords_announce_event[] = { { "completed", 1 }, { "stopped", 2 }, { NULL, -3 } }; static ot_keywords keywords_announce_event[] = { { "completed", 1 }, { "stopped", 2 }, { NULL, -3 } };
static ssize_t http_handle_announce( const int64 sock, struct ot_workstruct *ws, char *read_ptr ) { static ssize_t http_handle_announce( const int64 sock, struct ot_workstruct *ws, char *read_ptr ) {
int numwant, tmp, scanon; int numwant, tmp, scanon;
ot_peer peer; ot_peer peer;
ot_hash *hash = NULL; ot_hash *hash = NULL;
unsigned short port = htons(6881); unsigned short port = htons(6881);
char *write_ptr; char *write_ptr;
ssize_t len; ssize_t len;
struct http_data *cookie = io_getcookie( sock );
/* This is to hack around stupid clients that send "announce ?info_hash" */ /* This is to hack around stupid clients that send "announce ?info_hash" */
if( read_ptr[-1] != '?' ) { if( read_ptr[-1] != '?' ) {
while( ( *read_ptr != '?' ) && ( *read_ptr != '\n' ) ) ++read_ptr; while( ( *read_ptr != '?' ) && ( *read_ptr != '\n' ) ) ++read_ptr;
@ -320,7 +321,33 @@ static ssize_t http_handle_announce( const int64 sock, struct ot_workstruct *ws,
++read_ptr; ++read_ptr;
} }
OT_SETIP( &peer, ((struct http_data*)io_getcookie( sock ) )->ip ); #ifdef WANT_IP_FROM_PROXY
if( accesslist_isblessed( cookie->ip, OT_PERMISSION_MAY_PROXY ) ) {
ot_ip6 proxied_ip;
char *fwd, *fwd_new = ws->request;
/* Zero terminate for string routines. Normally we'd only overwrite bollocks */
ws->request[ws->request_size-1] = 0;
/* Find last occurence of the forwarded header */
do {
fwd = fwd_new;
fwd_new = strcasestr( fwd_new, "\nX-Forwarded-For:" );
} while( fwd_new );
/* Skip spaces between : and the ip address */
if( fwd ) {
fwd += 18; /* sizeof( "\nX-Forwarded-For:" ) */
while( *fwd == ' ' ) ++fwd;
}
if( fwd && scan_ip6( fwd, proxied_ip ) )
OT_SETIP( &peer, proxied_ip );
else
OT_SETIP( &peer, cookie->ip );
}
#endif
OT_SETIP( &peer, cookie->ip );
OT_SETPORT( &peer, &port ); OT_SETPORT( &peer, &port );
OT_PEERFLAG( &peer ) = 0; OT_PEERFLAG( &peer ) = 0;
numwant = 50; numwant = 50;

5
ot_mutex.c
Unescape Escape View File

@ -18,6 +18,7 @@
/* Opentracker */ /* Opentracker */
#include "trackerlogic.h" #include "trackerlogic.h"
#include "ot_mutex.h" #include "ot_mutex.h"
#include "ot_stats.h"
/* #define MTX_DBG( STRING ) fprintf( stderr, STRING ) */ /* #define MTX_DBG( STRING ) fprintf( stderr, STRING ) */
#define MTX_DBG( STRING ) #define MTX_DBG( STRING )
@ -47,8 +48,10 @@ static int bucket_check( int bucket ) {
/* See, if bucket is already locked */ /* See, if bucket is already locked */
for( i=0; i<bucket_locklist_count; ++i ) for( i=0; i<bucket_locklist_count; ++i )
if( bucket_locklist[ i ] == bucket ) if( bucket_locklist[ i ] == bucket ) {
stats_issue_event( EVENT_BUCKET_LOCKED, 0, 0 );
return -1; return -1;
}
return 0; return 0;
} }

341
ot_stats.c
Unescape Escape View File

@ -1,7 +1,7 @@
/* This software was written by Dirk Engling <erdgeist@erdgeist.org> /* This software was written by Dirk Engling <erdgeist@erdgeist.org>
It is considered beerware. Prost. Skol. Cheers or whatever. It is considered beerware. Prost. Skol. Cheers or whatever.
$id$ */ $id$ */
/* System */ /* System */
#include <stdlib.h> #include <stdlib.h>
@ -50,12 +50,13 @@ static unsigned long long ot_full_scrape_size = 0;
static unsigned long long ot_failed_request_counts[CODE_HTTPERROR_COUNT]; static unsigned long long ot_failed_request_counts[CODE_HTTPERROR_COUNT];
static unsigned long long ot_renewed[OT_PEER_TIMEOUT]; static unsigned long long ot_renewed[OT_PEER_TIMEOUT];
static unsigned long long ot_overall_sync_count; static unsigned long long ot_overall_sync_count;
static unsigned long long ot_overall_stall_count;
static time_t ot_start_time; static time_t ot_start_time;
#ifdef WANT_LOG_NETWORKS #ifdef WANT_LOG_NETWORKS
#define STATS_NETWORK_NODE_BITWIDTH 8 #define STATS_NETWORK_NODE_BITWIDTH 8
#define STATS_NETWORK_NODE_MAXDEPTH 3 #define STATS_NETWORK_NODE_MAXDEPTH 16
#define STATS_NETWORK_NODE_BITMASK ((1<<STATS_NETWORK_NODE_BITWIDTH)-1) #define STATS_NETWORK_NODE_BITMASK ((1<<STATS_NETWORK_NODE_BITWIDTH)-1)
#define STATS_NETWORK_NODE_COUNT (1<<STATS_NETWORK_NODE_BITWIDTH) #define STATS_NETWORK_NODE_COUNT (1<<STATS_NETWORK_NODE_BITWIDTH)
@ -68,19 +69,20 @@ union stats_network_node {
static stats_network_node *stats_network_counters_root = NULL; static stats_network_node *stats_network_counters_root = NULL;
static int stat_increase_network_count( stats_network_node **node, int depth, uint32_t ip ) { static int stat_increase_network_count( stats_network_node **node, int depth, uintptr_t ip ) {
int foo = ( ip >> ( 32 - STATS_NETWORK_NODE_BITWIDTH * ( ++depth ) ) ) & STATS_NETWORK_NODE_BITMASK; ot_ip6 *_ip = (ot_ip6*)ip;
int foo = (*_ip)[depth];
if( !*node ) { if( !*node ) {
*node = malloc( sizeof( stats_network_node ) ); *node = malloc( sizeof( stats_network_node ) );
if( !*node ) if( !*node )
return -1; return -1;
memset( *node, 0, sizeof( stats_network_node ) ); memset( *node, 0, sizeof( stats_network_node ) );
} }
if( depth < STATS_NETWORK_NODE_MAXDEPTH ) if( depth < STATS_NETWORK_NODE_MAXDEPTH )
return stat_increase_network_count( &(*node)->children[ foo ], depth, ip ); return stat_increase_network_count( &(*node)->children[ foo ], depth, ip );
(*node)->counters[ foo ]++; (*node)->counters[ foo ]++;
return 0; return 0;
} }
@ -88,40 +90,40 @@ static int stat_increase_network_count( stats_network_node **node, int depth, ui
static int stats_shift_down_network_count( stats_network_node **node, int depth, int shift ) { static int stats_shift_down_network_count( stats_network_node **node, int depth, int shift ) {
int i, rest = 0; int i, rest = 0;
if( !*node ) return 0; if( !*node ) return 0;
if( ++depth == STATS_NETWORK_NODE_MAXDEPTH ) if( ++depth == STATS_NETWORK_NODE_MAXDEPTH )
for( i=0; i<STATS_NETWORK_NODE_COUNT; ++i ) { for( i=0; i<STATS_NETWORK_NODE_COUNT; ++i ) {
rest += ((*node)->counters[i]>>=shift); rest += ((*node)->counters[i]>>=shift);
return rest; return rest;
} }
for( i=0; i<STATS_NETWORK_NODE_COUNT; ++i ) { for( i=0; i<STATS_NETWORK_NODE_COUNT; ++i ) {
stats_network_node **childnode = &(*node)->children[i]; stats_network_node **childnode = &(*node)->children[i];
int rest_val; int rest_val;
if( !*childnode ) continue; if( !*childnode ) continue;
rest += rest_val = stats_shift_down_network_count( childnode, depth, shift ); rest += rest_val = stats_shift_down_network_count( childnode, depth, shift );
if( rest_val ) continue; if( rest_val ) continue;
free( (*node)->children[i] ); free( (*node)->children[i] );
(*node)->children[i] = NULL; (*node)->children[i] = NULL;
} }
return rest; return rest;
} }
static void stats_get_highscore_networks( stats_network_node *node, int depth, uint32_t node_value, int *scores, uint32_t *networks, int network_count ) { static void stats_get_highscore_networks( stats_network_node *node, int depth, uint32_t node_value, int *scores, uint32_t *networks, int network_count ) {
int i; int i;
if( !node ) return; if( !node ) return;
if( !depth++ ) { if( !depth++ ) {
memset( scores, 0, sizeof( *scores ) * network_count ); memset( scores, 0, sizeof( *scores ) * network_count );
memset( networks, 0, sizeof( *networks ) * network_count ); memset( networks, 0, sizeof( *networks ) * network_count );
} }
if( depth < STATS_NETWORK_NODE_MAXDEPTH ) { if( depth < STATS_NETWORK_NODE_MAXDEPTH ) {
for( i=0; i<STATS_NETWORK_NODE_COUNT; ++i ) for( i=0; i<STATS_NETWORK_NODE_COUNT; ++i )
if( node->children[i] ) if( node->children[i] )
@ -130,15 +132,15 @@ static void stats_get_highscore_networks( stats_network_node *node, int depth, u
for( i=0; i<STATS_NETWORK_NODE_COUNT; ++i ) { for( i=0; i<STATS_NETWORK_NODE_COUNT; ++i ) {
int j=1; int j=1;
if( node->counters[i] <= scores[0] ) continue; if( node->counters[i] <= scores[0] ) continue;
while( (j<network_count) && (node->counters[i]>scores[j] ) ) ++j; while( (j<network_count) && (node->counters[i]>scores[j] ) ) ++j;
--j; --j;
memcpy( scores, scores + 1, j * sizeof( *scores ) ); memcpy( scores, scores + 1, j * sizeof( *scores ) );
memcpy( networks, networks + 1, j * sizeof( *networks ) ); memcpy( networks, networks + 1, j * sizeof( *networks ) );
scores[ j ] = node->counters[ i ]; scores[ j ] = node->counters[ i ];
networks[ j ] = node_value | ( i << ( 32 - depth * STATS_NETWORK_NODE_BITWIDTH ) ); networks[ j ] = node_value | ( i << ( 32 - depth * STATS_NETWORK_NODE_BITWIDTH ) );
} }
} }
static size_t stats_return_busy_networks( char * reply ) { static size_t stats_return_busy_networks( char * reply ) {
@ -146,17 +148,31 @@ static size_t stats_return_busy_networks( char * reply ) {
int scores[16]; int scores[16];
int i; int i;
char * r = reply; char * r = reply;
stats_get_highscore_networks( stats_network_counters_root, 0, 0, scores, networks, 16 ); stats_get_highscore_networks( stats_network_counters_root, 0, 0, scores, networks, 16 );
for( i=15; i>=0; --i) for( i=15; i>=0; --i)
r += sprintf( r, "%08i: %d.%d.%d.0/24\n", scores[i], (networks[i]>>24)&0xff, (networks[i]>>16)&0xff, (networks[i]>>8)&0xff ); r += sprintf( r, "%08i: %d.%d.%d.0/24\n", scores[i], (networks[i]>>24)&0xff, (networks[i]>>16)&0xff, (networks[i]>>8)&0xff );
return r - reply; return r - reply;
} }
#endif #endif
typedef struct {
unsigned long long torrent_count;
unsigned long long peer_count;
unsigned long long seed_count;
} torrent_stats;
static int torrent_statter( ot_torrent *torrent, uintptr_t data ) {
torrent_stats *stats = (torrent_stats*)data;
stats->torrent_count++;
stats->peer_count += torrent->peer_list->peer_count;
stats->seed_count += torrent->peer_list->seed_count;
return 0;
}
/* Converter function from memory to human readable hex strings */ /* Converter function from memory to human readable hex strings */
static char*to_hex(char*d,uint8_t*s){char*m="0123456789ABCDEF";char *t=d;char*e=d+40;while(d<e){*d++=m[*s>>4];*d++=m[*s++&15];}*d=0;return t;} static char*to_hex(char*d,uint8_t*s){char*m="0123456789ABCDEF";char *t=d;char*e=d+40;while(d<e){*d++=m[*s>>4];*d++=m[*s++&15];}*d=0;return t;}
@ -168,10 +184,10 @@ size_t stats_top10_txt( char * reply ) {
ot_record top10s[10], top10c[10]; ot_record top10s[10], top10c[10];
char *r = reply, hex_out[42]; char *r = reply, hex_out[42];
int idx, bucket; int idx, bucket;
byte_zero( top10s, sizeof( top10s ) ); byte_zero( top10s, sizeof( top10s ) );
byte_zero( top10c, sizeof( top10c ) ); byte_zero( top10c, sizeof( top10c ) );
for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) { for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) {
ot_vector *torrents_list = mutex_bucket_lock( bucket ); ot_vector *torrents_list = mutex_bucket_lock( bucket );
for( j=0; j<torrents_list->size; ++j ) { for( j=0; j<torrents_list->size; ++j ) {
@ -193,7 +209,7 @@ size_t stats_top10_txt( char * reply ) {
if( !g_opentracker_running ) if( !g_opentracker_running )
return 0; return 0;
} }
r += sprintf( r, "Top 10 torrents by peers:\n" ); r += sprintf( r, "Top 10 torrents by peers:\n" );
for( idx=0; idx<10; ++idx ) for( idx=0; idx<10; ++idx )
if( top10c[idx].torrent ) if( top10c[idx].torrent )
@ -202,31 +218,31 @@ size_t stats_top10_txt( char * reply ) {
for( idx=0; idx<10; ++idx ) for( idx=0; idx<10; ++idx )
if( top10s[idx].torrent ) if( top10s[idx].torrent )
r += sprintf( r, "\t%zd\t%s\n", top10s[idx].val, to_hex( hex_out, top10s[idx].torrent->hash) ); r += sprintf( r, "\t%zd\t%s\n", top10s[idx].val, to_hex( hex_out, top10s[idx].torrent->hash) );
return r - reply; return r - reply;
} }
/* This function collects 4096 /24s in 4096 possible /* This function collects 4096 /24s in 4096 possible
malloc blocks malloc blocks
*/ */
static size_t stats_slash24s_txt( char * reply, size_t amount, uint32_t thresh ) { static size_t stats_slash24s_txt( char * reply, size_t amount, uint32_t thresh ) {
#define NUM_TOPBITS 12 #define NUM_TOPBITS 12
#define NUM_LOWBITS (24-NUM_TOPBITS) #define NUM_LOWBITS (24-NUM_TOPBITS)
#define NUM_BUFS (1<<NUM_TOPBITS) #define NUM_BUFS (1<<NUM_TOPBITS)
#define NUM_S24S (1<<NUM_LOWBITS) #define NUM_S24S (1<<NUM_LOWBITS)
#define MSK_S24S (NUM_S24S-1) #define MSK_S24S (NUM_S24S-1)
uint32_t *counts[ NUM_BUFS ]; uint32_t *counts[ NUM_BUFS ];
uint32_t slash24s[amount*2]; /* first dword amount, second dword subnet */ uint32_t slash24s[amount*2]; /* first dword amount, second dword subnet */
size_t i, j, k, l; size_t i, j, k, l;
char *r = reply; char *r = reply;
byte_zero( counts, sizeof( counts ) ); byte_zero( counts, sizeof( counts ) );
byte_zero( slash24s, amount * 2 * sizeof(uint32_t) ); byte_zero( slash24s, amount * 2 * sizeof(uint32_t) );
r += sprintf( r, "Stats for all /24s with more than %u announced torrents:\n\n", thresh ); r += sprintf( r, "Stats for all /24s with more than %u announced torrents:\n\n", thresh );
#if 0 #if 0
/* XXX: TOOD: Doesn't work yet with new peer storage model */ /* XXX: TOOD: Doesn't work yet with new peer storage model */
for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) { for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) {
@ -257,7 +273,7 @@ static size_t stats_slash24s_txt( char * reply, size_t amount, uint32_t thresh )
goto bailout_cleanup; goto bailout_cleanup;
} }
#endif #endif
k = l = 0; /* Debug: count allocated bufs */ k = l = 0; /* Debug: count allocated bufs */
for( i=0; i < NUM_BUFS; ++i ) { for( i=0; i < NUM_BUFS; ++i ) {
uint32_t *count = counts[i]; uint32_t *count = counts[i];
@ -281,28 +297,28 @@ static size_t stats_slash24s_txt( char * reply, size_t amount, uint32_t thresh )
} }
free( count ); free( count );
} }
r += sprintf( r, "Allocated bufs: %zd, used s24s: %zd\n", k, l ); r += sprintf( r, "Allocated bufs: %zd, used s24s: %zd\n", k, l );
for( i=0; i < amount; ++i ) for( i=0; i < amount; ++i )
if( slash24s[ 2*i ] >= thresh ) { if( slash24s[ 2*i ] >= thresh ) {
uint32_t ip = slash24s[ 2*i +1 ]; uint32_t ip = slash24s[ 2*i +1 ];
r += sprintf( r, "% 10ld %d.%d.%d.0/24\n", (long)slash24s[ 2*i ], (int)(ip >> 16), (int)(255 & ( ip >> 8 )), (int)(ip & 255) ); r += sprintf( r, "% 10ld %d.%d.%d.0/24\n", (long)slash24s[ 2*i ], (int)(ip >> 16), (int)(255 & ( ip >> 8 )), (int)(ip & 255) );
} }
return r - reply; return r - reply;
for( i=0; i < NUM_BUFS; ++i ) for( i=0; i < NUM_BUFS; ++i )
free( counts[i] ); free( counts[i] );
return 0; return 0;
} }
/* /*
struct { struct {
size_t size size_t size
size_t space size_t space
size_t count size_t count
} }
*/ */
@ -313,105 +329,95 @@ static unsigned long events_per_time( unsigned long long events, time_t t ) {
static size_t stats_connections_mrtg( char * reply ) { static size_t stats_connections_mrtg( char * reply ) {
ot_time t = time( NULL ) - ot_start_time; ot_time t = time( NULL ) - ot_start_time;
return sprintf( reply, return sprintf( reply,
"%llu\n%llu\n%i seconds (%i hours)\nopentracker connections, %lu conns/s :: %lu success/s.", "%llu\n%llu\n%i seconds (%i hours)\nopentracker connections, %lu conns/s :: %lu success/s.",
ot_overall_tcp_connections+ot_overall_udp_connections, ot_overall_tcp_connections+ot_overall_udp_connections,
ot_overall_tcp_successfulannounces+ot_overall_udp_successfulannounces+ot_overall_udp_connects, ot_overall_tcp_successfulannounces+ot_overall_udp_successfulannounces+ot_overall_udp_connects,
(int)t, (int)t,
(int)(t / 3600), (int)(t / 3600),
events_per_time( ot_overall_tcp_connections+ot_overall_udp_connections, t ), events_per_time( ot_overall_tcp_connections+ot_overall_udp_connections, t ),
events_per_time( ot_overall_tcp_successfulannounces+ot_overall_udp_successfulannounces+ot_overall_udp_connects, t ) events_per_time( ot_overall_tcp_successfulannounces+ot_overall_udp_successfulannounces+ot_overall_udp_connects, t )
); );
} }
static size_t stats_udpconnections_mrtg( char * reply ) { static size_t stats_udpconnections_mrtg( char * reply ) {
ot_time t = time( NULL ) - ot_start_time; ot_time t = time( NULL ) - ot_start_time;
return sprintf( reply, return sprintf( reply,
"%llu\n%llu\n%i seconds (%i hours)\nopentracker udp4 stats, %lu conns/s :: %lu success/s.", "%llu\n%llu\n%i seconds (%i hours)\nopentracker udp4 stats, %lu conns/s :: %lu success/s.",
ot_overall_udp_connections, ot_overall_udp_connections,
ot_overall_udp_successfulannounces+ot_overall_udp_connects, ot_overall_udp_successfulannounces+ot_overall_udp_connects,
(int)t, (int)t,
(int)(t / 3600), (int)(t / 3600),
events_per_time( ot_overall_udp_connections, t ), events_per_time( ot_overall_udp_connections, t ),
events_per_time( ot_overall_udp_successfulannounces+ot_overall_udp_connects, t ) events_per_time( ot_overall_udp_successfulannounces+ot_overall_udp_connects, t )
); );
} }
static size_t stats_tcpconnections_mrtg( char * reply ) { static size_t stats_tcpconnections_mrtg( char * reply ) {
time_t t = time( NULL ) - ot_start_time; time_t t = time( NULL ) - ot_start_time;
return sprintf( reply, return sprintf( reply,
"%llu\n%llu\n%i seconds (%i hours)\nopentracker tcp4 stats, %lu conns/s :: %lu success/s.", "%llu\n%llu\n%i seconds (%i hours)\nopentracker tcp4 stats, %lu conns/s :: %lu success/s.",
ot_overall_tcp_connections, ot_overall_tcp_connections,
ot_overall_tcp_successfulannounces, ot_overall_tcp_successfulannounces,
(int)t, (int)t,
(int)(t / 3600), (int)(t / 3600),
events_per_time( ot_overall_tcp_connections, t ), events_per_time( ot_overall_tcp_connections, t ),
events_per_time( ot_overall_tcp_successfulannounces, t ) events_per_time( ot_overall_tcp_successfulannounces, t )
); );
} }
static size_t stats_scrape_mrtg( char * reply ) { static size_t stats_scrape_mrtg( char * reply ) {
time_t t = time( NULL ) - ot_start_time; time_t t = time( NULL ) - ot_start_time;
return sprintf( reply, return sprintf( reply,
"%llu\n%llu\n%i seconds (%i hours)\nopentracker scrape stats, %lu scrape/s (tcp and udp)", "%llu\n%llu\n%i seconds (%i hours)\nopentracker scrape stats, %lu scrape/s (tcp and udp)",
ot_overall_tcp_successfulscrapes, ot_overall_tcp_successfulscrapes,
ot_overall_udp_successfulscrapes, ot_overall_udp_successfulscrapes,
(int)t, (int)t,
(int)(t / 3600), (int)(t / 3600),
events_per_time( (ot_overall_tcp_successfulscrapes+ot_overall_udp_successfulscrapes), t ) events_per_time( (ot_overall_tcp_successfulscrapes+ot_overall_udp_successfulscrapes), t )
); );
} }
static size_t stats_fullscrapes_mrtg( char * reply ) { static size_t stats_fullscrapes_mrtg( char * reply ) {
ot_time t = time( NULL ) - ot_start_time; ot_time t = time( NULL ) - ot_start_time;
return sprintf( reply, return sprintf( reply,
"%llu\n%llu\n%i seconds (%i hours)\nopentracker full scrape stats, %lu conns/s :: %lu bytes/s.", "%llu\n%llu\n%i seconds (%i hours)\nopentracker full scrape stats, %lu conns/s :: %lu bytes/s.",
ot_full_scrape_count * 1000, ot_full_scrape_count * 1000,
ot_full_scrape_size, ot_full_scrape_size,
(int)t, (int)t,
(int)(t / 3600), (int)(t / 3600),
events_per_time( ot_full_scrape_count, t ), events_per_time( ot_full_scrape_count, t ),
events_per_time( ot_full_scrape_size, t ) events_per_time( ot_full_scrape_size, t )
); );
} }
static size_t stats_peers_mrtg( char * reply ) { static size_t stats_peers_mrtg( char * reply ) {
size_t torrent_count = 0, peer_count = 0, seed_count = 0, j; torrent_stats stats = {0,0,0};
int bucket;
iterate_all_torrents( torrent_statter, (uintptr_t)&stats );
for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) {
ot_vector *torrents_list = mutex_bucket_lock( bucket ); return sprintf( reply, "%llu\n%llu\nopentracker serving %llu torrents\nopentracker",
torrent_count += torrents_list->size; stats.peer_count,
for( j=0; j<torrents_list->size; ++j ) { stats.seed_count,
ot_peerlist *peer_list = ( ((ot_torrent*)(torrents_list->data))[j] ).peer_list; stats.torrent_count
peer_count += peer_list->peer_count; seed_count += peer_list->seed_count; );
}
mutex_bucket_unlock( bucket, 0 );
if( !g_opentracker_running )
return 0;
}
return sprintf( reply, "%zd\n%zd\nopentracker serving %zd torrents\nopentracker",
peer_count,
seed_count,
torrent_count
);
} }
static size_t stats_startstop_mrtg( char * reply ) static size_t stats_startstop_mrtg( char * reply )
{ {
size_t torrent_count = mutex_get_torrent_count(); size_t torrent_count = mutex_get_torrent_count();
return sprintf( reply, "%zd\n%zd\nopentracker handling %zd torrents\nopentracker", return sprintf( reply, "%zd\n%zd\nopentracker handling %zd torrents\nopentracker",
(size_t)0, (size_t)0,
(size_t)0, (size_t)0,
torrent_count torrent_count
); );
} }
static size_t stats_toraddrem_mrtg( char * reply ) static size_t stats_toraddrem_mrtg( char * reply )
{ {
size_t peer_count = 0, j; size_t peer_count = 0, j;
int bucket; int bucket;
for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket )
{ {
ot_vector *torrents_list = mutex_bucket_lock( bucket ); ot_vector *torrents_list = mutex_bucket_lock( bucket );
@ -424,53 +430,63 @@ static size_t stats_toraddrem_mrtg( char * reply )
if( !g_opentracker_running ) if( !g_opentracker_running )
return 0; return 0;
} }
return sprintf( reply, "%zd\n%zd\nopentracker handling %zd peers\nopentracker", return sprintf( reply, "%zd\n%zd\nopentracker handling %zd peers\nopentracker",
(size_t)0, (size_t)0,
(size_t)0, (size_t)0,
peer_count peer_count
); );
} }
static size_t stats_torrents_mrtg( char * reply ) static size_t stats_torrents_mrtg( char * reply )
{ {
size_t torrent_count = mutex_get_torrent_count(); size_t torrent_count = mutex_get_torrent_count();
return sprintf( reply, "%zd\n%zd\nopentracker serving %zd torrents\nopentracker", return sprintf( reply, "%zd\n%zd\nopentracker serving %zd torrents\nopentracker",
torrent_count, torrent_count,
(size_t)0, (size_t)0,
torrent_count torrent_count
); );
} }
static size_t stats_httperrors_txt ( char * reply ) { static size_t stats_httperrors_txt ( char * reply ) {
return sprintf( reply, "302 RED %llu\n400 ... %llu\n400 PAR %llu\n400 COM %llu\n403 IP %llu\n404 INV %llu\n500 SRV %llu\n", return sprintf( reply, "302 RED %llu\n400 ... %llu\n400 PAR %llu\n400 COM %llu\n403 IP %llu\n404 INV %llu\n500 SRV %llu\n",
ot_failed_request_counts[0], ot_failed_request_counts[1], ot_failed_request_counts[2], ot_failed_request_counts[0], ot_failed_request_counts[1], ot_failed_request_counts[2],
ot_failed_request_counts[3], ot_failed_request_counts[4], ot_failed_request_counts[5], ot_failed_request_counts[3], ot_failed_request_counts[4], ot_failed_request_counts[5],
ot_failed_request_counts[6] ); ot_failed_request_counts[6] );
} }
static size_t stats_return_renew_bucket( char * reply ) { static size_t stats_return_renew_bucket( char * reply ) {
char *r = reply; char *r = reply;
int i; int i;
for( i=0; i<OT_PEER_TIMEOUT; ++i ) for( i=0; i<OT_PEER_TIMEOUT; ++i )
r+=sprintf(r,"%02i %llu\n", i, ot_renewed[i] ); r+=sprintf(r,"%02i %llu\n", i, ot_renewed[i] );
return r - reply; return r - reply;
} }
static size_t stats_return_sync_mrtg( char * reply ) static size_t stats_return_sync_mrtg( char * reply ) {
{
ot_time t = time( NULL ) - ot_start_time; ot_time t = time( NULL ) - ot_start_time;
return sprintf( reply, return sprintf( reply,
"%llu\n%llu\n%i seconds (%i hours)\nopentracker connections, %lu conns/s :: %lu success/s.", "%llu\n%llu\n%i seconds (%i hours)\nopentracker connections, %lu conns/s :: %lu success/s.",
ot_overall_sync_count, ot_overall_sync_count,
0LL, 0LL,
(int)t, (int)t,
(int)(t / 3600), (int)(t / 3600),
events_per_time( ot_overall_tcp_connections+ot_overall_udp_connections, t ), events_per_time( ot_overall_tcp_connections+ot_overall_udp_connections, t ),
events_per_time( ot_overall_tcp_successfulannounces+ot_overall_udp_successfulannounces+ot_overall_udp_connects, t ) events_per_time( ot_overall_tcp_successfulannounces+ot_overall_udp_successfulannounces+ot_overall_udp_connects, t )
); );
}
static size_t stats_return_everything( char * reply ) {
char * r = reply;
r += sprintf( r, "<stats>\n" );
r += sprintf( r, " <uptime>%llu</uptime>\n", (unsigned long long)(time( NULL ) - ot_start_time) );
r += sprintf( r, " <torrents>%zd</torrents>\n", mutex_get_torrent_count() );
/* r += sprintf( r, " <peers>%llu</peers>\n", ); */
r += sprintf( reply, "</stats>" );
return r - reply;
} }
extern const char extern const char
@ -480,9 +496,9 @@ extern const char
size_t stats_return_tracker_version( char *reply ) { size_t stats_return_tracker_version( char *reply ) {
return sprintf( reply, "%s%s%s%s%s%s%s%s%s%s%s%s%s", return sprintf( reply, "%s%s%s%s%s%s%s%s%s%s%s%s%s",
g_version_opentracker_c, g_version_accesslist_c, g_version_clean_c, g_version_fullscrape_c, g_version_http_c, g_version_opentracker_c, g_version_accesslist_c, g_version_clean_c, g_version_fullscrape_c, g_version_http_c,
g_version_iovec_c, g_version_mutex_c, g_version_stats_c, g_version_udp_c, g_version_vector_c, g_version_iovec_c, g_version_mutex_c, g_version_stats_c, g_version_udp_c, g_version_vector_c,
g_version_scan_urlencoded_query_c, g_version_trackerlogic_c, g_version_livesync_c ); g_version_scan_urlencoded_query_c, g_version_trackerlogic_c, g_version_livesync_c );
} }
size_t return_stats_for_tracker( char *reply, int mode, int format ) { size_t return_stats_for_tracker( char *reply, int mode, int format ) {
@ -509,7 +525,7 @@ size_t return_stats_for_tracker( char *reply, int mode, int format ) {
case TASK_STATS_RENEW: case TASK_STATS_RENEW:
return stats_return_renew_bucket( reply ); return stats_return_renew_bucket( reply );
case TASK_STATS_SYNCS: case TASK_STATS_SYNCS:
return stats_return_sync_mrtg( reply ); return stats_return_sync_mrtg( reply );
#ifdef WANT_LOG_NETWORKS #ifdef WANT_LOG_NETWORKS
case TASK_STATS_BUSY_NETWORKS: case TASK_STATS_BUSY_NETWORKS:
return stats_return_busy_networks( reply ); return stats_return_busy_networks( reply );
@ -521,12 +537,12 @@ size_t return_stats_for_tracker( char *reply, int mode, int format ) {
static void stats_make( int *iovec_entries, struct iovec **iovector, ot_tasktype mode ) { static void stats_make( int *iovec_entries, struct iovec **iovector, ot_tasktype mode ) {
char *r; char *r;
*iovec_entries = 0; *iovec_entries = 0;
*iovector = NULL; *iovector = NULL;
if( !( r = iovec_increase( iovec_entries, iovector, OT_STATS_TMPSIZE ) ) ) if( !( r = iovec_increase( iovec_entries, iovector, OT_STATS_TMPSIZE ) ) )
return; return;
switch( mode & TASK_TASK_MASK ) { switch( mode & TASK_TASK_MASK ) {
case TASK_STATS_TORRENTS: r += stats_torrents_mrtg( r ); break; case TASK_STATS_TORRENTS: r += stats_torrents_mrtg( r ); break;
case TASK_STATS_PEERS: r += stats_peers_mrtg( r ); break; case TASK_STATS_PEERS: r += stats_peers_mrtg( r ); break;
@ -560,26 +576,26 @@ void stats_issue_event( ot_status_event event, PROTO_FLAG proto, uintptr_t event
ot_full_scrape_size += event_data; ot_full_scrape_size += event_data;
break; break;
case EVENT_FULLSCRAPE_REQUEST: case EVENT_FULLSCRAPE_REQUEST:
{ {
ot_ip6 *ip = (ot_ip6*)event_data; /* ugly hack to transfer ip to stats */ ot_ip6 *ip = (ot_ip6*)event_data; /* ugly hack to transfer ip to stats */
char _debug[512]; char _debug[512];
int off = snprintf( _debug, sizeof(_debug), "[%08d] scrp: ", (unsigned int)(g_now_seconds - ot_start_time)/60 ); int off = snprintf( _debug, sizeof(_debug), "[%08d] scrp: ", (unsigned int)(g_now_seconds - ot_start_time)/60 );
off += fmt_ip6( _debug+off, *ip ); off += fmt_ip6( _debug+off, *ip );
off += snprintf( _debug+off, sizeof(_debug)-off, " - FULL SCRAPE\n" ); off += snprintf( _debug+off, sizeof(_debug)-off, " - FULL SCRAPE\n" );
write( 2, _debug, off ); write( 2, _debug, off );
ot_full_scrape_request_count++; ot_full_scrape_request_count++;
} }
break; break;
case EVENT_FULLSCRAPE_REQUEST_GZIP: case EVENT_FULLSCRAPE_REQUEST_GZIP:
{ {
ot_ip6 *ip = (ot_ip6*)event_data; /* ugly hack to transfer ip to stats */ ot_ip6 *ip = (ot_ip6*)event_data; /* ugly hack to transfer ip to stats */
char _debug[512]; char _debug[512];
int off = snprintf( _debug, sizeof(_debug), "[%08d] scrp: ", (unsigned int)(g_now_seconds - ot_start_time)/60 ); int off = snprintf( _debug, sizeof(_debug), "[%08d] scrp: ", (unsigned int)(g_now_seconds - ot_start_time)/60 );
off += fmt_ip6(_debug+off, *ip ); off += fmt_ip6(_debug+off, *ip );
off += snprintf( _debug+off, sizeof(_debug)-off, " - FULL SCRAPE\n" ); off += snprintf( _debug+off, sizeof(_debug)-off, " - FULL SCRAPE\n" );
write( 2, _debug, off ); write( 2, _debug, off );
ot_full_scrape_request_count++; ot_full_scrape_request_count++;
} }
break; break;
case EVENT_FAILED: case EVENT_FAILED:
ot_failed_request_counts[event_data]++; ot_failed_request_counts[event_data]++;
@ -590,6 +606,9 @@ void stats_issue_event( ot_status_event event, PROTO_FLAG proto, uintptr_t event
case EVENT_SYNC: case EVENT_SYNC:
ot_overall_sync_count+=event_data; ot_overall_sync_count+=event_data;
break; break;
case EVENT_BUCKET_LOCKED:
ot_overall_stall_count++;
break;
default: default:
break; break;
} }
@ -598,9 +617,9 @@ void stats_issue_event( ot_status_event event, PROTO_FLAG proto, uintptr_t event
static void * stats_worker( void * args ) { static void * stats_worker( void * args ) {
int iovec_entries; int iovec_entries;
struct iovec *iovector; struct iovec *iovector;
args = args; args = args;
while( 1 ) { while( 1 ) {
ot_tasktype tasktype = TASK_STATS; ot_tasktype tasktype = TASK_STATS;
ot_taskid taskid = mutex_workqueue_poptask( &tasktype ); ot_taskid taskid = mutex_workqueue_poptask( &tasktype );

3
ot_stats.h
Unescape Escape View File

@ -17,7 +17,8 @@ typedef enum {
EVENT_FULLSCRAPE_REQUEST, EVENT_FULLSCRAPE_REQUEST,
EVENT_FULLSCRAPE_REQUEST_GZIP, EVENT_FULLSCRAPE_REQUEST_GZIP,
EVENT_FULLSCRAPE, /* TCP only */ EVENT_FULLSCRAPE, /* TCP only */
EVENT_FAILED EVENT_FAILED,
EVENT_BUCKET_LOCKED
} ot_status_event; } ot_status_event;
enum { enum {

19
trackerlogic.c
Unescape Escape View File

@ -337,6 +337,23 @@ size_t remove_peer_from_torrent( ot_hash hash, ot_peer *peer, char *reply, PROTO
return reply_size; return reply_size;
} }
void iterate_all_torrents( int (*for_each)( ot_torrent* torrent, uintptr_t data ), uintptr_t data ) {
int bucket;
size_t j;
for( bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) {
ot_vector *torrents_list = mutex_bucket_lock( bucket );
ot_torrent *torrents = (ot_torrent*)(torrents_list->data);
for( j=0; j<torrents_list->size; ++j )
if( for_each( torrents + j, data ) )
break;
mutex_bucket_unlock( bucket, 0 );
if( !g_opentracker_running ) return;
}
}
void exerr( char * message ) { void exerr( char * message ) {
fprintf( stderr, "%s\n", message ); fprintf( stderr, "%s\n", message );
exit( 111 ); exit( 111 );
@ -358,7 +375,7 @@ void trackerlogic_init( ) {
void trackerlogic_deinit( void ) { void trackerlogic_deinit( void ) {
int bucket, delta_torrentcount = 0; int bucket, delta_torrentcount = 0;
size_t j; size_t j;
/* Free all torrents... */ /* Free all torrents... */
for(bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) { for(bucket=0; bucket<OT_BUCKET_COUNT; ++bucket ) {
ot_vector *torrents_list = mutex_bucket_lock( bucket ); ot_vector *torrents_list = mutex_bucket_lock( bucket );

3
trackerlogic.h
Unescape Escape View File

@ -148,6 +148,9 @@ size_t remove_peer_from_torrent( ot_hash hash, ot_peer *peer, char *reply, PROT
size_t return_tcp_scrape_for_torrent( ot_hash *hash, int amount, char *reply ); size_t return_tcp_scrape_for_torrent( ot_hash *hash, int amount, char *reply );
size_t return_udp_scrape_for_torrent( ot_hash hash, char *reply ); size_t return_udp_scrape_for_torrent( ot_hash hash, char *reply );
/* torrent iterator */
void iterate_all_torrents( int (*for_each)( ot_torrent* torrent, uintptr_t data ), uintptr_t data );
/* Helper, before it moves to its own object */ /* Helper, before it moves to its own object */
void free_peerlist( ot_peerlist *peer_list ); void free_peerlist( ot_peerlist *peer_list );

Write Preview
Loading…
Cancel
Save