~drizzle-trunk/drizzle/jenkins-Drizzle-Builder-175 : revision 2629

77

#include <drizzled/statistics_variables.h>

78

#include <drizzled/table/cache.h>

79

#include <drizzled/temporal_format.h> /* For init_temporal_formats() */

80

#include <drizzled/unireg.h>

80

#include <drizzled/drizzled_abort.h>

81

#include <plugin/myisam/myisam.h>

82

#include <drizzled/typelib.h>

83

#include <drizzled/visibility.h>

437

(void)close(file); /* We can ignore the error, since we are going to error anyway at this point */

438

}

439

440

unireg_abort << "Can't start server, was unable to create PID file: " << pid_file.string();

440

drizzled_abort << "Can't start server, was unable to create PID file: " << pid_file.string();

441

}

442

443

#ifdef DEFINED_O_CLOEXEC

524

}

525

}

526

527

static bool unireg_startup_completed= false;

528

void unireg_startup_finished()

527

static bool drizzled_startup_completed= false;

528

void drizzled_startup_finished()

529

{

530

unireg_startup_completed= true;

530

drizzled_startup_completed= true;

531

}

532

533

void unireg_exit()

533

void drizzled_exit()

534

{

535

internal::my_end();

536

assert(unireg_startup_completed == false);

536

assert(drizzled_startup_completed == false);

537

exit(EXIT_SUCCESS);

538

}

539

540

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

540

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

541

{

542

std::stringstream temp;

543

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

546

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

547

internal::my_end();

548

549

assert(unireg_startup_completed == false);

549

assert(drizzled_startup_completed == false);

550

exit(EXIT_FAILURE);

551

}

552

607

}

608

if (not user)

609

{

610

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

610

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

611

}

612

613

if (strcmp(user, "root") == 0)

635

636

if (failed)

637

{

638

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

638

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

639

640

#ifdef PR_SET_DUMPABLE

641

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

657

initgroups(user, user_info_arg->pw_gid);

658

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

659

{

660

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

660

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

661

}

662

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

663

{

664

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

664

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

665

}

666

}

667

672

{

673

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

674

{

675

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

675

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

676

}

677

}

678

771

global_system_variables.auto_increment_increment= 1;

772

if (in_auto_increment_increment < 1 || in_auto_increment_increment > UINT64_MAX)

773

{

774

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

774

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

775

}

776

global_system_variables.auto_increment_increment= in_auto_increment_increment;

777

}

781

global_system_variables.auto_increment_offset= 1;

782

if (in_auto_increment_offset < 1 || in_auto_increment_offset > UINT64_MAX)

783

{

784

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

784

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

785

}

786

global_system_variables.auto_increment_offset= in_auto_increment_offset;

787

}

791

global_system_variables.completion_type= 0;

792

if (in_completion_type > 2)

793

{

794

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

794

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

795

}

796

global_system_variables.completion_type= in_completion_type;

797

}

802

global_system_variables.div_precincrement= 4;

803

if (in_div_precincrement > DECIMAL_MAX_SCALE)

804

{

805

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

805

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

806

}

807

global_system_variables.div_precincrement= in_div_precincrement;

808

}

812

global_system_variables.group_concat_max_len= 1024;

813

if (in_group_concat_max_len > ULONG_MAX || in_group_concat_max_len < 4)

814

{

815

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

815

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

816

}

817

global_system_variables.group_concat_max_len= in_group_concat_max_len;

818

}

822

global_system_variables.join_buff_size= (128*1024L);

823

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

824

{

825

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

825

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

826

}

827

in_join_buffer_size-= in_join_buffer_size % IO_SIZE;

828

global_system_variables.join_buff_size= in_join_buffer_size;

833

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

834

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

835

{

836

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

836

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

837

}

838

in_max_allowed_packet-= in_max_allowed_packet % 1024;

839

global_system_variables.max_allowed_packet= in_max_allowed_packet;

844

global_system_variables.max_error_count= DEFAULT_ERROR_COUNT;

845

if (in_max_error_count > 65535)

846

{

847

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

847

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

848

}

849

global_system_variables.max_error_count= in_max_error_count;

850

}

854

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

855

if (in_max_heap_table_size < 16384 || in_max_heap_table_size > MAX_MEM_TABLE_SIZE)

856

{

857

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

857

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

858

}

859

in_max_heap_table_size-= in_max_heap_table_size % 1024;

860

global_system_variables.max_heap_table_size= in_max_heap_table_size;

865

global_system_variables.min_examined_row_limit= 0;

866

if (in_min_examined_row_limit > ULONG_MAX)

867

{

868

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

868

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

869

}

870

global_system_variables.min_examined_row_limit= in_min_examined_row_limit;

871

}

875

global_system_variables.max_join_size= INT32_MAX;

876

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

877

{

878

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

878

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

879

}

880

global_system_variables.max_join_size= in_max_join_size;

881

}

885

global_system_variables.max_length_for_sort_data= 1024;

886

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

887

{

888

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

888

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

889

}

890

global_system_variables.max_length_for_sort_data= in_max_length_for_sort_data;

891

}

895

global_system_variables.max_seeks_for_key= ULONG_MAX;

896

if (in_max_seeks_for_key < 1 || in_max_seeks_for_key > ULONG_MAX)

897

{

898

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

898

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

899

}

900

global_system_variables.max_seeks_for_key= in_max_seeks_for_key;

901

}

905

global_system_variables.max_sort_length= 1024;

906

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

907

{

908

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

908

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

909

}

910

global_system_variables.max_sort_length= in_max_sort_length;

911

}

915

global_system_variables.optimizer_search_depth= 0;

916

if (in_optimizer_search_depth > MAX_TABLES + 2)

917

{

918

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

918

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

919

}

920

global_system_variables.optimizer_search_depth= in_optimizer_search_depth;

921

}

925

global_system_variables.preload_buff_size= (32*1024L);

926

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

927

{

928

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

928

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

929

}

930

global_system_variables.preload_buff_size= in_preload_buff_size;

931

}

935

global_system_variables.query_alloc_block_size= QUERY_ALLOC_BLOCK_SIZE;

936

if (in_query_alloc_block_size < 1024)

937

{

938

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

938

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

939

}

940

in_query_alloc_block_size-= in_query_alloc_block_size % 1024;

941

global_system_variables.query_alloc_block_size= in_query_alloc_block_size;

946

global_system_variables.query_prealloc_size= QUERY_ALLOC_PREALLOC_SIZE;

947

if (in_query_prealloc_size < QUERY_ALLOC_PREALLOC_SIZE)

948

{

949

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

949

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

950

}

951

in_query_prealloc_size-= in_query_prealloc_size % 1024;

952

global_system_variables.query_prealloc_size= in_query_prealloc_size;

957

global_system_variables.range_alloc_block_size= RANGE_ALLOC_BLOCK_SIZE;

958

if (in_range_alloc_block_size < RANGE_ALLOC_BLOCK_SIZE)

959

{

960

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

960

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

961

}

962

in_range_alloc_block_size-= in_range_alloc_block_size % 1024;

963

global_system_variables.range_alloc_block_size= in_range_alloc_block_size;

968

global_system_variables.read_buff_size= (128*1024L);

969

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

970

{

971

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

971

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

972

}

973

in_read_buff_size-= in_read_buff_size % IO_SIZE;

974

global_system_variables.read_buff_size= in_read_buff_size;

979

global_system_variables.read_rnd_buff_size= (256*1024L);

980

if (in_read_rnd_buff_size < 64 || in_read_rnd_buff_size > UINT32_MAX)

981

{

982

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

982

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

983

}

984

global_system_variables.read_rnd_buff_size= in_read_rnd_buff_size;

985

}

989

global_system_variables.sortbuff_size= MAX_SORT_MEMORY;

990

if ((uint32_t)in_sortbuff_size < MIN_SORT_MEMORY)

991

{

992

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

992

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

993

}

994

global_system_variables.sortbuff_size= in_sortbuff_size;

995

}

999

table_def_size= 128;

1000

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

1001

{

1002

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

1002

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

1003

}

1004

table_def_size= in_table_def_size;

1005

}

1009

table_cache_size= TABLE_OPEN_CACHE_DEFAULT;

1010

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

1011

{

1012

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

1012

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

1013

}

1014

table_cache_size= in_table_cache_size;

1015

}

1019

table_lock_wait_timeout= 50;

1020

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

1021

{

1022

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

1022

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

1023

}

1024

table_lock_wait_timeout= in_table_lock_wait_timeout;

1025

}

1034

global_system_variables.tmp_table_size= 16*1024*1024L;

1035

if (in_tmp_table_size < 1024 || in_tmp_table_size > MAX_MEM_TABLE_SIZE)

1036

{

1037

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

1037

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

1038

}

1039

global_system_variables.tmp_table_size= in_tmp_table_size;

1040

}

1044

transaction_message_threshold= 1024*1024;

1045

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

1046

{

1047

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

1047

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

1048

}

1049

transaction_message_threshold= in_transaction_message_threshold;

1050

}

1092

}

1093

else

1094

{

1095

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

1095

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

1096

}

1097

}

1098

}

1344

}

1345

catch (std::exception&)

1346

{

1347

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

1347

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

1348

}

1349

1350

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

1356

}

1357

catch (po::validation_error &err)

1358

{

1359

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

1359

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

1360

}

1361

1362

if (vm.count("version"))

1363

{

1364

print_version();

1365

unireg_exit();

1365

drizzled_exit();

1366

}

1367

1368

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

1397

}

1398

catch (po::validation_error &err)

1399

{

1400

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

1400

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

1401

}

1402

1403

return true;

1404

}

1405

1406

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

1406

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

1407

// by the caller.

1408

bool init_variables_after_daemonizing(module::Registry &plugins)

1409

{

1417

1418

if (plugin_init(plugins, plugin_options))

1419

{

1420

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

1420

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

1421

}

1422

1423

full_options.add(plugin_options);

1443

}

1444

catch (po::validation_error &err)

1445

{

1446

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

1446

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

1447

}

1448

catch (po::invalid_command_line_syntax &err)

1449

{

1450

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

1450

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

1451

}

1452

catch (po::unknown_option &err)

1453

{

1454

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

1454

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

1455

}

1456

1457

try

1460

}

1461

catch (po::validation_error &err)

1462

{

1463

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

1463

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

1464

}

1465

1466

get_options();

1543

1544

/*

1545

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

1546

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

1546

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

1547

*/

1548

1549

// Resize the definition Cache at startup

1558

1559

if (plugin_finalize(plugins))

1560

{

1561

unireg_abort << "plugin_finalize() failed";

1561

drizzled_abort << "plugin_finalize() failed";

1562

}

1563

1564

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

1565

{

1566

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

1566

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

1567

}

1568

1569

/*

1581

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

1582

if (engine == NULL)

1583

{

1584

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

1584

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

1585

}

1586

global_system_variables.storage_engine= engine;

1587

}

1589

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

1590

{

1591

/* This function alredy generates error messages */

1592

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

1592

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

1593

}

1594

1595

init_update_queries();

1940

{

1941

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

1942

{

1943

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

1943

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

1944

}

1945

1946

if (default_collation_name == NULL)

1966

all_options.add(plugin_options);

1967

cout << all_options << endl;

1968

1969

unireg_exit();

1969

drizzled_exit();

1970

}

1971

1972

/**

2078

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

2079

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

2080

{

2081

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

2081

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

2082

}

2083

2084

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

2089

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

2090

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

2091

{

2092

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

2092

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

2093

}

2094

2095

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

2100

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

2101

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

2102

{

2103

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

2103

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

2104

}

2105

2106

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

2111

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

2112

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

2113

{

2114

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

2114

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

2115

}

2116

2117

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

2145

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

2146

if (not default_collation)

2147

{

2148

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

2148

drizzled_abort << "Unknown collation: " << default_collation_name;

2149

}

2150

2151

if (not my_charset_same(default_charset_info, default_collation))

2152

{

2153

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

2153

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

2154

}

2155

default_charset_info= default_collation;

2156

}

2243

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

2244

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

2245

{

2246

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

2246

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

2247

}

2248

2249

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

2250

{

2251

if (errno != EEXIST)

2252

{

2253

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

2253

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

2254

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

2255

<< "' part of the path '"

2256

<< drizzle_tmpdir

2260

2261

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

2262

{

2263

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

2263

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

2264

}

2265

}

2266