adding table availability issues, removing obsolete config issues

src/clustering/administration/issues/issue.hpp

@@ -86,7 +86,7 @@ class issue_tracker_t {
 public:
     issue_tracker_t() { }
     virtual ~issue_tracker_t() { }
-    virtual std::vector<scoped_ptr_t<issue_t> > get_issues() const = 0;
+    virtual std::vector<scoped_ptr_t<issue_t> > get_issues(signal_t *interruptor) const = 0;
 private:
     DISABLE_COPYING(issue_tracker_t);
 };

src/clustering/administration/issues/issues_backend.cc

@@ -2,6 +2,7 @@
 #include "clustering/administration/issues/issues_backend.hpp"
 #include "clustering/administration/datum_adapter.hpp"
 #include "clustering/administration/main/watchable_fields.hpp"
+#include "concurrency/cross_thread_signal.hpp"
 
 issues_artificial_table_backend_t::issues_artificial_table_backend_t(
         boost::shared_ptr<semilattice_read_view_t<cluster_semilattice_metadata_t> >
@@ -25,12 +26,12 @@ issues_artificial_table_backend_t::issues_artificial_table_backend_t(
             incremental_field_getter_t<server_id_t,
                                        cluster_directory_metadata_t>(
                 &cluster_directory_metadata_t::server_id))),
-    invalid_config_issue_tracker(cluster_sl_view),
-    name_collision_issue_tracker(cluster_sl_view, table_meta_client)
+    name_collision_issue_tracker(cluster_sl_view, table_meta_client),
+    table_issue_tracker(server_config_client, table_meta_client)
 {
     trackers.insert(&remote_issue_tracker);
-    trackers.insert(&invalid_config_issue_tracker);
     trackers.insert(&name_collision_issue_tracker);
+    trackers.insert(&table_issue_tracker);
 }
 
 issues_artificial_table_backend_t::~issues_artificial_table_backend_t() {
@@ -42,15 +43,16 @@ std::string issues_artificial_table_backend_t::get_primary_key_name() {
 }
 
 bool issues_artificial_table_backend_t::read_all_rows_as_vector(
-        UNUSED signal_t *interruptor,
+        signal_t *interruptor,
         std::vector<ql::datum_t> *rows_out,
         UNUSED std::string *error_out) {
+    cross_thread_signal_t ct_interruptor(interruptor, home_thread());
     on_thread_t rethreader(home_thread());
     rows_out->clear();
 
     cluster_semilattice_metadata_t metadata = cluster_sl_view->get();
     for (auto const &tracker : trackers) {
-        for (auto const &issue : tracker->get_issues()) {
+        for (auto const &issue : tracker->get_issues(&ct_interruptor)) {
             ql::datum_t row;
             bool still_valid = issue->to_datum(cluster_sl_view->get(),
                 server_config_client, table_meta_client, identifier_format, &row);
@@ -66,16 +68,17 @@ bool issues_artificial_table_backend_t::read_all_rows_as_vector(
 }
 
 bool issues_artificial_table_backend_t::read_row(ql::datum_t primary_key,
-                                                 UNUSED signal_t *interruptor,
+                                                 signal_t *interruptor,
                                                  ql::datum_t *row_out,
                                                  UNUSED std::string *error_out) {
+    cross_thread_signal_t ct_interruptor(interruptor, home_thread());
     on_thread_t rethreader(home_thread());
     *row_out = ql::datum_t();
 
     uuid_u issue_id;
     std::string dummy_error;
     if (convert_uuid_from_datum(primary_key, &issue_id, &dummy_error)) {
-        std::vector<scoped_ptr_t<issue_t> > issues = all_issues();
+        std::vector<scoped_ptr_t<issue_t> > issues = all_issues(&ct_interruptor);
 
         for (auto const &issue : issues) {
             if (issue->get_id() == issue_id) {
@@ -92,11 +95,12 @@ bool issues_artificial_table_backend_t::read_row(ql::datum_t primary_key,
     return true;
 }
 
-std::vector<scoped_ptr_t<issue_t> > issues_artificial_table_backend_t::all_issues() const {
+std::vector<scoped_ptr_t<issue_t> > issues_artificial_table_backend_t::all_issues(
+        signal_t *interruptor) const {
     std::vector<scoped_ptr_t<issue_t> > all_issues;
 
     for (auto const &tracker : trackers) {
-        std::vector<scoped_ptr_t<issue_t> > issues = tracker->get_issues();
+        std::vector<scoped_ptr_t<issue_t> > issues = tracker->get_issues(interruptor);
         std::move(issues.begin(), issues.end(), std::back_inserter(all_issues));
     }
 

src/clustering/administration/issues/issues_backend.hpp

@@ -11,8 +11,8 @@
 #include "rdb_protocol/artificial_table/caching_cfeed_backend.hpp"
 #include "clustering/administration/metadata.hpp"
 #include "concurrency/watchable.hpp"
-#include "clustering/administration/issues/invalid_config.hpp"
 #include "clustering/administration/issues/name_collision.hpp"
+#include "clustering/administration/issues/table.hpp"
 #include "clustering/administration/issues/remote.hpp"
 
 
@@ -49,7 +49,7 @@ class issues_artificial_table_backend_t :
                    std::string *error_out);
 
 private:
-    std::vector<scoped_ptr_t<issue_t> > all_issues() const;
+    std::vector<scoped_ptr_t<issue_t> > all_issues(signal_t *interruptor) const;
 
     admin_identifier_format_t identifier_format;
 
@@ -64,8 +64,8 @@ class issues_artificial_table_backend_t :
     // Global issues are tracked here, local issues are collected by
     // the remote_issue_tracker out of the directory metadata
     remote_issue_tracker_t remote_issue_tracker;
-    invalid_config_issue_tracker_t invalid_config_issue_tracker;
     name_collision_issue_tracker_t name_collision_issue_tracker;
+    table_issue_tracker_t table_issue_tracker;
 };
 
 #endif /* CLUSTERING_ADMINISTRATION_ISSUES_ISSUES_BACKEND_HPP_ */

src/clustering/administration/issues/name_collision.cc

@@ -4,6 +4,81 @@
 #include "clustering/table_manager/table_meta_client.hpp"
 #include "rdb_protocol/configured_limits.hpp"
 
+// Base issue for all name collisions (server, database, and table)
+class name_collision_issue_t : public issue_t {
+public:
+    name_collision_issue_t(const issue_id_t &_issue_id,
+                           const name_string_t &_name,
+                           const std::vector<uuid_u> &_collided_ids);
+    bool is_critical() const { return true; }
+
+protected:
+    const name_string_t name;
+    const std::vector<uuid_u> collided_ids;
+};
+
+// Issue for server name collisions
+class server_name_collision_issue_t : public name_collision_issue_t {
+public:
+    explicit server_name_collision_issue_t(
+        const name_string_t &_name,
+        const std::vector<server_id_t> &_collided_ids);
+    const datum_string_t &get_name() const { return server_name_collision_issue_type; }
+
+private:
+    static const datum_string_t server_name_collision_issue_type;
+    static const issue_id_t base_issue_id;
+    bool build_info_and_description(
+        const metadata_t &metadata,
+        server_config_client_t *server_config_client,
+        table_meta_client_t *table_meta_client,
+        admin_identifier_format_t identifier_format,
+        ql::datum_t *info_out,
+        datum_string_t *description_out) const;
+};
+
+// Issue for database name collisions
+class db_name_collision_issue_t : public name_collision_issue_t {
+public:
+    explicit db_name_collision_issue_t(
+        const name_string_t &_name,
+        const std::vector<server_id_t> &_collided_ids);
+    const datum_string_t &get_name() const { return db_name_collision_issue_type; }
+
+private:
+    static const datum_string_t db_name_collision_issue_type;
+    static const issue_id_t base_issue_id;
+    bool build_info_and_description(
+        const metadata_t &metadata,
+        server_config_client_t *server_config_client,
+        table_meta_client_t *table_meta_client,
+        admin_identifier_format_t identifier_format,
+        ql::datum_t *info_out,
+        datum_string_t *description_out) const;
+};
+
+// Issue for table name collisions
+class table_name_collision_issue_t : public name_collision_issue_t {
+public:
+    table_name_collision_issue_t(
+        const name_string_t &_name,
+        const database_id_t &_db_id,
+        const std::vector<server_id_t> &_collided_ids);
+    const datum_string_t &get_name() const { return table_name_collision_issue_type; }
+
+private:
+    static const datum_string_t table_name_collision_issue_type;
+    static const issue_id_t base_issue_id;
+    const database_id_t db_id;
+    bool build_info_and_description(
+        const metadata_t &metadata,
+        server_config_client_t *server_config_client,
+        table_meta_client_t *table_meta_client,
+        admin_identifier_format_t identifier_format,
+        ql::datum_t *info_out,
+        datum_string_t *description_out) const;
+};
+
 const datum_string_t server_name_collision_issue_t::server_name_collision_issue_type =
     datum_string_t("server_name_collision");
 const uuid_u server_name_collision_issue_t::base_issue_id =
@@ -181,7 +256,8 @@ void find_table_duplicates(
     }
 }
 
-std::vector<scoped_ptr_t<issue_t> > name_collision_issue_tracker_t::get_issues() const {
+std::vector<scoped_ptr_t<issue_t> > name_collision_issue_tracker_t::get_issues(
+        UNUSED signal_t *interruptor) const {
     cluster_semilattice_metadata_t metadata = cluster_sl_view->get();
     std::vector<scoped_ptr_t<issue_t> > issues;