~drizzle-trunk/drizzle/development : revision 130

21

#include "sql_repl.h" // For check_binlog_magic

22

#include "rpl_utility.h"

23

24

static int count_relay_log_space(Relay_log_info* rli);

24

static int32_t count_relay_log_space(Relay_log_info* rli);

25

26

// Defined in slave.cc

27

int init_intvar_from_file(int* var, IO_CACHE* f, int default_val);

28

int init_strvar_from_file(char *var, int max_size, IO_CACHE *f,

27

int32_t init_intvar_from_file(int32_t* var, IO_CACHE* f, int32_t default_val);

28

int32_t init_strvar_from_file(char *var, int32_t max_size, IO_CACHE *f,

29

const char *default_val);

30

31

77

}

78

79

80

int init_relay_log_info(Relay_log_info* rli,

80

int32_t init_relay_log_info(Relay_log_info* rli,

81

const char* info_fname)

82

{

83

char fname[FN_REFLEN+128];

84

int info_fd;

84

int32_t info_fd;

85

const char* msg = 0;

86

int error = 0;

86

int32_t error = 0;

87

assert(!rli->no_storage); // Don't init if there is no storage

88

89

if (rli->inited) // Set if this function called

194

reinit_io_cache(&rli->info_file, READ_CACHE, 0L,0,0);

195

else

196

{

197

int error=0;

197

int32_t error=0;

198

if ((info_fd = my_open(fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0)

199

{

200

sql_print_error("\

221

}

222

223

rli->info_fd = info_fd;

224

int relay_log_pos, master_log_pos;

224

int32_t relay_log_pos, master_log_pos;

225

if (init_strvar_from_file(rli->group_relay_log_name,

226

sizeof(rli->group_relay_log_name),

227

&rli->info_file, "") ||

285

}

286

287

288

static inline int add_relay_log(Relay_log_info* rli,LOG_INFO* linfo)

288

static inline int32_t add_relay_log(Relay_log_info* rli,LOG_INFO* linfo)

289

{

290

struct stat s;

291

if (stat(linfo->log_file_name,&s))

299

}

300

301

302

static int count_relay_log_space(Relay_log_info* rli)

302

static int32_t count_relay_log_space(Relay_log_info* rli)

303

{

304

LOG_INFO linfo;

305

rli->log_space_total= 0;

372

1 error. errmsg is set to point to the error message

373

*/

374

375

int init_relay_log_pos(Relay_log_info* rli,const char* log,

376

ulonglong pos, bool need_data_lock,

375

int32_t init_relay_log_pos(Relay_log_info* rli,const char* log,

376

uint64_t pos, bool need_data_lock,

377

const char** errmsg,

378

bool look_for_description_event)

379

{

551

timeout timeout in seconds before giving up waiting

552

553

NOTES

554

timeout is longlong whereas it should be ulong ; but this is

554

timeout is longlong whereas it should be uint32_t ; but this is

555

to catch if the user submitted a negative timeout.

556

557

RETURN VALUES

564

before reaching the desired log/position

565

*/

566

567

int Relay_log_info::wait_for_pos(THD* thd, String* log_name,

567

int32_t Relay_log_info::wait_for_pos(THD* thd, String* log_name,

568

longlong log_pos,

569

longlong timeout)

570

{

571

int event_count = 0;

572

ulong init_abort_pos_wait;

573

int error=0;

571

int32_t event_count = 0;

572

uint32_t init_abort_pos_wait;

573

int32_t error=0;

574

struct timespec abstime; // for timeout checking

575

const char *msg;

576

600

/*

601

We'll need to

602

handle all possible log names comparisons (e.g. 999 vs 1000).

603

We use ulong for string->number conversion ; this is no

603

We use uint32_t for string->number conversion ; this is no

604

stronger limitation than in find_uniq_filename in sql/log.cc

605

*/

606

ulong log_name_extension;

606

uint32_t log_name_extension;

607

char log_name_tmp[FN_REFLEN]; //make a char[] from String

608

609

strmake(log_name_tmp, log_name->ptr(), min(log_name->length(), FN_REFLEN-1));

636

slave_running)

637

{

638

bool pos_reached;

639

int cmp_result= 0;

639

int32_t cmp_result= 0;

640

641

/*

642

group_master_log_name can be "", if we are just after a fresh

662

if the names do not match up to '.' included, return error

663

*/

664

char *q= (char*)(fn_ext(basename)+1);

665

if (strncmp(basename, log_name_tmp, (int)(q-basename)))

665

if (strncmp(basename, log_name_tmp, (int32_t)(q-basename)))

666

{

667

error= -2;

668

break;

669

}

670

// Now compare extensions.

671

char *q_end;

672

ulong group_master_log_name_extension= strtoul(q, &q_end, 10);

672

uint32_t group_master_log_name_extension= strtoul(q, &q_end, 10);

673

if (group_master_log_name_extension < log_name_extension)

674

cmp_result= -1 ;

675

else

676

cmp_result= (group_master_log_name_extension > log_name_extension) ? 1 : 0 ;

677

678

pos_reached= ((!cmp_result && group_master_log_pos >= (ulonglong)log_pos) ||

678

pos_reached= ((!cmp_result && group_master_log_pos >= (uint64_t)log_pos) ||

679

cmp_result > 0);

680

if (pos_reached || thd->killed)

681

break;

724

}

725

726

727

void Relay_log_info::inc_group_relay_log_pos(ulonglong log_pos,

727

void Relay_log_info::inc_group_relay_log_pos(uint64_t log_pos,

728

bool skip_lock)

729

{

730

if (!skip_lock)

802

Assumes to have a run lock on rli and that no slave thread are running.

803

*/

804

805

int purge_relay_logs(Relay_log_info* rli, THD *thd, bool just_reset,

805

int32_t purge_relay_logs(Relay_log_info* rli, THD *thd, bool just_reset,

806

const char** errmsg)

807

{

808

int error=0;

808

int32_t error=0;

809

810

/*

811

Even if rli->inited==0, we still try to empty rli->master_log_* variables.

916

bool Relay_log_info::is_until_satisfied(my_off_t master_beg_pos)

917

{

918

const char *log_name;

919

ulonglong log_pos;

919

uint64_t log_pos;

920

921

assert(until_condition != UNTIL_NONE);

922

946

const char *basename= log_name + dirname_length(log_name);

947

948

const char *q= (const char*)(fn_ext(basename)+1);

949

if (strncmp(basename, until_log_name, (int)(q-basename)) == 0)

949

if (strncmp(basename, until_log_name, (int32_t)(q-basename)) == 0)

950

{

951

/* Now compare extensions. */

952

char *q_end;

953

ulong log_name_extension= strtoul(q, &q_end, 10);

953

uint32_t log_name_extension= strtoul(q, &q_end, 10);

954

if (log_name_extension < until_log_name_extension)

955

until_log_names_cmp_result= UNTIL_LOG_NAMES_CMP_LESS;

956

else

999

void Relay_log_info::stmt_done(my_off_t event_master_log_pos,

1000

time_t event_creation_time)

1001

{

1002

extern uint debug_not_change_ts_if_art_event;

1002

extern uint32_t debug_not_change_ts_if_art_event;

1003

clear_flag(IN_STMT);

1004

1005

/*