/* since /root <timestamp> [patterns] */
static void cmd_since(struct watchman_client* client, const json_ref& args) {
const char *clockspec;
/* resolve the root */
if (json_array_size(args) < 3) {
send_error_response(client, "not enough arguments for 'since'");
return;
}
auto root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
auto clock_ele = json_array_get(args, 2);
clockspec = json_string_value(clock_ele);
if (!clockspec) {
send_error_response(client,
"expected argument 2 to be a valid clockspec");
return;
}
auto query = w_query_parse_legacy(root, args, 3, nullptr, clockspec, nullptr);
auto res = w_query_execute(query.get(), root, nullptr);
auto response = make_response();
response.set({{"is_fresh_instance", json_boolean(res.is_fresh_instance)},
{"clock", res.clockAtStartOfQuery.toJson()},
{"files", std::move(res.resultsArray)}});
add_root_warnings_to_response(response, root);
send_and_dispose_response(client, std::move(response));
}
ClockSpec watchman_client_subscription::runSubscriptionRules(
watchman_user_client* client,
const std::shared_ptr<w_root_t>& root) {
ClockSpec position;
auto response = buildSubscriptionResults(root, position);
if (response) {
add_root_warnings_to_response(response, root);
client->enqueueResponse(std::move(response), false);
}
return position;
}
/* must be called with root and client locked */
void w_run_subscription_rules(
struct watchman_client *client,
struct watchman_client_subscription *sub,
w_root_t *root)
{
json_t *response = build_subscription_results(sub, root);
if (!response) {
return;
}
add_root_warnings_to_response(response, root);
if (!enqueue_response(client, response, true)) {
w_log(W_LOG_DBG, "failed to queue sub response\n");
json_decref(response);
}
}
/* subscribe /root subname {query}
* Subscribes the client connection to the specified root. */
static void cmd_subscribe(
struct watchman_client* clientbase,
const json_ref& args) {
std::shared_ptr<watchman_client_subscription> sub;
json_ref resp, initial_subscription_results;
json_ref jfield_list;
json_ref jname;
std::shared_ptr<w_query> query;
json_ref query_spec;
int defer = true; /* can't use bool because json_unpack requires int */
json_ref defer_list;
json_ref drop_list;
struct watchman_user_client *client =
(struct watchman_user_client *)clientbase;
if (json_array_size(args) != 4) {
send_error_response(client, "wrong number of arguments for subscribe");
return;
}
auto root = resolve_root_or_err(client, args, 1, true);
if (!root) {
return;
}
jname = args.at(2);
if (!json_is_string(jname)) {
send_error_response(
client, "expected 2nd parameter to be subscription name");
return;
}
query_spec = args.at(3);
query = w_query_parse(root, query_spec);
defer_list = query_spec.get_default("defer");
if (defer_list && !json_is_array(defer_list)) {
send_error_response(client, "defer field must be an array of strings");
return;
}
drop_list = query_spec.get_default("drop");
if (drop_list && !json_is_array(drop_list)) {
send_error_response(client, "drop field must be an array of strings");
return;
}
sub = std::make_shared<watchman_client_subscription>(
root, client->shared_from_this());
sub->name = json_to_w_string(jname);
sub->query = query;
json_unpack(query_spec, "{s?:b}", "defer_vcs", &defer);
sub->vcs_defer = defer;
if (drop_list || defer_list) {
size_t i;
if (defer_list) {
for (i = 0; i < json_array_size(defer_list); i++) {
sub->drop_or_defer[json_to_w_string(json_array_get(defer_list, i))] =
false;
}
}
if (drop_list) {
for (i = 0; i < json_array_size(drop_list); i++) {
sub->drop_or_defer[json_to_w_string(json_array_get(drop_list, i))] =
true;
}
}
}
// If they want SCM aware results we should wait for SCM events to finish
// before dispatching subscriptions
if (query->since_spec && query->since_spec->hasScmParams()) {
sub->vcs_defer = true;
// If they didn't specify any drop/defer behavior, default to a reasonable
// setting that works together with the fsmonitor extension for hg.
if (sub->drop_or_defer.find("hg.update") == sub->drop_or_defer.end()) {
sub->drop_or_defer["hg.update"] = false; // defer
}
}
// Connect the root to our subscription
{
std::weak_ptr<watchman_client> clientRef(client->shared_from_this());
client->unilateralSub.insert(std::make_pair(
sub,
root->unilateralResponses->subscribe(
[clientRef, sub]() {
auto client = clientRef.lock();
if (client) {
client->ping->notify();
}
},
sub->name)));
}
client->subscriptions[sub->name] = sub;
resp = make_response();
resp.set("subscribe", json_ref(jname));
add_root_warnings_to_response(resp, root);
ClockSpec position;
initial_subscription_results = sub->buildSubscriptionResults(root, position);
resp.set("clock", position.toJson());
send_and_dispose_response(client, std::move(resp));
if (initial_subscription_results) {
send_and_dispose_response(client, std::move(initial_subscription_results));
}
}
static void cmd_flush_subscriptions(
struct watchman_client* clientbase,
const json_ref& args) {
auto client = (watchman_user_client*)clientbase;
int sync_timeout;
json_ref subs(nullptr);
if (json_array_size(args) == 3) {
auto& sync_timeout_obj = args.at(2).get("sync_timeout");
subs = args.at(2).get_default("subscriptions", nullptr);
if (!json_is_integer(sync_timeout_obj)) {
send_error_response(client, "'sync_timeout' must be an integer");
return;
}
sync_timeout = json_integer_value(sync_timeout_obj);
} else {
send_error_response(
client, "wrong number of arguments to 'flush-subscriptions'");
return;
}
auto root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
std::vector<w_string> subs_to_sync;
if (subs) {
if (!json_is_array(subs)) {
send_error_response(
client,
"expected 'subscriptions' to be an array of subscription names");
return;
}
for (auto& sub_name : subs.array()) {
if (!json_is_string(sub_name)) {
send_error_response(
client,
"expected 'subscriptions' to be an array of subscription names");
return;
}
auto& sub_name_str = json_to_w_string(sub_name);
auto sub_iter = client->subscriptions.find(sub_name_str);
if (sub_iter == client->subscriptions.end()) {
send_error_response(
client,
"this client does not have a subscription named '%s'",
sub_name_str.c_str());
return;
}
auto& sub = sub_iter->second;
if (sub->root != root) {
send_error_response(
client,
"subscription '%s' is on root '%s' different from command root "
"'%s'",
sub_name_str.c_str(),
sub->root->root_path.c_str(),
root->root_path.c_str());
return;
}
subs_to_sync.push_back(sub_name_str);
}
} else {
// Look for all subscriptions matching this root.
for (auto& sub_iter : client->subscriptions) {
if (sub_iter.second->root == root) {
subs_to_sync.push_back(sub_iter.first);
}
}
}
if (!root->syncToNow(std::chrono::milliseconds(sync_timeout))) {
send_error_response(client, "sync_timeout expired");
return;
}
auto resp = make_response();
auto synced = json_array();
auto no_sync_needed = json_array();
auto dropped = json_array();
for (auto& sub_name_str : subs_to_sync) {
auto sub_iter = client->subscriptions.find(sub_name_str);
auto& sub = sub_iter->second;
sub_action action;
w_string policy_name;
std::tie(action, policy_name) = get_subscription_action(sub.get(), root);
if (action == sub_action::drop) {
auto position = root->view()->getMostRecentRootNumberAndTickValue();
sub->last_sub_tick = position.ticks;
sub->query->since_spec = watchman::make_unique<ClockSpec>(position);
watchman::log(
watchman::DBG,
"(flush-subscriptions) dropping subscription notifications for ",
sub->name,
" until state ",
policy_name,
" is vacated. Advanced ticks to ",
sub->last_sub_tick,
"\n");
json_array_append(dropped, w_string_to_json(sub_name_str));
} else {
// flush-subscriptions means that we _should NOT defer_ notifications. So
// ignore defer and defer_vcs.
ClockSpec out_position;
watchman::log(
watchman::DBG,
"(flush-subscriptions) executing subscription ",
sub->name,
"\n");
auto sub_result = sub->buildSubscriptionResults(root, out_position);
if (sub_result) {
send_and_dispose_response(client, std::move(sub_result));
json_array_append(synced, w_string_to_json(sub_name_str));
} else {
json_array_append(no_sync_needed, w_string_to_json(sub_name_str));
}
}
}
resp.set({{"synced", std::move(synced)},
{"no_sync_needed", std::move(no_sync_needed)},
{"dropped", std::move(dropped)}});
add_root_warnings_to_response(resp, root);
send_and_dispose_response(client, std::move(resp));
}
/* subscribe /root subname {query}
* Subscribes the client connection to the specified root. */
static void cmd_subscribe(struct watchman_client *client, json_t *args)
{
w_root_t *root;
struct watchman_client_subscription *sub;
json_t *resp;
const char *name;
json_t *jfield_list;
w_query *query;
json_t *query_spec;
struct w_query_field_list field_list;
char *errmsg;
int defer = true; /* can't use bool because json_unpack requires int */
json_t *defer_list = NULL;
json_t *drop_list = NULL;
if (json_array_size(args) != 4) {
send_error_response(client, "wrong number of arguments for subscribe");
return;
}
root = resolve_root_or_err(client, args, 1, true);
if (!root) {
return;
}
name = json_string_value(json_array_get(args, 2));
if (!name) {
send_error_response(client,
"expected 2nd parameter to be subscription name");
goto done;
}
query_spec = json_array_get(args, 3);
jfield_list = json_object_get(query_spec, "fields");
if (!parse_field_list(jfield_list, &field_list, &errmsg)) {
send_error_response(client, "invalid field list: %s", errmsg);
free(errmsg);
goto done;
}
query = w_query_parse(root, query_spec, &errmsg);
if (!query) {
send_error_response(client, "failed to parse query: %s", errmsg);
free(errmsg);
goto done;
}
json_unpack(query_spec, "{s?:o}", "defer", &defer_list);
if (defer_list && !json_is_array(defer_list)) {
send_error_response(client, "defer field must be an array of strings");
goto done;
}
json_unpack(query_spec, "{s?:o}", "drop", &drop_list);
if (drop_list && !json_is_array(drop_list)) {
send_error_response(client, "drop field must be an array of strings");
goto done;
}
sub = calloc(1, sizeof(*sub));
if (!sub) {
send_error_response(client, "no memory!");
goto done;
}
sub->name = w_string_new(name);
sub->query = query;
json_unpack(query_spec, "{s?:b}", "defer_vcs", &defer);
sub->vcs_defer = defer;
if (drop_list || defer_list) {
size_t i;
sub->drop_or_defer = w_ht_new(2, &w_ht_string_funcs);
if (defer_list) {
for (i = 0; i < json_array_size(defer_list); i++) {
w_ht_replace(sub->drop_or_defer,
w_ht_ptr_val(w_string_new(json_string_value(
json_array_get(defer_list, i)))), false);
}
}
if (drop_list) {
for (i = 0; i < json_array_size(drop_list); i++) {
w_ht_replace(sub->drop_or_defer,
w_ht_ptr_val(w_string_new(json_string_value(
json_array_get(drop_list, i)))), true);
}
}
}
memcpy(&sub->field_list, &field_list, sizeof(field_list));
sub->root = root;
pthread_mutex_lock(&w_client_lock);
w_ht_replace(client->subscriptions, w_ht_ptr_val(sub->name),
w_ht_ptr_val(sub));
pthread_mutex_unlock(&w_client_lock);
resp = make_response();
annotate_with_clock(root, resp);
set_prop(resp, "subscribe", json_string(name));
add_root_warnings_to_response(resp, root);
send_and_dispose_response(client, resp);
resp = build_subscription_results(sub, root);
if (resp) {
send_and_dispose_response(client, resp);
}
done:
w_root_delref(root);
}
/* query /root {query} */
static void cmd_query(struct watchman_client *client, json_t *args)
{
w_root_t *root;
w_query *query;
json_t *query_spec;
char *errmsg = NULL;
w_query_res res;
json_t *response;
json_t *file_list, *jfield_list;
char clockbuf[128];
struct w_query_field_list field_list;
if (json_array_size(args) != 3) {
send_error_response(client, "wrong number of arguments for 'query'");
return;
}
root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
query_spec = json_array_get(args, 2);
jfield_list = json_object_get(query_spec, "fields");
if (!parse_field_list(jfield_list, &field_list, &errmsg)) {
send_error_response(client, "invalid field list: %s", errmsg);
free(errmsg);
w_root_delref(root);
return;
}
query = w_query_parse(root, query_spec, &errmsg);
if (!query) {
send_error_response(client, "failed to parse query: %s", errmsg);
free(errmsg);
w_root_delref(root);
return;
}
if (client->client_mode) {
query->sync_timeout = 0;
}
if (!w_query_execute(query, root, &res, NULL, NULL)) {
send_error_response(client, "query failed: %s", res.errmsg);
w_query_result_free(&res);
w_root_delref(root);
w_query_delref(query);
return;
}
w_query_delref(query);
file_list = w_query_results_to_json(&field_list,
res.num_results, res.results);
w_query_result_free(&res);
response = make_response();
if (clock_id_string(res.root_number, res.ticks, clockbuf, sizeof(clockbuf))) {
set_prop(response, "clock", json_string_nocheck(clockbuf));
}
set_prop(response, "is_fresh_instance",
json_pack("b", res.is_fresh_instance));
set_prop(response, "files", file_list);
add_root_warnings_to_response(response, root);
send_and_dispose_response(client, response);
w_root_delref(root);
}
/* subscribe /root subname {query}
* Subscribes the client connection to the specified root. */
static void cmd_subscribe(struct watchman_client *client, json_t *args)
{
w_root_t *root;
struct watchman_client_subscription *sub;
json_t *resp;
const char *name;
json_t *jfield_list;
w_query *query;
json_t *query_spec;
struct w_query_field_list field_list;
char *errmsg;
if (json_array_size(args) != 4) {
send_error_response(client, "wrong number of arguments for subscribe");
return;
}
root = resolve_root_or_err(client, args, 1, true);
if (!root) {
return;
}
name = json_string_value(json_array_get(args, 2));
if (!name) {
send_error_response(client,
"expected 2nd parameter to be subscription name");
goto done;
}
query_spec = json_array_get(args, 3);
jfield_list = json_object_get(query_spec, "fields");
if (!parse_field_list(jfield_list, &field_list, &errmsg)) {
send_error_response(client, "invalid field list: %s", errmsg);
free(errmsg);
goto done;
}
query = w_query_parse(root, query_spec, &errmsg);
if (!query) {
send_error_response(client, "failed to parse query: %s", errmsg);
free(errmsg);
goto done;
}
sub = calloc(1, sizeof(*sub));
if (!sub) {
send_error_response(client, "no memory!");
goto done;
}
sub->name = w_string_new(name);
sub->query = query;
memcpy(&sub->field_list, &field_list, sizeof(field_list));
sub->root = root;
pthread_mutex_lock(&w_client_lock);
w_ht_replace(client->subscriptions, w_ht_ptr_val(sub->name),
w_ht_ptr_val(sub));
pthread_mutex_unlock(&w_client_lock);
resp = make_response();
annotate_with_clock(root, resp);
set_prop(resp, "subscribe", json_string(name));
add_root_warnings_to_response(resp, root);
send_and_dispose_response(client, resp);
resp = build_subscription_results(sub, root);
if (resp) {
send_and_dispose_response(client, resp);
}
done:
w_root_delref(root);
}
