/* unsubscribe /root subname
* Cancels a subscription */
static void cmd_unsubscribe(
struct watchman_client* clientbase,
const json_ref& args) {
const char *name;
bool deleted{false};
struct watchman_user_client *client =
(struct watchman_user_client *)clientbase;
auto root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
auto jstr = json_array_get(args, 2);
name = json_string_value(jstr);
if (!name) {
send_error_response(
client, "expected 2nd parameter to be subscription name");
return;
}
auto sname = json_to_w_string(jstr);
deleted = client->unsubByName(sname);
auto resp = make_response();
resp.set({{"unsubscribe", typed_string_to_json(name)},
{"deleted", json_boolean(deleted)}});
send_and_dispose_response(client, std::move(resp));
}
/* debug-ageout */
static void cmd_debug_ageout(
struct watchman_client* client,
const json_ref& args) {
/* resolve the root */
if (json_array_size(args) != 3) {
send_error_response(client,
"wrong number of arguments for 'debug-ageout'");
return;
}
auto root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
std::chrono::seconds min_age(json_integer_value(json_array_get(args, 2)));
auto resp = make_response();
root->performAgeOut(min_age);
resp.set("ageout", json_true());
send_and_dispose_response(client, std::move(resp));
}
static void cmd_debug_recrawl(struct watchman_client *client, json_t *args)
{
w_root_t *root;
json_t *resp;
/* resolve the root */
if (json_array_size(args) != 2) {
send_error_response(client,
"wrong number of arguments for 'debug-recrawl'");
return;
}
root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
resp = make_response();
w_root_lock(root);
w_root_schedule_recrawl(root, "debug-recrawl");
w_root_unlock(root);
set_prop(resp, "recrawl", json_true());
send_and_dispose_response(client, resp);
w_root_delref(root);
}
static void cmd_debug_show_cursors(
struct watchman_client* client,
const json_ref& args) {
json_ref cursors;
/* resolve the root */
if (json_array_size(args) != 2) {
send_error_response(client,
"wrong number of arguments for 'debug-show-cursors'");
return;
}
auto root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
auto resp = make_response();
{
auto map = root->inner.cursors.rlock();
cursors = json_object_of_size(map->size());
for (const auto& it : *map) {
const auto& name = it.first;
const auto& ticks = it.second;
cursors.set(name.c_str(), json_integer(ticks));
}
}
resp.set("cursors", std::move(cursors));
send_and_dispose_response(client, std::move(resp));
}
/* debug-ageout */
static void cmd_debug_ageout(struct watchman_client *client, json_t *args)
{
w_root_t *root;
json_t *resp;
int min_age;
/* resolve the root */
if (json_array_size(args) != 3) {
send_error_response(client,
"wrong number of arguments for 'debug-ageout'");
return;
}
root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
min_age = json_integer_value(json_array_get(args, 2));
resp = make_response();
w_root_lock(root);
w_root_perform_age_out(root, min_age);
w_root_unlock(root);
set_prop(resp, "ageout", json_true());
send_and_dispose_response(client, resp);
w_root_delref(root);
}
/* find /root [patterns] */
static void cmd_find(struct watchman_client* client, const json_ref& args) {
/* resolve the root */
if (json_array_size(args) < 2) {
send_error_response(client, "not enough arguments for 'find'");
return;
}
auto root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
auto query = w_query_parse_legacy(root, args, 2, nullptr, nullptr, nullptr);
if (client->client_mode) {
query->sync_timeout = std::chrono::milliseconds(0);
}
auto res = w_query_execute(query.get(), root, nullptr);
auto response = make_response();
response.set({{"clock", res.clockAtStartOfQuery.toJson()},
{"files", std::move(res.resultsArray)}});
send_and_dispose_response(client, std::move(response));
}
/* 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));
}
static void cmd_debug_show_cursors(struct watchman_client *client, json_t *args)
{
w_root_t *root;
json_t *resp, *cursors;
w_ht_iter_t i;
/* resolve the root */
if (json_array_size(args) != 2) {
send_error_response(client,
"wrong number of arguments for 'debug-show-cursors'");
return;
}
root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
resp = make_response();
w_root_lock(root);
cursors = json_object_of_size(w_ht_size(root->cursors));
if (w_ht_first(root->cursors, &i)) do {
w_string_t *name = w_ht_val_ptr(i.key);
set_prop(cursors, name->buf, json_integer(i.value));
} while (w_ht_next(root->cursors, &i));
w_root_unlock(root);
set_prop(resp, "cursors", cursors);
send_and_dispose_response(client, resp);
w_root_delref(root);
}
/* watch /root */
static void cmd_watch(struct watchman_client *client, json_t *args)
{
w_root_t *root;
json_t *resp;
/* resolve the root */
if (json_array_size(args) != 2) {
send_error_response(client, "wrong number of arguments to 'watch'");
return;
}
root = resolve_root_or_err(client, args, 1, true);
if (!root) {
return;
}
resp = make_response();
w_root_lock(root);
if (root->failure_reason) {
set_prop(resp, "error", json_string_nocheck(root->failure_reason->buf));
} else if (root->cancelled) {
set_prop(resp, "error", json_string_nocheck("root was cancelled"));
} else {
set_prop(resp, "watch", json_string_nocheck(root->root_path->buf));
}
send_and_dispose_response(client, resp);
w_root_unlock(root);
w_root_delref(root);
}
/* find /root [patterns] */
static void cmd_find(struct watchman_client *client, json_t *args)
{
w_root_t *root;
w_query *query;
char *errmsg = NULL;
struct w_query_field_list field_list;
w_query_res res;
json_t *response;
json_t *file_list;
char clockbuf[128];
/* resolve the root */
if (json_array_size(args) < 2) {
send_error_response(client, "not enough arguments for 'find'");
return;
}
root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
query = w_query_parse_legacy(root, args, &errmsg, 2, NULL, NULL, NULL);
if (errmsg) {
send_error_response(client, "%s", errmsg);
free(errmsg);
w_root_delref(root);
return;
}
w_query_legacy_field_list(&field_list);
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, "files", file_list);
send_and_dispose_response(client, response);
w_root_delref(root);
}
/* trigger /root triggername [watch patterns] -- cmd to run
* Sets up a trigger so that we can execute a command when a change
* is detected */
void cmd_trigger(struct watchman_client *client, json_t *args)
{
w_root_t *root;
struct watchman_trigger_command *cmd;
json_t *resp;
json_t *trig;
char *errmsg = NULL;
root = resolve_root_or_err(client, args, 1, true);
if (!root) {
return;
}
if (json_array_size(args) < 3) {
send_error_response(client, "not enough arguments");
goto done;
}
trig = json_array_get(args, 2);
if (json_is_string(trig)) {
trig = build_legacy_trigger(client, args);
if (!trig) {
goto done;
}
} else {
// Add a ref so that we don't need to conditionally decref later
// for the legacy case later
json_incref(trig);
}
cmd = w_build_trigger_from_def(root, trig, &errmsg);
json_decref(trig);
if (!cmd) {
send_error_response(client, "%s", errmsg);
goto done;
}
w_root_lock(root);
w_ht_replace(root->commands, w_ht_ptr_val(cmd->triggername),
w_ht_ptr_val(cmd));
w_root_unlock(root);
w_state_save();
resp = make_response();
set_prop(resp, "triggerid", json_string_nocheck(cmd->triggername->buf));
send_and_dispose_response(client, resp);
done:
if (errmsg) {
free(errmsg);
}
w_root_delref(root);
}
static void cmd_debug_get_subscriptions(
struct watchman_client* clientbase,
const json_ref& args) {
auto client = (watchman_user_client*)clientbase;
auto root = resolve_root_or_err(client, args, 1, false);
auto resp = make_response();
auto debug_info = root->unilateralResponses->getDebugInfo();
// copy over all the key-value pairs from debug_info
resp.object().insert(debug_info.object().begin(), debug_info.object().end());
send_and_dispose_response(clientbase, std::move(resp));
}
/* trigger-del /root triggername
* Delete a trigger from a root
*/
static void cmd_trigger_delete(struct watchman_client *client, json_t *args)
{
w_root_t *root;
json_t *resp;
json_t *jname;
w_string_t *tname;
bool res;
root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
if (json_array_size(args) != 3) {
send_error_response(client, "wrong number of arguments");
w_root_delref(root);
return;
}
jname = json_array_get(args, 2);
if (!json_is_string(jname)) {
send_error_response(client, "expected 2nd parameter to be trigger name");
w_root_delref(root);
return;
}
tname = json_to_w_string_incref(jname);
w_root_lock(root, "trigger-del");
res = w_ht_del(root->commands, w_ht_ptr_val(tname));
w_root_unlock(root);
if (res) {
w_state_save();
}
w_string_delref(tname);
resp = make_response();
set_prop(resp, "deleted", json_boolean(res));
json_incref(jname);
set_prop(resp, "trigger", jname);
send_and_dispose_response(client, resp);
w_root_delref(root);
}
/* trigger-list /root
* Displays a list of registered triggers for a given root
*/
void cmd_trigger_list(struct watchman_client *client, json_t *args)
{
w_root_t *root;
json_t *resp;
json_t *arr;
root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
resp = make_response();
w_root_lock(root);
arr = w_root_trigger_list_to_json(root);
w_root_unlock(root);
set_prop(resp, "triggers", arr);
send_and_dispose_response(client, resp);
w_root_delref(root);
}
/* trigger-del /root triggername
* Delete a trigger from a root
*/
void cmd_trigger_delete(struct watchman_client *client, json_t *args)
{
w_root_t *root;
json_t *resp;
const char *name;
w_string_t *tname;
bool res;
root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
if (json_array_size(args) != 3) {
send_error_response(client, "wrong number of arguments");
w_root_delref(root);
return;
}
name = json_string_value(json_array_get(args, 2));
if (!name) {
send_error_response(client, "expected 2nd parameter to be trigger name");
w_root_delref(root);
return;
}
tname = w_string_new(name);
w_root_lock(root);
res = w_ht_del(root->commands, (w_ht_val_t)tname);
w_root_unlock(root);
w_state_save();
w_string_delref(tname);
resp = make_response();
set_prop(resp, "deleted", json_boolean(res));
set_prop(resp, "trigger", json_string_nocheck(name));
send_and_dispose_response(client, resp);
w_root_delref(root);
}
/* unsubscribe /root subname
* Cancels a subscription */
static void cmd_unsubscribe(struct watchman_client *clientbase, json_t *args)
{
w_root_t *root;
const char *name;
w_string_t *sname;
bool deleted;
json_t *resp;
const json_t *jstr;
struct watchman_user_client *client =
(struct watchman_user_client *)clientbase;
root = resolve_root_or_err(&client->client, args, 1, false);
if (!root) {
return;
}
jstr = json_array_get(args, 2);
name = json_string_value(jstr);
if (!name) {
send_error_response(&client->client,
"expected 2nd parameter to be subscription name");
w_root_delref(root);
return;
}
sname = json_to_w_string_incref(jstr);
pthread_mutex_lock(&w_client_lock);
deleted = w_ht_del(client->subscriptions, w_ht_ptr_val(sname));
pthread_mutex_unlock(&w_client_lock);
w_string_delref(sname);
resp = make_response();
set_bytestring_prop(resp, "unsubscribe", name);
set_prop(resp, "deleted", json_boolean(deleted));
send_and_dispose_response(&client->client, resp);
w_root_delref(root);
}
static void cmd_get_config(struct watchman_client *client, json_t *args)
{
w_root_t *root;
json_t *resp;
json_t *config;
if (json_array_size(args) != 2) {
send_error_response(client, "wrong number of arguments for 'get-config'");
return;
}
root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
resp = make_response();
w_root_lock(root);
{
config = root->config_file;
if (config) {
// set_prop will claim this ref
json_incref(config);
}
}
w_root_unlock(root);
if (!config) {
// set_prop will own this
config = json_object();
}
json_incref(root->config_file);
set_prop(resp, "config", config);
send_and_dispose_response(client, resp);
w_root_delref(root);
}
/* watch-del /root
* Stops watching the specified root */
static void cmd_watch_delete(struct watchman_client *client, json_t *args)
{
w_root_t *root;
json_t *resp;
/* resolve the root */
if (json_array_size(args) != 2) {
send_error_response(client, "wrong number of arguments to 'watch-del'");
return;
}
root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
resp = make_response();
set_prop(resp, "watch-del", json_boolean(w_root_stop_watch(root)));
set_prop(resp, "root", json_string_nocheck(root->root_path->buf));
send_and_dispose_response(client, resp);
w_root_delref(root);
}
static void cmd_debug_poison(
struct watchman_client* client,
const json_ref& args) {
struct timeval now;
auto root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
gettimeofday(&now, NULL);
set_poison_state(
root->root_path,
now,
"debug-poison",
std::error_code(ENOMEM, std::generic_category()));
auto resp = make_response();
resp.set("poison", typed_string_to_json(poisoned_reason, W_STRING_UNICODE));
send_and_dispose_response(client, std::move(resp));
}
// A helper command to facilitate testing that we can successfully
// resync the stream.
static void cmd_debug_fsevents_inject_drop(
struct watchman_client* client,
const json_ref& args) {
FSEventStreamEventId last_good;
/* resolve the root */
if (json_array_size(args) != 2) {
send_error_response(
client, "wrong number of arguments for 'debug-fsevents-inject-drop'");
return;
}
auto root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
auto watcher = watcherFromRoot(root);
if (!watcher) {
send_error_response(client, "root is not using the fsevents watcher");
return;
}
if (!watcher->attempt_resync_on_drop) {
send_error_response(client, "fsevents_try_resync is not enabled");
return;
}
{
auto wlock = watcher->items_.wlock();
last_good = watcher->stream->last_good;
watcher->stream->inject_drop = true;
}
auto resp = make_response();
resp.set("last_good", json_integer(last_good));
send_and_dispose_response(client, std::move(resp));
}
static void cmd_debug_recrawl(
struct watchman_client* client,
const json_ref& args) {
/* resolve the root */
if (json_array_size(args) != 2) {
send_error_response(client,
"wrong number of arguments for 'debug-recrawl'");
return;
}
auto root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
auto resp = make_response();
root->scheduleRecrawl("debug-recrawl");
resp.set("recrawl", json_true());
send_and_dispose_response(client, std::move(resp));
}
static void cmd_debug_poison(struct watchman_client *client, json_t *args)
{
w_root_t *root;
struct timeval now;
struct watchman_dir *dir;
json_t *resp;
root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
dir = w_root_resolve_dir(root, root->root_path, false);
gettimeofday(&now, NULL);
set_poison_state(root, dir, now, "debug-poison", ENOMEM);
resp = make_response();
set_prop(resp, "poison", json_string_nocheck(poisoned_reason));
send_and_dispose_response(client, resp);
w_root_delref(root);
}
/* clock /root
* Returns the current clock value for a watched root
*/
static void cmd_clock(struct watchman_client *client, json_t *args)
{
w_root_t *root;
json_t *resp;
/* resolve the root */
if (json_array_size(args) != 2) {
send_error_response(client, "wrong number of arguments to 'clock'");
return;
}
root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
resp = make_response();
w_root_lock(root);
annotate_with_clock(root, resp);
w_root_unlock(root);
send_and_dispose_response(client, resp);
w_root_delref(root);
}
/* subscribe /root subname {query}
* Subscribes the client connection to the specified root. */
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(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));
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);
send_and_dispose_response(client, response);
w_root_delref(root);
}
/* since /root <timestamp> [patterns] */
static void cmd_since(struct watchman_client *client, json_t *args)
{
const char *clockspec;
w_root_t *root;
w_query *query;
char *errmsg = NULL;
struct w_query_field_list field_list;
w_query_res res;
json_t *response, *clock_ele;
json_t *file_list;
char clockbuf[128];
/* resolve the root */
if (json_array_size(args) < 3) {
send_error_response(client, "not enough arguments for 'since'");
return;
}
root = resolve_root_or_err(client, args, 1, false);
if (!root) {
return;
}
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");
w_root_delref(root);
return;
}
query = w_query_parse_legacy(args, &errmsg, 3, NULL, clockspec, NULL);
if (errmsg) {
send_error_response(client, "%s", errmsg);
free(errmsg);
w_root_delref(root);
return;
}
w_query_legacy_field_list(&field_list);
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);
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;
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);
}
/* trigger /root triggername [watch patterns] -- cmd to run
* Sets up a trigger so that we can execute a command when a change
* is detected */
static void cmd_trigger(struct watchman_client *client, json_t *args)
{
w_root_t *root;
struct watchman_trigger_command *cmd, *old;
json_t *resp;
json_t *trig;
char *errmsg = NULL;
bool need_save = true;
root = resolve_root_or_err(client, args, 1, true);
if (!root) {
return;
}
if (json_array_size(args) < 3) {
send_error_response(client, "not enough arguments");
goto done;
}
trig = json_array_get(args, 2);
if (json_is_string(trig)) {
trig = build_legacy_trigger(root, client, args);
if (!trig) {
goto done;
}
} else {
// Add a ref so that we don't need to conditionally decref later
// for the legacy case later
json_incref(trig);
}
cmd = w_build_trigger_from_def(root, trig, &errmsg);
json_decref(trig);
if (!cmd) {
send_error_response(client, "%s", errmsg);
goto done;
}
resp = make_response();
set_prop(resp, "triggerid", json_string_nocheck(cmd->triggername->buf));
w_root_lock(root);
old = w_ht_val_ptr(w_ht_get(root->commands,
w_ht_ptr_val(cmd->triggername)));
if (old && json_equal(cmd->definition, old->definition)) {
// Same definition: we don't and shouldn't touch things, so that we
// preserve the associated trigger clock and don't cause the trigger
// to re-run immediately
set_prop(resp, "disposition", json_string_nocheck("already_defined"));
w_trigger_command_free(cmd);
cmd = NULL;
need_save = false;
} else {
set_prop(resp, "disposition", json_string_nocheck(
old ? "replaced" : "created"));
w_ht_replace(root->commands, w_ht_ptr_val(cmd->triggername),
w_ht_ptr_val(cmd));
// Force the trigger to be eligible to run now
root->ticks++;
root->pending_trigger_tick = root->ticks;
}
w_root_unlock(root);
if (need_save) {
w_state_save();
}
send_and_dispose_response(client, resp);
done:
if (errmsg) {
free(errmsg);
}
w_root_delref(root);
}
/* 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));
}
