~drizzle-trunk/drizzle/jenkins-Drizzle-Builder-213 : revision 2392.1.1

204

205

TYPELIB tx_isolation_typelib= {array_elements(tx_isolation_names) - 1, "", tx_isolation_names, NULL};

206

207

/*

208

Used with --help for detailed option

209

*/

210

bool opt_help= false;

211

212

207

arg_cmp_func Arg_comparator::comparator_matrix[5][2] =

213

208

{{&Arg_comparator::compare_string, &Arg_comparator::compare_e_string},

214

209

{&Arg_comparator::compare_real, &Arg_comparator::compare_e_real},

356

351

static void get_options();

357

352

static void fix_paths();

358

353

359

static void usage();

360

354

void close_connections();

361

355

362

356

fs::path base_plugin_dir(PKGPLUGINDIR);

363

357

358

po::options_description general_options(_("General Options"));

364

359

po::options_description config_options(_("Config File Options"));

365

360

po::options_description long_options(_("Kernel Options"));

366

361

po::options_description plugin_load_options(_("Plugin Loading Options"));

383

378

return g_hostname;

384

379

}

385

380

381

static void print_version()

382

{

383

/*

384

Note: the instance manager keys off the string 'Ver' so it can find the

385

version from the output of 'drizzled --version', so don't change it!

386

*/

387

printf("%s Ver %s for %s-%s on %s (%s)\n", internal::my_progname,

388

PANDORA_RELEASE_VERSION, HOST_VENDOR, HOST_OS, HOST_CPU, COMPILATION_COMMENT);

389

}

390

386

391

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

387

392

** Code to end drizzled

388

393

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

454

459

}

455

460

}

456

461

457

458

void unireg_abort(int exit_code)

459

{

460

if (exit_code)

461

{

462

errmsg_printf(error::ERROR, _("Aborting"));

463

}

464

else if (opt_help)

465

{

466

usage();

467

}

468

469

clean_up(!opt_help && exit_code);

470

internal::my_end();

471

exit(exit_code);

462

static bool unireg_startup_completed= false;

463

void unireg_startup_finished()

464

{

465

unireg_startup_completed= true;

466

}

467

468

void unireg_exit()

469

{

470

internal::my_end();

471

assert(unireg_startup_completed == false);

472

exit(EXIT_SUCCESS);

473

}

474

475

void unireg_actual_abort(const char *file, int line, const char *func, const std::string& message)

476

{

477

std::stringstream temp;

478

temp << _("Aborting:") << "\"" << message << "\"" << ". Abort was called from " << file << ":" << line << " in " << func << "()";

479

errmsg_printf(error::ERROR, temp.str().c_str());

480

481

clean_up(vm.count("help") == 0);

482

internal::my_end();

483

484

assert(unireg_startup_completed == false);

485

exit(EXIT_FAILURE);

472

486

}

473

487

474

488

518

532

tmp_user_info= getpwnam(user);

519

533

if ((!tmp_user_info || user_id != tmp_user_info->pw_uid) &&

520

534

global_system_variables.log_warnings)

521

errmsg_printf(error::WARN, _("One can only use the --user switch "

522

"if running as root\n"));

535

{

536

errmsg_printf(error::WARN, _("One can only use the --user switch if running as root"));

537

}

523

538

}

524

539

return NULL;

525

540

}

526

541

if (not user)

527

542

{

528

errmsg_printf(error::ERROR, _("Fatal error: Please read \"Security\" section of "

529

"the manual to find out how to run drizzled as root"));

530

unireg_abort(1);

543

unireg_abort << _("drizzled cannot be run as root, use --user to start drizzled up as another user");

531

544

}

532

545

533

546

if (not strcmp(user, "root"))

547

{

534

548

return NULL; // Avoid problem with dynamic libraries

549

}

535

550

536

if (!(tmp_user_info= getpwnam(user)))

551

if ((tmp_user_info= getpwnam(user)) == NULL)

537

552

{

538

553

// Allow a numeric uid to be used

539

554

const char *pos;

540

555

for (pos= user; my_isdigit(&my_charset_utf8_general_ci,*pos); pos++) ;

541

556

if (*pos) // Not numeric id

542

557

goto err;

543

if (!(tmp_user_info= getpwuid(atoi(user))))

558

559

if ((tmp_user_info= getpwuid(atoi(user))) == NULL)

544

560

goto err;

545

561

}

546

562

return tmp_user_info;

547

563

548

564

err:

549

errmsg_printf(error::ERROR, _("Fatal error: Can't change to run as user '%s' ; "

550

"Please check that the user exists!\n"),user);

551

unireg_abort(1);

565

unireg_abort << "Fatal error: Can't change to run as user '" << user << "' ; Please check that the user exists!";

552

566

553

567

#ifdef PR_SET_DUMPABLE

554

568

if (getDebug().test(debug::CORE_ON_SIGNAL))

558

572

}

559

573

#endif

560

574

561

/* Sun Studio 5.10 doesn't like this line. 5.9 requires it */

562

#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x590)

563

575

return NULL;

564

#endif

565

566

576

}

567

577

568

578

void set_user(const char *user, passwd *user_info_arg)

571

581

initgroups(user, user_info_arg->pw_gid);

572

582

if (setgid(user_info_arg->pw_gid) == -1)

573

583

{

574

sql_perror(_("Set process group ID failed"));

575

unireg_abort(1);

584

unireg_abort << _("Set process group ID failed ") << strerror(errno);

576

585

}

577

586

if (setuid(user_info_arg->pw_uid) == -1)

578

587

{

579

sql_perror(_("Set process user ID failed"));

580

unireg_abort(1);

588

unireg_abort << _("Set process user ID failed") << strerror(errno);

581

589

}

582

590

}

583

591

586

594

/** Change root user if started with @c --chroot . */

587

595

static void set_root(const char *path)

588

596

{

589

if ((chroot(path) == -1) || !chdir("/"))

597

if ((chroot(path) == -1) or chdir("/") == 0)

590

598

{

591

sql_perror(_("Process chroot failed"));

592

unireg_abort(1);

599

unireg_abort << _("Process chroot failed");

593

600

}

594

601

}

595

602

688

695

global_system_variables.auto_increment_increment= 1;

689

696

if (in_auto_increment_increment < 1 || in_auto_increment_increment > UINT64_MAX)

690

697

{

691

cout << _("Error: Invalid Value for auto_increment_increment");

692

exit(-1);

698

unireg_abort << _("Invalid Value for auto_increment_increment");

693

699

}

694

700

global_system_variables.auto_increment_increment= in_auto_increment_increment;

695

701

}

699

705

global_system_variables.auto_increment_offset= 1;

700

706

if (in_auto_increment_offset < 1 || in_auto_increment_offset > UINT64_MAX)

701

707

{

702

cout << _("Error: Invalid Value for auto_increment_offset");

703

exit(-1);

708

unireg_abort << _("Invalid Value for auto_increment_offset");

704

709

}

705

710

global_system_variables.auto_increment_offset= in_auto_increment_offset;

706

711

}

710

715

global_system_variables.completion_type= 0;

711

716

if (in_completion_type > 2)

712

717

{

713

cout << _("Error: Invalid Value for completion_type");

714

exit(-1);

718

unireg_abort << _("Invalid Value for completion_type");

715

719

}

716

720

global_system_variables.completion_type= in_completion_type;

717

721

}

722

726

global_system_variables.div_precincrement= 4;

723

727

if (in_div_precincrement > DECIMAL_MAX_SCALE)

724

728

{

725

cout << _("Error: Invalid Value for div-precision-increment");

726

exit(-1);

729

unireg_abort << _("Invalid Value for div-precision-increment");

727

730

}

728

731

global_system_variables.div_precincrement= in_div_precincrement;

729

732

}

733

736

global_system_variables.group_concat_max_len= 1024;

734

737

if (in_group_concat_max_len > ULONG_MAX || in_group_concat_max_len < 4)

735

738

{

736

cout << _("Error: Invalid Value for group_concat_max_len");

737

exit(-1);

739

unireg_abort << _("Invalid Value for group_concat_max_len");

738

740

}

739

741

global_system_variables.group_concat_max_len= in_group_concat_max_len;

740

742

}

744

746

global_system_variables.join_buff_size= (128*1024L);

745

747

if (in_join_buffer_size < IO_SIZE*2 || in_join_buffer_size > ULONG_MAX)

746

748

{

747

cout << _("Error: Invalid Value for join_buffer_size");

748

exit(-1);

749

unireg_abort << _("Invalid Value for join_buffer_size");

749

750

}

750

751

in_join_buffer_size-= in_join_buffer_size % IO_SIZE;

751

752

global_system_variables.join_buff_size= in_join_buffer_size;

756

757

global_system_variables.max_allowed_packet= (64*1024*1024L);

757

758

if (in_max_allowed_packet < 1024 || in_max_allowed_packet > 1024*1024L*1024L)

758

759

{

759

cout << _("Error: Invalid Value for max_allowed_packet");

760

exit(-1);

760

unireg_abort << _("Invalid Value for max_allowed_packet");

761

}

762

in_max_allowed_packet-= in_max_allowed_packet % 1024;

763

global_system_variables.max_allowed_packet= in_max_allowed_packet;

768

global_system_variables.max_error_count= DEFAULT_ERROR_COUNT;

769

if (in_max_error_count > 65535)

770

{

771

cout << _("Error: Invalid Value for max_error_count");

772

exit(-1);

771

unireg_abort << _("Invalid Value for max_error_count");

773

772

}

774

773

global_system_variables.max_error_count= in_max_error_count;

775

774

}

779

778

global_system_variables.max_heap_table_size= (16*1024*1024L);

780

779

if (in_max_heap_table_size < 16384 || in_max_heap_table_size > MAX_MEM_TABLE_SIZE)

781

780

{

782

cout << _("Error: Invalid Value for max_heap_table_size");

783

exit(-1);

781

unireg_abort << _("Invalid Value for max_heap_table_size");

784

782

}

785

783

in_max_heap_table_size-= in_max_heap_table_size % 1024;

786

784

global_system_variables.max_heap_table_size= in_max_heap_table_size;

791

789

global_system_variables.min_examined_row_limit= 0;

792

790

if (in_min_examined_row_limit > ULONG_MAX)

793

791

{

794

cout << _("Error: Invalid Value for min_examined_row_limit");

795

exit(-1);

792

unireg_abort << _("Invalid Value for min_examined_row_limit");

796

793

}

797

794

global_system_variables.min_examined_row_limit= in_min_examined_row_limit;

798

795

}

802

799

global_system_variables.max_join_size= INT32_MAX;

803

800

if ((uint64_t)in_max_join_size < 1 || (uint64_t)in_max_join_size > INT32_MAX)

804

801

{

805

cout << _("Error: Invalid Value for max_join_size");

806

exit(-1);

802

unireg_abort << _("Invalid Value for max_join_size");

807

803

}

808

804

global_system_variables.max_join_size= in_max_join_size;

809

805

}

813

809

global_system_variables.max_length_for_sort_data= 1024;

814

810

if (in_max_length_for_sort_data < 4 || in_max_length_for_sort_data > 8192*1024L)

815

811

{

816

cout << _("Error: Invalid Value for max_length_for_sort_data");

817

exit(-1);

812

unireg_abort << _("Invalid Value for max_length_for_sort_data");

818

813

}

819

814

global_system_variables.max_length_for_sort_data= in_max_length_for_sort_data;

820

815

}

824

819

global_system_variables.max_seeks_for_key= ULONG_MAX;

825

820

if (in_max_seeks_for_key < 1 || in_max_seeks_for_key > ULONG_MAX)

826

821

{

827

cout << _("Error: Invalid Value for max_seeks_for_key");

828

exit(-1);

822

unireg_abort << _("Invalid Value for max_seeks_for_key");

829

823

}

830

824

global_system_variables.max_seeks_for_key= in_max_seeks_for_key;

831

825

}

835

829

global_system_variables.max_sort_length= 1024;

836

830

if ((int64_t)in_max_sort_length < 4 || (int64_t)in_max_sort_length > 8192*1024L)

837

831

{

838

cout << _("Error: Invalid Value for max_sort_length");

839

exit(-1);

832

unireg_abort << _("Invalid Value for max_sort_length");

840

833

}

841

834

global_system_variables.max_sort_length= in_max_sort_length;

842

835

}

846

839

global_system_variables.optimizer_search_depth= 0;

847

840

if (in_optimizer_search_depth > MAX_TABLES + 2)

848

841

{

849

cout << _("Error: Invalid Value for optimizer_search_depth");

850

exit(-1);

842

unireg_abort << _("Invalid Value for optimizer_search_depth");

851

843

}

852

844

global_system_variables.optimizer_search_depth= in_optimizer_search_depth;

853

845

}

857

849

global_system_variables.preload_buff_size= (32*1024L);

858

850

if (in_preload_buff_size < 1024 || in_preload_buff_size > 1024*1024*1024L)

859

851

{

860

cout << _("Error: Invalid Value for preload_buff_size");

861

exit(-1);

852

unireg_abort << _("Invalid Value for preload_buff_size");

862

853

}

863

854

global_system_variables.preload_buff_size= in_preload_buff_size;

864

855

}

868

859

global_system_variables.query_alloc_block_size= QUERY_ALLOC_BLOCK_SIZE;

869

860

if (in_query_alloc_block_size < 1024)

870

861

{

871

cout << _("Error: Invalid Value for query_alloc_block_size");

872

exit(-1);

862

unireg_abort << _("Invalid Value for query_alloc_block_size");

873

863

}

874

864

in_query_alloc_block_size-= in_query_alloc_block_size % 1024;

875

865

global_system_variables.query_alloc_block_size= in_query_alloc_block_size;

880

870

global_system_variables.query_prealloc_size= QUERY_ALLOC_PREALLOC_SIZE;

881

871

if (in_query_prealloc_size < QUERY_ALLOC_PREALLOC_SIZE)

882

872

{

883

cout << _("Error: Invalid Value for query_prealloc_size");

884

exit(-1);

873

unireg_abort << _("Invalid Value for query_prealloc_size");

885

874

}

886

875

in_query_prealloc_size-= in_query_prealloc_size % 1024;

887

876

global_system_variables.query_prealloc_size= in_query_prealloc_size;

892

881

global_system_variables.range_alloc_block_size= RANGE_ALLOC_BLOCK_SIZE;

893

882

if (in_range_alloc_block_size < RANGE_ALLOC_BLOCK_SIZE)

894

883

{

895

cout << _("Error: Invalid Value for range_alloc_block_size");

896

exit(-1);

884

unireg_abort << _("Invalid Value for range_alloc_block_size");

897

885

}

898

886

in_range_alloc_block_size-= in_range_alloc_block_size % 1024;

899

887

global_system_variables.range_alloc_block_size= in_range_alloc_block_size;

904

892

global_system_variables.read_buff_size= (128*1024L);

905

893

if (in_read_buff_size < IO_SIZE*2 || in_read_buff_size > INT32_MAX)

906

894

{

907

cout << _("Error: Invalid Value for read_buff_size");

908

exit(-1);

895

unireg_abort << _("Invalid Value for read_buff_size");

909

896

}

910

897

in_read_buff_size-= in_read_buff_size % IO_SIZE;

911

898

global_system_variables.read_buff_size= in_read_buff_size;

916

903

global_system_variables.read_rnd_buff_size= (256*1024L);

917

904

if (in_read_rnd_buff_size < 64 || in_read_rnd_buff_size > UINT32_MAX)

918

905

{

919

cout << _("Error: Invalid Value for read_rnd_buff_size");

920

exit(-1);

906

unireg_abort << _("Invalid Value for read_rnd_buff_size");

921

907

}

922

908

global_system_variables.read_rnd_buff_size= in_read_rnd_buff_size;

923

909

}

927

913

global_system_variables.sortbuff_size= MAX_SORT_MEMORY;

928

914

if ((uint32_t)in_sortbuff_size < MIN_SORT_MEMORY)

929

915

{

930

cout << _("Error: Invalid Value for sort_buff_size");

931

exit(-1);

916

unireg_abort << _("Invalid Value for sort_buff_size");

932

917

}

933

918

global_system_variables.sortbuff_size= in_sortbuff_size;

934

919

}

938

923

table_def_size= 128;

939

924

if (in_table_def_size < 1 || in_table_def_size > 512*1024L)

940

925

{

941

cout << _("Error: Invalid Value for table_def_size");

942

exit(-1);

926

unireg_abort << _("Invalid Value for table_def_size");

943

927

}

944

928

table_def_size= in_table_def_size;

945

929

}

949

933

table_cache_size= TABLE_OPEN_CACHE_DEFAULT;

950

934

if (in_table_cache_size < TABLE_OPEN_CACHE_MIN || in_table_cache_size > 512*1024L)

951

935

{

952

cout << _("Error: Invalid Value for table_cache_size");

953

exit(-1);

936

unireg_abort << _("Invalid Value for table_cache_size");

954

937

}

955

938

table_cache_size= in_table_cache_size;

956

939

}

960

943

table_lock_wait_timeout= 50;

961

944

if (in_table_lock_wait_timeout < 1 || in_table_lock_wait_timeout > 1024*1024*1024)

962

945

{

963

cout << _("Error: Invalid Value for table_lock_wait_timeout");

964

exit(-1);

946

unireg_abort << _("Invalid Value for table_lock_wait_timeout");

965

947

}

966

948

table_lock_wait_timeout= in_table_lock_wait_timeout;

967

949

}

976

958

global_system_variables.tmp_table_size= 16*1024*1024L;

977

959

if (in_tmp_table_size < 1024 || in_tmp_table_size > MAX_MEM_TABLE_SIZE)

978

960

{

979

cout << _("Error: Invalid Value for table_lock_wait_timeout");

980

exit(-1);

961

unireg_abort << _("Invalid Value for table_lock_wait_timeout");

981

962

}

982

963

global_system_variables.tmp_table_size= in_tmp_table_size;

983

964

}

987

968

transaction_message_threshold= 1024*1024;

988

969

if ((int64_t) in_transaction_message_threshold < 128*1024 || (int64_t)in_transaction_message_threshold > 1024*1024)

989

970

{

990

cout << _("Error: Invalid Value for transaction_message_threshold valid values are between 131072 - 1048576 bytes");

991

exit(-1);

971

unireg_abort << _("Invalid Value for transaction_message_threshold valid values are between 131072 - 1048576 bytes");

992

972

}

993

973

transaction_message_threshold= in_transaction_message_threshold;

994

974

}

1024

1004

{

1025

1005

fs::path p(it);

1026

1006

if (fs::is_regular_file(p))

1007

{

1027

1008

defaults_file_list.push_back(it);

1009

}

1028

1010

else

1029

1011

{

1030

errmsg_printf(error::ERROR, _("Defaults file '%s' not found\n"), it.c_str());

1031

unireg_abort(1);

1012

unireg_abort << "Defaults file '" << it << "' not found";

1032

1013

}

1033

1014

}

1034

1015

}

1035

1016

1036

int init_basic_variables(int argc, char **argv)

1017

bool init_variables_before_daemonizing(int argc, char **argv)

1037

1018

{

1038

1019

umask(((~internal::my_umask) & 0666));

1039

1020

decimal_zero.set_zero(); // set decimal_zero constant;

1041

1022

1042

1023

time_t curr_time= time(NULL);

1043

1024

if (curr_time == (time_t)-1)

1044

return 1;

1025

{

1026

return false;

1027

}

1045

1028

1046

1029

max_system_variables.pseudo_thread_id= UINT32_MAX;

1047

1030

server_start_time= flush_status_time= curr_time;

1065

1048

1066

1049

system_config_dir /= "drizzle";

1067

1050

1068

config_options.add_options()

1069

("help,?", po::value<bool>(&opt_help)->default_value(false)->zero_tokens(),

1070

_("Display this help and exit."))

1051

general_options.add_options()

1052

("help,?",

1053

_("Display help and exit."))

1071

1054

("daemon,d", po::value<bool>(&opt_daemon)->default_value(false)->zero_tokens(),

1072

1055

_("Run as a daemon."))

1056

("user,u", po::value<string>(),

1057

_("Run drizzled daemon as user."))

1058

("version,V",

1059

_("Print version information and exit."))

1060

;

1061

1062

config_options.add_options()

1073

1063

("no-defaults", po::value<bool>()->default_value(false)->zero_tokens(),

1074

1064

_("Configuration file defaults are not used if no-defaults is set"))

1075

1065

("defaults-file", po::value<vector<string> >()->composing()->notifier(&compose_defaults_file_list),

1149

1139

_("Default transaction isolation level."))

1150

1140

("transaction-message-threshold", po::value<size_t>(&transaction_message_threshold)->default_value(1024*1024)->notifier(&check_limits_transaction_message_threshold),

1151

1141

_("Max message size written to transaction log, valid values 131072 - 1048576 bytes."))

1152

("user,u", po::value<string>(),

1153

_("Run drizzled daemon as user."))

1154

("version,V",

1155

_("Output version information and exit."))

1156

1142

("back-log", po::value<back_log_constraints>(&back_log),

1157

1143

_("The number of outstanding connection requests Drizzle can have. This "

1158

1144

"comes into play when the main Drizzle thread gets very many connection "

1260

1246

full_options.add(long_options);

1261

1247

full_options.add(plugin_load_options);

1262

1248

1249

initial_options.add(general_options);

1263

1250

initial_options.add(config_options);

1264

1251

initial_options.add(plugin_load_options);

1265

1252

1266

1253

int style = po::command_line_style::default_style & ~po::command_line_style::allow_guessing;

1254

1267

1255

/* Get options about where config files and the like are */

1268

1256

po::parsed_options parsed= po::command_line_parser(argc, argv).style(style).

1269

1257

options(initial_options).allow_unregistered().run();

1270

unknown_options=

1271

po::collect_unrecognized(parsed.options, po::include_positional);

1258

1259

unknown_options= po::collect_unrecognized(parsed.options, po::include_positional);

1272

1260

1273

1261

try

1274

1262

{

1276

1264

}

1277

1265

catch (std::exception&)

1278

1266

{

1279

errmsg_printf(error::ERROR, _("Duplicate entry for command line option\n"));

1280

unireg_abort(1);

1281

}

1282

1283

if (not vm["no-defaults"].as<bool>())

1267

unireg_abort << _("Duplicate entry for command line option");

1268

}

1269

1270

/* TODO: here is where we should add a process_env_vars */

1271

1272

/* We need a notify here so that plugin_init will work properly */

1273

try

1274

{

1275

po::notify(vm);

1276

}

1277

catch (po::validation_error &err)

1278

{

1279

unireg_abort << "Use --help to get a list of available options. " << err.what();

1280

}

1281

1282

if (vm.count("version"))

1283

{

1284

print_version();

1285

unireg_exit();

1286

}

1287

1288

if (vm.count("no-defaults"))

1284

1289

{

1285

1290

fs::path system_config_file_drizzle(system_config_dir);

1286

1291

system_config_file_drizzle /= "drizzled.cnf";

1301

1306

}

1302

1307

}

1303

1308

1304

/* TODO: here is where we should add a process_env_vars */

1305

1306

/* We need a notify here so that plugin_init will work properly */

1307

try

1308

{

1309

po::notify(vm);

1310

}

1311

catch (po::validation_error &err)

1312

{

1313

errmsg_printf(error::ERROR, _("%s: %s.\nUse --help to get a list of available options\n"), internal::my_progname, err.what());

1314

unireg_abort(1);

1315

}

1316

1317

1309

process_defaults_files();

1318

1310

1319

1311

/* Process with notify a second time because a config file may contain

1325

1317

}

1326

1318

catch (po::validation_error &err)

1327

1319

{

1328

errmsg_printf(error::ERROR, _("%s: %s.\nUse --help to get a list of available options\n"), internal::my_progname, err.what());

1329

unireg_abort(1);

1320

unireg_abort << "Use --help to get a list of available options. " << err.what();

1330

1321

}

1331

1322

1332

return 0;

1323

return true;

1333

1324

}

1334

1325

1335

int init_remaining_variables(module::Registry &plugins)

1326

// Return failure if we can't pass this, unireg_abort() will then be called

1327

// by the caller.

1328

bool init_variables_after_daemonizing(module::Registry &plugins)

1336

1329

{

1337

1330

int style = po::command_line_style::default_style & ~po::command_line_style::allow_guessing;

1338

1331

1344

1337

1345

1338

if (plugin_init(plugins, plugin_options))

1346

1339

{

1347

errmsg_printf(error::ERROR, _("Failed to initialize plugins\n"));

1348

unireg_abort(1);

1340

unireg_abort << _("Failed to initialize plugins");

1349

1341

}

1350

1342

1351

1343

full_options.add(plugin_options);

1365

1357

}

1366

1358

catch (po::validation_error &err)

1367

1359

{

1368

errmsg_printf(error::ERROR,

1369

_("%s: %s.\n"

1370

"Use --help to get a list of available options\n"),

1371

internal::my_progname, err.what());

1372

unireg_abort(1);

1360

unireg_abort << "Use --help to get a list of available options. " << err.what();

1373

1361

}

1374

1362

catch (po::invalid_command_line_syntax &err)

1375

1363

{

1376

errmsg_printf(error::ERROR,

1377

_("%s: %s.\n"

1378

"Use --help to get a list of available options\n"),

1379

internal::my_progname, err.what());

1380

unireg_abort(1);

1364

unireg_abort << "Use --help to get a list of available options. " << err.what();

1381

1365

}

1382

1366

catch (po::unknown_option &err)

1383

1367

{

1384

errmsg_printf(error::ERROR,

1385

_("%s\nUse --help to get a list of available options\n"),

1386

err.what());

1387

unireg_abort(1);

1368

unireg_abort << "Use --help to get a list of available options. " << err.what();

1388

1369

}

1389

1370

1390

1371

try

1393

1374

}

1394

1375

catch (po::validation_error &err)

1395

1376

{

1396

errmsg_printf(error::ERROR,

1397

_("%s: %s.\n"

1398

"Use --help to get a list of available options\n"),

1399

internal::my_progname, err.what());

1400

unireg_abort(1);

1377

unireg_abort << "Use --help to get a list of available options. " << err.what();

1401

1378

}

1402

1379

1403

1380

get_options();

1406

1383

1407

1384

global_system_variables.optimizer_prune_level= not vm.count("disable-optimizer-prune");

1408

1385

1409

if (! vm["help"].as<bool>())

1386

if ((user_info= check_user(drizzled_user)))

1410

1387

{

1411

if ((user_info= check_user(drizzled_user)))

1412

{

1413

set_user(drizzled_user, user_info);

1414

}

1388

set_user(drizzled_user, user_info);

1415

1389

}

1416

1390

1417

1391

fix_paths();

1420

1394

1421

1395

item_create_init();

1422

1396

if (sys_var_init())

1423

return 1;

1397

{

1398

return false;

1399

}

1400

1424

1401

/* Creates static regex matching for temporal values */

1425

1402

if (not init_temporal_formats())

1426

return 1;

1403

{

1404

return false;

1405

}

1427

1406

1428

if (!(default_charset_info=

1429

get_charset_by_csname(default_character_set_name, MY_CS_PRIMARY)))

1407

if (!(default_charset_info= get_charset_by_csname(default_character_set_name, MY_CS_PRIMARY)))

1430

1408

{

1431

1409

errmsg_printf(error::ERROR, _("Error getting default charset"));

1432

return 1; // Eof of the list

1410

return false; // Eof of the list

1433

1411

}

1434

1412

1435

1413

if (vm.count("scheduler"))

1414

{

1436

1415

opt_scheduler= vm["scheduler"].as<string>().c_str();

1416

}

1437

1417

1438

if (default_collation_name)

1439

{

1440

const charset_info_st * const default_collation= get_charset_by_name(default_collation_name);

1441

if (not default_collation)

1442

{

1443

errmsg_printf(error::ERROR, _(ER(ER_UNKNOWN_COLLATION)), default_collation_name);

1444

return 1;

1445

}

1446

if (not my_charset_same(default_charset_info, default_collation))

1447

{

1448

errmsg_printf(error::ERROR, _(ER(ER_COLLATION_CHARSET_MISMATCH)),

1449

default_collation_name,

1450

default_charset_info->csname);

1451

return 1;

1452

}

1453

default_charset_info= default_collation;

1454

}

1455

1418

/* Set collactions that depends on the default collation */

1456

1419

global_system_variables.collation_server= default_charset_info;

1457

1420

1459

1422

get_charset_by_csname(character_set_filesystem_name, MY_CS_PRIMARY)))

1460

1423

{

1461

1424

errmsg_printf(error::ERROR, _("Error setting collation"));

1462

return 1;

1425

return false;

1463

1426

}

1464

1427

global_system_variables.character_set_filesystem= character_set_filesystem;

1465

1428

1466

if (!(my_default_lc_time_names=

1467

my_locale_by_name(lc_time_names_name)))

1429

if ((my_default_lc_time_names= my_locale_by_name(lc_time_names_name)) == NULL)

1468

1430

{

1469

1431

errmsg_printf(error::ERROR, _("Unknown locale: '%s'"), lc_time_names_name);

1470

return 1;

1432

return false;

1471

1433

}

1472

1434

global_system_variables.lc_time_names= my_default_lc_time_names;

1473

1435

1474

1436

/* Reset table_alias_charset */

1475

1437

table_alias_charset= files_charset_info;

1476

1438

1477

return 0;

1478

}

1479

1439

return true;

1440

}

1441

1442

bool was_help_requested()

1443

{

1444

if (vm.count("help") == 0)

1445

{

1446

return false;

1447

}

1448

1449

return true;

1450

}

1451

1452

void usage();

1480

1453

1481

1454

void init_server_components(module::Registry &plugins)

1482

1455

{

1456

if (was_help_requested())

1457

{

1458

usage();

1459

}

1460

1483

1461

/*

1484

1462

We need to call each of these following functions to ensure that

1485

1463

all things are initialized so that unireg_abort() doesn't fail

1495

1473

/* Allow storage engine to give real error messages */

1496

1474

ha_init_errors();

1497

1475

1498

if (opt_help)

1499

unireg_abort(0);

1500

1501

1476

if (plugin_finalize(plugins))

1502

1477

{

1503

unireg_abort(1);

1478

unireg_abort << "plugin_finalize() failed";

1504

1479

}

1505

1480

1506

1481

if (plugin::Scheduler::setPlugin(opt_scheduler))

1507

1482

{

1508

errmsg_printf(error::ERROR, _("No scheduler found, cannot continue!\n"));

1509

unireg_abort(1);

1483

unireg_abort << _("No scheduler found");

1510

1484

}

1511

1485

1512

1486

/*

1524

1498

plugin::StorageEngine *engine= plugin::StorageEngine::findByName(default_storage_engine_str);

1525

1499

if (engine == NULL)

1526

1500

{

1527

errmsg_printf(error::ERROR, _("Unknown/unsupported storage engine: %s\n"), default_storage_engine_str);

1528

unireg_abort(1);

1501

unireg_abort << _("Unknown/unsupported storage engine: ") << default_storage_engine_str;

1529

1502

}

1530

1503

global_system_variables.storage_engine= engine;

1531

1504

}

1533

1506

if (plugin::XaResourceManager::recoverAllXids())

1534

1507

{

1535

1508

/* This function alredy generates error messages */

1536

unireg_abort(1);

1509

unireg_abort << "plugin::XaResourceManager::recoverAllXids() failed";

1537

1510

}

1538

1511

1539

1512

init_update_queries();

1611

1584

1612

1585

struct option my_long_options[] =

1613

1586

{

1614

1615

{"help", '?', N_("Display this help and exit."),

1616

(char**) &opt_help, NULL, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,

1617

0, 0},

1618

{"daemon", 'd', N_("Run as daemon."),

1619

(char**) &opt_daemon, NULL, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,

1620

0, 0},

1621

1587

{"auto-increment-increment", OPT_AUTO_INCREMENT,

1622

1588

N_("Auto-increment columns are incremented by this"),

1623

1589

(char**) &global_system_variables.auto_increment_increment,

1638

1604

N_("Chroot drizzled daemon during startup."),

1639

1605

(char**) &drizzled_chroot, NULL, 0, GET_STR, REQUIRED_ARG,

1640

1606

0, 0, 0, 0, 0, 0},

1641

{"collation-server", OPT_DEFAULT_COLLATION,

1642

N_("Set the default collation."),

1643

(char**) &default_collation_name, NULL,

1644

0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },

1645

1607

{"completion-type", OPT_COMPLETION_TYPE,

1646

1608

N_("Default completion type."),

1647

1609

(char**) &global_system_variables.completion_type,

1897

1859

{0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}

1898

1860

};

1899

1861

1900

static void print_version()

1862

void usage()

1901

1863

{

1902

/*

1903

Note: the instance manager keys off the string 'Ver' so it can find the

1904

version from the output of 'drizzled --version', so don't change it!

1905

*/

1906

printf("%s Ver %s for %s-%s on %s (%s)\n", internal::my_progname,

1907

PANDORA_RELEASE_VERSION, HOST_VENDOR, HOST_OS, HOST_CPU, COMPILATION_COMMENT);

1908

}

1864

if ((default_charset_info= get_charset_by_csname(default_character_set_name, MY_CS_PRIMARY)) == NULL)

1865

{

1866

unireg_abort << "Failed to load default_charset_info:" << default_character_set_name;

1867

}

1909

1868

1910

static void usage()

1911

{

1912

if (!(default_charset_info= get_charset_by_csname(default_character_set_name, MY_CS_PRIMARY)))

1913

exit(1);

1914

if (!default_collation_name)

1869

if (default_collation_name == NULL)

1870

{

1915

1871

default_collation_name= default_charset_info->name;

1872

}

1873

1916

1874

print_version();

1917

1875

1918

1876

"This software comes with ABSOLUTELY NO WARRANTY. "

1919

1877

"This is free software,\n"

1920

1878

"and you are welcome to modify and redistribute it under the GPL "

1924

1882

printf(_("Usage: %s [OPTIONS]\n"), internal::my_progname);

1925

1883

1926

1884

po::options_description all_options("Drizzled Options");

1885

all_options.add(general_options);

1927

1886

all_options.add(config_options);

1928

1887

all_options.add(plugin_load_options);

1929

1888

all_options.add(long_options);

1930

1889

all_options.add(plugin_options);

1931

1890

cout << all_options << endl;

1932

1891

1892

unireg_exit();

1933

1893

}

1934

1894

1935

1895

/**

2026

1986

2027

1987

if (vm.count("user"))

2028

1988

{

2029

if (! drizzled_user || ! strcmp(drizzled_user, vm["user"].as<string>().c_str()))

1989

if (drizzled_user == NULL or strcmp(drizzled_user, vm["user"].as<string>().c_str()) == 0)

1990

{

2030

1991

drizzled_user= (char *)vm["user"].as<string>().c_str();

2031

1992

}

2032

1993

else

2033

errmsg_printf(error::WARN, _("Ignoring user change to '%s' because the user was "

2034

"set to '%s' earlier on the command line\n"),

1994

{

1995

errmsg_printf(error::WARN, _("Ignoring user change to '%s' because the user was set to '%s' earlier on the command line"),

2035

1996

vm["user"].as<string>().c_str(), drizzled_user);

2036

}

2037

2038

if (vm.count("version"))

2039

{

2040

print_version();

2041

exit(0);

1997

}

2042

1998

}

2043

1999

2044

2000

if (vm.count("sort-heap-threshold"))

2045

2001

{

2046

2002

if ((vm["sort-heap-threshold"].as<uint64_t>() > 0) and

2047

(vm["sort-heap-threshold"].as<uint64_t>() <

2048

global_system_variables.sortbuff_size))

2003

(vm["sort-heap-threshold"].as<uint64_t>() < global_system_variables.sortbuff_size))

2049

2004

{

2050

cout << _("Error: sort-heap-threshold cannot be less than sort-buffer-size") << endl;

2051

exit(-1);

2005

unireg_abort << _("sort-heap-threshold cannot be less than sort-buffer-size");

2052

2006

}

2053

2007

2054

2008

global_sort_buffer.setMaxSize(vm["sort-heap-threshold"].as<uint64_t>());

2057

2011

if (vm.count("join-heap-threshold"))

2058

2012

{

2059

2013

if ((vm["join-heap-threshold"].as<uint64_t>() > 0) and

2060

(vm["join-heap-threshold"].as<uint64_t>() <

2061

global_system_variables.join_buff_size))

2014

(vm["join-heap-threshold"].as<uint64_t>() < global_system_variables.join_buff_size))

2062

2015

{

2063

cout << _("Error: join-heap-threshold cannot be less than join-buffer-size") << endl;

2064

exit(-1);

2016

unireg_abort << _("join-heap-threshold cannot be less than join-buffer-size");

2065

2017

}

2066

2018

2067

2019

global_join_buffer.setMaxSize(vm["join-heap-threshold"].as<uint64_t>());

2070

2022

if (vm.count("read-rnd-threshold"))

2071

2023

{

2072

2024

if ((vm["read-rnd-threshold"].as<uint64_t>() > 0) and

2073

(vm["read-rnd-threshold"].as<uint64_t>() <

2074

global_system_variables.read_rnd_buff_size))

2025

(vm["read-rnd-threshold"].as<uint64_t>() < global_system_variables.read_rnd_buff_size))

2075

2026

{

2076

cout << _("Error: read-rnd-threshold cannot be less than read-rnd-buffer-size") << endl;

2077

exit(-1);

2027

unireg_abort << _("read-rnd-threshold cannot be less than read-rnd-buffer-size");

2078

2028

}

2079

2029

2080

2030

global_read_rnd_buffer.setMaxSize(vm["read-rnd-threshold"].as<uint64_t>());

2083

2033

if (vm.count("read-buffer-threshold"))

2084

2034

{

2085

2035

if ((vm["read-buffer-threshold"].as<uint64_t>() > 0) and

2086

(vm["read-buffer-threshold"].as<uint64_t>() <

2087

global_system_variables.read_buff_size))

2036

(vm["read-buffer-threshold"].as<uint64_t>() < global_system_variables.read_buff_size))

2088

2037

{

2089

cout << _("Error: read-buffer-threshold cannot be less than read-buffer-size") << endl;

2090

exit(-1);

2038

unireg_abort << _("read-buffer-threshold cannot be less than read-buffer-size");

2091

2039

}

2092

2040

2093

2041

global_read_buffer.setMaxSize(vm["read-buffer-threshold"].as<uint64_t>());

2113

2061

2114

2062

if (vm.count("skip-symlinks"))

2115

2063

{

2116

internal::my_use_symdir=0;

2064

internal::my_use_symdir= 0;

2065

}

2066

2067

if (vm.count("collation-server"))

2068

{

2069

const charset_info_st * const default_collation= get_charset_by_name(vm["collation-server"].as<string>().c_str());

2070

if (not default_collation)

2071

{

2072

unireg_abort << "Unknown collation: " << default_collation_name;

2073

}

2074

2075

if (not my_charset_same(default_charset_info, default_collation))

2076

{

2077

unireg_abort << "COLLATION '" << default_collation_name << "' is not valid for CHARACTER SET '" << default_charset_info->csname << "'";

2078

}

2079

default_charset_info= default_collation;

2117

2080

}

2118

2081

2119

2082

if (vm.count("transaction-isolation"))

2149

2112

}

2150

2113

2151

2114

if (drizzled_chroot)

2115

{

2152

2116

set_root(drizzled_chroot);

2117

}

2153

2118

2154

2119

/*

2155

2120

Set some global variables from the global_system_variables

2161

2126

2162

2127

static void fix_paths()

2163

2128

{

2129

if (vm.count("help"))

2130

return;

2131

2164

2132

fs::path pid_file_path(pid_file);

2165

2133

if (pid_file_path.root_path().string() == "")

2166

2134

{

2169

2137

}

2170

2138

pid_file= fs::system_complete(pid_file_path);

2171

2139

2172

if (not opt_help)

2173

{

2174

const char *tmp_string= getenv("TMPDIR");

2175

struct stat buf;

2176

drizzle_tmpdir.clear();

2177

2178

if (vm.count("tmpdir"))

2179

{

2180

drizzle_tmpdir.append(vm["tmpdir"].as<string>());

2181

}

2182

else if (tmp_string == NULL)

2183

{

2184

drizzle_tmpdir.append(getDataHome().file_string());

2185

drizzle_tmpdir.push_back(FN_LIBCHAR);

2186

drizzle_tmpdir.append(GLOBAL_TEMPORARY_EXT);

2187

}

2188

else

2189

{

2190

drizzle_tmpdir.append(tmp_string);

2191

}

2192

2193

drizzle_tmpdir= fs::path(fs::system_complete(fs::path(drizzle_tmpdir))).file_string();

2194

assert(drizzle_tmpdir.size());

2195

2196

if (mkdir(drizzle_tmpdir.c_str(), 0777) == -1)

2197

{

2198

if (errno != EEXIST)

2199

{

2200

errmsg_printf(error::ERROR, _("There was an error creating the '%s' part of the path '%s'. Please check the path exists and is writable.\n"), fs::path(drizzle_tmpdir).leaf().c_str(), drizzle_tmpdir.c_str());

2201

exit(1);

2202

}

2203

}

2204

2205

if (stat(drizzle_tmpdir.c_str(), &buf) || not S_ISDIR(buf.st_mode))

2206

{

2207

errmsg_printf(error::ERROR, _("There was an error opening the path '%s', please check the path exists and is writable.\n"), drizzle_tmpdir.c_str());

2208

exit(1);

2209

}

2210

}

2211

2140

const char *tmp_string= getenv("TMPDIR");

2141

struct stat buf;

2142

drizzle_tmpdir.clear();

2143

2144

if (vm.count("tmpdir"))

2145

{

2146

drizzle_tmpdir.append(vm["tmpdir"].as<string>());

2147

}

2148

else if (tmp_string == NULL)

2149

{

2150

drizzle_tmpdir.append(getDataHome().file_string());

2151

drizzle_tmpdir.push_back(FN_LIBCHAR);

2152

drizzle_tmpdir.append(GLOBAL_TEMPORARY_EXT);

2153

}

2154

else

2155

{

2156

drizzle_tmpdir.append(tmp_string);

2157

}

2158

2159

drizzle_tmpdir= fs::path(fs::system_complete(fs::path(drizzle_tmpdir))).file_string();

2160

assert(drizzle_tmpdir.size());

2161

2162

assert(getuid() != 0 and geteuid() != 0);

2163

if (getuid() == 0 or geteuid() == 0)

2164

{

2165

unireg_abort << "Drizzle cannot be run as root, please see the Security piece of the manual for more information.";

2166

}

2167

2168

if (mkdir(drizzle_tmpdir.c_str(), 0777) == -1)

2169

{

2170

if (errno != EEXIST)

2171

{

2172

unireg_abort << "There was an error creating the '"

2173

<< fs::path(drizzle_tmpdir).leaf()

2174

<< "' part of the path '"

2175

<< drizzle_tmpdir

2176

<< "'. Please check the path exists and is writable.";

2177

}

2178

}

2179

2180

if (stat(drizzle_tmpdir.c_str(), &buf) || not S_ISDIR(buf.st_mode))

2181

{

2182

unireg_abort << "There was an error opening the path '" << drizzle_tmpdir << "', please check the path exists and is writable.";

2183

}

2212

2184

}

2213

2185

2214

2186

} /* namespace drizzled */