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 "common/logging.h"
  29
  30 #include "lib/util/debug.h"
  31
  32 #include "protocol/protocol.h"
  33 #include "protocol/protocol_api.h"
  34 #include "client/client_private.h"
  35 #include "client/client.h"
  36
  37 int ctdb_message_recd_update_ip(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
  38                                 struct ctdb_client_context *client,
  39                                 int destnode, struct ctdb_public_ip *pubip)
  40 {
  41         struct ctdb_req_message message;
  42         int ret;
  43
  44         message.srvid = CTDB_SRVID_RECD_UPDATE_IP;
  45         message.data.pubip = pubip;
  46
  47         ret = ctdb_client_message(mem_ctx, ev, client, destnode, &message);
  48         if (ret != 0) {
  49                 DEBUG(DEBUG_ERR,
  50                       ("Message RECD_UPDATE_IP failed to node %u\n",
  51                        destnode));
  52         }
  53
  54         return ret;
  55 }
  56
  57 int ctdb_message_mem_dump(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
  58                           struct ctdb_client_context *client,
  59                           int destnode, struct ctdb_srvid_message *msg)
  60 {
  61         struct ctdb_req_message message;
  62         int ret;
  63
  64         message.srvid = CTDB_SRVID_MEM_DUMP;
  65         message.data.msg = msg;
  66
  67         ret = ctdb_client_message(mem_ctx, ev, client, destnode, &message);
  68         if (ret != 0) {
  69                 DEBUG(DEBUG_ERR,
  70                       ("Message MEM_DUMP failed to node %u\n", destnode));
  71         }
  72
  73         return ret;
  74 }
  75
  76 int ctdb_message_reload_nodes(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
  77                               struct ctdb_client_context *client,
  78                               int destnode)
  79 {
  80         struct ctdb_req_message message;
  81         int ret;
  82
  83         message.srvid = CTDB_SRVID_RELOAD_NODES;
  84
  85         ret = ctdb_client_message(mem_ctx, ev, client, destnode, &message);
  86         if (ret != 0) {
  87                 DEBUG(DEBUG_ERR,
  88                       ("Message RELOAD_NODES failed to node %u\n", destnode));
  89         }
  90
  91         return ret;
  92 }
  93
  94 int ctdb_message_takeover_run(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
  95                               struct ctdb_client_context *client,
  96                               int destnode, struct ctdb_srvid_message *msg)
  97 {
  98         struct ctdb_req_message message;
  99         int ret;
 100
 101         message.srvid = CTDB_SRVID_TAKEOVER_RUN;
 102         message.data.msg = msg;
 103
 104         ret = ctdb_client_message(mem_ctx, ev, client, destnode, &message);
 105         if (ret != 0) {
 106                 DEBUG(DEBUG_ERR,
 107                       ("Message TAKEOVER_RUN failed to node %u\n", destnode));
 108         }
 109
 110         return ret;
 111 }
 112
 113 int ctdb_message_rebalance_node(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
 114                                 struct ctdb_client_context *client,
 115                                 int destnode, uint32_t pnn)
 116 {
 117         struct ctdb_req_message message;
 118         int ret;
 119
 120         message.srvid = CTDB_SRVID_REBALANCE_NODE;
 121         message.data.pnn = pnn;
 122
 123         ret = ctdb_client_message(mem_ctx, ev, client, destnode, &message);
 124         if (ret != 0) {
 125                 DEBUG(DEBUG_ERR,
 126                       ("Message REBALANCE_NODE failed to node %u\n",
 127                        destnode));
 128         }
 129
 130         return ret;
 131 }
 132
 133 int ctdb_message_disable_takeover_runs(TALLOC_CTX *mem_ctx,
 134                                        struct tevent_context *ev,
 135                                        struct ctdb_client_context *client,
 136                                        int destnode,
 137                                        struct ctdb_disable_message *disable)
 138 {
 139         struct ctdb_req_message message;
 140         int ret;
 141
 142         message.srvid = CTDB_SRVID_DISABLE_TAKEOVER_RUNS;
 143         message.data.disable = disable;
 144
 145         ret = ctdb_client_message(mem_ctx, ev, client, destnode, &message);
 146         if (ret != 0) {
 147                 DEBUG(DEBUG_ERR,
 148                       ("Message DISABLE_TAKEOVER_RUNS failed to node %u\n",
 149                        destnode));
 150         }
 151
 152         return ret;
 153 }
 154
 155 int ctdb_message_disable_recoveries(TALLOC_CTX *mem_ctx,
 156                                     struct tevent_context *ev,
 157                                     struct ctdb_client_context *client,
 158                                     int destnode,
 159                                     struct ctdb_disable_message *disable)
 160 {
 161         struct ctdb_req_message message;
 162         int ret;
 163
 164         message.srvid = CTDB_SRVID_DISABLE_RECOVERIES;
 165         message.data.disable = disable;
 166
 167         ret = ctdb_client_message(mem_ctx, ev, client, destnode, &message);
 168         if (ret != 0) {
 169                 DEBUG(DEBUG_ERR,
 170                       ("Message DISABLE_RECOVERIES failed to node %u\n",
 171                        destnode));
 172         }
 173
 174         return ret;
 175 }
 176
 177 int ctdb_message_disable_ip_check(TALLOC_CTX *mem_ctx,
 178                                   struct tevent_context *ev,
 179                                   struct ctdb_client_context *client,
 180                                   int destnode, uint32_t timeout)
 181 {
 182         struct ctdb_req_message message;
 183         int ret;
 184
 185         message.srvid = CTDB_SRVID_DISABLE_IP_CHECK;
 186         message.data.timeout = timeout;
 187
 188         ret = ctdb_client_message(mem_ctx, ev, client, destnode, &message);
 189         if (ret != 0) {
 190                 DEBUG(DEBUG_ERR,
 191                       ("Message DISABLE_IP_CHECK failed to node %u\n",
 192                        destnode));
 193         }
 194
 195         return ret;
 196 }