~ubuntu-branches/ubuntu/trusty/mod-gearman/trusty

execlp("gearmand", "gearmand", "--listen=127.0.0.1", "--threads=10", "--job-retries=0", port, "--verbose=DEBUG", "--log-file=/tmp/gearmand.log" , (char *)NULL);

} else if(atof(gearman_version()) > 0.14) {

execlp("gearmand", "gearmand", "--threads=10", "--job-retries=0", port, "--verbose=999", "--log-file=/tmp/gearmand.log" , (char *)NULL);

execlp("gearmand", "gearmand", "--listen=127.0.0.1", "--threads=10", "--job-retries=0", port, "--verbose=999", "--log-file=/tmp/gearmand.log" , (char *)NULL);

} else {

/* for gearman 0.14 */

execlp("gearmand", "gearmand", "-t 10", "-j 0", port, (char *)NULL);

if(pid == 0) {

sid = setsid();

char options[150];

snprintf(options, 150, "server=localhost:%d", GEARMAND_TEST_PORT);

snprintf(options, 150, "server=127.0.0.1:%d", GEARMAND_TEST_PORT);

char logf[150];

snprintf(logf, 150, "logfile=%s", worker_logfile);

if(key != NULL) {

200

ok(create_client( mod_gm_opt->server_list, &client ) == GM_OK, "created test client");

201

202

ok(create_worker( mod_gm_opt->server_list, &worker ) == GM_OK, "created test worker");

203

ok(worker_add_function( &worker, GM_DEFAULT_RESULT_QUEUE, get_results ) == GM_OK, "added result worker");

204

ok(worker_add_function( &worker, "dummy", dummy ) == GM_OK, "added dummy worker");

203

205

//gearman_worker_add_options(&worker, GEARMAN_WORKER_NON_BLOCKING);

204

206

gearman_worker_set_timeout(&worker, 5000);

205

ok(worker_add_function( &worker, GM_DEFAULT_RESULT_QUEUE, get_results ) == GM_OK, "added result worker");

206

ok(worker_add_function( &worker, "dummy", dummy ) == GM_OK, "added dummy worker");

207

return;

208

}

209

214

int x = 0;

215

for(x=0;x<nr;x++) {

216

ret = gearman_worker_work( &worker );

217

//ok(ret == GEARMAN_SUCCESS, 'got valid job' );

217

ok(ret == GEARMAN_SUCCESS, "got valid job from result queue" );

218

}

219

return;

220

}

240

line = malloc(GM_BUFFERSIZE);

241

while(fgets(line, GM_BUFFERSIZE, fp) != NULL) {

242

if(strstr(line, "ERROR") != NULL) {

243

mode == 2 && diag("logfile: %s", line);

243

if(mode == 2)

244

diag("logfile: %s", line);

244

245

errors++;

245

246

}

246

247

}

268

269

return;

269

270

}

270

271

272

/* diag queues */

273

void diag_queues(void);

274

void diag_queues() {

275

char * message = NULL;

276

char * version = NULL;

277

int rc, x;

278

mod_gm_server_status_t *stats;

279

280

// print some debug info

281

stats = malloc(sizeof(mod_gm_server_status_t));

282

stats->function_num = 0;

283

stats->worker_num = 0;

284

rc = get_gearman_server_data(stats, &message, &version, "127.0.0.1", GEARMAND_TEST_PORT);

285

diag("get_gearman_server_data: rc: %d\n", rc);

286

diag("get_gearman_server_data: msg: %s\n", message);

287

diag("get_gearman_server_data: ver: %s\n", version);

288

if( rc == STATE_OK ) {

289

diag("%-35s %-9s %-9s\n", "queue", "waiting", "running");

290

for(x=0; x<stats->function_num;x++) {

291

diag("%-35s %-9d %-9d\n", stats->function[x]->queue, stats->function[x]->waiting, stats->function[x]->running);

292

}

293

}

294

free(message);

295

free(version);

296

free_mod_gm_status_server(stats);

297

return;

298

}

299

271

300

/* wait till the given queue is empty */

272

301

void wait_for_empty_queue(char *queue, int timeout);

273

302

void wait_for_empty_queue(char *queue, int timeout) {

283

312

stats = malloc(sizeof(mod_gm_server_status_t));

284

313

stats->function_num = 0;

285

314

stats->worker_num = 0;

286

rc = get_gearman_server_data(stats, &message, &version, "localhost", GEARMAND_TEST_PORT);

315

rc = get_gearman_server_data(stats, &message, &version, "127.0.0.1", GEARMAND_TEST_PORT);

287

316

if( rc == STATE_OK ) {

288

317

for(x=0; x<stats->function_num;x++) {

289

//diag("%s %d %d\n", stats->function[x]->queue, stats->function[x]->waiting, stats->function[x]->running);

290

318

if(stats->function[x]->waiting == 0 &&

291

319

stats->function[x]->running == 0 &&

292

320

!strcmp( stats->function[x]->queue, queue )

302

330

}

303

331

304

332

ok(tries < timeout, "queue %s empty after %d seconds", queue, tries);

333

334

if(tries >= timeout) {

335

diag_queues();

336

}

337

305

338

return;

306

339

}

307

340

317

350

return sfn;

318

351

}

319

352

353

void check_no_worker_running(char*);

354

void check_no_worker_running(char* worker_logfile) {

355

char cmd[150];

356

char *result, *error;

357

int rrc;

358

359

// ensure no worker are running anymore

360

char *username=getenv("USER");

361

snprintf(cmd, 150, "ps -efl 2>/dev/null | grep -v grep | grep '%s' | grep mod_gearman_worker", username);

362

rrc = real_exit_code(run_check(cmd, &result, &error));

363

ok(rrc == 1, "no worker running anymore");

364

like(result, "^\\s*$", "ps output should be empty");

365

like(error, "^\\s*$", "ps error output should be empty");

366

if(rrc != 1) {

367

check_logfile(worker_logfile, 3);

368

}

369

return;

370

}

371

372

320

373

/* main tests */

321

374

int main (int argc, char **argv, char **env) {

322

375

argc = argc; argv = argv; env = env;

323

376

int status, chld, rc;

324

int tests = 92;

377

int tests = 127;

325

378

int rrc;

326

379

char cmd[150];

327

380

char *result, *error, *message, *output;

338

391

#endif

339

392

340

393

char options[150];

341

snprintf(options, 150, "--server=localhost:%d", GEARMAND_TEST_PORT);

394

snprintf(options, 150, "--server=127.0.0.1:%d", GEARMAND_TEST_PORT);

342

395

ok(parse_args_line(mod_gm_opt, options, 0) == 0, "parse_args_line()");

343

396

mod_gm_opt->debug_level = GM_LOG_ERROR;

344

397

350

403

351

404

/* first fire up a gearmand server and one worker */

352

405

start_gearmand((void*)NULL);

406

sleep(2);

353

407

start_worker((void*)NULL);

408

sleep(2);

354

409

355

410

/* wait one second and catch died procs */

356

sleep(1);

357

while((chld = waitpid(-1, &status, WNOHANG)) != -1 && chld > 0) {

411

while((chld = waitpid(-1, &status, WNOHANG)) != -1 && chld > 0) {

358

412

diag( "waitpid() %d exited with %d\n", chld, status);

359

413

status = 0;

360

414

}

361

415

362

if(!ok(gearmand_pid > 0, "'gearmand started with pid: %d", GEARMAND_TEST_PORT, gearmand_pid)) {

416

if(!ok(gearmand_pid > 0, "'gearmand started with port %d and pid: %d", GEARMAND_TEST_PORT, gearmand_pid)) {

363

417

diag("make sure gearmand is in your PATH. Common locations are /usr/sbin or /usr/local/sbin");

364

418

exit( EXIT_FAILURE );

365

419

}

366

420

if(!ok(pid_alive(gearmand_pid) == TRUE, "gearmand alive")) {

421

check_logfile("/tmp/gearmand.log", 3);

422

kill(gearmand_pid, SIGTERM);

423

kill(worker_pid, SIGTERM);

367

424

exit( EXIT_FAILURE );

368

425

}

369

426

if(!ok(worker_pid > 0, "worker started with pid: %d", worker_pid))

371

428

if(!ok(pid_alive(worker_pid) == TRUE, "worker alive")) {

372

429

check_logfile(worker_logfile, 3);

373

430

kill(gearmand_pid, SIGTERM);

431

kill(worker_pid, SIGTERM);

374

432

exit( EXIT_FAILURE );

375

433

}

376

434

384

442

385

443

/* send big job */

386

444

send_big_jobs(GM_ENCODE_ONLY);

445

//diag_queues();

446

wait_for_empty_queue("eventhandler", 20);

447

wait_for_empty_queue("service", 20);

448

//diag_queues();

387

449

do_result_work(1);

450

//diag_queues();

451

wait_for_empty_queue(GM_DEFAULT_RESULT_QUEUE, 5);

388

452

389

453

/*****************************************

390

454

* test check

391

455

456

//diag_queues();

392

457

test_servicecheck(GM_ENCODE_ONLY, "./t/crit.pl");

458

//diag_queues();

459

wait_for_empty_queue("eventhandler", 20);

460

wait_for_empty_queue("service", 5);

461

//diag_queues();

393

462

do_result_work(1);

463

//diag_queues();

464

wait_for_empty_queue(GM_DEFAULT_RESULT_QUEUE, 5);

465

//diag_queues();

394

466

like(last_result, "test plugin CRITICAL", "stdout output from ./t/crit.pl");

395

467

like(last_result, "some errors on stderr", "stderr output from ./t/crit.pl");

396

468

397

469

/*****************************************

398

470

* test check2

399

471

472

//diag_queues();

400

473

test_servicecheck(GM_ENCODE_ONLY, "./t/both");

474

//diag_queues();

475

wait_for_empty_queue("eventhandler", 20);

476

wait_for_empty_queue("service", 5);

477

//diag_queues();

401

478

do_result_work(1);

479

//diag_queues();

480

wait_for_empty_queue(GM_DEFAULT_RESULT_QUEUE, 5);

402

481

like(last_result, "stdout output", "stdout output from ./t/both");

403

482

like(last_result, "stderr output", "stderr output from ./t/both");

404

483

405

484

/* try to send some data with base64 only */

485

//diag_queues();

406

486

test_eventhandler(GM_ENCODE_ONLY);

487

//diag_queues();

407

488

test_servicecheck(GM_ENCODE_ONLY, NULL);

408

do_result_work(1);

489

//diag_queues();

409

490

wait_for_empty_queue("eventhandler", 20);

410

491

wait_for_empty_queue("service", 5);

492

//diag_queues();

493

do_result_work(1);

494

//diag_queues();

411

495

wait_for_empty_queue(GM_DEFAULT_RESULT_QUEUE, 5);

412

496

sleep(1);

413

497

kill(worker_pid, SIGTERM);

414

498

waitpid(worker_pid, &status, 0);

415

ok(status == 0, "worker exited with exit code %d", real_exit_code(status));

499

ok(status == 0, "worker (%d) exited with exit code %d", worker_pid, real_exit_code(status));

416

500

status = 0;

501

check_no_worker_running(worker_logfile);

417

502

check_logfile(worker_logfile, 0);

418

503

419

504

char * test_keys[] = {

436

521

437

522

test_eventhandler(GM_ENCODE_AND_ENCRYPT);

438

523

test_servicecheck(GM_ENCODE_AND_ENCRYPT, NULL);

439

do_result_work(1);

440

441

524

wait_for_empty_queue("eventhandler", 20);

442

525

wait_for_empty_queue("service", 5);

526

do_result_work(1);

443

527

wait_for_empty_queue(GM_DEFAULT_RESULT_QUEUE, 5);

444

528

sleep(1);

445

529

446

530

kill(worker_pid, SIGTERM);

447

531

waitpid(worker_pid, &status, 0);

448

ok(status == 0, "worker exited with exit code %d", real_exit_code(status));

532

ok(status == 0, "worker (%d) exited with exit code %d", worker_pid, real_exit_code(status));

449

533

status = 0;

534

check_no_worker_running(worker_logfile);

450

535

check_logfile(worker_logfile, 0);

451

536

}

452

537

453

538

/*****************************************

454

539

* send_gearman

455

540

456

snprintf(cmd, 150, "./send_gearman --server=localhost:%d --key=testtest --host=test --service=test --message=test --returncode=0", GEARMAND_TEST_PORT);

541

snprintf(cmd, 150, "./send_gearman --server=127.0.0.1:%d --key=testtest --host=test --service=test --message=test --returncode=0", GEARMAND_TEST_PORT);

457

542

rrc = real_exit_code(run_check(cmd, &result, &error));

458

543

cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc);

459

544

like(result, "^\\s*$", "output from ./send_gearman");

463

548

/*****************************************

464

549

* send_multi

465

550

466

snprintf(cmd, 150, "./send_multi --server=localhost:%d --host=blah < t/data/send_multi.txt", GEARMAND_TEST_PORT);

551

snprintf(cmd, 150, "./send_multi --server=127.0.0.1:%d --host=blah < t/data/send_multi.txt", GEARMAND_TEST_PORT);

467

552

rrc = real_exit_code(run_check(cmd, &result, &error));

468

553

cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc);

469

554

like(result, "send_multi OK: 2 check_multi child checks submitted", "output from ./send_multi");

473

558

/*****************************************

474

559

* check_gearman

475

560

476

snprintf(cmd, 150, "./check_gearman -H localhost:%d -s check -a -q worker_test", GEARMAND_TEST_PORT);

561

snprintf(cmd, 150, "./check_gearman -H 127.0.0.1:%d -s check -a -q worker_test", GEARMAND_TEST_PORT);

477

562

rrc = real_exit_code(run_check(cmd, &result, &error));

478

563

cmp_ok(rrc, "==", 0, "cmd '%s' returned rc %d", cmd, rrc);

479

564

like(result, "check_gearman OK - sending background job succeded", "output from ./check_gearman");

486

571

free_worker(&worker);

487

572

488

573

/* shutdown gearmand */

489

rc = send2gearmandadmin("shutdown\n", "localhost", GEARMAND_TEST_PORT, &output, &message);

574

rc = send2gearmandadmin("shutdown\n", "127.0.0.1", GEARMAND_TEST_PORT, &output, &message);

490

575

ok(rc == 0, "rc of send2gearmandadmin %d", rc);

491

576

like(output, "OK", "output contains OK");

492

577

free(message);

497

582

waitpid(gearmand_pid, &status, WNOHANG);

498

583

if(pid_alive(gearmand_pid) == FALSE) {

499

584

todo();

500

ok(status == 0, "gearmand exited with: %d", real_exit_code(status));

585

ok(status == 0, "gearmand (%d) exited with: %d", gearmand_pid, real_exit_code(status));

501

586

endtodo;

502

587

break;

503

588

}

508

593

/* kill it the hard way */

509

594

kill(gearmand_pid, SIGTERM);

510

595

waitpid(gearmand_pid, &status, 0);

511

ok(status == 0, "gearmand exited with exit code %d", real_exit_code(status));

596

ok(status == 0, "gearmand (%d) exited with exit code %d", gearmand_pid, real_exit_code(status));

512

597

status = 0;

513

598

ok(false, "gearmand had to be killed!");

514

599

}

518

603

519

604

kill(worker_pid, SIGTERM);

520

605

waitpid(worker_pid, &status, 0);

521

ok(status == 0, "worker exited with exit code %d", real_exit_code(status));

606

ok(status == 0, "worker (%d) exited with exit code %d", worker_pid, real_exit_code(status));

607

check_no_worker_running(worker_logfile);

522

608

check_logfile(worker_logfile, 2);

523

609

status = 0;

524

610

Older »