static void free_used_memory(void)
{
/* Free memory allocated by 'load_defaults' */
free_defaults(defaults_argv);
dynstr_free(&ds_args);
}
static void mgmd_exit(int result)
{
g_eventLogger->close();
/* Free memory allocated by 'load_defaults' */
free_defaults(defaults_argv);
ndb_end(opt_ndb_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);
ndb_daemon_exit(result);
}
int main(int argc, char *argv[])
{
int pid = 0;
int t = 0;
int ret = -1;
char **save_argv;
load_defaults("my",load_default_groups,&argc,&argv);
save_argv = argv;
progname= argv[0];
if (handle_options(&argc, &argv, my_long_options, get_one_option))
exit(-1);
if (!argv[0] || !argv[1] || (pid = atoi(argv[0])) <= 0 || (t= atoi(argv[1])) <= 0)
ret = mysqlcc_main(argc, argv);
free_defaults(save_argv);
return ret;
}
int OGRMySQLDataSource::Open( const char * pszNewName, int bUpdate,
int bTestOpen )
{
CPLAssert( nLayers == 0 );
/* -------------------------------------------------------------------- */
/* Verify MySQL prefix. */
/* -------------------------------------------------------------------- */
if( !EQUALN(pszNewName,"MYSQL:",6) )
{
if( !bTestOpen )
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not conform to MySQL naming convention,"
" MYSQL:dbname[, user=..][,password=..][,host=..][,port=..][tables=table;table;...]",
pszNewName );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Use options process to get .my.cnf file contents. */
/* -------------------------------------------------------------------- */
int nPort = 0, i;
char **papszTableNames=NULL;
std::string oHost, oPassword, oUser, oDB;
char *apszArgv[2] = { (char*) "org", NULL };
char **papszArgv = apszArgv;
int nArgc = 1;
const char *client_groups[] = {"client", "ogr", NULL };
my_init(); // I hope there is no problem with calling this multiple times!
load_defaults( "my", client_groups, &nArgc, &papszArgv );
for( i = 0; i < nArgc; i++ )
{
if( EQUALN(papszArgv[i],"--user="******"--host=",7) )
oHost = papszArgv[i] + 7;
else if( EQUALN(papszArgv[i],"--password="******"--port=",7) )
nPort = atoi(papszArgv[i] + 7);
}
// cleanup
free_defaults( papszArgv );
/* -------------------------------------------------------------------- */
/* Parse out connection information. */
/* -------------------------------------------------------------------- */
char **papszItems = CSLTokenizeString2( pszNewName+6, ",",
CSLT_HONOURSTRINGS );
if( CSLCount(papszItems) < 1 )
{
CSLDestroy( papszItems );
CPLError( CE_Failure, CPLE_AppDefined,
"MYSQL: request missing databasename." );
return FALSE;
}
oDB = papszItems[0];
for( i = 1; papszItems[i] != NULL; i++ )
{
if( EQUALN(papszItems[i],"user="******"password="******"host=",5) )
oHost = papszItems[i] + 5;
else if( EQUALN(papszItems[i],"port=",5) )
nPort = atoi(papszItems[i] + 5);
else if( EQUALN(papszItems[i],"tables=",7) )
{
papszTableNames = CSLTokenizeStringComplex(
papszItems[i] + 7, ";", FALSE, FALSE );
}
else
CPLError( CE_Warning, CPLE_AppDefined,
"'%s' in MYSQL datasource definition not recognised and ignored.", papszItems[i] );
}
CSLDestroy( papszItems );
/* -------------------------------------------------------------------- */
/* Try to establish connection. */
/* -------------------------------------------------------------------- */
hConn = mysql_init( NULL );
if( hConn == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"mysql_init() failed." );
}
/* -------------------------------------------------------------------- */
/* Set desired options on the connection: charset and timeout. */
/* -------------------------------------------------------------------- */
if( hConn )
{
const char *pszTimeoutLength =
CPLGetConfigOption( "MYSQL_TIMEOUT", "0" );
unsigned int timeout = atoi(pszTimeoutLength);
mysql_options(hConn, MYSQL_OPT_CONNECT_TIMEOUT, (char*)&timeout);
mysql_options(hConn, MYSQL_SET_CHARSET_NAME, "utf8" );
}
/* -------------------------------------------------------------------- */
/* Perform connection. */
/* -------------------------------------------------------------------- */
if( hConn
&& mysql_real_connect( hConn,
oHost.length() ? oHost.c_str() : NULL,
oUser.length() ? oUser.c_str() : NULL,
oPassword.length() ? oPassword.c_str() : NULL,
oDB.length() ? oDB.c_str() : NULL,
nPort, NULL, CLIENT_INTERACTIVE ) == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"MySQL connect failed for: %s\n%s",
pszNewName + 6, mysql_error( hConn ) );
mysql_close( hConn );
hConn = NULL;
}
if( hConn == NULL )
{
CSLDestroy( papszTableNames );
return FALSE;
}
pszName = CPLStrdup( pszNewName );
bDSUpdate = bUpdate;
/* -------------------------------------------------------------------- */
/* Get a list of available tables. */
/* -------------------------------------------------------------------- */
if( papszTableNames == NULL )
{
MYSQL_RES *hResultSet;
MYSQL_ROW papszRow;
if( mysql_query( hConn, "SHOW TABLES" ) )
{
ReportError( "SHOW TABLES Failed" );
return FALSE;
}
hResultSet = mysql_store_result( hConn );
if( hResultSet == NULL )
{
ReportError( "mysql_store_result() failed on SHOW TABLES result.");
return FALSE;
}
while( (papszRow = mysql_fetch_row( hResultSet )) != NULL )
{
if( papszRow[0] == NULL )
continue;
if( EQUAL(papszRow[0],"spatial_ref_sys")
|| EQUAL(papszRow[0],"geometry_columns") )
continue;
papszTableNames = CSLAddString(papszTableNames, papszRow[0] );
}
mysql_free_result( hResultSet );
}
/* -------------------------------------------------------------------- */
/* Get the schema of the available tables. */
/* -------------------------------------------------------------------- */
int iRecord;
for( iRecord = 0;
papszTableNames != NULL && papszTableNames[iRecord] != NULL;
iRecord++ )
{
// FIXME: This should be fixed to deal with tables
// for which we can't open because the name is bad/
OpenTable( papszTableNames[iRecord], bUpdate, FALSE );
}
CSLDestroy( papszTableNames );
return nLayers > 0 || bUpdate;
}
/*
* Constructor: Create a defaults_t struct populated with default
* values. This defaults_t must be freed.
*
* @param defaults
* RETURN: a pointer to a new defaults_t
*
* @return 0
* if successful
*
* @return non-zero
* if an error occurred. Use get_error_string() to
* retrieve the associated error message.
*/
int
new_defaults(
defaults_t **defaults)
{
devconfig_t *diskset;
int error = 0;
*defaults = (defaults_t *)calloc(1, sizeof (defaults_t));
if (*defaults == NULL) {
volume_set_error(gettext("new_defaults calloc() failed"));
return (-1);
}
/*
* Create initial "global" (disk set-independent) defaults, as
* a devconfig_t of type disk set with NULL name
*/
if ((error = new_devconfig(&diskset, TYPE_DISKSET)) != 0) {
free_defaults(*defaults);
return (error);
}
/* Append global defaults disk set to disksets */
defaults_set_disksets(
*defaults, dlist_append(dlist_new_item(diskset),
defaults_get_disksets(*defaults), AT_TAIL));
/* Set defaults */
if ((error = defaults_set_mirror_nsubs(
*defaults, NULL, DEFAULT_MIRROR_NSUBS)) != 0 ||
(error = defaults_set_mirror_read(
*defaults, NULL, DEFAULT_MIRROR_READ)) != 0 ||
(error = defaults_set_mirror_write(
*defaults, NULL, DEFAULT_MIRROR_WRITE)) != 0 ||
(error = defaults_set_mirror_pass(
*defaults, NULL, DEFAULT_MIRROR_PASS)) != 0 ||
(error = defaults_set_mirror_usehsp(
*defaults, NULL, DEFAULT_MIRROR_USEHSP)) != 0 ||
(error = defaults_set_concat_usehsp(
*defaults, NULL, DEFAULT_CONCAT_USEHSP)) != 0 ||
(error = defaults_set_stripe_interlace(
*defaults, NULL, DEFAULT_STRIPE_INTERLACE)) != 0 ||
(error = defaults_set_stripe_mincomp(
*defaults, NULL, DEFAULT_STRIPE_MINCOMP)) != 0 ||
(error = defaults_set_stripe_maxcomp(
*defaults, NULL, DEFAULT_STRIPE_MAXCOMP)) != 0 ||
(error = defaults_set_stripe_usehsp(
*defaults, NULL, DEFAULT_STRIPE_USEHSP)) != 0 ||
(error = defaults_set_volume_redundancy_level(
*defaults, NULL, DEFAULT_VOLUME_REDUND_LEVEL)) != 0 ||
(error = defaults_set_volume_npaths(
*defaults, NULL, DEFAULT_VOLUME_NPATHS)) != 0 ||
(error = defaults_set_volume_usehsp(
*defaults, NULL, DEFAULT_VOLUME_USEHSP)) != 0) {
free_defaults(*defaults);
return (error);
}
return (0);
}
int main(int argc, char **argv)
{
LSN lsn;
char **default_argv;
uint warnings_count;
MY_INIT(argv[0]);
maria_data_root= (char *)".";
load_defaults("my", load_default_groups, &argc, &argv);
default_argv= argv;
get_options(&argc, &argv);
maria_in_recovery= TRUE;
if (maria_init())
{
fprintf(stderr, "Can't init Aria engine (%d)\n", errno);
goto err;
}
maria_block_size= 0; /* Use block size from file */
/* we don't want to create a control file, it MUST exist */
if (ma_control_file_open(FALSE, TRUE))
{
fprintf(stderr, "Can't open control file (%d)\n", errno);
goto err;
}
if (last_logno == FILENO_IMPOSSIBLE)
{
fprintf(stderr, "Can't find any log\n");
goto err;
}
if (init_pagecache(maria_pagecache, opt_page_buffer_size, 0, 0,
maria_block_size, MY_WME) == 0)
{
fprintf(stderr, "Got error in init_pagecache() (errno: %d)\n", errno);
goto err;
}
/*
If log handler does not find the "last_logno" log it will return error,
which is good.
But if it finds a log and this log was crashed, it will create a new log,
which is useless. TODO: start log handler in read-only mode.
*/
if (init_pagecache(maria_log_pagecache, opt_translog_buffer_size,
0, 0, TRANSLOG_PAGE_SIZE, MY_WME) == 0 ||
translog_init(maria_data_root, TRANSLOG_FILE_SIZE,
0, 0, maria_log_pagecache, TRANSLOG_DEFAULT_FLAGS,
opt_display_only))
{
fprintf(stderr, "Can't init loghandler (%d)\n", errno);
goto err;
}
if (opt_display_only)
printf("You are using --display-only, NOTHING will be written to disk\n");
lsn= translog_first_lsn_in_log();
if (lsn == LSN_ERROR)
{
fprintf(stderr, "Opening transaction log failed\n");
goto end;
}
if (lsn == LSN_IMPOSSIBLE)
{
fprintf(stdout, "The transaction log is empty\n");
}
if (opt_start_from_checkpoint && !opt_start_from_lsn &&
last_checkpoint_lsn != LSN_IMPOSSIBLE)
{
lsn= LSN_IMPOSSIBLE; /* LSN set in maria_apply_log() */
fprintf(stdout, "Starting from checkpoint (%lu,0x%lx)\n",
LSN_IN_PARTS(last_checkpoint_lsn));
}
else
fprintf(stdout, "The transaction log starts from lsn (%lu,0x%lx)\n",
LSN_IN_PARTS(lsn));
if (opt_start_from_lsn)
{
if (opt_start_from_lsn < (ulonglong) lsn)
{
fprintf(stderr, "start_from_lsn is too small. Aborting\n");
maria_end();
goto err;
}
lsn= (LSN) opt_start_from_lsn;
fprintf(stdout, "Starting reading log from lsn (%lu,0x%lx)\n",
LSN_IN_PARTS(lsn));
}
if (opt_end_lsn != LSN_IMPOSSIBLE)
{
/* We can't apply undo if we use end_lsn */
opt_apply_undo= 0;
}
fprintf(stdout, "TRACE of the last aria_read_log\n");
if (maria_apply_log(lsn, opt_end_lsn, opt_apply ? MARIA_LOG_APPLY :
(opt_check ? MARIA_LOG_CHECK :
MARIA_LOG_DISPLAY_HEADER), opt_silent ? NULL : stdout,
opt_apply_undo, FALSE, FALSE, &warnings_count))
goto err;
if (warnings_count == 0)
fprintf(stdout, "%s: SUCCESS\n", my_progname_short);
else
fprintf(stdout, "%s: DOUBTFUL (%u warnings, check previous output)\n",
my_progname_short, warnings_count);
end:
maria_end();
free_tmpdir(&maria_chk_tmpdir);
free_defaults(default_argv);
my_end(0);
exit(0);
return 0; /* No compiler warning */
err:
/* don't touch anything more, in case we hit a bug */
fprintf(stderr, "%s: FAILED\n", my_progname_short);
free_tmpdir(&maria_chk_tmpdir);
free_defaults(default_argv);
exit(1);
}
