Enable destruction of servers

The servers can now be destroyed which removes them from the list of
active servers. If the server was not created at runtime, a warning is
logged.

include/maxscale/monitor.h

@@ -233,4 +233,11 @@ connect_result_t mon_connect_to_db(MONITOR* mon, MONITOR_SERVERS *database);
 void mon_log_connect_error(MONITOR_SERVERS* database, connect_result_t rval);
 void mon_log_state_change(MONITOR_SERVERS *ptr);
 
+/**
+ * Check if a monitor uses @c servers
+ * @param server Server that is queried
+ * @return True if server is used by at least one monitor
+ */
+bool monitor_server_in_use(const SERVER *server);
+
 MXS_END_DECLS

include/maxscale/server.h

@@ -243,4 +243,13 @@ extern void server_update_ssl(SERVER *server, const char *key, const char *value
  */
 bool server_serialize(SERVER *server);
 
+/**
+ * @brief Destroy a server
+ *
+ * This removes any created server configuration files and marks the server removed
+ * If the server is not in use.
+ * @param server Server to destroy
+ */
+void server_destroy(SERVER *server);
+
 MXS_END_DECLS

include/maxscale/service.h

@@ -257,4 +257,11 @@ static inline uint64_t service_get_capabilities(const SERVICE *service)
     return service->capabilities;
 }
 
+/**
+ * Check if a service uses @c servers
+ * @param server Server that is queried
+ * @return True if server is used by at least one service
+ */
+bool service_server_in_use(const SERVER *server);
+
 MXS_END_DECLS

server/core/monitor.c

@@ -1130,3 +1130,29 @@ void mon_log_state_change(MONITOR_SERVERS *ptr)
     MXS_FREE(prev);
     MXS_FREE(next);
 }
+
+bool monitor_server_in_use(const SERVER *server)
+{
+    bool rval = false;
+
+    spinlock_acquire(&monLock);
+
+    for (MONITOR *mon = allMonitors; mon && !rval; mon = mon->next)
+    {
+        spinlock_acquire(&mon->lock);
+
+        for (MONITOR_SERVERS *db = mon->databases; db && !rval; db = db->next)
+        {
+            if (db->server == server)
+            {
+                rval = true;
+            }
+        }
+
+        spinlock_release(&mon->lock);
+    }
+
+    spinlock_release(&monLock);
+
+    return rval;
+}

server/core/server.c

@@ -38,6 +38,8 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
+#include <maxscale/service.h>
+#include <maxscale/monitor.h>
 #include <maxscale/session.h>
 #include <maxscale/server.h>
 #include <maxscale/spinlock.h>
@@ -1240,6 +1242,39 @@ bool server_serialize(SERVER *server)
     return rval;
 }
 
+void server_destroy(SERVER *server)
+{
+    if (service_server_in_use(server) || monitor_server_in_use(server))
+    {
+        MXS_ERROR("Cannot destroy server '%s' as it is used by at least one "
+                  "service or monitor", server->unique_name);
+    }
+    else
+    {
+        char filename[PATH_MAX];
+        snprintf(filename, sizeof(filename), "%s/%s.cnf", get_config_persistdir(),
+                 server->unique_name);
+
+        if (unlink(filename) == -1)
+        {
+            if (errno != ENOENT)
+            {
+                char err[MXS_STRERROR_BUFLEN];
+                MXS_ERROR("Failed to remove persisted server configuration '%s': %d, %s",
+                          filename, errno, strerror_r(errno, err, sizeof(err)));
+            }
+            else
+            {
+                MXS_WARNING("Server '%s' was not created at runtime. Remove the "
+                            "server manually from the correct configuration file.",
+                            server->unique_name);
+            }
+        }
+
+        server->is_active = false;
+    }
+}
+
 bool server_is_ssl_parameter(const char *key)
 {
     // TODO: Implement this

server/core/service.c

@@ -2188,3 +2188,29 @@ static void service_calculate_weights(SERVICE *service)
         }
     }
 }
+
+bool service_server_in_use(const SERVER *server)
+{
+    bool rval = false;
+
+    spinlock_acquire(&service_spin);
+
+    for (SERVICE *service = allServices; service && !rval; service = service->next)
+    {
+        spinlock_acquire(&service->spin);
+
+        for (SERVER_REF *ref = service->dbref; ref && !rval; ref = ref->next)
+        {
+            if (ref->server == server)
+            {
+                rval = true;
+            }
+        }
+
+        spinlock_release(&service->spin);
+    }
+
+    spinlock_release(&service_spin);
+
+    return rval;
+}