ctdb/libctdb/test/readrecordlock.c

   1 #include "utils.h"
   2 #include "log.h"
   3 #include "tui.h"
   4 #include "ctdb-test.h"
   5 #include <ctdb.h>
   6 #include <tdb.h>
   7 #include <talloc.h>
   8 #include <dlinklist.h>
   9 #include <errno.h>
  10
  11 struct lock {
  12         struct lock *next, *prev;
  13         struct ctdb_db *db;
  14         struct ctdb_lock *lock;
  15         unsigned int id;
  16 };
  17
  18 static unsigned int lock_id;
  19 static struct lock *locks;
  20
  21 static void readrecordlock_help(int argc, char **argv)
  22 {
  23 #include "generated-readrecordlock-help:readrecordlock"
  24 /*** XML Help:
  25     <section id="c:readrecordlock">
  26      <title><command>readrecordlock</command></title>
  27      <para>Read and lock a record in a ctdb database</para>
  28      <cmdsynopsis>
  29       <command>readrecordlock</command>
  30       <arg choice="req"><replaceable>db-id</replaceable></arg>
  31       <arg choice="req"><replaceable>key</replaceable></arg>
  32      </cmdsynopsis>
  33
  34      <para>Read and lock a record.  Prints the record, and a 1-based
  35      sequential handle on success, which should be handed to
  36      <command>releaselock</command>
  37      </para>
  38      </section>
  39 */
  40 }
  41
  42 static void releaselock_help(int argc, char **argv)
  43 {
  44 #include "generated-readrecordlock-help:releaselock"
  45 /*** XML Help:
  46     <section id="c:releaselock">
  47      <title><command>releaselock</command></title>
  48      <para>Unlock a record in a ctdb database</para>
  49      <cmdsynopsis>
  50       <command>releaselock</command>
  51       <arg choice="req"><replaceable>db-id</replaceable></arg>
  52       <arg choice="req"><replaceable>lock-id</replaceable></arg>
  53      </cmdsynopsis>
  54
  55      <para>Unlock a record successfully locked by
  56      <command>readrecordlock</command>.  </para>
  57
  58      </section>
  59 */
  60 }
  61
  62 static void writerecord_help(int argc, char **argv)
  63 {
  64 #include "generated-readrecordlock-help:writerecord"
  65 /*** XML Help:
  66     <section id="c:writerecord">
  67      <title><command>writerecord</command></title>
  68      <para>Write to a locked record in a ctdb database</para>
  69      <cmdsynopsis>
  70       <command>writerecord</command>
  71       <arg choice="req"><replaceable>db-id</replaceable></arg>
  72       <arg choice="req"><replaceable>lock-id</replaceable></arg>
  73       <arg choice="req"><replaceable>data</replaceable></arg>
  74      </cmdsynopsis>
  75
  76      <para>Once a record is locked with
  77      <command>readrecordlock</command>, you can write to it. </para>
  78      </section>
  79 */
  80 }
  81
  82 static int lock_destructor(struct lock *lock)
  83 {
  84         ctdb_release_lock(lock->db, lock->lock);
  85         DLIST_REMOVE(locks, lock);
  86         return 0;
  87 }
  88
  89 static bool releaselock(int argc, char **argv)
  90 {
  91         struct ctdb_db *db;
  92         struct lock *lock;
  93
  94         if (argc != 3) {
  95                 log_line(LOG_ALWAYS, "Need database number and lock number");
  96                 return false;
  97         }
  98
  99         db = find_db_by_id(atoi(argv[1]));
 100         if (!db) {
 101                 log_line(LOG_ALWAYS, "Unknown db number %s", argv[1]);
 102                 return false;
 103         }
 104
 105         for (lock = locks; lock; lock = lock->next) {
 106                 if (lock->id == atoi(argv[2]))
 107                         break;
 108         }
 109         if (!lock) {
 110                 log_line(LOG_ALWAYS, "Unknown lock number %s", argv[2]);
 111                 return false;
 112         }
 113         talloc_free(lock);
 114         return true;
 115 }
 116
 117 static bool writerecord(int argc, char **argv)
 118 {
 119         struct ctdb_db *db;
 120         struct lock *lock;
 121         TDB_DATA data;
 122
 123         if (argc != 4) {
 124                 log_line(LOG_ALWAYS, "Need db-id, lock-id and data");
 125                 return false;
 126         }
 127
 128         db = find_db_by_id(atoi(argv[1]));
 129         if (!db) {
 130                 log_line(LOG_ALWAYS, "Unknown db number %s", argv[1]);
 131                 return false;
 132         }
 133
 134         for (lock = locks; lock; lock = lock->next) {
 135                 if (lock->id == atoi(argv[2]))
 136                         break;
 137         }
 138         if (!lock) {
 139                 log_line(LOG_ALWAYS, "Unknown lock number %s", argv[2]);
 140                 return false;
 141         }
 142
 143         data.dptr = (unsigned char *)argv[3];
 144         data.dsize = strlen(argv[3]);
 145
 146         if (!ctdb_writerecord(db, lock->lock, data)) {
 147                 log_line(LOG_UI, "writerecordlock: failed %s", strerror(errno));
 148                 return false;
 149         }
 150         return true;
 151 }
 152
 153 static bool readrecordlock(int argc, char **argv)
 154 {
 155         struct lock *lock = talloc(working, struct lock);
 156         TDB_DATA key, data;
 157
 158         if (!get_ctdb()) {
 159                 log_line(LOG_ALWAYS, "No ctdb connection");
 160                 return false;
 161         }
 162         if (argc != 3) {
 163                 log_line(LOG_ALWAYS, "Need db-id and key");
 164                 return false;
 165         }
 166
 167         lock->db = find_db_by_id(atoi(argv[1]));
 168         if (!lock->db) {
 169                 log_line(LOG_ALWAYS, "Unknown db number %s", argv[1]);
 170                 return false;
 171         }
 172
 173         key.dptr = (unsigned char *)argv[2];
 174         key.dsize = strlen(argv[2]);
 175
 176         lock->lock = ctdb_readrecordlock(get_ctdb(), lock->db, key, &data);
 177         if (!lock->lock) {
 178                 log_line(LOG_UI, "readrecordlock: failed %s", strerror(errno));
 179                 return false;
 180         }
 181         lock->id = ++lock_id;
 182         DLIST_ADD(locks, lock);
 183         talloc_set_destructor(lock, lock_destructor);
 184
 185         log_line(LOG_UI, "lock %u: data '%.*s'",
 186                  lock->id, data.dsize, (char *)data.dptr);
 187         return true;
 188 }
 189
 190 static void readrecordlock_init(void)
 191 {
 192         tui_register_command("readrecordlock",
 193                              readrecordlock, readrecordlock_help);
 194         tui_register_command("releaselock", releaselock, releaselock_help);
 195         tui_register_command("writerecord", writerecord, writerecord_help);
 196 }
 197 init_call(readrecordlock_init);