Пример #1
0
/*
 * Custom keys pg.index.* (for each field in pg_statio_all_indexes)
 *
 * Returns the requested IO statistic for the specified index
 *
 * Parameters:
 *   0:  connection string
 *   1:  connection database
 *   2:  filter by index name (default: sum of all indexes)
 *
 * Returns: u
 */
int    PG_STATIO_ALL_INDEXES(AGENT_REQUEST *request, AGENT_RESULT *result)
{
    int         ret = SYSINFO_RET_FAIL;                     // Request result code
    const char  *__function_name = "PG_STAT_ALL_INDEXES";   // Function name for log file
    
    char        *index = NULL;

    char        *field;
    char        query[MAX_STRING_LEN];
    
    zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
    
    // Get stat field from requested key name "pb.index.<field>"
    field = &request->key[9];
    
    // Build query
    index = get_rparam(request, PARAM_FIRST);
    if(strisnull(index))
        zbx_snprintf(query, sizeof(query), PGSQL_GET_INDEX_STATIO_SUM, field);
    else
        zbx_snprintf(query, sizeof(query),  "SELECT %s FROM pg_statio_all_indexes WHERE indexrelname = $1", field);

    ret = pg_get_int(request, result, query, param_new(index));
    
    zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
    return ret;
}
Пример #2
0
/*
 * Custom keys pg.index.* (for each field in pg_stat_all_indexes)
 *
 * Returns the requested statistic for the specified index
 *
 * Parameters:
 *   0:  connection string
 *   1:  connection database
 *   2:  filter by index name (default: sum of all indexes)
 *
 * Returns: u
 */
int    PG_STAT_ALL_INDEXES(AGENT_REQUEST *request, AGENT_RESULT *result)
{
    int         ret = SYSINFO_RET_FAIL;                     // Request result code
    const char  *__function_name = "PG_STAT_ALL_INDEXES";   // Function name for log file
    
    char        *index = NULL;
    
    PGconn      *conn = NULL;
    PGresult    *res = NULL;
    
    char        *field;
    char        query[MAX_STRING_LEN];
    char        *buffer = NULL;
    
    zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
    
    // Get stat field from requested key name "pb.table.<field>"
    field = &request->key[9];
    
    // Build query
    index = get_rparam(request, PARAM_FIRST);
    if(strisnull(index))
        zbx_snprintf(query, sizeof(query), "SELECT SUM(%s) FROM pg_stat_all_indexes", field);
    else
        zbx_snprintf(query, sizeof(query),  "SELECT %s FROM pg_stat_all_indexes WHERE indexrelname = $1", field);

    // Connect to PostreSQL
    if(NULL == (conn = pg_connect_request(request)))
        goto out;
    
    // Execute a query
    res = pg_exec(conn, query, param_new(index));
    if(PQresultStatus(res) != PGRES_TUPLES_OK) {
        zabbix_log(LOG_LEVEL_ERR, "Failed to execute PostgreSQL query in %s() with: %s", __function_name, PQresultErrorMessage(res));
        goto out;
    }
    
    if(0 == PQntuples(res)) {
        zabbix_log(LOG_LEVEL_ERR, "No results returned for query \"%s\" in %s()", query, __function_name);
        goto out;
    }
    
    // Set result
    buffer = strdup(PQgetvalue(res, 0, 0));
    SET_UI64_RESULT(result, atoi(buffer));
    ret = SYSINFO_RET_OK;
        
out:
    PQclear(res);
    PQfinish(conn);
    
    zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
    return ret;
}
Пример #3
0
static void
ws_params(sr_session_t *s, char **params, ...)
{
	struct sr_session_priv *priv = s->priv;
	GList *l = NULL;
	va_list args;
	GString *params_str, *tmp;
	gchar *api_sig;

	if (!params)
		return;

	params_str = g_string_sized_new(0x100);

	va_start(args, params);
	do {
		const char *key, *value;
		key = va_arg(args, char *);
		if (!key)
			break;
		value = va_arg(args, char *);
		if (!value)
			break;
		l = g_list_prepend(l, param_new(key, value));
		g_string_append_printf(params_str, "&%s=%s", key, value);
	} while (true);
	va_end(args);

	l = g_list_sort(l, (GCompareFunc) param_compare);

	tmp = g_string_sized_new(0x100);

	GList *c;
	for (c = l; c; c = c->next) {
		struct ws_param *p = c->data;
		g_string_append_printf(tmp, "%s%s", p->key, p->value);
	}

	g_string_append(tmp, priv->api_secret);

	api_sig = g_compute_checksum_for_string(G_CHECKSUM_MD5, tmp->str, -1);

	g_string_free(tmp, TRUE);
	g_list_foreach(l, (GFunc) free, NULL);

	g_string_append_printf(params_str, "&api_sig=%s", api_sig);
	g_free(api_sig);

	*params = params_str->str;
	g_string_free(params_str, FALSE);
}
Пример #4
0
/*
 * Custom key pg.index.size
 *
 * Returns the disk usage in bytes for the specified index
 *
 * Parameters:
 *   0:  connection string
 *   1:  connection database
 *   2:  filter by index name (default: sum of all indexes)
 *
 * Returns: u
 */
int    PG_INDEX_SIZE(AGENT_REQUEST *request, AGENT_RESULT *result)
{
    int         ret = SYSINFO_RET_FAIL;             // Request result code
    const char  *__function_name = "PG_INDEX_SIZE"; // Function name for log file
    char        *index = NULL; //, *include = NULL;
            
    zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
    
    // Parse parameters
    index = get_rparam(request, PARAM_FIRST);
    
    // Build query  
    if(strisnull(index))
        ret = pg_get_int(request, result, PGSQL_GET_INDEX_SIZE_SUM, NULL);
    else
        ret = pg_get_int(request, result, PGSQL_GET_INDEX_SIZE, param_new(index));
    
    zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
    return ret;
}
Пример #5
0
/*
 * Custom key pg.tablespace.size
 *
 * Returns the size of the specified tablespace in bytes
 *
 * Parameters:
 *   0:  connection string
 *   1:  tablespace name
 *
 * Returns: u
 */
int    PG_TABLESPACE_SIZE(AGENT_REQUEST *request, AGENT_RESULT *result)
{
    int         ret = SYSINFO_RET_FAIL;                     // Request result code
    const char  *__function_name = "PG_TABLESPACE_SIZE";    // Function name for log file
    char        *tablespace = NULL;
    
    zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
    
    // Build query
    tablespace = get_rparam(request, PARAM_FIRST);
    if(strisnull(tablespace)) {
        zabbix_log(LOG_LEVEL_ERR, "No tablespace specified in %s()", __function_name);
        goto out;
    }
    
    // execute query
    ret = pg_get_int(request, result, PGSQL_GET_TS_SIZE, param_new(tablespace));
    
out:
    zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
    return ret;
}
Пример #6
0
RunParams *init_params(char *fname_ini)
{
  FILE *fi;
  int n,ii,stat,ibin;
  double *x,*a,*y,dchi;
  RunParams *par=param_new();
  par->cpar=csm_params_new();
  read_parameter_file(fname_ini,par);

  csm_unset_gsl_eh();
  if(par->has_bg) {
    double hub;
    csm_background_set(par->cpar,par->om,par->ol,par->ob,par->w0,par->wa,par->h0,D_TCMB);
    par->chi_horizon=csm_radial_comoving_distance(par->cpar,0.);
    par->chi_kappa=csm_radial_comoving_distance(par->cpar,1./(1+par->z_kappa));
    par->chi_isw=csm_radial_comoving_distance(par->cpar,1./(1+par->z_isw));
    hub=csm_hubble(par->cpar,1.);
    par->prefac_lensing=1.5*hub*hub*par->om;
    
    n=(int)(par->chi_horizon/par->dchi)+1;
    dchi=par->chi_horizon/n;
    par->dchi=dchi;
    
    x=(double *)my_malloc(n*sizeof(double));
    a=(double *)my_malloc(n*sizeof(double));
    y=(double *)my_malloc(n*sizeof(double));
    
    for(ii=0;ii<n;ii++)
      x[ii]=dchi*ii;
    
    printf("Setting up background splines\n");
    //Set chi <-> a correspondence
    const gsl_root_fdfsolver_type *T=gsl_root_fdfsolver_newton;
    gsl_root_fdfsolver *s=gsl_root_fdfsolver_alloc(T);
    double a_old=1.0;
    for(ii=0;ii<n;ii++)
      a[ii]=a_of_chi(x[ii],par->cpar,&a_old,s);
    gsl_root_fdfsolver_free(s);
    par->aofchi=spline_init(n,x,a,1.0,0.0);
    
    //Compute redshift
    for(ii=0;ii<n;ii++)
      y[ii]=1./a[ii]-1;
    par->zofchi=spline_init(n,x,y,y[0],y[n-1]);
    
    //Compute hubble scale
    for(ii=0;ii<n;ii++)
      y[ii]=csm_hubble(par->cpar,a[ii]);
    par->hofchi=spline_init(n,x,y,y[0],y[n-1]);
    
    //Compute growth factor
    double g0=csm_growth_factor(par->cpar,1.0);
    for(ii=0;ii<n;ii++)
      y[ii]=csm_growth_factor(par->cpar,a[ii])/g0;
    par->gfofchi=spline_init(n,x,y,1.,0.);
    
    //Compute growth rate
    for(ii=0;ii<n;ii++)
      y[ii]=csm_f_growth(par->cpar,a[ii]);
    par->fgofchi=spline_init(n,x,y,y[0],1.);
    free(x); free(a); free(y);
  }

  //Allocate power spectra
  if(par->do_nc) {
    par->cl_dd=(double *)my_malloc((par->lmax+1)*sizeof(double));
    if(par->do_shear) {
      par->cl_d1l2=(double *)my_malloc((par->lmax+1)*sizeof(double));
      par->cl_d2l1=(double *)my_malloc((par->lmax+1)*sizeof(double));
    }
    if(par->do_cmblens)
      par->cl_dc=(double *)my_malloc((par->lmax+1)*sizeof(double));
    if(par->do_isw)
      par->cl_di=(double *)my_malloc((par->lmax+1)*sizeof(double));
  }
  if(par->do_shear) {
    par->cl_ll=(double *)my_malloc((par->lmax+1)*sizeof(double));
    if(par->do_cmblens)
      par->cl_lc=(double *)my_malloc((par->lmax+1)*sizeof(double));
    if(par->do_isw)
      par->cl_li=(double *)my_malloc((par->lmax+1)*sizeof(double));
  }
  if(par->do_cmblens) {
    par->cl_cc=(double *)my_malloc((par->lmax+1)*sizeof(double));
    if(par->do_isw)
      par->cl_ci=(double *)my_malloc((par->lmax+1)*sizeof(double));
  }
  if(par->do_isw)
    par->cl_ii=(double *)my_malloc((par->lmax+1)*sizeof(double));

  if(par->do_w_theta) {
    if(par->do_nc) {
      par->wt_dd=(double *)my_malloc(par->n_th*sizeof(double));
      if(par->do_shear) {
	par->wt_d1l2=(double *)my_malloc(par->n_th*sizeof(double));
	par->wt_d2l1=(double *)my_malloc(par->n_th*sizeof(double));
      }
      if(par->do_cmblens)
	par->wt_dc=(double *)my_malloc(par->n_th*sizeof(double));
      if(par->do_isw)
	par->wt_di=(double *)my_malloc(par->n_th*sizeof(double));
    }
    if(par->do_shear) {
      par->wt_ll_pp=(double *)my_malloc(par->n_th*sizeof(double));
      par->wt_ll_mm=(double *)my_malloc(par->n_th*sizeof(double));
      if(par->do_cmblens)
	par->wt_lc=(double *)my_malloc(par->n_th*sizeof(double));
      if(par->do_isw)
	par->wt_li=(double *)my_malloc(par->n_th*sizeof(double));
    }
    if(par->do_cmblens) {
      par->wt_cc=(double *)my_malloc(par->n_th*sizeof(double));
      if(par->do_isw)
	par->wt_ci=(double *)my_malloc(par->n_th*sizeof(double));
    }
    if(par->do_isw)
      par->wt_ii=(double *)my_malloc(par->n_th*sizeof(double));
  }
    
  if(par->do_nc || par->do_shear || par->do_cmblens || par->do_isw)
    csm_set_linear_pk(par->cpar,par->fname_pk,D_LKMIN,D_LKMAX,0.01,par->ns,par->s8);
  
  if(par->do_nc || par->do_shear) {
    par->wind_0=my_malloc(2*sizeof(SplPar *));
    for(ibin=0;ibin<2;ibin++) {
      printf("Reading window function %s\n",par->fname_window[ibin]);
      fi=my_fopen(par->fname_window[ibin],"r");
      n=my_linecount(fi); rewind(fi);
      //Read unnormalized window
      x=(double *)my_malloc(n*sizeof(double));
      y=(double *)my_malloc(n*sizeof(double));
      for(ii=0;ii<n;ii++) {
	stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
	if(stat!=2)
	  report_error(1,"Error reading file, line %d\n",ii+1);
      }
      fclose(fi);
      par->wind_0[ibin]=spline_init(n,x,y,0.,0.);
      //Normalize window
      double norm,enorm;
      gsl_function F;
      gsl_integration_workspace *w=gsl_integration_workspace_alloc(1000);
      F.function=&speval_bis;
      F.params=par->wind_0[ibin];
      gsl_integration_qag(&F,x[0],x[n-1],0,1E-4,1000,GSL_INTEG_GAUSS41,w,&norm,&enorm);
      gsl_integration_workspace_free(w);
      for(ii=0;ii<n;ii++)
      	y[ii]/=norm;
      spline_free(par->wind_0[ibin]);
      par->wind_0[ibin]=spline_init(n,x,y,0.,0.);

      double zmin,zmax;
      double ymax=-1000;
      for(ii=0;ii<n;ii++) {
	if(y[ii]>ymax)
	  ymax=y[ii];
      }
      ii=0;
      while(y[ii]<1E-3*ymax)
	ii++;
      zmin=x[ii];
      ii=n-1;
      while(y[ii]<1E-3*ymax)
	ii--;
      zmax=x[ii];

      par->chimin_nc[ibin]=csm_radial_comoving_distance(par->cpar,1./(1+zmin));
      par->chimax_nc[ibin]=csm_radial_comoving_distance(par->cpar,1./(1+zmax));
#ifdef _DEBUG
      printf("%d %lE %lE %lE %lE\n",
	     ibin,zmin,zmax,par->chimin_nc[ibin],par->chimax_nc[ibin]);
#endif //_DEBUG

      free(x); free(y);
    }
  }

  if(par->do_nc) {
    if(par->has_dens==1) {
      printf("Reading bias function %s\n",par->fname_bias);
      fi=my_fopen(par->fname_bias,"r");
      n=my_linecount(fi); rewind(fi);
      //Read bias
      x=(double *)my_malloc(n*sizeof(double));
      y=(double *)my_malloc(n*sizeof(double));
      for(ii=0;ii<n;ii++) {
	stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
	if(stat!=2)
	  report_error(1,"Error reading file, line %d\n",ii+1);
      }
      fclose(fi);
      par->bias=spline_init(n,x,y,y[0],y[n-1]);
      free(x); free(y);
    }

    if(par->has_lensing==1) {
      printf("Reading s-bias function %s\n",par->fname_sbias);
      fi=my_fopen(par->fname_sbias,"r");
      n=my_linecount(fi); rewind(fi);
      //Read s-bias
      x=(double *)my_malloc(n*sizeof(double));
      y=(double *)my_malloc(n*sizeof(double));
      for(ii=0;ii<n;ii++) {
	stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
	if(stat!=2)
	  report_error(1,"Error reading file, line %d\n",ii+1);
      }
      fclose(fi);
      par->sbias=spline_init(n,x,y,y[0],y[n-1]);
      free(x); free(y);
    
      printf("Computing lensing magnification window function\n");
      par->wind_M=my_malloc(2*sizeof(SplPar *));
      for(ibin=0;ibin<2;ibin++) {
	double dchi_here;
	double zmax=par->wind_0[ibin]->xf;
	double chimax=csm_radial_comoving_distance(par->cpar,1./(1+zmax));
	n=(int)(chimax/par->dchi)+1;
	dchi_here=chimax/n;
      
	x=(double *)my_malloc(n*sizeof(double));
	y=(double *)my_malloc(n*sizeof(double));

#ifdef _HAVE_OMP
#pragma omp parallel default(none) shared(n,x,y,par,dchi_here,ibin) 
	{
#endif //_HAVE_OMP
	  int j;
	  
#ifdef _HAVE_OMP
#pragma omp for	
#endif //_HAVE_OMP
	  for(j=0;j<n;j++) {
	    x[j]=dchi_here*j;
	    y[j]=window_magnification(x[j],par,ibin);
	  } //end omp for
#ifdef _HAVE_OMP
	} //end omp parallel
#endif //_HAVE_OMP
	par->wind_M[ibin]=spline_init(n,x,y,y[0],0);
	free(x); free(y);
      }
    }
  }

  if(par->do_shear) {
    if(par->has_intrinsic_alignment==1) {
      printf("Reading IA bias function %s\n",par->fname_abias);
      fi=my_fopen(par->fname_abias,"r");
      n=my_linecount(fi); rewind(fi);
    //Read bias
      x=(double *)my_malloc(n*sizeof(double));
      y=(double *)my_malloc(n*sizeof(double));
      for(ii=0;ii<n;ii++) {
	stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
	if(stat!=2)
	  report_error(1,"Error reading file, line %d\n",ii+1);
      }
      fclose(fi);
      par->abias=spline_init(n,x,y,y[0],y[n-1]);
      free(x); free(y);
    }

    printf("Computing lensing window function\n");
    par->wind_L=my_malloc(2*sizeof(SplPar *));
    for(ibin=0;ibin<2;ibin++) {
      double dchi_here;
      double zmax=par->wind_0[ibin]->xf;
      double chimax=csm_radial_comoving_distance(par->cpar,1./(1+zmax));
      n=(int)(chimax/par->dchi)+1;
      dchi_here=chimax/n;
    
      x=(double *)my_malloc(n*sizeof(double));
      y=(double *)my_malloc(n*sizeof(double));
    
#ifdef _HAVE_OMP
#pragma omp parallel default(none) shared(n,x,y,par,dchi_here,ibin) 
      {
#endif //_HAVE_OMP
	int j;
	
#ifdef _HAVE_OMP
#pragma omp for	
#endif //_HAVE_OMP
	for(j=0;j<n;j++) {
	  x[j]=dchi_here*j;
	  y[j]=window_lensing(x[j],par,ibin);
	}
#ifdef _HAVE_OMP
      } //end omp parallel
#endif //_HAVE_OMP
      par->wind_L[ibin]=spline_init(n,x,y,y[0],0);
      free(x); free(y);
    }
  }

#ifdef _DEBUG
  print_bg(par);
#endif //_DEBUG
  return par;
}