• stewart@mysql.com's avatar
    WL#2868 Fix backup trigger handling · d88e5766
    stewart@mysql.com authored
    BACKUP previous set up triggers using DICT.
    This lead to all kind of trouble.
    An smaller alternative to using SUMA for backup
      is to just make BACKUP handle triggers to TUP directly.
    
    This way all triggers will be totally local,
      and error handling is much simpler.
    
    --- old impl.
    
    Start: Master recives GSN_DEFINE_BACKUP_CONF from all participants
    Master sends CREATE_TRIG_REQ for all tables to local DICT (dict master)
    Master sends START_BACKUP_REQ to all paricipants with trigger ids from DICT
    Master sends ALTER_TRIG_REQ (online) to local DICT
    Master waits for GCP
    Master starts distributed scan
    When scan has finished
    Master waits for GCP
    Master sends DROP_TRIGGER to local DICT
    Master sends STOP_BACKUP_REQ to all participants
    
    --- new impl.
    
    Start: Master recives GSN_DEFINE_BACKUP_CONF from all participants
    Master sends START_BACKUP_REQ to all paricipants
      Participand sends CREATE_TRIG_REQ for all tables to local TUP
    Master waits for GCP
    Master starts distributed scan
    When scan has finished
    Master waits for GCP
    Master sends STOP_BACKUP_REQ to all participants
      Participant sends DROP_TRIGGER to local TUP
    
    Changes:
    All trigger handling is _local_
     This implies, that abort (e.g due to node failure) can be _local_
    
    
    fix testBackup test so that it will run successfully with the (now correct)
    backup trigger code.
    d88e5766
BackupImpl.cpp 4.39 KB
/* 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 */

#include <trigger_definitions.h>
#include <signaldata/BackupImpl.hpp>

bool 
printDEFINE_BACKUP_REQ(FILE * out, const Uint32 * data, Uint32 len, Uint16 bno){
  DefineBackupReq* sig = (DefineBackupReq*)data;
  fprintf(out, " backupPtr: %d backupId: %d clientRef: %d clientData: %d\n",
	  sig->backupPtr, sig->backupId, sig->clientRef, sig->clientData);
  fprintf(out, " backupKey: [ %08x%08x ] DataLength: %d\n",
	  sig->backupKey[0], sig->backupKey[1], sig->backupDataLen);
  char buf[_NDB_NODE_BITMASK_SIZE * 8 + 1];
  fprintf(out, " Nodes: %s\n", sig->nodes.getText(buf));
  return true;
}

bool 
printDEFINE_BACKUP_REF(FILE * out, const Uint32 * data, Uint32 len, Uint16 bno){
  DefineBackupRef* sig = (DefineBackupRef*)data;
  fprintf(out, " backupPtr: %d backupId: %d errorCode: %d\n",
	  sig->backupPtr, sig->backupId, sig->errorCode);
  return true;
}

bool 
printDEFINE_BACKUP_CONF(FILE * out, const Uint32 * data, Uint32 l, Uint16 bno){
  DefineBackupConf* sig = (DefineBackupConf*)data;
  fprintf(out, " backupPtr: %d backupId: %d\n",
	  sig->backupPtr, sig->backupId);
  return true;
}

bool 
printSTART_BACKUP_REQ(FILE * out, const Uint32 * data, Uint32 l, Uint16 bno){
  StartBackupReq* sig = (StartBackupReq*)data;
  fprintf(out, " backupPtr: %d backupId: %d\n",
	  sig->backupPtr, sig->backupId);
  return true;
}

bool 
printSTART_BACKUP_REF(FILE * out, const Uint32 * data, Uint32 len, Uint16 bno){
  StartBackupRef* sig = (StartBackupRef*)data;
  fprintf(out, " backupPtr: %d backupId: %d errorCode: %d\n",
	  sig->backupPtr, sig->backupId, sig->errorCode);
  return true;
}

bool 
printSTART_BACKUP_CONF(FILE * out, const Uint32 * data, Uint32 l, Uint16 bno){
  StartBackupConf* sig = (StartBackupConf*)data;
  fprintf(out, " backupPtr: %d backupId: %d\n",
	  sig->backupPtr, sig->backupId);
  return true;
}

bool 
printBACKUP_FRAGMENT_REQ(FILE * out, const Uint32 * data, Uint32 l, Uint16 bno){
  BackupFragmentReq* sig = (BackupFragmentReq*)data;
  fprintf(out, " backupPtr: %d backupId: %d\n",
	  sig->backupPtr, sig->backupId);
  fprintf(out, " tableId: %d fragmentNo: %d (count = %d)\n",
	  sig->tableId, sig->fragmentNo, sig->count);
  return true;
}

bool 
printBACKUP_FRAGMENT_REF(FILE * out, const Uint32 * data, Uint32 l, Uint16 bno){
  BackupFragmentRef* sig = (BackupFragmentRef*)data;
  fprintf(out, " backupPtr: %d backupId: %d nodeId: %d errorCode: %d\n",
	  sig->backupPtr, sig->backupId, sig->nodeId, sig->errorCode);
  return true;
}

bool 
printBACKUP_FRAGMENT_CONF(FILE * out, const Uint32 * data, Uint32 l, Uint16 b){
  BackupFragmentConf* sig = (BackupFragmentConf*)data;
  fprintf(out, " backupPtr: %d backupId: %d\n",
	  sig->backupPtr, sig->backupId);
  fprintf(out, " tableId: %d fragmentNo: %d records: %d bytes: %d\n",
	  sig->tableId, sig->fragmentNo, sig->noOfRecords, sig->noOfBytes);
  return true;
}

bool 
printSTOP_BACKUP_REQ(FILE * out, const Uint32 * data, Uint32 l, Uint16 bno){
  StopBackupReq* sig = (StopBackupReq*)data;
  fprintf(out, " backupPtr: %d backupId: %d\n",
	  sig->backupPtr, sig->backupId);
  return true;
}

bool 
printSTOP_BACKUP_REF(FILE * out, const Uint32 * data, Uint32 len, Uint16 bno){
  StopBackupRef* sig = (StopBackupRef*)data;
  fprintf(out, " backupPtr: %d backupId: %d errorCode: %d\n",
	  sig->backupPtr, sig->backupId, sig->errorCode);
  return true;
}

bool 
printSTOP_BACKUP_CONF(FILE * out, const Uint32 * data, Uint32 l, Uint16 bno){
  StopBackupConf* sig = (StopBackupConf*)data;
  fprintf(out, " backupPtr: %d backupId: %d\n",
	  sig->backupPtr, sig->backupId);
  return true;
}

bool 
printBACKUP_STATUS_REQ(FILE *, const Uint32 *, Uint32, Uint16){
  return false;
}

bool 
printBACKUP_STATUS_CONF(FILE *, const Uint32 *, Uint32, Uint16){
  return false;
}