Changeset 4398

Show
Ignore:
Timestamp:
10/01/06 23:27:30 (2 years ago)
Author:
morris
Message:

More cleanup

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trackerd/trunk/trackerd/clients.c

    r3947 r4398  
    5959 
    6060wt_client_t * wt_client_alloc(void) { 
    61         wt_client_t             *client; 
    62  
    63         client = wi_runtime_create_instance(wt_client_runtime_id, sizeof(wt_client_t)); 
    64  
    65         client->buffer_size = WT_CLIENT_BUFFER_INITIAL_SIZE; 
    66         client->buffer = wi_malloc(client->buffer_size); 
    67          
    68         return client; 
     61        return wi_runtime_create_instance(wt_client_runtime_id, sizeof(wt_client_t)); 
    6962} 
    7063 
    …… 
    7265 
    7366wt_client_t * wt_client_init_with_socket(wt_client_t *client, wi_socket_t *socket) { 
     67        client->buffer_size             = WT_CLIENT_BUFFER_INITIAL_SIZE; 
     68        client->buffer                  = wi_malloc(client->buffer_size); 
    7469        client->socket                  = wi_retain(socket); 
    7570        client->state                   = WT_CLIENT_STATE_CONNECTED; 

  • trackerd/trunk/trackerd/commands.c

    r4397 r4398  
    248248void wt_cmd_hello(wi_array_t *arguments) { 
    249249        wt_client_t             *client = wt_client(); 
    250         wi_string_t             *string; 
    251250 
    252251        if(client->state != WT_CLIENT_STATE_CONNECTED) 
    …… 
    263262        } 
    264263 
    265         string = wi_date_iso8601_string(wt_start_date); 
    266          
    267264        wt_reply(200, WI_STR("%#@%c%#@%c%#@%c%#@%c%#@"), 
    268265                         wt_server_version_string,              WT_FIELD_SEPARATOR, 
    …… 
    270267                         wt_settings.name,                              WT_FIELD_SEPARATOR, 
    271268                         wt_settings.description,               WT_FIELD_SEPARATOR, 
    272                          string); 
     269                         wi_date_iso8601_string(wt_start_date)); 
    273270         
    274271        client->state = WT_CLIENT_STATE_SAID_HELLO; 
    …… 
    287284        wi_address_t                            *address, *hostaddress; 
    288285        wi_url_t                                        *url; 
    289         wi_string_t                                     *string, *hostname; 
     286        wi_string_t                                     *hostname; 
    290287        wt_server_t                                     *server; 
    291288        unsigned int                            bandwidth; 
    …… 
    364361                if(wt_settings.reverselookup) { 
    365362                        /* reverse look up and compare to hostname */ 
    366                         string = wi_address_hostname(address); 
    367                         passed = wi_is_equal(string, hostname); 
    368                         wi_release(string); 
    369                          
    370                         if(!passed) { 
     363                        if(!wi_is_equal(wi_address_hostname(address), hostname)) { 
    371364                                /* reverse lookup failed */ 
    372365                                if(wt_settings.strictlookup) { 
    …… 
    412405        if(server) { 
    413406                if(server->port == wi_url_port(url)) { 
    414                         /* re-register existing server with same port */ 
    415                         wt_server_clear(server); 
    416                         wi_retain(server); 
     407                        /* remove existing server in preparation for re-registration */ 
     408                        wt_servers_remove_stats_for_server(server); 
     409                        wt_servers_remove_server(server); 
    417410                } else { 
    418411                        /* multiple servers from the same IP allowed? */ 
    419                         if(wt_settings.allowmultiple) { 
    420                                 server = NULL; 
    421                         } else { 
     412                        if(!wt_settings.allowmultiple) { 
    422413                                wt_reply(530, WI_STR("Address Registered")); 
    423414                                wi_log_warn(WI_STR("Register from %@ as \"%@\" URL %@ denied: %s"), 
    …… 
    430421        } 
    431422         
    432         /* add new server */ 
    433         if(!server) 
    434                 server = wt_server_init(wt_server_alloc()); 
    435          
    436423        /* rewrite URL if host verification failed */ 
    437424        if(failed) { 
    …… 
    445432        } 
    446433 
    447         /* set values */ 
    448         string                                  = wi_string_init_random_string_with_length(wi_string_alloc(), 1024); 
    449         server->key                             = wi_retain(wi_string_sha1(string)); 
    450         wi_release(string); 
    451          
     434        /* create new server */ 
     435        server                                  = wt_server_init(wt_server_alloc()); 
     436        server->key                             = wi_retain(wi_string_sha1(wi_autorelease(wi_string_init_random_string_with_length(wi_string_alloc(), 1024)))); 
    452437        server->port                    = wi_url_port(url); 
    453438        server->bandwidth               = bandwidth; 
    …… 
    462447        server->url                             = wi_copy(wi_url_string(url)); 
    463448 
     449        wt_servers_add_server(server); 
     450        wt_servers_add_stats_for_server(server); 
     451         
    464452        /* reply 700 */ 
    465453        wt_reply(700, WI_STR("%@"), server->key); 
    …… 
    476464 
    477465static void wt_cmd_servers(wi_array_t *arguments) { 
    478         wi_enumerator_t *enumerator; 
    479         wt_server_t             *server; 
    480  
    481466        /* reply all servers */ 
    482         wi_array_rdlock(wt_servers); 
    483          
    484         enumerator = wi_array_data_enumerator(wt_servers); 
    485          
    486         while((server = wi_enumerator_next_data(enumerator))) { 
    487                 wt_reply(720, WI_STR("%@%c%@%c%@%c%u%c%u%c%u%c%u%c%u%c%llu%c%@"), 
    488                                  server->category,              WT_FIELD_SEPARATOR, 
    489                                  server->url,                   WT_FIELD_SEPARATOR, 
    490                                  server->name,                  WT_FIELD_SEPARATOR, 
    491                                  server->users,                 WT_FIELD_SEPARATOR, 
    492                                  server->bandwidth,             WT_FIELD_SEPARATOR, 
    493                                  server->guest,                 WT_FIELD_SEPARATOR, 
    494                                  server->download,              WT_FIELD_SEPARATOR, 
    495                                  server->files,                 WT_FIELD_SEPARATOR, 
    496                                  server->size,                  WT_FIELD_SEPARATOR, 
    497                                  server->description); 
    498         } 
    499          
    500         wi_array_unlock(wt_servers); 
    501  
    502         wt_reply(721, WI_STR("Done")); 
     467        wt_servers_reply_server_list(); 
    503468 
    504469        /* update status */ 

  • trackerd/trunk/trackerd/servers.c

    r4397 r4398  
    3636#include "servers.h" 
    3737#include "settings.h" 
     38#include "tracker.h" 
    3839 
    3940#define WT_SERVER_MAGIC                                 "WTSV" 
    …… 
    8283static wi_timer_t                                               *wt_servers_timer; 
    8384 
    84 wi_array_t                                                            *wt_servers; 
     85static wi_hash_t                                              *wt_servers; 
    8586 
    8687static wi_runtime_id_t                                  wt_server_runtime_id = WI_RUNTIME_ID_NULL; 
    …… 
    9899        wt_server_runtime_id = wi_runtime_register_class(&wt_server_runtime_class); 
    99100 
    100         wt_servers = wi_array_init(wi_array_alloc()); 
     101        wt_servers = wi_hash_init(wi_hash_alloc()); 
    101102         
    102103        wt_servers_lock = wi_lock_init(wi_lock_alloc()); 
    …… 
    130131        wi_time_interval_t      interval, update; 
    131132        unsigned int            version, count = 0; 
     133        wi_boolean_t            loaded = false; 
    132134 
    133135        wi_lock_lock(wt_servers_lock); 
     136         
    134137        fp = fopen(wi_string_cstring(wt_settings.servers), "r"); 
    135138 
    …… 
    159162        interval = wi_time_interval(); 
    160163 
    161         wi_array_wrlock(wt_servers); 
    162164        while((fread(&server_packed, sizeof(wt_server_packed_t), 1, fp)) > 0) { 
    163165                update = server_packed.update_time > 0 ? server_packed.update_time : server_packed.register_time; 
    …… 
    165167                if(interval - update < wt_settings.minupdatetime) { 
    166168                        server = wt_server_init_with_packed(wt_server_alloc(), server_packed); 
    167  
    168                         wi_lock_lock(wt_status_lock); 
    169                         wt_current_servers++; 
    170                         wt_current_users += server->users; 
    171                         wt_current_files += server->files; 
    172                         wt_current_size += server->size; 
    173                         wi_lock_unlock(wt_status_lock); 
    174  
    175                         wi_array_add_data(wt_servers, server); 
     169                        wt_servers_add_server(server); 
     170                        wt_servers_add_stats_for_server(server); 
    176171                        wi_release(server); 
    177172 
    178                         count++; 
     173                        loaded = true; 
    179174                } 
    180175        } 
    181         wi_array_unlock(wt_servers); 
    182  
    183         if(count > 0) { 
     176 
     177        if(loaded) { 
    184178                wi_lock_lock(wt_status_lock); 
    185179                wt_write_status(true); 
    …… 
    221215        fwrite(&version, 4, 1, fp); 
    222216 
    223         wi_array_rdlock(wt_servers); 
    224          
    225         enumerator = wi_array_data_enumerator(wt_servers); 
     217        wi_hash_rdlock(wt_servers); 
     218         
     219        enumerator = wi_hash_data_enumerator(wt_servers); 
    226220         
    227221        while((server = wi_enumerator_next_data(enumerator))) { 
    …… 
    230224        } 
    231225 
    232         wi_array_unlock(wt_servers); 
     226        wi_hash_unlock(wt_servers); 
    233227 
    234228        fclose(fp); 
    …… 
    241235 
    242236static void wt_update_servers(wi_timer_t *timer) { 
     237        wi_enumerator_t         *enumerator; 
     238        wi_array_t                      *servers; 
    243239        wt_server_t                     *server; 
     240        void                            *key; 
    244241        wi_time_interval_t      interval, update; 
    245         wi_boolean_t            changed = false; 
    246         uint32_t                        i, count; 
    247  
    248         wi_array_rdlock(wt_servers); 
     242 
     243        servers = wi_array_init(wi_array_alloc()); 
     244        interval = wi_time_interval(); 
     245 
     246        wi_hash_wrlock(wt_servers); 
     247         
     248        enumerator = wi_hash_key_enumerator(wt_servers); 
     249         
     250        while((key = wi_enumerator_next_data(enumerator))) { 
     251                server = wi_hash_data_for_key(wt_servers, key); 
     252                update = server->update_time > 0.0 ? server->update_time : server->register_time; 
    249253                 
    250         count = wi_array_count(wt_servers); 
    251         interval = wi_time_interval(); 
    252  
    253         for(i = 0; i < count; i++) { 
    254                 server = WI_ARRAY(wt_servers, i); 
    255                 update = server->update_time > 0.0 ? server->update_time : server->register_time; 
    256  
    257254                if(interval - update > wt_settings.minupdatetime) { 
     255                        wi_array_add_data(servers, key); 
     256 
    258257                        wi_log_warn(WI_STR("Deleting \"%@\" with URL %@: Last update %.0f seconds ago considered too slow"), 
    259                                 server->name, server->url, interval - update); 
     258                                               server->name, server->url, interval - update); 
    260259 
    261260                        wt_servers_remove_stats_for_server(server); 
    262                          
    263                         wi_array_remove_data_at_index(wt_servers, i); 
    264                          
    265                         count--; 
    266                         i--; 
    267                         changed = true; 
    268261                } 
    269262        } 
    270  
    271         wi_array_unlock(wt_servers); 
    272  
    273         if(changed) { 
     263         
     264        enumerator = wi_array_data_enumerator(servers); 
     265         
     266        while((key = wi_enumerator_next_data(enumerator))) 
     267                wi_hash_remove_data_for_key(wt_servers, key); 
     268                 
     269        wi_hash_unlock(wt_servers); 
     270 
     271        if(wi_array_count(servers) > 0) { 
    274272                wi_lock_lock(wt_status_lock); 
    275273                wt_write_status(true); 
    …… 
    278276                wt_write_servers(); 
    279277        } 
     278         
     279        wi_release(servers); 
    280280} 
    281281 
    …… 
    283283 
    284284#pragma mark - 
     285 
     286void wt_servers_add_server(wt_server_t *server) { 
     287        wi_hash_wrlock(wt_servers); 
     288        wi_hash_set_data_for_key(wt_servers, server, server->key); 
     289        wi_hash_unlock(wt_servers); 
     290} 
     291 
     292 
     293 
     294void wt_servers_remove_server(wt_server_t *server) { 
     295        wi_hash_wrlock(wt_servers); 
     296        wi_hash_remove_data_for_key(wt_servers, server->key); 
     297        wi_hash_unlock(wt_servers); 
     298} 
     299 
     300 
    285301 
    286302wt_server_t * wt_servers_server_with_ip(wi_string_t *ip) { 
    …… 
    288304        wt_server_t             *server, *value = NULL; 
    289305 
    290         wi_array_rdlock(wt_servers); 
    291          
    292         enumerator = wi_array_data_enumerator(wt_servers); 
     306        wi_hash_rdlock(wt_servers); 
     307         
     308        enumerator = wi_hash_data_enumerator(wt_servers); 
    293309         
    294310        while((server = wi_enumerator_next_data(enumerator))) { 
    …… 
    300316        } 
    301317 
    302         wi_array_unlock(wt_servers); 
     318        wi_hash_unlock(wt_servers); 
    303319 
    304320        return value; 
    …… 
    308324 
    309325wt_server_t * wt_servers_server_with_key(wi_string_t *key) { 
    310         wi_enumerator_t *enumerator; 
    311         wt_server_t             *server, *value = NULL; 
    312  
    313         wi_array_rdlock(wt_servers); 
    314  
    315         enumerator = wi_array_data_enumerator(wt_servers); 
    316          
    317         while((server = wi_enumerator_next_data(enumerator))) { 
    318                 if(wi_is_equal(server->key, key)) { 
    319                         value = server; 
    320  
    321                         break; 
    322                 } 
    323         } 
    324          
    325         wi_array_unlock(wt_servers); 
    326  
    327         return value; 
     326        wt_server_t             *server; 
     327         
     328        wi_hash_rdlock(wt_servers); 
     329        server = wi_retain(wi_hash_data_for_key(wt_servers, key)); 
     330        wi_hash_unlock(wt_servers); 
     331         
     332        return wi_autorelease(server); 
    328333} 
    329334 
    …… 
    354359#pragma mark - 
    355360 
     361void wt_servers_reply_server_list(void) { 
     362        wi_enumerator_t         *enumerator; 
     363        wt_server_t                     *server; 
     364         
     365        wi_hash_rdlock(wt_servers); 
     366         
     367        enumerator = wi_hash_data_enumerator(wt_servers); 
     368         
     369        while((server = wi_enumerator_next_data(enumerator))) { 
     370                wt_reply(720, WI_STR("%@%c%@%c%@%c%u%c%u%c%u%c%u%c%u%c%llu%c%@"), 
     371                                 server->category,              WT_FIELD_SEPARATOR, 
     372                                 server->url,                   WT_FIELD_SEPARATOR, 
     373                                 server->name,                  WT_FIELD_SEPARATOR, 
     374                                 server->users,                 WT_FIELD_SEPARATOR, 
     375                                 server->bandwidth,             WT_FIELD_SEPARATOR, 
     376                                 server->guest,                 WT_FIELD_SEPARATOR, 
     377                                 server->download,              WT_FIELD_SEPARATOR, 
     378                                 server->files,                 WT_FIELD_SEPARATOR, 
     379                                 server->size,                  WT_FIELD_SEPARATOR, 
     380                                 server->description); 
     381        } 
     382         
     383        wi_hash_unlock(wt_servers); 
     384 
     385        wt_reply(721, WI_STR("Done")); 
     386} 
     387 
     388 
     389 
    356390wi_boolean_t wt_servers_category_is_valid(wi_string_t *category) { 
    357391        wi_file_t               *file; 
    …… 
    392426 
    393427wt_server_t * wt_server_init(wt_server_t *server) { 
    394         wi_array_wrlock(wt_servers); 
    395         wi_array_add_data(wt_servers, server); 
    396         wi_array_unlock(wt_servers); 
    397          
    398         wi_lock_lock(wt_status_lock); 
    399         wt_current_servers++; 
    400         wt_write_status(true); 
    401         wi_lock_unlock(wt_status_lock); 
    402          
    403428        return server; 
    404429} 
    …… 
    406431 
    407432 
    408 void wt_server_clear(wt_server_t *server) { 
    409         wi_release(server->key); 
    410         wi_release(server->ip); 
    411         wi_release(server->category); 
    412         wi_release(server->url); 
    413         wi_release(server->name); 
    414         wi_release(server->description); 
    415 } 
    416  
    417  
    418  
    419 static void wt_server_dealloc(wi_runtime_instance_t *instance) { 
    420         wt_server_t             *server = (wt_server_t *) instance; 
    421          
    422         wt_server_clear(server); 
    423 } 
    424  
    425  
    426  
    427 #pragma mark - 
    428  
    429 wt_server_t * wt_server_init_with_packed(wt_server_t *server, wt_server_packed_t server_packed) { 
     433static wt_server_t * wt_server_init_with_packed(wt_server_t *server, wt_server_packed_t server_packed) { 
    430434        server->key                             = wi_string_init_with_cstring(wi_string_alloc(), server_packed.key); 
    431435        server->update_time             = server_packed.update_time; 
    …… 
    451455 
    452456 
    453 wt_server_packed_t wt_server_packed(wt_server_t *server) { 
     457static void wt_server_dealloc(wi_runtime_instance_t *instance) { 
     458        wt_server_t             *server = (wt_server_t *) instance; 
     459         
     460        wi_release(server->key); 
     461        wi_release(server->ip); 
     462        wi_release(server->category); 
     463        wi_release(server->url); 
     464        wi_release(server->name); 
     465        wi_release(server->description); 
     466} 
     467 
     468 
     469 
     470#pragma mark - 
     471 
     472static wt_server_packed_t wt_server_packed(wt_server_t *server) { 
    454473        wt_server_packed_t      server_packed; 
    455474 

  • trackerd/trunk/trackerd/servers.h

    r4397 r4398  
    6262void                                                            wt_write_servers(void); 
    6363 
     64void                                                            wt_servers_add_server(wt_server_t *); 
     65void                                                            wt_servers_remove_server(wt_server_t *); 
    6466wt_server_t *                                           wt_servers_server_with_ip(wi_string_t *); 
    6567wt_server_t *                                           wt_servers_server_with_key(wi_string_t *); 
    …… 
    6769void                                                            wt_servers_remove_stats_for_server(wt_server_t *); 
    6870 
     71void                                                            wt_servers_reply_server_list(void); 
    6972wi_boolean_t                                            wt_servers_category_is_valid(wi_string_t *); 
    7073 
    7174wt_server_t *                                           wt_server_alloc(void); 
    7275wt_server_t *                                           wt_server_init(wt_server_t *); 
    73 void                                                            wt_server_clear(wt_server_t *); 
    74  
    75  
    76 extern wi_array_t                                       *wt_servers; 
    7776 
    7877#endif /* WT_SERVERS_H */ 

  • trackerd/trunk/trackerd/tracker.c

    r4397 r4398  
    317317 
    318318                                        wt_servers_remove_stats_for_server(server); 
    319  
    320                                         wi_array_wrlock(wt_servers); 
    321                                         wi_array_remove_data(wt_servers, server); 
    322                                         wi_array_unlock(wt_servers); 
    323  
    324                                         wi_lock_lock(wt_status_lock); 
    325                                         wt_write_status(true); 
    326                                         wi_lock_unlock(wt_status_lock); 
     319                                        wt_servers_remove_server(server); 
    327320 
    328321                                        wt_write_servers();