expr extract(expr const & e) {
lean_assert(is_nested_declaration(e));
expr const & d = visit(get_nested_declaration_arg(e));
name new_name = mk_name_for(e);
name new_real_name = get_namespace(m_env) + new_name;
collected_locals locals;
collect_locals(d, locals);
buffer<name> uparams;
collect_univ_params(d).to_buffer(uparams);
expr new_value = Fun(locals.get_collected(), d);
expr new_type = m_tc.infer(new_value).first;
level_param_names new_ps = to_list(uparams);
levels ls = param_names_to_levels(new_ps);
m_env = module::add(m_env, check(m_env, mk_definition(m_env, new_real_name, new_ps,
new_type, new_value)));
if (new_name != new_real_name)
m_env = add_expr_alias_rec(m_env, new_name, new_real_name);
decl_attributes const & attrs = get_nested_declaration_attributes(e);
m_env = attrs.apply(m_env, m_ios, new_real_name, get_namespace(m_env));
return mk_app(mk_constant(new_real_name, ls), locals.get_collected());
}
std::vector<const k8s_pod_t*> k8s_service_t::get_selected_pods(const std::vector<k8s_pod_t>& pods) const
{
std::vector<const k8s_pod_t*> pod_vec;
for(const auto& pod : pods)
{
if (selectors_in_labels(pod.get_labels()) && get_namespace() == pod.get_namespace())
{
pod_vec.push_back(&pod);
}
}
return pod_vec;
}
name mk_name_for(expr const & e) {
lean_assert(is_nested_declaration(e));
if (auto n = get_nested_declaration_name(e)) {
return *n;
} else {
name ns = get_namespace(m_env);
while (true) {
name aux = m_dname.append_after(m_idx);
m_idx++;
if (!m_env.find(ns + aux))
return aux;
}
}
}
Oid
name2id_cfg(text *name)
{
Oid arg[1];
bool isnull;
Datum pars[1];
int stat;
Oid id = findSNMap_t(&(CList.name2id_map), name);
void *plan;
char *nsp;
char buf[1024];
arg[0] = TEXTOID;
pars[0] = PointerGetDatum(name);
if (id)
return id;
nsp = get_namespace(TSNSP_FunctionOid);
SPI_connect();
sprintf(buf, "select oid from %s.pg_ts_cfg where ts_name = $1", nsp);
plan = SPI_prepare(buf, 1, arg);
if (!plan)
/* internal error */
elog(ERROR, "SPI_prepare() failed");
stat = SPI_execp(plan, pars, " ", 1);
if (stat < 0)
/* internal error */
elog(ERROR, "SPI_execp return %d", stat);
if (SPI_processed > 0)
{
id = DatumGetObjectId(SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull));
if (isnull)
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("null id for tsearch config")));
}
else
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("no tsearch config")));
SPI_freeplan(plan);
SPI_finish();
addSNMap_t(&(CList.name2id_map), name, id);
return id;
}
int
agent_flush_erroneous_container(worker_t *worker, GError **error)
{
GError *error_local = NULL;
request_t *req = NULL;
struct namespace_data_s *ns_data = NULL;
char ns_name[LIMIT_LENGTH_NSNAME+1];
gsize req_param_length;
TRACE_POSITION();
memset(ns_name, 0x00, sizeof(ns_name));
/*parse the request args, find the namespace*/
req = (request_t*) worker->data.session;
req_param_length = req->arg ? strlen(req->arg) : 0;
if (req_param_length<=0 || req_param_length>=LIMIT_LENGTH_NSNAME)
return __respond_message(worker, 0, "Invalid REQUEST format", error);
g_memmove( ns_name, req->arg, req_param_length);
ns_data = get_namespace(ns_name, &error_local);
if (!ns_data || !ns_data->configured)
return __respond_message(worker, 0, "NAMESPACE not found/ready", error);
DEBUG("Flushing the broken elements on [%s]", ns_name);
/*free outgoing data*/
if (ns_data->list_broken) {
g_slist_foreach( ns_data->list_broken, g_free1, NULL);
g_slist_free( ns_data->list_broken);
ns_data->list_broken = NULL;
}
/* Ask a distant flush, on the conscience */
if (!create_sub_worker(ns_data, worker, &error_local)) {
GSETERROR(&error_local, "Failed to connect to the conscience");
return __respond_error(worker, error_local, error);
}
/*free incomed data*/
if (ns_data->conscience && ns_data->conscience->broken_elements)
broken_holder_flush( ns_data->conscience->broken_elements );
if (error_local)
g_clear_error(&error_local);
worker->func = agent_worker_default_func;
return 1;
}
void
init_dict(Oid id, DictInfo * dict)
{
Oid arg[1];
bool isnull;
Datum pars[1];
int stat;
void *plan;
char buf[1024];
char *nsp = get_namespace(TSNSP_FunctionOid);
arg[0] = OIDOID;
pars[0] = ObjectIdGetDatum(id);
memset(dict, 0, sizeof(DictInfo));
SPI_connect();
sprintf(buf, "select dict_init, dict_initoption, dict_lexize from %s.pg_ts_dict where oid = $1", nsp);
pfree(nsp);
plan = SPI_prepare(buf, 1, arg);
if (!plan)
ts_error(ERROR, "SPI_prepare() failed");
stat = SPI_execp(plan, pars, " ", 1);
if (stat < 0)
ts_error(ERROR, "SPI_execp return %d", stat);
if (SPI_processed > 0)
{
Datum opt;
Oid oid = InvalidOid;
oid = DatumGetObjectId(SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull));
if (!(isnull || oid == InvalidOid))
{
opt = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 2, &isnull);
dict->dictionary = (void *) DatumGetPointer(OidFunctionCall1(oid, opt));
}
oid = DatumGetObjectId(SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 3, &isnull));
if (isnull || oid == InvalidOid)
ts_error(ERROR, "Null dict_lexize for dictonary %d", id);
fmgr_info_cxt(oid, &(dict->lexize_info), TopMemoryContext);
dict->dict_id = id;
}
else
ts_error(ERROR, "No dictionary with id %d", id);
SPI_freeplan(plan);
SPI_finish();
}
void
init_prs(Oid id, WParserInfo * prs)
{
Oid arg[1];
bool isnull;
Datum pars[1];
int stat;
void *plan;
char buf[1024],
*nsp;
arg[0] = OIDOID;
pars[0] = ObjectIdGetDatum(id);
memset(prs, 0, sizeof(WParserInfo));
SPI_connect();
nsp = get_namespace(TSNSP_FunctionOid);
sprintf(buf, "select prs_start, prs_nexttoken, prs_end, prs_lextype, prs_headline from %s.pg_ts_parser where oid = $1", nsp);
pfree(nsp);
plan = SPI_prepare(buf, 1, arg);
if (!plan)
ts_error(ERROR, "SPI_prepare() failed");
stat = SPI_execp(plan, pars, " ", 1);
if (stat < 0)
ts_error(ERROR, "SPI_execp return %d", stat);
if (SPI_processed > 0)
{
Oid oid = InvalidOid;
oid = DatumGetObjectId(SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull));
fmgr_info_cxt(oid, &(prs->start_info), TopMemoryContext);
oid = DatumGetObjectId(SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 2, &isnull));
fmgr_info_cxt(oid, &(prs->getlexeme_info), TopMemoryContext);
oid = DatumGetObjectId(SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 3, &isnull));
fmgr_info_cxt(oid, &(prs->end_info), TopMemoryContext);
prs->lextype = DatumGetObjectId(SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 4, &isnull));
oid = DatumGetObjectId(SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 5, &isnull));
fmgr_info_cxt(oid, &(prs->headline_info), TopMemoryContext);
prs->prs_id = id;
}
else
ts_error(ERROR, "No parser with id %d", id);
SPI_freeplan(plan);
SPI_finish();
}
int
agent_store_erroneous_container(worker_t *worker, GError **error)
{
GError *error_local = NULL;
gchar ns_name[LIMIT_LENGTH_NSNAME], broken_element[2048], **tokens;
request_t *req = NULL;
namespace_data_t *ns_data = NULL;
TRACE_POSITION();
memset(ns_name, 0x00, sizeof(ns_name));
memset(broken_element, 0x00, sizeof(broken_element));
if (!flag_manage_broken)
return __respond_message(worker, 0, "Broken elements not managed", error);
/*extract the fields packed in the request's parameter*/
req = (request_t*)worker->data.session;
tokens = buffer_split( req->arg, req->arg_size, ":", 2);
if (!tokens) {
GSETERROR(&error_local, "Invalid format (0)");
return 0;
}
else if (!tokens[0] || !tokens[1]) {
g_strfreev(tokens);
return __respond_message(worker, 0, "Invalid REQUEST format", error);
}
g_strlcpy(ns_name, tokens[0], sizeof(ns_name)-1);
g_strlcpy(broken_element, tokens[1], sizeof(broken_element)-1);
g_strfreev(tokens);
tokens = NULL;
DEBUG("[NS=%s] broken element received [%s]", ns_name, broken_element);
/* Get an initiated namespace data */
ns_data = get_namespace(ns_name, NULL);
if (!ns_data || !ns_data->configured)
return __respond_message(worker, 0, "NAMESPACE not found/ready", error);
if (!broken_holder_check_element_format( ns_data->conscience->broken_elements, broken_element))
return __respond_message(worker, 0, "Invalid ELEMENT format", error);
/*Element seems OK, keep it*/
ns_data->list_broken = g_slist_prepend(ns_data->list_broken, g_strdup(broken_element));
return __respond_message(worker, 1, "OK", error);
}
int
get_currcfg(void)
{
Oid arg[1] = {TEXTOID};
const char *curlocale;
Datum pars[1];
bool isnull;
int stat;
char buf[1024];
char *nsp;
void *plan;
if (current_cfg_id > 0)
return current_cfg_id;
nsp = get_namespace(TSNSP_FunctionOid);
SPI_connect();
sprintf(buf, "select oid from %s.pg_ts_cfg where locale = $1 ", nsp);
pfree(nsp);
plan = SPI_prepare(buf, 1, arg);
if (!plan)
/* internal error */
elog(ERROR, "SPI_prepare() failed");
curlocale = setlocale(LC_CTYPE, NULL);
pars[0] = PointerGetDatum(char2text((char *) curlocale));
stat = SPI_execp(plan, pars, " ", 1);
if (stat < 0)
/* internal error */
elog(ERROR, "SPI_execp return %d", stat);
if (SPI_processed > 0)
current_cfg_id = DatumGetObjectId(SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull));
else
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("could not find tsearch config by locale")));
pfree(DatumGetPointer(pars[0]));
SPI_freeplan(plan);
SPI_finish();
return current_cfg_id;
}
Oid
name2id_prs(text *name)
{
Oid arg[1];
bool isnull;
Datum pars[1];
int stat;
Oid id = findSNMap_t(&(PList.name2id_map), name);
char buf[1024],
*nsp;
void *plan;
arg[0] = TEXTOID;
pars[0] = PointerGetDatum(name);
if (id)
return id;
SPI_connect();
nsp = get_namespace(TSNSP_FunctionOid);
sprintf(buf, "select oid from %s.pg_ts_parser where prs_name = $1", nsp);
pfree(nsp);
plan = SPI_prepare(buf, 1, arg);
if (!plan)
ts_error(ERROR, "SPI_prepare() failed");
stat = SPI_execp(plan, pars, " ", 1);
if (stat < 0)
ts_error(ERROR, "SPI_execp return %d", stat);
if (SPI_processed > 0)
id = DatumGetObjectId(SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull));
else
ts_error(ERROR, "No parser '%s'", text2char(name));
SPI_freeplan(plan);
SPI_finish();
addSNMap_t(&(PList.name2id_map), name, id);
return id;
}
environment push_scope(environment const & env, io_state const & ios, scope_kind k, name const & n) {
if (k == scope_kind::Namespace && in_section(env))
throw exception("invalid namespace declaration, a namespace cannot be declared inside a section");
name new_n = get_namespace(env);
if (k == scope_kind::Namespace)
new_n = new_n + n;
scope_mng_ext ext = get_extension(env);
bool save_ns = false;
if (!ext.m_namespace_set.contains(new_n)) {
save_ns = true;
ext.m_namespace_set.insert(new_n);
}
ext.m_namespaces = cons(new_n, ext.m_namespaces);
ext.m_headers = cons(n, ext.m_headers);
ext.m_scope_kinds = cons(k, ext.m_scope_kinds);
environment r = update(env, ext);
for (auto const & t : get_exts()) {
r = std::get<0>(t)(r, ios, k);
}
if (save_ns)
r = module::add(r, *g_new_namespace_key, [=](environment const &, serializer & s) { s << new_n; });
return r;
}
/* ------------------------------------------------------------------------- */
int
nvsd_mon_handle_get(const char *bname,
const tstr_array * bname_parts,
void *data, bn_binding_array * resp_bindings)
{
int err = 0;
bn_binding *binding = NULL;
uint32 num_parts = 0;
UNUSED_ARGUMENT(data);
/*
* Check if the node is of interest to us
*/
if ((!lc_is_prefix("/nkn/nvsd/buffermgr/monitor", bname, false)) &&
(!lc_is_prefix("/nkn/nvsd/am/monitor", bname, false)) &&
(!lc_is_prefix("/nkn/nvsd/resource_mgr/ns", bname, false)) &&
(!lc_is_prefix("/nkn/nvsd/resource_mgr/monitor", bname, false)) &&
(!lc_is_prefix("/nkn/nvsd/services/monitor/state/nvsd",
bname, false))) {
/*
* Not for us
*/
goto bail;
}
num_parts = tstr_array_length_quick(bname_parts);
if (!strcmp("/nkn/nvsd/buffermgr/monitor/cachesize", bname)) {
err = bn_binding_new_parts_uint32
(&binding, bname, bname_parts, true, ba_value, 0, glob_ram_cachesize);
bail_error(err);
} else if (!strcmp
("/nkn/nvsd/buffermgr/monitor/max_cachesize_calculated", bname)) {
err =
bn_binding_new_parts_uint32(&binding, bname, bname_parts, true,
ba_value, 0,
g_max_ram_cachesize_calculated);
bail_error(err);
} else if (!strcmp("/nkn/nvsd/buffermgr/monitor/attributecount", bname)) {
err = bn_binding_new_parts_uint32
(&binding, bname, bname_parts, true,
ba_value, 0, (uint32_t) glob_bm_min_attrcount);
bail_error(err);
} else if (bn_binding_name_parts_pattern_match(bname_parts, true,
"/nkn/nvsd/resource_mgr/ns/*/cache_tier1_util")
|| bn_binding_name_parts_pattern_match(bname_parts, true,
"/nkn/nvsd/resource_mgr/ns/*/cache_tier2_util")
|| bn_binding_name_parts_pattern_match(bname_parts, true,
"/nkn/nvsd/resource_mgr/ns/*/cache_tier3_util")) {
/*
* Get the namespace node data,get the nsuid,
Call ns_stat_get_stat_token,
call ns_stat_get
We should be getting cache utilization per namespace.
compute the percentage acroos the reserved space for the resource pool
associated with the namespace.
*/
namespace_node_data_t *pstNamespace = NULL;
int ns_idx = 0;
ns_stat_token_t ns_stoken = NS_NULL_STAT_TOKEN;
uint64_t res_max = 0;
int64_t counter_val = 0;
uint64_t cache_ratio = 0;
const char *ns_namespace = NULL;
const char *str_res_type = NULL;
ns_stat_category_t ns_stat_category;
rp_type_en rp_type;
str_res_type = tstr_array_get_str_quick(bname_parts, num_parts - 1);
bail_null(str_res_type);
ns_namespace = tstr_array_get_str_quick(bname_parts, num_parts - 2);
bail_null(ns_namespace);
err = search_namespace(ns_namespace, &ns_idx);
bail_error(err);
pstNamespace = get_namespace(ns_idx);
if (pstNamespace && pstNamespace->uid)
ns_stoken = ns_stat_get_stat_token(pstNamespace->uid + 1);
if (!strcmp(str_res_type, "cache_tier1_util")) {
rp_type = RESOURCE_POOL_TYPE_UTIL_TIER1;
ns_stat_category = NS_USED_SPACE_SSD;
} else if (!strcmp(str_res_type, "cache_tier2_util")) {
rp_type = RESOURCE_POOL_TYPE_UTIL_TIER2;
ns_stat_category = NS_USED_SPACE_SAS;
} else if (!strcmp(str_res_type, "cache_tier3_util")) {
rp_type = RESOURCE_POOL_TYPE_UTIL_TIER3;
ns_stat_category = NS_USED_SPACE_SATA;
} else {
lc_log_basic(LOG_NOTICE, "Invalid resource Type");
if (ns_is_stat_token_null(ns_stoken))
ns_stat_free_stat_token(ns_stoken);
goto bail;
}
err = ns_stat_get(ns_stoken, ns_stat_category, &counter_val);
res_max =
AO_load(&pstNamespace->resource_pool->resources[rp_type - 1].max);
if (res_max) {
cache_ratio = ((uint64_t) counter_val / res_max) * 100;
}
ns_stat_free_stat_token(ns_stoken);
err = bn_binding_new_parts_uint64
(&binding, bname, bname_parts, true, ba_value, 0, cache_ratio);
bail_error(err);
} else if (!strcmp("/nkn/nvsd/buffermgr/monitor/cal_max_dict_size", bname)) {
err = bn_binding_new_parts_uint32
(&binding, bname, bname_parts, true,
ba_value, 0, g_cal_ram_dictsize_MB);
bail_error(err);
} else if (!strcmp("/nkn/nvsd/am/monitor/cal_am_mem_limit", bname)) {
err = bn_binding_new_parts_uint32
(&binding, bname, bname_parts, true,
ba_value, 0, g_cal_AM_mem_limit);
bail_error(err);
} else if (bn_binding_name_parts_pattern_match(bname_parts, true,
"/nkn/nvsd/resource_mgr/monitor/external/**")) {
const char *rsrc_pool = NULL;
const char *rsrc_name = NULL;
const char *get_type = NULL;
resource_pool_t *rp = NULL;
rp_type_en rp_type;
uint64_t res_used;
uint64_t res_max;
rsrc_pool = tstr_array_get_str_quick(bname_parts, num_parts - 3);
rsrc_name = tstr_array_get_str_quick(bname_parts, num_parts - 1);
get_type = tstr_array_get_str_quick(bname_parts, num_parts - 2);
bail_null(rsrc_pool);
bail_null(rsrc_name);
bail_null(get_type);
lc_log_basic(LOG_DEBUG,
"monitor request for rsrc mgr pool = %s, rsrc_name = %s, get_type = %s",
rsrc_pool, rsrc_name, get_type);
if (!strcmp(rsrc_name, "client_sessions")) {
rp_type = RESOURCE_POOL_TYPE_CLIENT_SESSION;
} else if (!strcmp(rsrc_name, "origin_sessions")) {
rp_type = RESOURCE_POOL_TYPE_ORIGIN_SESSION;
} else if (!strcmp(rsrc_name, "max_bandwidth")) {
rp_type = RESOURCE_POOL_TYPE_BW;
} else if (!strcmp(rsrc_name, "reserved_diskspace_tier1")) {
rp_type = RESOURCE_POOL_TYPE_UTIL_TIER1;
} else if (!strcmp(rsrc_name, "reserved_diskspace_tier2")) {
rp_type = RESOURCE_POOL_TYPE_UTIL_TIER2;
} else if (!strcmp(rsrc_name, "reserved_diskspace_tier3")) {
rp_type = RESOURCE_POOL_TYPE_UTIL_TIER3;
} else {
lc_log_basic(LOG_NOTICE, "Invalid Resource Type");
}
if (rp_type > RESOURCE_POOL_MAX)
goto bail;
rp = nvsd_mgmt_get_resource_mgr(rsrc_pool);
if (rp && (rp->resources) && (strcmp(get_type, "available") == 0)) {
res_used = AO_load(&rp->resources[rp_type - 1].used);
res_max = AO_load(&rp->resources[rp_type - 1].max);
err = bn_binding_new_parts_uint64
(&binding, bname, bname_parts, true,
ba_value, 0, res_max - res_used);
bail_error(err);
} else if (rp && (rp->resources) && (strcmp(get_type, "used") == 0)) {
// For Bw get the value from g_rsrc_bw_1_sec
if (rp_type == RESOURCE_POOL_TYPE_BW) {
res_used = g_rsrc_bw_1sec_val[rp->index];
} else {
res_used = AO_load(&rp->resources[rp_type - 1].used);
}
err = bn_binding_new_parts_uint64
(&binding, bname, bname_parts, true, ba_value, 0, res_used);
bail_error(err);
} else if (rp && (rp->resources) && (strcmp(get_type, "max") == 0)) {
res_used = AO_load(&rp->resources[rp_type - 1].max);
err = bn_binding_new_parts_uint64
(&binding, bname, bname_parts, true, ba_value, 0, res_used);
bail_error(err);
}
} else if (!strcmp("/nkn/nvsd/services/monitor/state/nvsd/global", bname)) {
/*
* Based on what is to be used for nvsd delivery readiness send the
* state
*/
const char *ret_msg = NULL;
if (nkn_system_inited && nkn_http_service_inited) {
if ((service_init_flags & PREREAD_INIT)) {
tbool ret = true;
mgmt_disk_tier_t tier;
for (tier = MGMT_TIER_SATA; tier < MGMT_TIER_MAX; tier++) {
ret &= is_dm2_preread_done(tier);
}
ret_msg = ret ? ("Ready") : ("Initializing");
} else {
ret_msg = "Ready";
}
} else {
ret_msg = "Initializing";
}
err = bn_binding_new_parts_str(&binding, bname, bname_parts, true,
ba_value, bt_string, 0, ret_msg);
bail_error(err);
} else if (!strcmp("/nkn/nvsd/services/monitor/state/nvsd/mgmt", bname)) {
/*
* Based on what is to be used for nvsd delivery readiness send the
* state
*/
const char *ret_msg = NULL;
if (nvsd_mgmt_thrd_initd) {
ret_msg = "Ready";
} else {
ret_msg = "Initializing";
}
err = bn_binding_new_parts_str(&binding, bname, bname_parts, true,
ba_value, bt_string, 0, ret_msg);
bail_error(err);
} else if (!strcmp ("/nkn/nvsd/services/monitor/state/nvsd/preread/global"
, bname)) {
/*
* Based on what is to be used for nvsd delivery readiness send the
* state
*/
const char *ret_msg = NULL;
tbool ret = true;
mgmt_disk_tier_t tier;
for (tier = MGMT_TIER_SATA; tier < MGMT_TIER_MAX; tier++) {
ret &= is_dm2_preread_done(tier);
}
if (ret) {
ret_msg = "Ready";
} else {
ret_msg = "Initializing";
}
if (!glob_dm2_init_done)
ret_msg = "Initializing";
err = bn_binding_new_parts_str(&binding, bname, bname_parts, true,
ba_value, bt_string, 0, ret_msg);
bail_error(err);
} else if (!strcmp("/nkn/nvsd/services/monitor/state/nvsd/preread/sas"
, bname)) {
/*
* Based on what is to be used for nvsd delivery readiness send the
* state
*/
const char *ret_msg = NULL;
if (is_dm2_preread_done(MGMT_TIER_SAS)) {
ret_msg = "Done";
} else {
ret_msg = "Reading";
}
if (!glob_dm2_sas_tier_avl)
ret_msg = "Hardware not present";
err = bn_binding_new_parts_str(&binding, bname, bname_parts, true,
ba_value, bt_string, 0, ret_msg);
bail_error(err);
} else if (!strcmp("/nkn/nvsd/services/monitor/state/nvsd/preread/ssd"
, bname)) {
/*
* Based on what is to be used for nvsd delivery readiness send the
* state
*/
const char *ret_msg = NULL;
if (is_dm2_preread_done(MGMT_TIER_SSD)) {
ret_msg = "Done";
} else {
ret_msg = "Reading";
}
if (!glob_dm2_ssd_tier_avl)
ret_msg = "Hardware not present";
err = bn_binding_new_parts_str(&binding, bname, bname_parts, true,
ba_value, bt_string, 0, ret_msg);
bail_error(err);
} else if (!strcmp ("/nkn/nvsd/services/monitor/state/nvsd/preread/sata"
, bname)) {
/*
* Based on what is to be used for nvsd delivery readiness send the
* state
*/
const char *ret_msg = NULL;
if (is_dm2_preread_done(MGMT_TIER_SATA)) {
ret_msg = "Done";
} else {
ret_msg = "Reading";
}
if (!glob_dm2_sata_tier_avl)
ret_msg = "Hardware not present";
err = bn_binding_new_parts_str(&binding, bname, bname_parts, true,
ba_value, bt_string, 0, ret_msg);
bail_error(err);
} else if (!strcmp("/nkn/nvsd/services/monitor/state/nvsd/network", bname)) {
/*
* Based on what is to be used for nvsd delivery readiness send the
* state
*/
const char *ret_msg = NULL;
if (nkn_http_service_inited) {
ret_msg = "Ready";
} else {
ret_msg = "Initializing";
}
err = bn_binding_new_parts_str(&binding, bname, bname_parts, true,
ba_value, bt_string, 0, ret_msg);
bail_error(err);
}
if (binding) {
err = bn_binding_array_append_takeover(resp_bindings, &binding);
bail_error(err);
}
bail:
return (err);
}
abstract_actor_ptr remote_actor_impl(stream_ptr_pair io, string_set expected) {
CPPA_LOGF_TRACE("io{" << io.first.get() << ", " << io.second.get() << "}");
auto mm = get_middleman();
auto pinf = mm->node();
std::uint32_t process_id = pinf->process_id();
// throws on error
io.second->write(&process_id, sizeof(std::uint32_t));
io.second->write(pinf->host_id().data(), pinf->host_id().size());
// deserialize: actor id, process id, node id, interface
actor_id remote_aid;
std::uint32_t peer_pid;
node_id::host_id_type peer_node_id;
std::uint32_t iface_size;
std::set<std::string> iface;
auto& in = io.first;
// -> actor id
in->read(&remote_aid, sizeof(actor_id));
// -> process id
in->read(&peer_pid, sizeof(std::uint32_t));
// -> node id
in->read(peer_node_id.data(), peer_node_id.size());
// -> interface
in->read(&iface_size, sizeof(std::uint32_t));
if (iface_size > max_iface_size) {
throw std::invalid_argument("Remote actor claims to have more than"
+std::to_string(max_iface_size)+
" message types? Someone is trying"
" something nasty!");
}
std::vector<char> strbuf;
for (std::uint32_t i = 0; i < iface_size; ++i) {
std::uint32_t str_size;
in->read(&str_size, sizeof(std::uint32_t));
if (str_size > max_iface_clause_size) {
throw std::invalid_argument("Remote actor claims to have a"
" reply_to<...>::with<...> clause with"
" more than"
+std::to_string(max_iface_clause_size)+
" characters? Someone is"
" trying something nasty!");
}
strbuf.reserve(str_size + 1);
strbuf.resize(str_size);
in->read(strbuf.data(), str_size);
strbuf.push_back('\0');
iface.insert(std::string{strbuf.data()});
}
// deserialization done, check interface
if (iface != expected) {
auto tostr = [](const std::set<std::string>& what) -> std::string {
if (what.empty()) return "actor";
std::string tmp;
tmp = "typed_actor<";
auto i = what.begin();
auto e = what.end();
tmp += *i++;
while (i != e) tmp += *i++;
tmp += ">";
return tmp;
};
auto iface_str = tostr(iface);
auto expected_str = tostr(expected);
if (expected.empty()) {
throw std::invalid_argument("expected remote actor to be a "
"dynamically typed actor but found "
"a strongly typed actor of type "
+ iface_str);
}
if (iface.empty()) {
throw std::invalid_argument("expected remote actor to be a "
"strongly typed actor of type "
+ expected_str +
" but found a dynamically typed actor");
}
throw std::invalid_argument("expected remote actor to be a "
"strongly typed actor of type "
+ expected_str +
" but found a strongly typed actor of type "
+ iface_str);
}
auto pinfptr = make_counted<node_id>(peer_pid, peer_node_id);
if (*pinf == *pinfptr) {
// this is a local actor, not a remote actor
CPPA_LOGF_INFO("remote_actor() called to access a local actor");
auto ptr = get_actor_registry()->get(remote_aid);
return ptr;
}
struct remote_actor_result { remote_actor_result* next; actor value; };
std::mutex qmtx;
std::condition_variable qcv;
intrusive::single_reader_queue<remote_actor_result> q;
mm->run_later([mm, io, pinfptr, remote_aid, &q, &qmtx, &qcv] {
CPPA_LOGC_TRACE("cppa",
"remote_actor$create_connection", "");
auto pp = mm->get_peer(*pinfptr);
CPPA_LOGF_INFO_IF(pp, "connection already exists (re-use old one)");
if (!pp) mm->new_peer(io.first, io.second, pinfptr);
auto res = mm->get_namespace().get_or_put(pinfptr, remote_aid);
q.synchronized_enqueue(qmtx, qcv, new remote_actor_result{0, res});
});
std::unique_ptr<remote_actor_result> result(q.synchronized_pop(qmtx, qcv));
CPPA_LOGF_DEBUG(CPPA_MARG(result, get));
return raw_access::get(result->value);
}
void
init_cfg(Oid id, TSCfgInfo * cfg)
{
Oid arg[2];
bool isnull;
Datum pars[2];
int stat,
i,
j;
text *ptr;
text *prsname = NULL;
char *nsp = get_namespace(TSNSP_FunctionOid);
char buf[1024];
MemoryContext oldcontext;
void *plan;
arg[0] = OIDOID;
arg[1] = OIDOID;
pars[0] = ObjectIdGetDatum(id);
pars[1] = ObjectIdGetDatum(id);
memset(cfg, 0, sizeof(TSCfgInfo));
SPI_connect();
sprintf(buf, "select prs_name from %s.pg_ts_cfg where oid = $1", nsp);
plan = SPI_prepare(buf, 1, arg);
if (!plan)
ts_error(ERROR, "SPI_prepare() failed");
stat = SPI_execp(plan, pars, " ", 1);
if (stat < 0)
ts_error(ERROR, "SPI_execp return %d", stat);
if (SPI_processed > 0)
{
prsname = (text *) DatumGetPointer(
SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull)
);
oldcontext = MemoryContextSwitchTo(TopMemoryContext);
prsname = ptextdup(prsname);
MemoryContextSwitchTo(oldcontext);
cfg->id = id;
}
else
ts_error(ERROR, "No tsearch cfg with id %d", id);
SPI_freeplan(plan);
arg[0] = TEXTOID;
sprintf(buf, "select lt.tokid, map.dict_name from %s.pg_ts_cfgmap as map, %s.pg_ts_cfg as cfg, %s.token_type( $1 ) as lt where lt.alias = map.tok_alias and map.ts_name = cfg.ts_name and cfg.oid= $2 order by lt.tokid desc;", nsp, nsp, nsp);
plan = SPI_prepare(buf, 2, arg);
if (!plan)
ts_error(ERROR, "SPI_prepare() failed");
pars[0] = PointerGetDatum(prsname);
stat = SPI_execp(plan, pars, " ", 0);
if (stat < 0)
ts_error(ERROR, "SPI_execp return %d", stat);
if (SPI_processed <= 0)
ts_error(ERROR, "No parser with id %d", id);
for (i = 0; i < SPI_processed; i++)
{
int lexid = DatumGetInt32(SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 1, &isnull));
ArrayType *toasted_a = (ArrayType *) PointerGetDatum(SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 2, &isnull));
ArrayType *a;
if (!cfg->map)
{
cfg->len = lexid + 1;
cfg->map = (ListDictionary *) malloc(sizeof(ListDictionary) * cfg->len);
if (!cfg->map)
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
memset(cfg->map, 0, sizeof(ListDictionary) * cfg->len);
}
if (isnull)
continue;
a = (ArrayType *) PointerGetDatum(PG_DETOAST_DATUM(DatumGetPointer(toasted_a)));
if (ARR_NDIM(a) != 1)
ts_error(ERROR, "Wrong dimension");
if (ARRNELEMS(a) < 1)
continue;
if (ARR_HASNULL(a))
ts_error(ERROR, "Array must not contain nulls");
cfg->map[lexid].len = ARRNELEMS(a);
cfg->map[lexid].dict_id = (Datum *) malloc(sizeof(Datum) * cfg->map[lexid].len);
if (!cfg->map[lexid].dict_id)
ts_error(ERROR, "No memory");
memset(cfg->map[lexid].dict_id, 0, sizeof(Datum) * cfg->map[lexid].len);
ptr = (text *) ARR_DATA_PTR(a);
oldcontext = MemoryContextSwitchTo(TopMemoryContext);
for (j = 0; j < cfg->map[lexid].len; j++)
{
cfg->map[lexid].dict_id[j] = PointerGetDatum(ptextdup(ptr));
ptr = NEXTVAL(ptr);
}
MemoryContextSwitchTo(oldcontext);
if (a != toasted_a)
pfree(a);
}
SPI_freeplan(plan);
SPI_finish();
cfg->prs_id = name2id_prs(prsname);
pfree(prsname);
pfree(nsp);
for (i = 0; i < cfg->len; i++)
{
for (j = 0; j < cfg->map[i].len; j++)
{
ptr = (text *) DatumGetPointer(cfg->map[i].dict_id[j]);
cfg->map[i].dict_id[j] = ObjectIdGetDatum(name2id_dict(ptr));
pfree(ptr);
}
}
}
void d_int(solid_vm *vm, char *name)
{
debug("%s: %d, type of %d", name, get_int_value(get_namespace(get_current_namespace(vm), solid_str(name))), get_namespace(get_current_namespace(vm), solid_str(name))->type);
}
void d_type(solid_vm *vm, char *name)
{
debug("%s: type of %d", name, get_namespace(get_current_namespace(vm), solid_str(name))->type);
}
void cpp_namespace_spect::output(std::ostream &out) const
{
out << " namespace: " << get_namespace() << std::endl;
}
// cpool_info
// {
// u30 int_count
// s32 integer[int_count]
// u30 uint_count
// u32 uinteger[uint_count]
// u30 double_count
// d64 double[double_count]
// u30 string_count
// string_info string[string_count]
// u30 namespace_count
// namespace_info namespace[namespace_count]
// u30 ns_set_count
// ns_set_info ns_set[ns_set_count]
// u30 multiname_count
// multiname_info multiname[multiname_count]
// }
void abc_def::read_cpool(stream* in)
{
int n;
// integer pool
n = in->read_vu30();
if (n > 0)
{
m_integer.resize(n);
m_integer[0] = 0; // default value
for (int i = 1; i < n; i++)
{
m_integer[i] = in->read_vs32();
IF_VERBOSE_PARSE(log_msg("cpool_info: integer[%d]=%d\n", i, m_integer[i]));
}
}
else
{
IF_VERBOSE_PARSE(log_msg("cpool_info: no integer pool\n"));
}
// uinteger pool
n = in->read_vu30();
if (n > 0)
{
m_uinteger.resize(n);
m_uinteger[0] = 0; // default value
for (int i = 1; i < n; i++)
{
m_uinteger[i] = in->read_vu32();
IF_VERBOSE_PARSE(log_msg("cpool_info: uinteger[%d]=%d\n", i, m_uinteger[i]));
}
}
else
{
IF_VERBOSE_PARSE(log_msg("cpool_info: no uinteger pool\n"));
}
// double pool
n = in->read_vu30();
if (n > 0)
{
m_double.resize(n);
m_double[0] = 0; // default value
for (int i = 1; i < n; i++)
{
m_double[i] = in->read_double();
IF_VERBOSE_PARSE(log_msg("cpool_info: double[%d]=%f\n", i, m_double[i]));
}
}
else
{
IF_VERBOSE_PARSE(log_msg("cpool_info: no double pool\n"));
}
// string pool
n = in->read_vu30();
if (n > 0)
{
m_string.resize(n);
m_string[0] = ""; // default value
for (int i = 1; i < n; i++)
{
int len = in->read_vs32();
in->read_string_with_length(len, &m_string[i]);
IF_VERBOSE_PARSE(log_msg("cpool_info: string[%d]='%s'\n", i, m_string[i].c_str()));
}
}
else
{
IF_VERBOSE_PARSE(log_msg("cpool_info: no string pool\n"));
}
// namespace pool
n = in->read_vu30();
if (n > 0)
{
m_namespace.resize(n);
namespac ns;
m_namespace[0] = ns; // default value
for (int i = 1; i < n; i++)
{
ns.m_kind = static_cast<namespac::kind>(in->read_u8());
ns.m_name = in->read_vu30();
m_namespace[i] = ns;
// User-defined namespaces have kind CONSTANT_Namespace or
// CONSTANT_ExplicitNamespace and a non-empty name.
// System namespaces have empty names and one of the other kinds
switch (ns.m_kind)
{
case namespac::CONSTANT_Namespace:
case namespac::CONSTANT_ExplicitNamespace:
//assert(*get_string(ns.m_name) != 0);
break;
case namespac::CONSTANT_PackageNamespace:
case namespac::CONSTANT_PackageInternalNs:
case namespac::CONSTANT_ProtectedNamespace:
case namespac::CONSTANT_StaticProtectedNs:
case namespac::CONSTANT_PrivateNs:
//assert(*get_string(ns.m_name) == 0);
break;
default:
assert(0);
}
IF_VERBOSE_PARSE(log_msg("cpool_info: namespace[%d]='%s', kind=0x%02X\n",
i, get_string(ns.m_name), ns.m_kind));
}
}
else
{
IF_VERBOSE_PARSE(log_msg("cpool_info: no namespace pool\n"));
}
// namespace sets pool
n = in->read_vu30();
if (n > 0)
{
m_ns_set.resize(n);
swf_array<int> ns;
m_ns_set[0] = ns; // default value
for (int i = 1; i < n; i++)
{
int count = in->read_vu30();
ns.resize(count);
for (int j = 0; j < count; j++)
{
ns[j] = in->read_vu30();
}
m_ns_set[i] = ns;
}
}
else
{
IF_VERBOSE_PARSE(log_msg("cpool_info: no namespace sets\n"));
}
// multiname pool
n = in->read_vu30();
if (n > 0)
{
m_multiname.resize(n);
multiname mn;
m_multiname[0] = mn; // default value
for (int i = 1; i < n; i++)
{
Uint8 kind = in->read_u8();
mn.m_kind = kind;
switch (kind)
{
case multiname::CONSTANT_QName:
case multiname::CONSTANT_QNameA:
{
mn.m_ns = in->read_vu30();
mn.m_name = in->read_vu30();
IF_VERBOSE_PARSE(log_msg("cpool_info: multiname[%d]='%s', ns='%s'\n",
i, get_string(mn.m_name), get_namespace(mn.m_ns)));
break;
}
case multiname::CONSTANT_RTQName:
assert(0&&"todo");
break;
case multiname::CONSTANT_RTQNameA:
assert(0&&"todo");
break;
case multiname::CONSTANT_RTQNameL:
assert(0&&"todo");
break;
case multiname::CONSTANT_RTQNameLA:
assert(0&&"todo");
break;
case multiname::CONSTANT_Multiname:
case multiname::CONSTANT_MultinameA:
mn.m_name = in->read_vu30();
mn.m_ns_set = in->read_vu30();
IF_VERBOSE_PARSE(log_msg("cpool_info: multiname[%d]='%s', ns_set='%s'\n",
i, get_string(mn.m_name), "todo"));
break;
case multiname::CONSTANT_MultinameL:
case multiname::CONSTANT_MultinameLA:
mn.m_ns_set = in->read_vu30();
mn.m_name = -1;
IF_VERBOSE_PARSE(log_msg("cpool_info: multiname[%d]=MultinameL, ns_set='%s'\n",
i, "todo"));
break;
default:
assert(0);
}
m_multiname[i] = mn;
}
}
else
{
IF_VERBOSE_PARSE(log_msg("cpool_info: no multiname pool\n"));
}
}
static gboolean
manage_service(struct service_info_s *si)
{
GError *error_local;
struct service_info_s *old_si = NULL;
struct service_tag_s *tag_first = NULL;
struct namespace_data_s *ns_data;
gsize key_size;
gchar key[LIMIT_LENGTH_SRVTYPE + STRLEN_ADDRINFO], str_addr[STRLEN_ADDRINFO];
if (!si) {
ERROR("Invalid parameter");
return FALSE;
}
key_size = agent_get_service_key(si, key, sizeof(key));
grid_addrinfo_to_string(&(si->addr), str_addr, sizeof(str_addr));
/*this service must refer to known namespace and service type*/
error_local = NULL;
if (!(ns_data = get_namespace(si->ns_name, &error_local))) {
ERROR("Namespace unavailable for service [ns=%s type=%s addr=%s] : %s",
si->ns_name, si->type, str_addr, gerror_get_message(error_local));
if (error_local)
g_error_free(error_local);
return FALSE;
}
/*Info trace when a service of a new type is used */
if (error_local)
g_error_free(error_local);
if (!conscience_get_srvtype(ns_data->conscience, &error_local, si->type, MODE_STRICT)) {
/*to avoid traces flooding, if the service already exists, no trace is sent */
if (!g_hash_table_lookup(ns_data->local_services, key)
&& !g_hash_table_lookup(ns_data->down_services, key)) {
INFO("New service type discovered [ns=%s type=%s addr=%s]", ns_data->name, si->type, str_addr);
}
}
/*replace MACRO tags by their true values */
if (error_local)
g_clear_error(&error_local);
metautils_srvinfo_ensure_tags (si);
si->score.value = SCORE_UNSET;
si->score.timestamp = oio_ext_real_time() / G_TIME_SPAN_SECOND;
/*then keep the score */
g_hash_table_remove(ns_data->down_services, key);
/* save first lauched tag if still in old si */
old_si = g_hash_table_lookup(ns_data->local_services, key);
if (old_si != NULL) {
tag_first = service_info_get_tag(old_si->tags, NAME_TAGNAME_RAWX_FIRST);
if (tag_first != NULL)
service_tag_set_value_boolean(service_info_ensure_tag(si->tags, NAME_TAGNAME_RAWX_FIRST), tag_first->value.b);
}
service_tag_set_value_boolean(service_info_ensure_tag(si->tags, "tag.up"), TRUE);
g_hash_table_insert(ns_data->local_services, g_strndup(key, key_size), si);
DEBUG("Service registration [ns=%s type=%s addr=%s]", ns_data->name, si->type, str_addr);
if (error_local)
g_error_free(error_local);
return TRUE;
}
environment add_token(environment const & env, token_entry const & e, bool persistent) {
return token_ext::add_entry(env, get_dummy_ios(), e, get_namespace(env), persistent);
}
void k8s_event_t::update(const Json::Value& item, k8s_state_t& state)
{
#ifndef _WIN32
time_t epoch_time_s = 0;
string event_name;
string description;
severity_t severity = sinsp_logger::SEV_EVT_INFORMATION;
string scope;
tag_map_t tags;
const Json::Value& obj = item["involvedObject"];
//g_logger.log(Json::FastWriter().write(item), sinsp_logger::SEV_TRACE);
if(!obj.isNull())
{
std::string sev = get_json_string(item, "type");
// currently, only "Normal" and "Warning"
severity = sinsp_logger::SEV_EVT_INFORMATION;
if(sev == "Warning") { severity = sinsp_logger::SEV_EVT_WARNING; }
g_logger.log("K8s EVENT : \ncomponent name = " + get_json_string(obj, "name") +
"\nuid = " + get_json_string(obj, "uid") +
"\ntype = " + get_json_string(obj, "kind") +
"\nseverity = " + get_json_string(item, "type") + " (" + std::to_string(severity) + ')', sinsp_logger::SEV_TRACE);
}
else
{
g_logger.log("K8s event: cannot get involved object (null)", sinsp_logger::SEV_ERROR);
}
std::string ts = get_json_string(item , "lastTimestamp");
if(!ts.empty())
{
if((epoch_time_s = get_epoch_utc_seconds(ts)) == (time_t) -1)
{
g_logger.log("K8s event: cannot convert [" + ts + "] to epoch timestamp", sinsp_logger::SEV_ERROR);
}
g_logger.log("K8s EVENT update: time:" + std::to_string(epoch_time_s), sinsp_logger::SEV_DEBUG);
}
else
{
g_logger.log("K8s event: cannot convert time (null, empty or not string)", sinsp_logger::SEV_ERROR);
}
event_name = get_json_string(item , "reason");
const auto& translation = m_name_translation.find(event_name);
if(translation != m_name_translation.end())
{
event_name = translation->second;
}
description = get_json_string(item, "message");
g_logger.log("K8s EVENT message:" + description, sinsp_logger::SEV_DEBUG);
string component_uid = get_json_string(obj, "uid");
if(!component_uid.empty())
{
std::string t;
const k8s_component* comp = state.get_component(component_uid, &t);
if(comp && !t.empty())
{
std::string node_name = comp->get_node_name();
if(!node_name.empty())
{
if(scope.length()) { scope.append(" and "); }
scope.append("kubernetes.node.name=").append(node_name);
}
if(scope.length()) { scope.append(" and "); }
scope.append("kubernetes.").append(t).append(".name=").append(comp->get_name());
const std::string& ns = get_namespace();
if(!ns.empty())
{
scope.append(" and kubernetes.namespace.name=").append(ns);
}
/* no labels for now
for(const auto& label : comp->get_labels())
{
tags[label.first] = label.second;
g_logger.log("EVENT label: [" + label.first + ':' + label.second + ']', sinsp_logger::SEV_DEBUG);
scope.append(" and kubernetes.").append(t).append(".label.").append(label.first).append(1, '=').append(label.second);
}*/
}
else
{
g_logger.log("K8s event: cannot obtain component (UID not found: [" + component_uid + "])", sinsp_logger::SEV_ERROR);
}
}
else
{
g_logger.log("K8s event: cannot obtain tags (UID not retrieved)", sinsp_logger::SEV_ERROR);
}
tags["source"] = "kubernetes";
g_logger.log(sinsp_user_event::to_string(epoch_time_s, std::move(event_name), std::move(description),
std::move(scope), std::move(tags)), severity);
// TODO: sysdig capture?
#endif // _WIN32
}
