main.cpp 9.84 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/* Copyright (C) 2003 MySQL AB

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

17 18
#include <ndb_global.h>
#include <ndb_opts.h>
19 20
#include <Vector.hpp>
#include <ndb_limits.h>
21
#include <NdbTCP.h>
22 23
#include <NdbOut.hpp>

24 25
#include "consumer_restore.hpp"
#include "consumer_printer.hpp"
26 27 28 29 30 31

extern FilteredNdbOut err;
extern FilteredNdbOut info;
extern FilteredNdbOut debug;

static int ga_nodeId = 0;
32
static int ga_nParallelism = 128;
33 34
static int ga_backupId = 0;
static bool ga_dont_ignore_systab_0 = false;
35
static Vector<class BackupConsumer *> g_consumers;
36

37
static const char* ga_backupPath = "." DIR_SEPARATOR;
38

39
static const char* opt_connect_str= NULL;
40 41 42 43 44 45

/**
 * print and restore flags
 */
static bool ga_restore = false;
static bool ga_print = false;
46 47 48 49 50 51
static int _print = 0;
static int _print_meta = 0;
static int _print_data = 0;
static int _print_log = 0;
static int _restore_data = 0;
static int _restore_meta = 0;
52
  
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
static struct my_option my_long_options[] =
{
  NDB_STD_OPTS("ndb_restore"),
  { "connect", 'c', "same as --connect-string",
    (gptr*) &opt_connect_str, (gptr*) &opt_connect_str, 0,
    GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
  { "nodeid", 'n', "Backup files from node with id",
    (gptr*) &ga_nodeId, (gptr*) &ga_nodeId, 0,
    GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
  { "backupid", 'b', "Backup id",
    (gptr*) &ga_backupId, (gptr*) &ga_backupId, 0,
    GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
  { "restore_data", 'r', 
    "Restore table data/logs into NDB Cluster using NDBAPI", 
    (gptr*) &_restore_data, (gptr*) &_restore_data,  0,
    GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
  { "restore_meta", 'm',
    "Restore meta data into NDB Cluster using NDBAPI",
    (gptr*) &_restore_meta, (gptr*) &_restore_meta,  0,
    GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
  { "parallelism", 'p',
    "No of parallel transactions during restore of data."
    "(parallelism can be 1 to 1024)", 
    (gptr*) &ga_nParallelism, (gptr*) &ga_nParallelism, 0,
    GET_INT, REQUIRED_ARG, 128, 0, 0, 0, 0, 0 },
  { "print", 256, "Print data and log to stdout",
    (gptr*) &_print, (gptr*) &_print, 0,
    GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
  { "print_data", 257, "Print data to stdout", 
    (gptr*) &_print_data, (gptr*) &_print_data, 0,
    GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
  { "print_meta", 258, "Print meta data to stdout",
    (gptr*) &_print_meta, (gptr*) &_print_meta,  0,
    GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
  { "print_log", 259, "Print log to stdout",
    (gptr*) &_print_log, (gptr*) &_print_log,  0,
    GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
  { "dont_ignore_systab_0", 'f',
    "Experimental. Do not ignore system table during restore.", 
    (gptr*) &ga_dont_ignore_systab_0, (gptr*) &ga_dont_ignore_systab_0, 0,
    GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
};
96

97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
static void short_usage_sub(void)
{
  printf("Usage: %s [OPTIONS] [<path to backup files>]\n", my_progname);
}
static void print_version()
{
  printf("MySQL distrib %s, for %s (%s)\n",MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
}
static void usage()
{
  short_usage_sub();
  print_version();
  my_print_help(my_long_options);
  my_print_variables(my_long_options);
}
static my_bool
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
	       char *argument)
{
  switch (optid) {
  case '#':
    DBUG_PUSH(argument ? argument : "d:t:O,/tmp/ndb_restore.trace");
    break;
  case 'V':
    print_version();
    exit(0);
  case '?':
    usage();
    exit(0);
  }
  return 0;
}
bool
readArguments(int *pargc, char*** pargv) 
{
  const char *load_default_groups[]= { "ndb_tools","ndb_restore",0 };
  load_defaults("my",load_default_groups,pargc,pargv);
  if (handle_options(pargc, pargv, my_long_options, get_one_option) || 
135 136 137
      ga_nodeId == 0  ||
      ga_backupId == 0 ||
      ga_nParallelism  < 1 ||
138 139
      ga_nParallelism >1024) {
    exit(1);
140 141 142 143 144 145 146 147 148
  }

  BackupPrinter* printer = new BackupPrinter();
  if (printer == NULL)
    return false;

  BackupRestore* restore = new BackupRestore(ga_nParallelism);
  if (restore == NULL) 
  {
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187
    delete printer;
    return false;
  }

  if (_print) 
  {
    ga_print = true;
    ga_restore = true;
    printer->m_print = true;
  } 
  if (_print_meta) 
  {
    ga_print = true;
    printer->m_print_meta = true;
  }
  if (_print_data) 
  {
    ga_print = true;
    printer->m_print_data = true;
  }
  if (_print_log) 
  {
    ga_print = true;
    printer->m_print_log = true;
  }

  if (_restore_data)
  {
    ga_restore = true;
    restore->m_restore = true; 
  }

  if (_restore_meta)
  {
    //    ga_restore = true;
    restore->m_restore_meta = true;
  }

  {
188
    BackupConsumer * c = printer;
189 190 191
    g_consumers.push_back(c);
  }
  {
192
    BackupConsumer * c = restore;
193 194 195
    g_consumers.push_back(c);
  }
  // Set backup file path
196
  if (*pargv[0] != NULL) 
197
  {
198
    ga_backupPath = *pargv[0];
199 200 201 202 203 204 205 206
  }

  return true;
}

void
clearConsumers()
{
207
  for(Uint32 i= 0; i<g_consumers.size(); i++)
208 209 210 211
    delete g_consumers[i];
  g_consumers.clear();
}

212
static bool
213 214 215 216 217 218 219 220 221
checkSysTable(const char *tableName) 
{
  return ga_dont_ignore_systab_0 ||
    (strcmp(tableName, "SYSTAB_0") != 0 &&
     strcmp(tableName, "NDB$EVENTS_0") != 0 &&
     strcmp(tableName, "sys/def/SYSTAB_0") != 0 &&
     strcmp(tableName, "sys/def/NDB$EVENTS_0") != 0);
}

222 223 224
static void
free_data_callback()
{
225
  for(Uint32 i= 0; i < g_consumers.size(); i++) 
226 227 228
    g_consumers[i]->tuple_free();
}

229
int
230
main(int argc, char** argv)
231
{
232 233 234
  NDB_INIT(argv[0]);

  if (!readArguments(&argc, &argv))
235 236 237 238
  {
    return -1;
  }

239
  Ndb::setConnectString(opt_connect_str);
240

241 242 243 244 245 246 247 248 249 250
  /**
   * we must always load meta data, even if we will only print it to stdout
   */
  RestoreMetaData metaData(ga_backupPath, ga_nodeId, ga_backupId);
  if (!metaData.readHeader())
  {
    ndbout << "Failed to read " << metaData.getFilename() << endl << endl;
    return -1;
  }
  /**
251
   * check wheater we can restore the backup (right version).
252
   */
253
  int res  = metaData.loadContent();
254

255
  if (res == 0)
256 257 258 259 260
  {
    ndbout_c("Restore: Failed to load content");
    return -1;
  }
  
261
  if (metaData.getNoOfTables() == 0) 
262
  {
263
    ndbout_c("Restore: The backup contains no tables ");
264 265 266 267 268 269 270 271 272 273
    return -1;
  }


  if (!metaData.validateFooter()) 
  {
    ndbout_c("Restore: Failed to validate footer.");
    return -1;
  }

274 275
  Uint32 i;
  for(i= 0; i < g_consumers.size(); i++)
276 277 278 279 280 281 282 283 284
  {
    if (!g_consumers[i]->init())
    {
      clearConsumers();
      return -11;
    }

  }

285
  for(i = 0; i<metaData.getNoOfTables(); i++)
286 287 288
  {
    if (checkSysTable(metaData[i]->getTableName()))
    {
289
      for(Uint32 j= 0; j < g_consumers.size(); j++)
290 291 292 293 294 295 296
	if (!g_consumers[j]->table(* metaData[i]))
	{
	  ndbout_c("Restore: Failed to restore table: %s. "
		   "Exiting...", 
		   metaData[i]->getTableName());
	  return -11;
	} 
297 298 299
    }
  }
  
300 301 302 303 304 305 306
  for(i= 0; i < g_consumers.size(); i++)
    if (!g_consumers[i]->endOfTables())
    {
      ndbout_c("Restore: Failed while closing tables");
      return -11;
    } 
  
307 308
  if (ga_restore || ga_print) 
  {
309 310 311 312 313 314
    if (ga_restore) 
    {
      RestoreDataIterator dataIter(metaData, &free_data_callback);
      
      // Read data file header
      if (!dataIter.readHeader())
315
      {
316 317 318 319 320 321 322 323 324
	ndbout << "Failed to read header of data file. Exiting..." ;
	return -11;
      }
      
      
      while (dataIter.readFragmentHeader(res= 0))
      {
	const TupleS* tuple;
	while ((tuple = dataIter.getNextTuple(res= 1)) != 0)
325
	{
326 327 328 329
	  if (checkSysTable(tuple->getTable()->getTableName()))
	    for(Uint32 i= 0; i < g_consumers.size(); i++) 
	      g_consumers[i]->tuple(* tuple);
	} // while (tuple != NULL);
330 331 332
	
	if (res < 0)
	{
333 334
	  ndbout_c("Restore: An error occured while restoring data. "
		   "Exiting...");
335 336
	  return -1;
	}
337 338 339
	if (!dataIter.validateFragmentFooter()) {
	  ndbout_c("Restore: Error validating fragment footer. "
		   "Exiting...");
340 341
	  return -1;
	}
342 343 344 345 346 347 348 349 350 351 352 353 354
      } // while (dataIter.readFragmentHeader(res))
      
      if (res < 0)
      {
	err << "Restore: An error occured while restoring data. Exiting... res=" << res << endl;
	return -1;
      }
      
      
      dataIter.validateFooter(); //not implemented
      
      for (i= 0; i < g_consumers.size(); i++)
	g_consumers[i]->endOfTuples();
355

356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
      RestoreLogIterator logIter(metaData);
      if (!logIter.readHeader())
      {
	err << "Failed to read header of data file. Exiting..." << endl;
	return -1;
      }
      
      const LogEntry * logEntry = 0;
      while ((logEntry = logIter.getNextLogEntry(res= 0)) != 0)
      {
	if (checkSysTable(logEntry->m_table->getTableName()))
	  for(Uint32 i= 0; i < g_consumers.size(); i++)
	    g_consumers[i]->logEntry(* logEntry);
      }
      if (res < 0)
      {
	err << "Restore: An restoring the data log. Exiting... res=" << res << endl;
	return -1;
374
      }
375 376 377
      logIter.validateFooter(); //not implemented
      for (i= 0; i < g_consumers.size(); i++)
	g_consumers[i]->endOfLogEntrys();
378 379 380 381 382 383 384 385 386 387 388 389 390 391
      for(i = 0; i<metaData.getNoOfTables(); i++)
      {
	if (checkSysTable(metaData[i]->getTableName()))
	{
	  for(Uint32 j= 0; j < g_consumers.size(); j++)
	    if (!g_consumers[j]->finalize_table(* metaData[i]))
	    {
	      ndbout_c("Restore: Failed to finalize restore table: %s. "
		       "Exiting...", 
		       metaData[i]->getTableName());
	      return -11;
	    } 
	}
      }
392
    }
393 394
  }
  clearConsumers();
395
  return 0;
396 397
} // main

398
template class Vector<BackupConsumer*>;