ctdb/client/client_message_sync.c

   1 /*
   2    CTDB client code
   3
   4    Copyright (C) Amitay Isaacs  2015
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "replace.h"
  21 #include "system/network.h"
  22 #include "system/filesys.h"
  23
  24 #include <talloc.h>
  25 #include <tevent.h>
  26 #include <tdb.h>
  27
  28 #include "lib/util/debug.h"
  29 #include "ctdb_logging.h"
  30
  31 #include "protocol/protocol.h"
  32 #include "protocol/protocol_api.h"
  33 #include "client/client_private.h"
  34 #include "client/client.h"
  35
  36 int ctdb_message_recd_update_ip(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
  37                                 struct ctdb_client_context *client,
  38                                 int destnode, struct ctdb_public_ip *pubip)
  39 {
  40         struct ctdb_req_message message;
  41         int ret;
  42
  43         message.srvid = CTDB_SRVID_RECD_UPDATE_IP;
  44         message.data.pubip = pubip;
  45
  46         ret = ctdb_client_message(mem_ctx, ev, client, destnode, &message);
  47         if (ret != 0) {
  48                 DEBUG(DEBUG_ERR,
  49                       ("Message RECD_UPDATE_IP failed to node %u\n",
  50                        destnode));
  51         }
  52
  53         return ret;
  54 }
  55
  56 int ctdb_message_mem_dump(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
  57                           struct ctdb_client_context *client,
  58                           int destnode, struct ctdb_srvid_message *msg)
  59 {
  60         struct ctdb_req_message message;
  61         int ret;
  62
  63         message.srvid = CTDB_SRVID_MEM_DUMP;
  64         message.data.msg = msg;
  65
  66         ret = ctdb_client_message(mem_ctx, ev, client, destnode, &message);
  67         if (ret != 0) {
  68                 DEBUG(DEBUG_ERR,
  69                       ("Message MEM_DUMP failed to node %u\n", destnode));
  70         }
  71
  72         return ret;
  73 }
  74
  75 int ctdb_message_reload_nodes(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
  76                               struct ctdb_client_context *client,
  77                               int destnode)
  78 {
  79         struct ctdb_req_message message;
  80         int ret;
  81
  82         message.srvid = CTDB_SRVID_RELOAD_NODES;
  83
  84         ret = ctdb_client_message(mem_ctx, ev, client, destnode, &message);
  85         if (ret != 0) {
  86                 DEBUG(DEBUG_ERR,
  87                       ("Message RELOAD_NODES failed to node %u\n", destnode));
  88         }
  89
  90         return ret;
  91 }
  92
  93 int ctdb_message_takeover_run(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
  94                               struct ctdb_client_context *client,
  95                               int destnode, struct ctdb_srvid_message *msg)
  96 {
  97         struct ctdb_req_message message;
  98         int ret;
  99
 100         message.srvid = CTDB_SRVID_TAKEOVER_RUN;
 101         message.data.msg = msg;
 102
 103         ret = ctdb_client_message(mem_ctx, ev, client, destnode, &message);
 104         if (ret != 0) {
 105                 DEBUG(DEBUG_ERR,
 106                       ("Message TAKEOVER_RUN failed to node %u\n", destnode));
 107         }
 108
 109         return ret;
 110 }
 111
 112 int ctdb_message_rebalance_node(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
 113                                 struct ctdb_client_context *client,
 114                                 int destnode, uint32_t pnn)
 115 {
 116         struct ctdb_req_message message;
 117         int ret;
 118
 119         message.srvid = CTDB_SRVID_REBALANCE_NODE;
 120         message.data.pnn = pnn;
 121
 122         ret = ctdb_client_message(mem_ctx, ev, client, destnode, &message);
 123         if (ret != 0) {
 124                 DEBUG(DEBUG_ERR,
 125                       ("Message REBALANCE_NODE failed to node %u\n",
 126                        destnode));
 127         }
 128
 129         return ret;
 130 }
 131
 132 int ctdb_message_disable_takeover_runs(TALLOC_CTX *mem_ctx,
 133                                        struct tevent_context *ev,
 134                                        struct ctdb_client_context *client,
 135                                        int destnode,
 136                                        struct ctdb_disable_message *disable)
 137 {
 138         struct ctdb_req_message message;
 139         int ret;
 140
 141         message.srvid = CTDB_SRVID_DISABLE_TAKEOVER_RUNS;
 142         message.data.disable = disable;
 143
 144         ret = ctdb_client_message(mem_ctx, ev, client, destnode, &message);
 145         if (ret != 0) {
 146                 DEBUG(DEBUG_ERR,
 147                       ("Message DISABLE_TAKEOVER_RUNS failed to node %u\n",
 148                        destnode));
 149         }
 150
 151         return ret;
 152 }
 153
 154 int ctdb_message_disable_recoveries(TALLOC_CTX *mem_ctx,
 155                                     struct tevent_context *ev,
 156                                     struct ctdb_client_context *client,
 157                                     int destnode,
 158                                     struct ctdb_disable_message *disable)
 159 {
 160         struct ctdb_req_message message;
 161         int ret;
 162
 163         message.srvid = CTDB_SRVID_DISABLE_RECOVERIES;
 164         message.data.disable = disable;
 165
 166         ret = ctdb_client_message(mem_ctx, ev, client, destnode, &message);
 167         if (ret != 0) {
 168                 DEBUG(DEBUG_ERR,
 169                       ("Message DISABLE_RECOVERIES failed to node %u\n",
 170                        destnode));
 171         }
 172
 173         return ret;
 174 }
 175
 176 int ctdb_message_disable_ip_check(TALLOC_CTX *mem_ctx,
 177                                   struct tevent_context *ev,
 178                                   struct ctdb_client_context *client,
 179                                   int destnode, uint32_t timeout)
 180 {
 181         struct ctdb_req_message message;
 182         int ret;
 183
 184         message.srvid = CTDB_SRVID_DISABLE_IP_CHECK;
 185         message.data.timeout = timeout;
 186
 187         ret = ctdb_client_message(mem_ctx, ev, client, destnode, &message);
 188         if (ret != 0) {
 189                 DEBUG(DEBUG_ERR,
 190                       ("Message DISABLE_IP_CHECK failed to node %u\n",
 191                        destnode));
 192         }
 193
 194         return ret;
 195 }