~kentokushiba/spiderformysql/spider-2.0-src : revision 16

26

#include "probes_mysql.h"

27

#include "sql_class.h"

28

#include "sql_partition.h"

29

#include "sql_acl.h"

29

30

#endif

30

31

#include "spd_err.h"

31

32

#include "spd_param.h"

46

47

extern PSI_mutex_key spd_key_mutex_mon_list_receptor;

47

48

extern PSI_mutex_key spd_key_mutex_mon_list_monitor;

48

49

extern PSI_mutex_key spd_key_mutex_mon_list_update_status;

50

extern PSI_mutex_key spd_key_mutex_mon_table_cache;

49

51

#endif

50

52

51

53

#ifndef WITHOUT_SPIDER_BG_SEARCH

57

59

pthread_mutex_t *spider_udf_table_mon_mutexes;

58

60

pthread_cond_t *spider_udf_table_mon_conds;

59

61

62

pthread_mutex_t spider_mon_table_cache_mutex;

63

DYNAMIC_ARRAY spider_mon_table_cache;

64

volatile ulonglong spider_mon_table_cache_version = 0;

65

volatile ulonglong spider_mon_table_cache_version_req = 1;

66

60

67

SPIDER_TABLE_MON_LIST *spider_get_ping_table_mon_list(

61

68

SPIDER_TRX *trx,

62

69

THD *thd,

69

76

) {

70

77

uint mutex_hash;

71

78

SPIDER_TABLE_MON_LIST *table_mon_list;

79

MEM_ROOT mem_root;

80

ulonglong mon_table_cache_version;

72

81

DBUG_ENTER("spider_get_ping_table_mon_list");

82

if (spider_mon_table_cache_version != spider_mon_table_cache_version_req)

83

{

84

init_alloc_root(&mem_root, 4096, 0);

85

if ((*error_num = spider_init_ping_table_mon_cache(thd, &mem_root,

86

need_lock)))

87

{

88

free_root(&mem_root, MYF(0));

89

goto error;

90

}

91

free_root(&mem_root, MYF(0));

92

}

93

73

94

mutex_hash = spider_udf_calc_hash(str->c_ptr(),

74

95

spider_udf_table_mon_mutex_count);

75

96

DBUG_PRINT("info",("spider hash key=%s", str->c_ptr()));

76

DBUG_PRINT("info",("spider hash key length=%ld", str->length()));

97

DBUG_PRINT("info",("spider hash key length=%u", str->length()));

77

98

pthread_mutex_lock(&spider_udf_table_mon_mutexes[mutex_hash]);

99

mon_table_cache_version = (ulonglong) spider_mon_table_cache_version;

78

100

if (!(table_mon_list = (SPIDER_TABLE_MON_LIST *) my_hash_search(

79

101

&spider_udf_table_mon_list_hash[mutex_hash],

80

(uchar*) str->c_ptr(), str->length())))

81

{

102

(uchar*) str->c_ptr(), str->length())) ||

103

table_mon_list->mon_table_cache_version != mon_table_cache_version

104

) {

82

105

DBUG_ASSERT(trx != spider_global_trx);

106

if (

107

table_mon_list &&

108

table_mon_list->mon_table_cache_version != mon_table_cache_version

109

)

110

spider_release_ping_table_mon_list_loop(mutex_hash, table_mon_list);

111

83

112

if (!(table_mon_list = spider_get_ping_table_tgt(thd, str->c_ptr(),

84

113

conv_name_length, link_idx, server_id, str, need_lock, error_num)))

85

114

{

87

116

goto error;

88

117

}

89

118

table_mon_list->mutex_hash = mutex_hash;

119

table_mon_list->mon_table_cache_version = mon_table_cache_version;

90

120

if (my_hash_insert(&spider_udf_table_mon_list_hash[mutex_hash],

91

121

(uchar*) table_mon_list))

92

122

{

98

128

}

99

129

}

100

130

table_mon_list->use_count++;

101

DBUG_PRINT("info",("spider table_mon_list->use_count=%d", table_mon_list->use_count));

131

DBUG_PRINT("info",("spider table_mon_list->use_count=%d",

132

table_mon_list->use_count));

102

133

pthread_mutex_unlock(&spider_udf_table_mon_mutexes[mutex_hash]);

103

134

DBUG_RETURN(table_mon_list);

104

135

122

153

DBUG_VOID_RETURN;

123

154

}

124

155

156

void spider_release_ping_table_mon_list_loop(

157

uint mutex_hash,

158

SPIDER_TABLE_MON_LIST *table_mon_list

159

) {

160

DBUG_ENTER("spider_release_ping_table_mon_list_loop");

161

my_hash_delete(&spider_udf_table_mon_list_hash[mutex_hash],

162

(uchar*) table_mon_list);

163

while (TRUE)

164

{

165

if (table_mon_list->use_count)

166

pthread_cond_wait(&spider_udf_table_mon_conds[mutex_hash],

167

&spider_udf_table_mon_mutexes[mutex_hash]);

168

else {

169

spider_ping_table_free_mon_list(table_mon_list);

170

break;

171

}

172

}

173

DBUG_VOID_RETURN;

174

}

175

125

176

void spider_release_ping_table_mon_list(

126

177

const char *conv_name,

127

178

uint conv_name_length,

135

186

DBUG_PRINT("info", ("spider conv_name=%s", conv_name));

136

187

DBUG_PRINT("info", ("spider conv_name_length=%u", conv_name_length));

137

188

DBUG_PRINT("info", ("spider link_idx=%d", link_idx));

138

link_idx_str_length = my_sprintf(link_idx_str, (link_idx_str, "%010ld",

189

link_idx_str_length = my_sprintf(link_idx_str, (link_idx_str, "%010d",

139

190

link_idx));

140

191

#ifdef _MSC_VER

141

192

String conv_name_str(conv_name_length + link_idx_str_length + 1);

155

206

if ((table_mon_list = (SPIDER_TABLE_MON_LIST *) my_hash_search(

156

207

&spider_udf_table_mon_list_hash[mutex_hash],

157

208

(uchar*) conv_name_str.c_ptr(), conv_name_str.length())))

158

{

159

while (TRUE)

160

{

161

if (table_mon_list->use_count)

162

pthread_cond_wait(&spider_udf_table_mon_conds[mutex_hash],

163

&spider_udf_table_mon_mutexes[mutex_hash]);

164

else {

165

my_hash_delete(&spider_udf_table_mon_list_hash[mutex_hash],

166

(uchar*) table_mon_list);

167

spider_ping_table_free_mon_list(table_mon_list);

168

break;

169

}

170

}

171

}

209

spider_release_ping_table_mon_list_loop(mutex_hash, table_mon_list);

172

210

pthread_mutex_unlock(&spider_udf_table_mon_mutexes[mutex_hash]);

173

211

DBUG_VOID_RETURN;

174

212

}

211

249

}

212

250

spider_store_tables_name(table_link_mon, name, name_length);

213

251

spider_store_tables_link_idx(table_link_mon, link_idx);

214

if ((error_num = spider_get_sys_table_by_idx(table_link_mon, table_key,

215

table_link_mon->s->primary_key, 3)))

216

{

217

if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE)

218

{

219

table_link_mon->file->print_error(error_num, MYF(0));

220

goto error;

221

}

222

} else

252

if (!(error_num = spider_ping_table_cache_compare(table_link_mon, mem_root)))

223

253

goto create_table_mon;

224

if (link_idx > 0)

225

{

226

spider_store_tables_link_idx(table_link_mon, 0);

227

if ((error_num = spider_get_sys_table_by_idx(table_link_mon, table_key,

228

table_link_mon->s->primary_key, 3)))

229

{

230

if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE)

231

{

232

table_link_mon->file->print_error(error_num, MYF(0));

233

goto error;

234

}

235

} else

236

goto create_table_mon;

237

}

254

if (error_num == HA_ERR_OUT_OF_MEM)

255

goto error;

238

256

if ((tmp_ptr = strstr(name, "#P#")))

239

257

{

240

258

*tmp_ptr = '\0';

241

259

spider_store_tables_name(table_link_mon, name, strlen(name));

242

spider_store_tables_link_idx(table_link_mon, link_idx);

243

260

*tmp_ptr = '#';

244

if ((error_num = spider_get_sys_table_by_idx(table_link_mon, table_key,

245

table_link_mon->s->primary_key, 3)))

246

{

247

if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE)

248

{

249

table_link_mon->file->print_error(error_num, MYF(0));

250

goto error;

251

}

252

} else

261

if (!(error_num = spider_ping_table_cache_compare(table_link_mon,

262

mem_root)))

253

263

goto create_table_mon;

254

255

if (link_idx > 0)

256

{

257

spider_store_tables_link_idx(table_link_mon, 0);

258

if ((error_num = spider_get_sys_table_by_idx(table_link_mon, table_key,

259

table_link_mon->s->primary_key, 3)))

260

{

261

if (

262

error_num != HA_ERR_KEY_NOT_FOUND &&

263

error_num != HA_ERR_END_OF_FILE

264

) {

265

table_link_mon->file->print_error(error_num, MYF(0));

266

goto error;

267

}

268

} else

269

goto create_table_mon;

270

}

264

if (error_num == HA_ERR_OUT_OF_MEM)

265

goto error;

271

266

}

267

error_num = HA_ERR_KEY_NOT_FOUND;

272

268

table_link_mon->file->print_error(error_num, MYF(0));

273

269

goto error;

274

270

275

271

create_table_mon:

272

if ((error_num = spider_get_sys_table_by_idx(table_link_mon, table_key,

273

table_link_mon->s->primary_key, 3)))

274

{

275

table_link_mon->file->print_error(error_num, MYF(0));

276

goto error;

277

}

278

276

279

do {

277

280

if (!(table_mon = (SPIDER_TABLE_MON *)

278

281

my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),

279

282

&table_mon, sizeof(SPIDER_TABLE_MON),

280

283

&tmp_share, sizeof(SPIDER_SHARE),

281

&tmp_connect_info, sizeof(char *) * 15,

282

&tmp_connect_info_length, sizeof(uint) * 15,

283

&tmp_long, sizeof(long) * 5,

284

&tmp_longlong, sizeof(longlong) * 3,

284

&tmp_connect_info, sizeof(char *) * SPIDER_TMP_SHARE_CHAR_PTR_COUNT,

285

&tmp_connect_info_length, sizeof(uint) * SPIDER_TMP_SHARE_UINT_COUNT,

286

&tmp_long, sizeof(long) * SPIDER_TMP_SHARE_LONG_COUNT,

287

&tmp_longlong, sizeof(longlong) * SPIDER_TMP_SHARE_LONGLONG_COUNT,

285

288

NullS))

286

289

) {

287

290

spider_sys_index_end(table_link_mon);

325

328

spider_sys_index_end(table_link_mon);

326

329

goto error;

327

330

}

331

DBUG_PRINT("info",("spider table_mon->server_id=%u",

332

table_mon->server_id));

333

DBUG_PRINT("info",("spider server_id=%u", server_id));

328

334

if (table_mon->server_id == server_id)

329

335

table_mon_list->current = table_mon;

330

336

list_size++;

396

402

my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),

397

403

&table_mon_list, sizeof(SPIDER_TABLE_MON_LIST),

398

404

&tmp_share, sizeof(SPIDER_SHARE),

399

&tmp_connect_info, sizeof(char *) * 15,

400

&tmp_connect_info_length, sizeof(uint) * 15,

401

&tmp_long, sizeof(long) * 5,

402

&tmp_longlong, sizeof(longlong) * 3,

405

&tmp_connect_info, sizeof(char *) * SPIDER_TMP_SHARE_CHAR_PTR_COUNT,

406

&tmp_connect_info_length, sizeof(uint) * SPIDER_TMP_SHARE_UINT_COUNT,

407

&tmp_long, sizeof(long) * SPIDER_TMP_SHARE_LONG_COUNT,

408

&tmp_longlong, sizeof(longlong) * SPIDER_TMP_SHARE_LONGLONG_COUNT,

403

409

&key_str, str->length() + 1,

404

410

NullS))

405

411

) {

562

568

DBUG_RETURN(NULL);

563

569

}

564

570

571

int spider_init_ping_table_mon_cache(

572

THD *thd,

573

MEM_ROOT *mem_root,

574

bool need_lock

575

) {

576

int error_num, same;

577

TABLE *table_link_mon = NULL;

578

#if MYSQL_VERSION_ID < 50500

579

Open_tables_state open_tables_backup;

580

#else

581

Open_tables_backup open_tables_backup;

582

#endif

583

SPIDER_MON_KEY mon_key;

584

DBUG_ENTER("spider_init_ping_table_mon_cache");

585

586

if (

587

!(table_link_mon = spider_open_sys_table(

588

thd, SPIDER_SYS_LINK_MON_TABLE_NAME_STR,

589

SPIDER_SYS_LINK_MON_TABLE_NAME_LEN, FALSE, &open_tables_backup,

590

need_lock, &error_num))

591

) {

592

my_error(error_num, MYF(0));

593

goto error_open_sys_table;

594

}

595

596

pthread_mutex_lock(&spider_mon_table_cache_mutex);

597

if (spider_mon_table_cache_version != spider_mon_table_cache_version_req)

598

{

599

/* reset */

600

spider_mon_table_cache.elements = 0;

601

602

if ((error_num = spider_sys_index_first(table_link_mon,

603

table_link_mon->s->primary_key)))

604

{

605

if (error_num != HA_ERR_KEY_NOT_FOUND && error_num != HA_ERR_END_OF_FILE)

606

{

607

table_link_mon->file->print_error(error_num, MYF(0));

608

goto error_sys_index_first;

609

}

610

}

611

612

if (!error_num)

613

{

614

mon_key.db_name_length = SPIDER_SYS_LINK_MON_TABLE_DB_NAME_SIZE + 1;

615

mon_key.table_name_length = SPIDER_SYS_LINK_MON_TABLE_TABLE_NAME_SIZE + 1;

616

mon_key.link_id_length = SPIDER_SYS_LINK_MON_TABLE_LINK_ID_SIZE + 1;

617

do {

618

if ((error_num = spider_get_sys_link_mon_key(table_link_mon, &mon_key,

619

mem_root, &same)))

620

goto error_get_sys_link_mon_key;

621

622

if (!same)

623

{

624

mon_key.sort = spider_calc_for_sort(3, mon_key.db_name,

625

mon_key.table_name, mon_key.link_id);

626

if (push_dynamic(&spider_mon_table_cache, (uchar *) &mon_key))

627

{

628

error_num = HA_ERR_OUT_OF_MEM;

629

goto error_push_dynamic;

630

}

631

}

632

633

if ((error_num = spider_sys_index_next(table_link_mon)))

634

{

635

if (

636

error_num != HA_ERR_KEY_NOT_FOUND &&

637

error_num != HA_ERR_END_OF_FILE

638

) {

639

table_link_mon->file->print_error(error_num, MYF(0));

640

goto error_sys_index_next;

641

}

642

}

643

} while (!error_num);

644

spider_sys_index_end(table_link_mon);

645

}

646

my_qsort(

647

(uchar *) dynamic_element(&spider_mon_table_cache, 0, SPIDER_MON_KEY *),

648

spider_mon_table_cache.elements, sizeof(SPIDER_MON_KEY),

649

(qsort_cmp) spider_compare_for_sort);

650

freeze_size(&spider_mon_table_cache);

651

spider_mon_table_cache_version = spider_mon_table_cache_version_req;

652

}

653

pthread_mutex_unlock(&spider_mon_table_cache_mutex);

654

spider_close_sys_table(thd, table_link_mon, &open_tables_backup, need_lock);

655

DBUG_RETURN(0);

656

657

error_push_dynamic:

658

error_get_sys_link_mon_key:

659

error_sys_index_next:

660

spider_sys_index_end(table_link_mon);

661

error_sys_index_first:

662

pthread_mutex_unlock(&spider_mon_table_cache_mutex);

663

spider_close_sys_table(thd, table_link_mon, &open_tables_backup, need_lock);

664

error_open_sys_table:

665

DBUG_RETURN(error_num);

666

}

667

668

int spider_ping_table_cache_compare(

669

TABLE *table,

670

MEM_ROOT *mem_root

671

) {

672

uint32 roop_count;

673

SPIDER_MON_KEY *mon_key;

674

char *db_name, *table_name, *link_id;

675

DBUG_ENTER("spider_ping_table_cache_compare");

676

677

if (

678

!(db_name = get_field(mem_root, table->field[0])) ||

679

!(table_name = get_field(mem_root, table->field[1])) ||

680

!(link_id = get_field(mem_root, table->field[2]))

681

)

682

DBUG_RETURN(HA_ERR_OUT_OF_MEM);

683

DBUG_PRINT("info", ("spider db_name=%s", db_name));

684

DBUG_PRINT("info", ("spider table_name=%s", table_name));

685

DBUG_PRINT("info", ("spider link_id=%s", link_id));

686

687

pthread_mutex_lock(&spider_mon_table_cache_mutex);

688

for (roop_count = 0; roop_count < spider_mon_table_cache.elements;

689

roop_count++)

690

{

691

mon_key = dynamic_element(&spider_mon_table_cache, roop_count,

692

SPIDER_MON_KEY *);

693

DBUG_PRINT("info", ("spider roop_count=%d", roop_count));

694

DBUG_PRINT("info", ("spider mon_key.db_name=%s", mon_key->db_name));

695

DBUG_PRINT("info", ("spider mon_key.table_name=%s", mon_key->table_name));

696

DBUG_PRINT("info", ("spider mon_key.link_id=%s", mon_key->link_id));

697

if (

698

!wild_case_compare(system_charset_info, db_name, mon_key->db_name) &&

699

!wild_case_compare(system_charset_info, table_name,

700

mon_key->table_name) &&

701

!wild_case_compare(system_charset_info, link_id, mon_key->link_id)

702

) {

703

spider_store_db_and_table_name(

704

table,

705

mon_key->db_name,

706

mon_key->db_name_length,

707

mon_key->table_name,

708

mon_key->table_name_length

709

);

710

spider_store_tables_link_idx_str(

711

table,

712

mon_key->link_id,

713

mon_key->link_id_length

714

);

715

pthread_mutex_unlock(&spider_mon_table_cache_mutex);

716

DBUG_PRINT("info", ("spider found"));

717

DBUG_RETURN(0);

718

}

719

}

720

pthread_mutex_unlock(&spider_mon_table_cache_mutex);

721

DBUG_PRINT("info", ("spider not found"));

722

DBUG_RETURN(1);

723

}

724

565

725

long long spider_ping_table_body(

566

726

UDF_INIT *initid,

567

727

UDF_ARGS *args,

569

729

char *error

570

730

) {

571

731

int error_num = 0, link_idx, flags, full_mon_count, current_mon_count,

572

success_count, fault_count;

732

success_count, fault_count, tmp_error_num = 0;

573

733

uint32 first_sid;

574

734

longlong limit, tmp_sid = -1;

575

735

SPIDER_MON_TABLE_RESULT *mon_table_result =

693

853

if (

694

854

table_mon_list->mon_status == SPIDER_LINK_MON_NG ||

695

855

error_num ||

696

spider_db_udf_ping_table(table_mon_list, table_mon_list->share, trx,

856

(tmp_error_num = spider_db_udf_ping_table(table_mon_list, table_mon_list->share, trx,

697

857

ping_conn, where_clause, args->lengths[4],

698

858

(flags & SPIDER_UDF_PING_TABLE_PING_ONLY),

699

859

(flags & SPIDER_UDF_PING_TABLE_USE_WHERE),

700

860

limit

701

)

861

))

702

862

) {

863

if (tmp_error_num == HA_ERR_OUT_OF_MEM)

864

goto error_with_free_table_mon_list;

865

else if(tmp_error_num)

866

thd->clear_error();

703

867

fault_count++;

704

868

error_num = 0;

705

869

if (fault_count > full_mon_count / 2)

897

1061

DBUG_VOID_RETURN;

898

1062

}

899

1063

1064

long long spider_flush_table_mon_cache_body()

1065

{

1066

DBUG_ENTER("spider_flush_table_mon_cache_body");

1067

spider_mon_table_cache_version_req++;

1068

DBUG_RETURN(1);

1069

}

1070

900

1071

void spider_ping_table_free_mon_list(

901

1072

SPIDER_TABLE_MON_LIST *table_mon_list

902

1073

) {

1004

1175

1005

1176

if (table_mon_list->mon_status == SPIDER_LINK_MON_NG)

1006

1177

{

1007

DBUG_PRINT("info", ("spider share->link_statuses[%d]=SPIDER_LINK_STATUS_NG",

1008

link_idx));

1178

DBUG_PRINT("info",

1179

("spider share->link_statuses[%d]=SPIDER_LINK_STATUS_NG", link_idx));

1009

1180

share->link_statuses[link_idx] = SPIDER_LINK_STATUS_NG;

1010

1181

error_num = ER_SPIDER_LINK_MON_NG_NUM;

1011

1182

my_printf_error(error_num,