/* 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)); }