Changeset 7fac98e75ec28ff3416403824554a269fee17ebe

Show
Ignore:
Timestamp:
03/01/11 20:52:47 (3 years ago)
Author:
Theo Schlossnagle <jesus@omniti.com>
git-committer:
Theo Schlossnagle <jesus@omniti.com> 1299012767 +0000
git-parent:

[fb9999f28a5f825abbec81618c22d88d639ddc7b]

git-author:
Theo Schlossnagle <jesus@omniti.com> 1299012767 +0000
Message:

Add an API for invoking a function over all checks against a particular target.

Change collectd to use new API to find all checks against a particular packet's
source and push metrics into all of them.

fixes #355

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • src/modules/collectd.c

    rce6a060 r7fac98e  
    13031303} 
    13041304 
     1305struct collectd_pkt { 
     1306  noit_module_t *self;  /* which collect load context */ 
     1307  char *payload; 
     1308  int len; 
     1309}; 
     1310 
     1311static int 
     1312push_packet_at_check(noit_check_t *check, void *closure) { 
     1313  struct collectd_pkt *pkt = closure; 
     1314  collectd_closure_t *ccl; 
     1315  char *security_buffer;  
     1316  collectd_mod_config_t *conf; 
     1317  conf = noit_module_get_userdata(pkt->self); 
     1318 
     1319  /* We need a check, and a collectd one at that */ 
     1320  if (!check || strcmp(check->module, pkt->self->hdr.name)) return 0; 
     1321 
     1322  // If its a new check retrieve some values 
     1323  if (check->closure == NULL) { 
     1324    // TODO: Verify if it could somehow retrieve data before the check closure exists  
     1325    ccl = check->closure = (void *)calloc(1, sizeof(collectd_closure_t));  
     1326    memset(ccl, 0, sizeof(collectd_closure_t)); 
     1327  } else { 
     1328    ccl = (collectd_closure_t*)check->closure; 
     1329  } 
     1330  // Default to NONE 
     1331  ccl->security_level = SECURITY_LEVEL_NONE; 
     1332  if (noit_hash_retr_str(check->config, "security_level", strlen("security_level"), 
     1333                         (const char**)&security_buffer))  
     1334  { 
     1335    ccl->security_level = atoi(security_buffer); 
     1336  } 
     1337 
     1338  // Is this outside to keep updates happening? 
     1339  if (!noit_hash_retr_str(check->config, "username", strlen("username"), 
     1340                         (const char**)&ccl->username) && 
     1341      !noit_hash_retr_str(conf->options, "username", strlen("username"), 
     1342                         (const char**)&ccl->username))  
     1343  { 
     1344    if (ccl->security_level == SECURITY_LEVEL_ENCRYPT) { 
     1345      noitL(nlerr, "collectd: no username defined for check.\n"); 
     1346      return 0; 
     1347    } else if (ccl->security_level == SECURITY_LEVEL_SIGN) { 
     1348      noitL(nlerr, "collectd: no username defined for check, " 
     1349          "will accept any signed packet.\n"); 
     1350    } 
     1351  } 
     1352 
     1353  if(!ccl->secret) 
     1354    noit_hash_retr_str(check->config, "secret", strlen("secret"), 
     1355                       (const char**)&ccl->secret); 
     1356  if(!ccl->secret) 
     1357    noit_hash_retr_str(conf->options, "secret", strlen("secret"), 
     1358                       (const char**)&ccl->secret); 
     1359  if(!ccl->secret) { 
     1360    if (ccl->security_level == SECURITY_LEVEL_ENCRYPT) { 
     1361      noitL(nlerr, "collectd: no secret defined for check.\n"); 
     1362      return 0; 
     1363    } 
     1364    else if (ccl->security_level == SECURITY_LEVEL_SIGN) { 
     1365      noitL(nlerr, "collectd: no secret defined for check, " 
     1366          "will accept any signed packet.\n"); 
     1367    } 
     1368  } 
     1369 
     1370  parse_packet(ccl, pkt->self, check, pkt->payload, pkt->len, 0); 
     1371  return 1; 
     1372} 
     1373 
    13051374static int noit_collectd_handler(eventer_t e, int mask, void *closure, 
    13061375                             struct timeval *now) { 
     
    13211390 
    13221391  while(1) { 
    1323     int inlen; 
    1324     noit_check_t *check; 
    1325     collectd_closure_t *ccl; 
    1326     char *security_buffer;  
     1392    struct collectd_pkt pkt; 
     1393    int inlen, check_cnt; 
    13271394 
    13281395    from_len = sizeof(remote); 
     
    13531420      break; 
    13541421    } 
    1355     check = noit_poller_lookup_by_name(ip_p, "collectd"); 
    1356     if (!check) { 
     1422 
     1423    pkt.self = self; 
     1424    pkt.payload = packet; 
     1425    pkt.len = inlen; 
     1426    check_cnt = noit_poller_target_do(ip_p, push_packet_at_check ,&pkt); 
     1427    if(check_cnt == 0) 
    13571428      noitL(nlerr, "collectd: No defined check from ip [%s].\n", ip_p); 
    1358       break; 
    1359     } 
    1360  
    1361     // If its a new check retrieve some values 
    1362     if (check->closure == NULL) { 
    1363       // TODO: Verify if it could somehow retrieve data before the check closure exists  
    1364       ccl = check->closure = (void *)calloc(1, sizeof(collectd_closure_t));  
    1365       memset(ccl, 0, sizeof(collectd_closure_t)); 
    1366     } else { 
    1367       ccl = (collectd_closure_t*)check->closure; 
    1368     } 
    1369     // Default to NONE 
    1370     ccl->security_level = SECURITY_LEVEL_NONE; 
    1371     if (noit_hash_retr_str(check->config, "security_level", strlen("security_level"), 
    1372                            (const char**)&security_buffer))  
    1373     { 
    1374       ccl->security_level = atoi(security_buffer); 
    1375     } 
    1376  
    1377     // Is this outside to keep updates happening? 
    1378     if (!noit_hash_retr_str(check->config, "username", strlen("username"), 
    1379                            (const char**)&ccl->username) && 
    1380         !noit_hash_retr_str(conf->options, "username", strlen("username"), 
    1381                            (const char**)&ccl->username))  
    1382     { 
    1383       if (ccl->security_level == SECURITY_LEVEL_ENCRYPT) { 
    1384         noitL(nlerr, "collectd: no username defined for check.\n"); 
    1385         goto cleanup; 
    1386       } else if (ccl->security_level == SECURITY_LEVEL_SIGN) { 
    1387         noitL(nlerr, "collectd: no username defined for check, " 
    1388             "will accept any signed packet.\n"); 
    1389       } 
    1390     } 
    1391  
    1392     if(!ccl->secret) 
    1393       noit_hash_retr_str(check->config, "secret", strlen("secret"), 
    1394                          (const char**)&ccl->secret); 
    1395     if(!ccl->secret) 
    1396       noit_hash_retr_str(conf->options, "secret", strlen("secret"), 
    1397                          (const char**)&ccl->secret); 
    1398     if(!ccl->secret) { 
    1399       if (ccl->security_level == SECURITY_LEVEL_ENCRYPT) { 
    1400         noitL(nlerr, "collectd: no secret defined for check.\n"); 
    1401         goto cleanup; 
    1402       } 
    1403       else if (ccl->security_level == SECURITY_LEVEL_SIGN) { 
    1404         noitL(nlerr, "collectd: no secret defined for check, " 
    1405             "will accept any signed packet.\n"); 
    1406       } 
    1407     } 
    1408  
    1409     parse_packet(ccl, self, check, packet, inlen, 0); 
    14101429  } 
    14111430  return EVENTER_READ | EVENTER_EXCEPTION; 
    1412  
    1413 cleanup: 
    1414   return 0; 
    14151431} 
    1416  
    14171432 
    14181433static int noit_collectd_initiate_check(noit_module_t *self, 
  • src/noit_check.c

    r01144b7 r7fac98e  
    797797  return check; 
    798798} 
     799int 
     800noit_poller_target_do(char *target, int (*f)(noit_check_t *, void *), 
     801                      void *closure) { 
     802  int count = 0; 
     803  noit_check_t pivot; 
     804  noit_skiplist_node *next; 
     805 
     806  memset(&pivot, 0, sizeof(pivot)); 
     807  pivot.target = target; 
     808  pivot.name = ""; 
     809  noit_skiplist_find_neighbors(&polls_by_name, &pivot, NULL, NULL, &next); 
     810  while(next && next->data) { 
     811    noit_check_t *check = next->data; 
     812    if(strcmp(check->target, target)) break; 
     813    count += f(check,closure); 
     814    noit_skiplist_next(&polls_by_name, &next); 
     815  } 
     816  return count; 
     817} 
    799818 
    800819int 
  • src/noit_check.h

    r7d308b7 r7fac98e  
    210210 
    211211API_EXPORT(int) 
     212   noit_poller_target_do(char *target, int (*f)(noit_check_t *, void *), 
     213                         void *closure); 
     214 
     215API_EXPORT(int) 
    212216  noit_check_xpath(char *xpath, int len, 
    213217                   const char *base, const char *arg);