~ubuntu-branches/ubuntu/trusty/drizzle/trusty

bool MSTempLogThread::try_ReleaseBLOBReference(CSThread *self, CSStringBuffer *buffer, uint32_t tab_id, int type, uint64_t blob_id, uint32_t auth_code)

271

{

272

volatile bool rtc = true;

273

try_(a) {

274

/* Release the BLOB reference. */

275

MSOpenTable *otab;

276

277

if (type == MS_TL_REPO_REF) {

278

MSRepoFile *repo_file;

279

280

if ((repo_file = iTempLogDatabase->getRepoFileFromPool(tab_id, true))) {

281

frompool_(repo_file);

282

repo_file->checkBlob(buffer, blob_id, auth_code, iTempLogFile->myTempLogID, iLogOffset);

283

backtopool_(repo_file);

284

}

285

}

286

else {

287

if ((otab = MSTableList::getOpenTableByID(iTempLogDatabase->myDatabaseID, tab_id))) {

288

frompool_(otab);

289

if (type == MS_TL_BLOB_REF) {

290

otab->checkBlob(buffer, blob_id, auth_code, iTempLogFile->myTempLogID, iLogOffset);

291

backtopool_(otab);

292

}

293

else {

294

ASSERT(type == MS_TL_TABLE_REF);

295

if ((type == MS_TL_TABLE_REF) && otab->deleteReferences(iTempLogFile->myTempLogID, iLogOffset, &myMustQuit)) {

296

/* Delete the file now... */

297

MSTable *tab;

298

CSPath *from_path;

299

MSOpenTablePool *tab_pool;

300

301

tab = otab->getDBTable();

302

from_path = otab->getDBTable()->getTableFile();

303

304

pop_(otab);

305

306

push_(from_path);

307

tab->retain();

308

push_(tab);

309

310

tab_pool = MSTableList::lockTablePoolForDeletion(otab); // This returns otab to the pool.

311

frompool_(tab_pool);

312

313

from_path->removeFile();

314

tab->myDatabase->removeTable(tab);

315

316

backtopool_(tab_pool); // The will unlock and close the table pool freeing all tables in it.

317

pop_(tab); // Returning the pool will have released this. (YUK!)

318

release_(from_path);

319

}

320

else

321

backtopool_(otab);

322

}

323

}

324

}

325

326

rtc = false;

327

}

328

329

catch_(a);

330

cont_(a);

331

return rtc;

332

}

333

334

bool MSTempLogThread::doWork()

335

{

336

size_t tfer;

337

MSTempLogItemRec log_item;

338

CSStringBuffer *buffer;

339

SearchTXNLog txn_log(iTempLogDatabase->myDatabaseID, MSTransactionManager::tm_Log);

340

341

enter_();

342

new_(buffer, CSStringBuffer(20));

343

push_(buffer);

344

while (!myMustQuit) {

345

if (!iTempLogFile) {

346

size_t head_size;

347

if (!(iTempLogFile = iTempLogDatabase->openTempLogFile(0, &iLogRecSize, &head_size))) {

348

release_(buffer);

349

return_(true);

350

}

351

iLogOffset = head_size;

352

}

353

354

tfer = iTempLogFile->read(&log_item, iLogOffset, sizeof(MSTempLogItemRec), 0);

355

if (tfer == 0) {

356

/* No more data to be read: */

357

358

/* Check to see if there is a log after this: */

359

if (iTempLogDatabase->getTempLogCount() <= 1) {

360

/* The next log does not yet exist. We wait for

361

* it to be created before we delete and

362

* close the current log.

363

364

myWaitTime = PBMSParameters::getTempBlobTimeout() * 1000;

365

break;

366

}

367

368

iTempLogFile->myTempLog->deleteLog();

369

iTempLogDatabase->removeTempLog(iTempLogFile->myTempLogID);

370

close();

371

}

372

else if (tfer == sizeof(MSTempLogItemRec)) {

373

/* We have a record: */

374

int type;

375

uint32_t tab_id;

376

uint64_t blob_id= 0;

377

uint32_t auth_code;

378

uint32_t then;

379

time_t now;

380

381

382

* Items in the temp log are never updated.

383

* If a temp operation is canceled then the object

384

* records this itself and when the temp operation

385

* is attempted it will recognize by the templog

386

* id and offset that it is no longer a valid

387

* operation.

388

389

tab_id = CS_GET_DISK_4(log_item.ti_table_id_4);

390

391

type = CS_GET_DISK_1(log_item.ti_type_1);

392

blob_id = CS_GET_DISK_6(log_item.ti_blob_id_6);

393

auth_code = CS_GET_DISK_4(log_item.ti_auth_code_4);

394

then = CS_GET_DISK_4(log_item.ti_time_4);

395

396

now = time(NULL);

397

if (now < (time_t)(then + PBMSParameters::getTempBlobTimeout())) {

398

/* Time has not yet exired, adjust wait time: */

399

myWaitTime = MSTempLog::adjustWaitTime(then, now);

400

break;

401

}

402

403

if (try_ReleaseBLOBReference(self, buffer, tab_id, type, blob_id, auth_code)) {

404

int err = self->myException.getErrorCode();

405

406

if (err == MS_ERR_TABLE_LOCKED) {

407

throw_();

408

}

409

else if (err == MS_ERR_REMOVING_REPO) {

410

/* Wait for the compactor to finish: */

411

myWaitTime = 2 * 1000;

412

release_(buffer);

413

return_(true);

414

}

415

else if ((err == MS_ERR_UNKNOWN_TABLE) || (err == MS_ERR_DATABASE_DELETED))

416

;

417

else

418

self->myException.log(NULL);

419

}

420

421

}

422

else {

423

// Only part of the data read, don't wait very long to try again:

424

myWaitTime = 2 * 1000;

425

break;

426

}

427

iLogOffset += iLogRecSize;

428

}

429

430

release_(buffer);

431

return_(true);

432

}

433

434

void *MSTempLogThread::completeWork()

435

{

436

close();

437

return NULL;

438

}

439

Older »