static pa_hook_result_t process(struct userdata *u, pa_proplist *p) {
struct rule *r;
time_t now;
const char *pn;
pa_assert(u);
pa_assert(p);
if (!(pn = pa_proplist_gets(p, PA_PROP_APPLICATION_PROCESS_BINARY)))
return PA_HOOK_OK;
if (*pn == '.' || strchr(pn, '/'))
return PA_HOOK_OK;
time(&now);
pa_log_debug("Looking for .desktop file for %s", pn);
if ((r = pa_hashmap_get(u->cache, pn))) {
if (now-r->timestamp > STAT_INTERVAL) {
r->timestamp = now;
update_rule(r);
}
} else {
make_room(u->cache);
r = pa_xnew0(struct rule, 1);
r->process_name = pa_xstrdup(pn);
r->timestamp = now;
pa_hashmap_put(u->cache, r->process_name, r);
update_rule(r);
}
apply_rule(r, p);
return PA_HOOK_OK;
}
static void
handle_request(void *ctx) {
conn_t *conn = ctx;
struct evbuffer *rsps = evbuffer_new();
struct state *s = conn->state;
if (strcmp(conn->method, "GET") == 0) {
if (strcmp(conn->url, "/getproxies") == 0)
get_proxies(rsps);
else if (strcmp(conn->url, "/getlists") == 0)
get_lists(rsps);
else if (strncmp(conn->url, "/query?", 7) == 0)
query(rsps, evhttp_decode_uri(conn->url + 7));
else if (strcmp(conn->url, "/getlog") == 0)
get_log(rsps);
else if (strcmp(conn->url, "/gettrylist") == 0)
get_trylist(rsps);
else if (strcmp(conn->url, "/getversion") == 0)
evbuffer_add_printf(rsps, VERSION);
}
else if (strcmp(conn->method, "POST") == 0) {
struct evkeyvalq kv;
struct evhttp_uri *uri = evhttp_uri_parse_with_flags(conn->url, 0);
evhttp_parse_query_str(evhttp_uri_get_query(uri), &kv);
char *cont;
if (s->length)
cont = s->body;
const char *path = evhttp_uri_get_path(uri);
if (strcmp(path, "/addrule") == 0 || strcmp(path, "/rmrule") == 0) {
struct evkeyvalq kvc;
evhttp_parse_query_str(cont, &kvc);
char *list = evhttp_decode_uri(evhttp_find_header(&kvc, "list"));
char *rule = evhttp_decode_uri(evhttp_find_header(&kvc, "rule"));
if (get_domain(rule) == NULL)
evbuffer_add_printf(rsps, "Invalid rule.");
else {
if (strcmp(path, "/addrule") == 0)
update_rule(list, rule);
else
remove_rule(list, rule);
evbuffer_add_printf(rsps, "OK");
}
free(list);
free(rule);
free(cont);
}
else if (strcmp(path, "/flush") == 0) {
flush_list();
evbuffer_add_printf(rsps, "OK");
}
else if (strcmp(path, "/rmlog") == 0) {
rm_log(rsps);
}
else if (strcmp(path, "/purgetrylist") == 0) {
purgetrylist(rsps);
}
evhttp_uri_free(uri);
}
ret(conn->be_client, rsps);
evbuffer_free(rsps);
}
void L2SimpleSGDTrainer::update_lookup_params(real scale, real gscale, size_t idx) {
auto &p = model->lookup_parameters_list()[idx];
update_rule(scale, gscale, {&p->all_values, &p->all_grads});
}
void L2SimpleSGDTrainer::update_params(real scale, real gscale, size_t idx) {
auto &p = model->parameters_list()[idx];
update_rule(scale, gscale, {&p->values, &p->g});
}
//! reads foreign keys info from database
void Table::loadForeignKeys()
{
if (foreignKeysLoadedM)
return;
foreignKeysM.clear();
DatabasePtr db = getDatabase();
wxMBConv* conv = db->getCharsetConverter();
MetadataLoader* loader = db->getMetadataLoader();
// first start a transaction for metadata loading, then lock the table
// when objects go out of scope and are destroyed, table will be unlocked
// before the transaction is committed - any update() calls on observers
// can possibly use the same transaction
MetadataLoaderTransaction tr(loader);
SubjectLocker lock(this);
IBPP::Statement& st1 = loader->getStatement(
"select r.rdb$constraint_name, i.rdb$field_name, c.rdb$update_rule, "
" c.rdb$delete_rule, c.RDB$CONST_NAME_UQ, r.rdb$index_name "
"from rdb$relation_constraints r, rdb$index_segments i, rdb$ref_constraints c "
"where r.rdb$relation_name=? and r.rdb$index_name=i.rdb$index_name "
"and r.rdb$constraint_name = c.rdb$constraint_name "
"and (r.rdb$constraint_type='FOREIGN KEY') order by 1, i.rdb$field_position"
);
IBPP::Statement& st2 = loader->getStatement(
"select r.rdb$relation_name, i.rdb$field_name"
" from rdb$relation_constraints r"
" join rdb$index_segments i on i.rdb$index_name = r.rdb$index_name "
" where r.rdb$constraint_name = ?"
" order by i.rdb$field_position "
);
st1->Set(1, wx2std(getName_(), conv));
st1->Execute();
ForeignKey *fkp = 0;
while (st1->Fetch())
{
std::string s;
st1->Get(1, s);
wxString cname(std2wxIdentifier(s, conv));
st1->Get(2, s);
wxString fname(std2wxIdentifier(s, conv));
st1->Get(3, s);
wxString update_rule(std2wxIdentifier(s, conv));
st1->Get(4, s);
wxString delete_rule(std2wxIdentifier(s, conv));
std::string ref_constraint;
st1->Get(5, ref_constraint);
st1->Get(6, s);
wxString ixname(std2wxIdentifier(s, conv));
if (fkp && fkp->getName_() == cname) // add column
fkp->columnsM.push_back(fname);
else
{
ForeignKey fk;
foreignKeysM.push_back(fk);
fkp = &foreignKeysM.back();
fkp->setName_(cname);
fkp->setParent(this);
fkp->updateActionM = update_rule;
fkp->deleteActionM = delete_rule;
fkp->indexNameM = ixname;
st2->Set(1, ref_constraint);
st2->Execute();
std::string rtable;
while (st2->Fetch())
{
st2->Get(1, rtable);
st2->Get(2, s);
fkp->referencedColumnsM.push_back(std2wxIdentifier(s, conv));
}
fkp->referencedTableM = std2wxIdentifier(rtable, conv);
fkp->columnsM.push_back(fname);
}
}
foreignKeysLoadedM = true;
}
