int
example_main(int argc, char **argv)
{
/* Create a database with the current schema definition */
db_t hdb = create_database( EXAMPLE_DATABASE, &v2_schema, init_data_cb );
/* Create database with v1 schema */
db_t hdb_upgrade = create_database( EXAMPLE_UPGRADE_DATABASE, &v1_schema, init_data_cb );
/* Open database with v1 schema and upgrade to current schema */
db_shutdown( hdb_upgrade, 0, NULL );
hdb = open_database( EXAMPLE_UPGRADE_DATABASE, &v2_schema, &upgrade_schema_cb );
if( hdb != NULL ) {
int v = get_schema_version( hdb_upgrade );
db_shutdown( hdb_upgrade, 0, NULL );
db_shutdown( hdb, 0, NULL );
if (v == v2_schema.version) {
return EXIT_SUCCESS;
}
}
db_shutdown( hdb_upgrade, 0, NULL );
db_shutdown( hdb, 0, NULL );
return EXIT_FAILURE;
}
int
example_main(int argc, char **argv)
{
int rc = EXIT_FAILURE;
db_t hdb; // db to create and insert rows
trans_stat_t stat = { 0, 0 };
hdb = create_database( EXAMPLE_DATABASE, &db_schema, NULL );
if (!hdb) {
goto exit;
}
// Start transactions generation. Part of transactions commit with DB_LAZY_COMPLETION flag to make them to be deferred
rc = perform_transactions( hdb, &stat );
db_shutdown(hdb, DB_SOFT_SHUTDOWN, NULL);
if( rc != EXIT_SUCCESS ) {goto exit; }
rc = EXIT_FAILURE;
// Reopen DB and check if all transactions are really there
hdb = db_open_file_storage(EXAMPLE_DATABASE, NULL);
if (!hdb) {
goto exit;
}
rc = check_data( hdb, &stat );
exit:
return rc;
}
int
example_main(int argc, char **argv)
{
int rc = EXIT_FAILURE;
db_t hdb;
if( 2 < argc && 0 == strncmp( "-h", argv[1], 2 ) ) {
fprintf( stdout,
"Usage:\n"
" %s <messageid> <locale>\n"
"Parameters:\n"
" messageid - Integer in range [1-%d]. '1' by default\n"
" locale - One of en, jp, fr, es, ru. 'ru' by default\n"
"",
argv[0], DB_ARRAY_DIM(texts)
);
}
hdb = create_database( EXAMPLE_DATABASE, &db_schema );
if( hdb != NULL ) {
rc = load_data( hdb );
if( 0 == rc ) {
rc = find_text( hdb, argc > 1 ? argv[1] : "1", argc > 2 ? argv[2] : "ru" );
}
}
db_shutdown(hdb, DB_SOFT_SHUTDOWN, NULL);
return rc;
}
db_t
create_database(char* database_name, dbs_versioned_schema_def_t *versioned_schema, InitDataCallback cb)
{
db_t hdb;
/* Create a new file storage database with default parameters. */
hdb = db_create_file_storage(database_name, NULL);
if (hdb == NULL) {
return NULL;
}
if (dbs_create_schema(hdb, &versioned_schema->schema) < 0) {
db_shutdown(hdb, DB_SOFT_SHUTDOWN, NULL);
/* Remove incomplete database. */
remove(database_name);
return NULL;
}
if( cb && 0 != (*cb)( hdb, versioned_schema->version ) ) {
print_error_message( "Couldn't initialize table data in created database", NULL);
return NULL;
}
set_schema_version( hdb, versioned_schema->version );
db_commit_tx( hdb, DB_DEFAULT_COMPLETION );
return hdb;
}
/*
* shutdown_db
*
* arguments:
*
* returns/side-effects: int
*
* description:
*/
int
shutdown_db (void)
{
int error;
char *env_val;
error = db_shutdown ();
/*
* As a courtesy, also remove our errlog file if it is empty.
*/
env_val = (char *) getenv ("CUBRID_ERROR_LOG");
if (env_val)
{
struct stat stat_buf;
if ((stat (env_val, &stat_buf) == 0) && stat_buf.st_size == 0)
{
if (unlink (env_val) < 0)
{
fprintf (stderr,
"qacsql cleanup: unlink of error log file: %s failed, errno = %d\n",
env_val, errno);
}
}
}
return error;
}
/*
int write_in_file(UINT8 rx_bps, UINT4 rx_pps){
FILE* fileName = NULL;
fileName = fopen(FILENAME, "w");
if(!fileName){
printf("Open file failed!\n");
return -1;
}
fprintf(fileName, "eth%d %lu bps, %u pps.", sockfd,rx_bps*8+rx_pps*PAD_LEN*8, rx_pps);
if(fprintf < 0){
printf("fprintf wrong!\n");
return -1;
}
fclose(fileName);
return 0;
}
*/
int db_insert(UINT8 bps, UINT4 pps){
int handle;
int retValue;
char sql[100];
retValue = db_init();
if(retValue == DB_FAILURE){
if(debug_flag){
printf("db_init failure!\n");
}
return -1;
}
handle = db_open(HOST, DB_NAME, USER_NAME, PASSWD, DB_MYSQL);
if(handle == DB_FAILURE){
if(debug_flag){
printf("open database failure!\n");
}
db_shutdown();
return -1;
}
sprintf(sql, "insert into flow_now (bps, pps) values (%lu, %u)", bps,pps);
retValue = db_excute(handle, sql);
if(retValue == DB_FAILURE){
if(debug_flag){
printf("excute sql failure!\n");
}
db_close(handle);
db_shutdown();
return -1;
}
db_close(handle);
db_shutdown();
return 1;
}
db_t
create_database(char* database_name, dbs_schema_def_t *schema)
{
db_t hdb;
/* Create a new file storage database with default parameters. */
hdb = db_create_file_storage(database_name, NULL);
if (hdb == NULL) {
return NULL;
}
if (dbs_create_schema(hdb, schema) < 0) {
db_shutdown(hdb, DB_SOFT_SHUTDOWN, NULL);
/* Remove incomplete database. */
remove(database_name);
return NULL;
}
return hdb;
}
db_t
create_database(char* database_name, dbs_schema_def_t *schema, db_file_storage_config_t * storage_cfg)
{
db_t hdb;
/* Create a new file storage database with default parameters. */
hdb = db_create_file_storage(database_name, storage_cfg);
if (hdb == NULL) {
print_error_message( "Couldn't create DB", NULL );
return NULL;
}
if (dbs_create_schema(hdb, schema) < 0) {
print_error_message( "Couldn't initialize DB objects", NULL );
db_shutdown(hdb, DB_SOFT_SHUTDOWN, NULL);
/* Remove incomplete database. */
remove(database_name);
return NULL;
}
return hdb;
}
static int
cubrid_statdump_read ()
{
char submit_name[256];
/* Execution statistics for the file io */
value_t file_num_creates[1];
value_t file_num_removes[1];
value_t file_num_ioreads[1];
value_t file_num_iowrites[1];
value_t file_num_iosynches[1];
/* Execution statistics for the page buffer manager */
value_t pb_num_fetches[1];
value_t pb_num_dirties[1];
value_t pb_num_ioreads[1];
value_t pb_num_iowrites[1];
value_t pb_num_victims[1];
value_t pb_num_replacements[1];
/* Execution statistics for the log manager */
value_t log_num_ioreads[1];
value_t log_num_iowrites[1];
value_t log_num_appendrecs[1];
value_t log_num_archives[1];
value_t log_num_checkpoints[1];
value_t log_num_wals[1];
/* Execution statistics for the lock manager */
value_t lk_num_acquired_on_pages[1];
value_t lk_num_acquired_on_objects[1];
value_t lk_num_converted_on_pages[1];
value_t lk_num_converted_on_objects[1];
value_t lk_num_re_requested_on_pages[1];
value_t lk_num_re_requested_on_objects[1];
value_t lk_num_waited_on_pages[1];
value_t lk_num_waited_on_objects[1];
/* Execution statistics for transactions */
value_t tran_num_commits[1];
value_t tran_num_rollbacks[1];
value_t tran_num_savepoints[1];
value_t tran_num_start_topops[1];
value_t tran_num_end_topops[1];
value_t tran_num_interrupts[1];
/* Execution statistics for the btree manager */
value_t bt_num_inserts[1];
value_t bt_num_deletes[1];
value_t bt_num_updates[1];
/* Execution statistics for the query manger */
value_t qm_num_selects[1];
value_t qm_num_inserts[1];
value_t qm_num_deletes[1];
value_t qm_num_updates[1];
value_t qm_num_sscans[1];
value_t qm_num_iscans[1];
value_t qm_num_lscans[1];
value_t qm_num_setscans[1];
value_t qm_num_methscans[1];
value_t qm_num_nljoins[1];
value_t qm_num_mjoins[1];
value_t qm_num_objfetches[1];
/* flush control */
value_t fc_num_pages[1];
value_t fc_num_log_pages[1];
value_t fc_tokens[1];
/* Execution statistics for network communication */
value_t net_num_requests[1];
MNT_SERVER_EXEC_GLOBAL_STATS *mystat;
mystat = malloc (sizeof (MNT_SERVER_EXEC_GLOBAL_STATS));
sprintf (submit_name, "statdump_%s", db);
AU_DISABLE_PASSWORDS ();
db_set_client_type (DB_CLIENT_TYPE_ADMIN_UTILITY);
db_login ("dba", NULL);
db_restart (db, TRUE, db);
histo_start (true);
mnt_server_copy_global_stats (mystat);
file_num_creates[0].gauge = mystat->file_num_creates;
file_num_removes[0].gauge = mystat->file_num_removes;
file_num_ioreads[0].gauge = mystat->file_num_ioreads;
file_num_iowrites[0].gauge = mystat->file_num_iowrites;
file_num_iosynches[0].gauge = mystat->file_num_iosynches;
pb_num_fetches[0].gauge = mystat->pb_num_fetches;
pb_num_dirties[0].gauge = mystat->pb_num_dirties;
pb_num_ioreads[0].gauge = mystat->pb_num_ioreads;
pb_num_iowrites[0].gauge = mystat->pb_num_iowrites;
pb_num_victims[0].gauge = mystat->pb_num_victims;
pb_num_replacements[0].gauge = mystat->pb_num_replacements;
log_num_ioreads[0].gauge = mystat->log_num_ioreads;
log_num_iowrites[0].gauge = mystat->log_num_iowrites;
log_num_appendrecs[0].gauge = mystat->log_num_appendrecs;
log_num_archives[0].gauge = mystat->log_num_archives;
log_num_checkpoints[0].gauge = mystat->log_num_checkpoints;
log_num_wals[0].gauge = mystat->log_num_wals;
lk_num_acquired_on_pages[0].gauge = mystat->lk_num_acquired_on_pages;
lk_num_acquired_on_objects[0].gauge = mystat->lk_num_acquired_on_objects;
lk_num_converted_on_pages[0].gauge = mystat->lk_num_converted_on_pages;
lk_num_converted_on_objects[0].gauge = mystat->lk_num_converted_on_objects;
lk_num_re_requested_on_pages[0].gauge =
mystat->lk_num_re_requested_on_pages;
lk_num_re_requested_on_objects[0].gauge =
mystat->lk_num_re_requested_on_objects;
lk_num_waited_on_pages[0].gauge = mystat->lk_num_waited_on_pages;
lk_num_waited_on_objects[0].gauge = mystat->lk_num_waited_on_objects;
tran_num_commits[0].gauge = mystat->tran_num_commits;
tran_num_rollbacks[0].gauge = mystat->tran_num_rollbacks;
tran_num_savepoints[0].gauge = mystat->tran_num_savepoints;
tran_num_start_topops[0].gauge = mystat->tran_num_start_topops;
tran_num_end_topops[0].gauge = mystat->tran_num_end_topops;
tran_num_interrupts[0].gauge = mystat->tran_num_interrupts;
bt_num_inserts[0].gauge = mystat->bt_num_inserts;
bt_num_deletes[0].gauge = mystat->bt_num_deletes;
bt_num_updates[0].gauge = mystat->bt_num_updates;
qm_num_selects[0].gauge = mystat->qm_num_selects;
qm_num_inserts[0].gauge = mystat->qm_num_inserts;
qm_num_deletes[0].gauge = mystat->qm_num_deletes;
qm_num_updates[0].gauge = mystat->qm_num_updates;
qm_num_sscans[0].gauge = mystat->qm_num_sscans;
qm_num_iscans[0].gauge = mystat->qm_num_iscans;
qm_num_lscans[0].gauge = mystat->qm_num_lscans;
qm_num_setscans[0].gauge = mystat->qm_num_setscans;
qm_num_methscans[0].gauge = mystat->qm_num_methscans;
qm_num_nljoins[0].gauge = mystat->qm_num_nljoins;
qm_num_mjoins[0].gauge = mystat->qm_num_mjoins;
qm_num_objfetches[0].gauge = mystat->qm_num_objfetches;
fc_num_pages[0].gauge = mystat->fc_num_pages;
fc_num_log_pages[0].gauge = mystat->fc_num_log_pages;
fc_tokens[0].gauge = mystat->fc_tokens;
net_num_requests[0].gauge = mystat->net_num_requests;
submit ("file_num_creates", submit_name, file_num_creates, 1);
submit ("file_num_removes", submit_name, file_num_removes, 1);
submit ("file_num_ioreads", submit_name, file_num_ioreads, 1);
submit ("file_num_iowrites", submit_name, file_num_iowrites, 1);
submit ("file_num_iosynches", submit_name, file_num_iosynches, 1);
submit ("pb_num_fetches", submit_name, pb_num_fetches, 1);
submit ("pb_num_dirties", submit_name, pb_num_dirties, 1);
submit ("pb_num_ioreads", submit_name, pb_num_ioreads, 1);
submit ("pb_num_iowrites", submit_name, pb_num_iowrites, 1);
submit ("pb_num_victims", submit_name, pb_num_victims, 1);
submit ("pb_num_replacements", submit_name, pb_num_replacements, 1);
submit ("log_num_ioreads", submit_name, log_num_ioreads, 1);
submit ("log_num_iowrites", submit_name, log_num_iowrites, 1);
submit ("log_num_appendrecs", submit_name, log_num_appendrecs, 1);
submit ("log_num_archives", submit_name, log_num_archives, 1);
submit ("log_num_checkpoints", submit_name, log_num_checkpoints, 1);
submit ("log_num_wals", submit_name, log_num_wals, 1);
submit ("lk_num_acquired_on_pages", submit_name, lk_num_acquired_on_pages,
1);
submit ("lk_num_acquired_on_objects", submit_name,
lk_num_acquired_on_objects, 1);
submit ("lk_num_converted_on_pages", submit_name, lk_num_converted_on_pages,
1);
submit ("lk_num_converted_on_objects", submit_name,
lk_num_converted_on_objects, 1);
submit ("lk_num_re_requested_on_pages", submit_name,
lk_num_re_requested_on_pages, 1);
submit ("lk_num_re_requested_on_objects", submit_name,
lk_num_re_requested_on_objects, 1);
submit ("lk_num_waited_on_pages", submit_name, lk_num_waited_on_pages, 1);
submit ("lk_num_waited_on_objects", submit_name, lk_num_waited_on_objects,
1);
submit ("tran_num_commits", submit_name, tran_num_commits, 1);
submit ("tran_num_rollbacks", submit_name, tran_num_rollbacks, 1);
submit ("tran_num_savepoints", submit_name, tran_num_savepoints, 1);
submit ("tran_num_start_topops", submit_name, tran_num_start_topops, 1);
submit ("tran_num_end_topops", submit_name, tran_num_end_topops, 1);
submit ("tran_num_interrupts", submit_name, tran_num_interrupts, 1);
submit ("bt_num_inserts", submit_name, bt_num_inserts, 1);
submit ("bt_num_deletes", submit_name, bt_num_deletes, 1);
submit ("bt_num_updates", submit_name, bt_num_updates, 1);
submit ("qm_num_selects", submit_name, qm_num_selects, 1);
submit ("qm_num_inserts", submit_name, qm_num_inserts, 1);
submit ("qm_num_deletes", submit_name, qm_num_deletes, 1);
submit ("qm_num_updates", submit_name, qm_num_updates, 1);
submit ("qm_num_sscans", submit_name, qm_num_sscans, 1);
submit ("qm_num_iscans", submit_name, qm_num_iscans, 1);
submit ("qm_num_lscans", submit_name, qm_num_lscans, 1);
submit ("qm_num_setscans", submit_name, qm_num_setscans, 1);
submit ("qm_num_nljoins", submit_name, qm_num_nljoins, 1);
submit ("qm_num_mjoins", submit_name, qm_num_mjoins, 1);
submit ("qm_num_objfetches", submit_name, qm_num_objfetches, 1);
submit ("fc_num_pages", submit_name, fc_num_pages, 1);
submit ("fc_num_log_pages", submit_name, fc_num_log_pages, 1);
submit ("fc_tokens", submit_name, fc_tokens, 1);
submit ("net_num_requests", submit_name, net_num_requests, 1);
histo_clear_global_stats ();
histo_stop ();
free (mystat);
db_shutdown ();
return 0;
}
/*
* loaddb_internal - internal main loaddb function
* return: NO_ERROR if successful, error code otherwise
* argc(in): argc of main
* argv(in): argv of main
* dba_mode(in):
*/
static int
loaddb_internal (UTIL_FUNCTION_ARG * arg, int dba_mode)
{
UTIL_ARG_MAP *arg_map = arg->arg_map;
int error = NO_ERROR;
/* set to static to avoid copiler warning (clobbered by longjump) */
static FILE *schema_file = NULL;
static FILE *index_file = NULL;
static FILE *object_file = NULL;
FILE *error_file = NULL;
int status = 0;
int errors, objects, defaults;
#if !defined (LDR_OLD_LOADDB)
int lastcommit = 0;
#endif /* !LDR_OLD_LOADDB */
char *passwd;
/* set to static to avoid copiler warning (clobbered by longjump) */
static int interrupted = false;
int au_save = 0;
extern bool obt_Enable_autoincrement;
char log_file_name[PATH_MAX];
LOADDB_INIT_DEBUG ();
obt_Enable_autoincrement = false;
Volume = utility_get_option_string_value (arg_map, OPTION_STRING_TABLE, 0);
Input_file = utility_get_option_string_value (arg_map, OPTION_STRING_TABLE,
1);
User_name = utility_get_option_string_value (arg_map, LOAD_USER_S, 0);
Password = utility_get_option_string_value (arg_map, LOAD_PASSWORD_S, 0);
Syntax_check = utility_get_option_bool_value (arg_map, LOAD_CHECK_ONLY_S);
Load_only = utility_get_option_bool_value (arg_map, LOAD_LOAD_ONLY_S);
Estimated_size = utility_get_option_int_value (arg_map,
LOAD_ESTIMATED_SIZE_S);
Verbose = utility_get_option_bool_value (arg_map, LOAD_VERBOSE_S);
Disable_statistics =
utility_get_option_bool_value (arg_map, LOAD_NO_STATISTICS_S);
Periodic_commit = utility_get_option_int_value (arg_map,
LOAD_PERIODIC_COMMIT_S);
Verbose_commit = Periodic_commit > 0 ? true : false;
No_oid_hint = utility_get_option_bool_value (arg_map, LOAD_NO_OID_S);
Schema_file = utility_get_option_string_value (arg_map, LOAD_SCHEMA_FILE_S,
0);
Index_file = utility_get_option_string_value (arg_map, LOAD_INDEX_FILE_S,
0);
Object_file = utility_get_option_string_value (arg_map, LOAD_DATA_FILE_S,
0);
Error_file = utility_get_option_string_value (arg_map,
LOAD_ERROR_CONTROL_FILE_S, 0);
Ignore_logging = utility_get_option_bool_value (arg_map,
LOAD_IGNORE_LOGGING_S);
#if !defined (LDR_OLD_LOADDB)
Ignore_class_file = utility_get_option_string_value (arg_map,
LOAD_IGNORE_CLASS_S,
0);
#endif
Input_file = Input_file ? Input_file : "";
Schema_file = Schema_file ? Schema_file : "";
Index_file = Index_file ? Index_file : "";
Object_file = Object_file ? Object_file : "";
Error_file = Error_file ? Error_file : "";
if (ldr_validate_object_file (stderr, arg->argv0))
{
goto error_return;
}
/* error message log file */
sprintf (log_file_name, "%s_%s.err", Volume, arg->command_name);
er_init (log_file_name, ER_NEVER_EXIT);
if (Index_file[0] != '\0'
&& PRM_SR_NBUFFERS < LOAD_INDEX_MIN_SORT_BUFFER_PAGES)
{
sysprm_set_force (PRM_NAME_SR_NBUFFERS,
LOAD_INDEX_MIN_SORT_BUFFER_PAGES_STRING);
}
sysprm_set_force (PRM_NAME_JAVA_STORED_PROCEDURE, "no");
/* login */
if (User_name != NULL || !dba_mode)
{
(void) db_login (User_name, Password);
if ((error = db_restart (arg->command_name, true, Volume)))
{
if (error == ER_AU_INVALID_PASSWORD)
{
/* prompt for password and try again */
error = NO_ERROR;
passwd = getpass (msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_PASSWORD_PROMPT));
if (!strlen (passwd))
passwd = NULL;
(void) db_login (User_name, passwd);
error = db_restart (arg->command_name, true, Volume);
}
}
}
else
{
/* if we're in the protected dba mode, just login without
authorization */
AU_DISABLE_PASSWORDS ();
db_set_client_type (DB_CLIENT_TYPE_ADMIN_UTILITY);
(void) db_login ("dba", NULL);
error = db_restart (arg->command_name, true, Volume);
}
/* open loaddb log file */
sprintf (log_file_name, "%s_loaddb.log", Volume);
loaddb_log_file = fopen (log_file_name, "w+");
if (loaddb_log_file == NULL)
{
printf ("Cannot open log file %s\n", log_file_name);
status = 2;
goto error_return;
}
#if 0
#if !defined (LDR_OLD_LOADDB)
/* Execute old loaddb if no optimization flag is set true
* or LOADDB_NOPT is set, we must pass the argv except
* -no option and invoke execvp() for no optimized loaddb
*/
if (No_optimization || envvar_get ("LOADDB_NOPT"))
{
char **tmp;
char *lastslash, path[PATH_MAX];
int i = 1, j = 1;
tmp = (char **) malloc (sizeof (char *) * (argc + 1));
tmp[0] = (char *) "loaddb";
while (j < argc)
{
if (!strcmp (argv[j], "-no"))
j++;
else
tmp[i++] = argv[j++];
};
tmp[i] = 0;
strcpy (path, argv[0]);
lastslash = strrchr (path, (int) '/');
#if defined(WINDOWS)
{
char *p, exec_path[1024], cmd_line[1024 * 8];
int cp_len = 0;
db_shutdown ();
p = envvar_root ();
if (p == NULL)
{
printf ("The `CUBRID' environment variable is not set.\n");
}
else
{
sprintf (exec_path, "%s/migdb_o.exe", p);
for (i = 0; tmp[i]; i++)
{
cp_len += sprintf (cmd_line + cp_len, "\"%s\" ", tmp[i]);
}
if (envvar_get ("FRONT_DEBUG") != NULL)
{
printf ("Executing:%s %s\n", exec_path, cmd_line);
}
run_proc (exec_path, cmd_line);
}
exit (0);
}
#else /* !WINDOWS */
if (lastslash != NULL)
strcpy (lastslash + 1, "migdb_o");
else
strcpy (path, "migdb_o");
if (execvp (path, tmp) == -1)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_NOPT_ERR));
exit (0);
};
#endif /* WINDOWS */
}
#endif /* !LDR_OLD_LOADDB */
#endif
/* check if schema/index/object files exist */
ldr_check_file_name_and_line_no ();
if (Schema_file[0] != 0)
{
schema_file = fopen (Schema_file, "r");
if (schema_file == NULL)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_BAD_INFILE),
Schema_file);
status = 2;
goto error_return;
}
}
if (Index_file[0] != 0)
{
index_file = fopen (Index_file, "r");
if (index_file == NULL)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_BAD_INFILE),
Index_file);
status = 2;
goto error_return;
}
}
if (Object_file[0] != 0)
{
object_file = fopen_ex (Object_file, "rb"); /* keep out ^Z */
if (object_file == NULL)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_BAD_INFILE),
Object_file);
status = 2;
goto error_return;
}
}
#if !defined (LDR_OLD_LOADDB)
if (Ignore_class_file)
{
int retval;
retval = get_ignore_class_list (Ignore_class_file);
if (retval < 0)
{
status = 2;
goto error_return;
}
}
#endif
/* Disallow syntax only and load only options together */
if (Load_only && Syntax_check)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_INCOMPATIBLE_ARGS),
"--" LOAD_LOAD_ONLY_L, "--" LOAD_CHECK_ONLY_L);
status = 1; /* parsing error */
goto error_return;
}
if (Error_file[0] != 0)
{
if (Syntax_check)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_INCOMPATIBLE_ARGS),
"--" LOAD_ERROR_CONTROL_FILE_L,
"--" LOAD_CHECK_ONLY_L);
status = 1; /* parsing error */
goto error_return;
}
error_file = fopen_ex (Error_file, "rt");
if (error_file == NULL)
{
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_BAD_INFILE),
Error_file);
status = 2;
goto error_return;
}
er_filter_fileset (error_file);
fclose (error_file);
}
/* check if no log option can be applied */
if (error
|| (Ignore_logging != 0 && locator_log_force_nologging () != NO_ERROR))
{
/* couldn't log in */
print_log_msg (1, "%s\n", db_error_string (3));
status = 3;
db_shutdown ();
goto error_return;
}
/* change "print_key_value_on_unique_error" parameter */
sysprm_change_server_parameters ("print_key_value_on_unique_error=1");
/* if schema file is specified, do schema loading */
if (schema_file != NULL)
{
print_log_msg (1, "\nStart schema loading.\n");
/*
* CUBRID 8.2 should be compatible with earlier versions of CUBRID.
* Therefore, we do not perform user authentication when the loader
* is executing by DBA group user.
*/
if (au_is_dba_group_member (Au_user))
{
AU_DISABLE (au_save);
}
if (ldr_exec_query_from_file (Schema_file, schema_file,
&schema_file_start_line,
Periodic_commit) != 0)
{
print_log_msg (1, "\nError occurred during schema loading."
"\nAborting current transaction...");
status = 3;
db_shutdown ();
print_log_msg (1,
" done.\n\nRestart loaddb with '-%c %s:%d' option\n",
LOAD_SCHEMA_FILE_S, Schema_file,
schema_file_start_line);
goto error_return;
}
if (au_is_dba_group_member (Au_user))
{
AU_ENABLE (au_save);
}
print_log_msg (1, "Schema loading from %s finished.\n", Schema_file);
/* update catalog statistics */
AU_DISABLE (au_save);
sm_update_all_catalog_statistics ();
AU_ENABLE (au_save);
print_log_msg (1,
"Statistics for Catalog classes have been updated.\n\n");
db_commit_transaction ();
fclose (schema_file);
schema_file = NULL;
}
/* if index file is specified, do index creation */
if (object_file != NULL)
{
#if defined (SA_MODE)
locator_Dont_check_foreign_key = true;
#endif
print_log_msg (1, "\nStart object loading.\n");
ldr_init (Verbose);
/* set the flag to indicate what type of interrupts to raise
* If logging has been disabled set commit flag.
* If logging is enabled set abort flag.
*/
if (Ignore_logging)
Interrupt_type = LDR_STOP_AND_COMMIT_INTERRUPT;
else
Interrupt_type = LDR_STOP_AND_ABORT_INTERRUPT;
if (Periodic_commit)
{
/* register the post commit function */
#if defined(LDR_OLD_LOADDB)
ldr_register_post_commit_handler (&loaddb_report_num_of_commits);
#else /* !LDR_OLD_LOADDB */
ldr_register_post_commit_handler (&loaddb_report_num_of_commits,
NULL);
#endif /* LDR_OLD_LOADDB */
}
/* Check if we need to perform syntax checking. */
if (!Load_only)
{
print_log_msg ((int) Verbose, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_CHECKING));
do_loader_parse (object_file);
#if defined(LDR_OLD_LOADDB)
ldr_stats (&errors, &objects, &defaults);
#else /* !LDR_OLD_LOADDB */
ldr_stats (&errors, &objects, &defaults, &lastcommit);
#endif /* LDR_OLD_LOADDB */
}
else
errors = 0;
if (errors)
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_ERROR_COUNT), errors);
else if (!Syntax_check)
{
/* now do it for real if there were no errors and we aren't
doing a simple syntax check */
ldr_start (Periodic_commit);
fclose (object_file);
object_file = fopen_ex (Object_file, "rb"); /* keep out ^Z */
if (object_file != NULL)
{
print_log_msg ((int) Verbose,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_INSERTING));
/* make sure signals are caught */
util_arm_signal_handlers (signal_handler, signal_handler);
/* register function to call and jmp environment to longjmp to
* after aborting or committing.
*/
ldr_register_post_interrupt_handler
(&loaddb_get_num_of_inserted_objects, &loaddb_jmp_buf);
if (setjmp (loaddb_jmp_buf) != 0)
{
/* We have had an interrupt, the transaction should have
* been already been aborted or committed by the loader.
* If Total_objects_loaded is -1 an error occurred during
* rollback or commit.
*/
if (Total_objects_loaded != -1)
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_OBJECT_COUNT),
Total_objects_loaded);
#if !defined(LDR_OLD_LOADDB)
ldr_stats (&errors, &objects, &defaults, &lastcommit);
if (lastcommit > 0)
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_LAST_COMMITTED_LINE),
lastcommit);
#endif /* !LDR_OLD_LOADDB */
interrupted = true;
}
else
{
do_loader_parse (object_file);
#if defined(LDR_OLD_LOADDB)
ldr_stats (&errors, &objects, &defaults);
#else /* !LDR_OLD_LOADDB */
ldr_stats (&errors, &objects, &defaults, &lastcommit);
#endif /* LDR_OLD_LOADDB */
if (errors)
{
#if defined(LDR_OLD_LOADDB)
print_log_msg (1, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_ERROR_COUNT),
errors);
#else /* !LDR_OLD_LOADDB */
if (lastcommit > 0)
print_log_msg (1,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_LAST_COMMITTED_LINE),
lastcommit);
#endif /* LDR_OLD_LOADDB */
/*
* don't allow the transaction to be committed at
* this point, note that if we ever move to a scheme
* where we write directly to the heap without the
* transaction context, we will have to unwind the
* changes made if errors are detected !
*/
db_abort_transaction ();
}
else
{
if (objects)
print_log_msg (1,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_OBJECT_COUNT),
objects);
if (defaults)
print_log_msg (1,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_DEFAULT_COUNT),
defaults);
print_log_msg ((int) Verbose,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_COMMITTING));
/* commit the transaction and then update statistics */
if (!db_commit_transaction ())
{
if (!Disable_statistics)
{
if (Verbose)
print_log_msg (1,
msgcat_message
(MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_UPDATING_STATISTICS));
if (!ldr_update_statistics ())
{
/*
* would it be faster to update statistics
* before the first commit and just have a
* single commit ?
*/
print_log_msg ((int) Verbose,
msgcat_message
(MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_COMMITTING));
(void) db_commit_transaction ();
}
}
}
}
}
}
}
ldr_final ();
if (object_file != NULL)
{
fclose (object_file);
object_file = NULL;
}
}
/* create index */
if (!interrupted && index_file != NULL)
{
print_log_msg (1, "\nStart index loading.\n");
if (ldr_exec_query_from_file (Index_file, index_file,
&index_file_start_line,
Periodic_commit) != 0)
{
print_log_msg (1, "\nError occurred during index loading."
"\nAborting current transaction...");
status = 3;
db_shutdown ();
print_log_msg (1,
" done.\n\nRestart loaddb with '-%c %s:%d' option\n",
LOAD_INDEX_FILE_S, Index_file,
index_file_start_line);
goto error_return;
}
/* update catalog statistics */
AU_DISABLE (au_save);
sm_update_catalog_statistics (CT_INDEX_NAME);
sm_update_catalog_statistics (CT_INDEXKEY_NAME);
AU_ENABLE (au_save);
print_log_msg (1, "Index loading from %s finished.\n", Index_file);
db_commit_transaction ();
}
print_log_msg ((int) Verbose, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_LOADDB,
LOADDB_MSG_CLOSING));
(void) db_shutdown ();
#if !defined (LDR_OLD_LOADDB)
free_ignoreclasslist ();
#endif
return (status);
error_return:
if (schema_file != NULL)
fclose (schema_file);
if (object_file != NULL)
fclose (object_file);
if (index_file != NULL)
fclose (index_file);
#if !defined (LDR_OLD_LOADDB)
free_ignoreclasslist ();
#endif
return status;
}
int check_data( db_t hdb, const trans_stat_t * stat )
{
int rc = EXIT_FAILURE;
db_result_t db_rc = DB_OK;
db_row_t row;
storage_t row_data;
db_cursor_t c; // Cursor to scan table to check
// Cursor parameters
db_table_cursor_t p = {
PKEY_INDEX_NAME, //< Index by which to sort the table
DB_SCAN_FORWARD | DB_LOCK_DEFAULT
};
// Open cursor
c = db_open_table_cursor(hdb, STORAGE_TABLE, &p);
row = db_alloc_row( binds_def, DB_ARRAY_DIM( binds_def ) );
db_rc = db_seek_first(c);
// Scan table and check that pkey values are monotonically increase
{
int counter = 0;
trans_stat_t s = { 0, 0 };
for(; !db_eof(c) && DB_OK == db_rc; db_rc = db_seek_next(c) )
{
db_rc = db_fetch(c, row, &row_data);
if( row_data.f1 != ++counter ) {
break;
}
s.lazy_tx += row_data.f2 == 50 ? 1 : 0;
s.forced_tx += row_data.f2 == 16 ? 1 : 0;
}
if( DB_OK != db_rc ) {
print_error_message( "Error to scan table of backup db\n", c );
}
else if( row_data.f1 != counter ) {
fprintf( stderr, "Pkey field values sequence violation detected in backup db: (%" PRId64 ", %d)\n",
row_data.f1, counter
);
}
else if( s.lazy_tx != stat->lazy_tx ) {
fprintf( stderr, "Unexpected count of records which was commited in lazy-commit mode: %d, but expected %d.\n",
s.lazy_tx, stat->lazy_tx );
}
else if( s.forced_tx != stat->forced_tx ) {
fprintf( stderr, "Unexpected count of records which was commited in force-commit mode: %d, but expected %d.\n",
s.forced_tx, stat->forced_tx );
}
else {
fprintf( stdout, "%d records is inside\n", counter );
rc = EXIT_SUCCESS;
}
}
db_close_cursor( c );
db_free_row( row );
db_shutdown(hdb, DB_SOFT_SHUTDOWN, NULL);
return rc;
}
static int
dbmt_user_login (int argc, char *argv[], int opt_begin)
{
const char *outfile, *errfile, *dbname, *dbuser, *dbpasswd;
FILE *outfp = NULL, *errfp = NULL;
bool isdba = false;
if (argc - opt_begin < 5)
return -1;
outfile = argv[opt_begin++];
outfile = (outfile) ? outfile : "";
errfile = argv[opt_begin++];
errfile = (errfile) ? errfile : "";
dbname = argv[opt_begin++];
dbname = (dbname) ? dbname : "";
dbuser = argv[opt_begin++];
dbuser = (dbuser) ? dbuser : "";
dbpasswd = argv[opt_begin++];
dbpasswd = (dbpasswd) ? dbpasswd : "";
outfp = fopen (outfile, "w");
errfp = fopen (errfile, "w");
if (outfp == NULL || errfp == NULL)
{
goto login_err;
}
db_login (dbuser, dbpasswd);
if (db_restart (argv[0], 0, dbname) < 0)
{
fprintf (errfp, "%s", db_error_string (1));
goto login_err;
}
if (strcasecmp (dbuser, "DBA") == 0)
{
isdba = true;
}
else
{
DB_OBJECT *user, *obj;
DB_VALUE v;
DB_COLLECTION *col;
int i;
char *username;
user = db_find_user (dbuser);
if (user == NULL)
{
fprintf (errfp, "%s", db_error_string (1));
goto login_err;
}
db_get (user, "groups", &v);
col = db_get_set (&v);
for (i = 0; i < db_set_size (col); i++)
{
db_set_get (col, i, &v);
obj = db_get_object (&v);
db_get (obj, "name", &v);
username = db_get_string (&v);
if (username != NULL && strcasecmp (username, "DBA") == 0)
{
isdba = true;
break;
}
}
}
if (isdba == true)
fprintf (outfp, "isdba\n");
else
fprintf (outfp, "isnotdba\n");
db_shutdown ();
fclose (outfp);
fclose (errfp);
return 0;
login_err:
db_shutdown ();
if (outfp != NULL)
fclose (outfp);
if (errfp != NULL)
fclose (errfp);
return -1;
}
/*
* compactdb - compactdb main routine
* return: 0 if successful, error code otherwise
* arg(in): a map of command line arguments
*/
int
compactdb (UTIL_FUNCTION_ARG * arg)
{
UTIL_ARG_MAP *arg_map = arg->arg_map;
const char *exec_name = arg->command_name;
int error;
int i, status = 0;
const char *database_name;
bool verbose_flag = 0, delete_old_repr_flag = 0;
char *input_filename = NULL;
DB_OBJECT **req_class_table = NULL;
LIST_MOPS *all_class_table = NULL;
int maximum_processed_space = 10 * DB_PAGESIZE, pages;
int instance_lock_timeout, class_lock_timeout;
char **tables = NULL;
int table_size = 0;
database_name =
utility_get_option_string_value (arg_map, OPTION_STRING_TABLE, 0);
verbose_flag = utility_get_option_bool_value (arg_map, COMPACT_VERBOSE_S);
input_filename =
utility_get_option_string_value (arg_map, COMPACT_INPUT_CLASS_FILE_S, 0);
pages =
utility_get_option_int_value (arg_map, COMPACT_PAGES_COMMITED_ONCE_S);
if (pages < COMPACT_MIN_PAGES || pages > COMPACT_MAX_PAGES)
{
fprintf (stderr, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_FAILURE));
fprintf (stderr,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_OUT_OF_RANGE_PAGES),
COMPACT_MIN_PAGES, COMPACT_MAX_PAGES);
return ER_GENERIC_ERROR;
}
if (database_name == NULL || database_name[0] == '\0'
|| utility_get_option_string_table_size (arg_map) < 1)
{
compactdb_usage (arg->argv0);
return ER_GENERIC_ERROR;
}
table_size = utility_get_option_string_table_size (arg_map);
if (table_size > 1 && input_filename != NULL)
{
compactdb_usage (arg->argv0);
return ER_GENERIC_ERROR;
}
instance_lock_timeout = utility_get_option_int_value
(arg_map, COMPACT_INSTANCE_LOCK_TIMEOUT_S);
if (instance_lock_timeout < COMPACT_INSTANCE_MIN_LOCK_TIMEOUT ||
instance_lock_timeout > COMPACT_INSTANCE_MAX_LOCK_TIMEOUT)
{
fprintf (stderr, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_FAILURE));
fprintf (stderr,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_OUT_OF_RANGE_INSTANCE_LOCK_TIMEOUT),
COMPACT_INSTANCE_MIN_LOCK_TIMEOUT,
COMPACT_INSTANCE_MAX_LOCK_TIMEOUT);
return ER_GENERIC_ERROR;
}
class_lock_timeout = utility_get_option_int_value
(arg_map, COMPACT_CLASS_LOCK_TIMEOUT_S);
if (class_lock_timeout < COMPACT_CLASS_MIN_LOCK_TIMEOUT ||
class_lock_timeout > COMPACT_CLASS_MAX_LOCK_TIMEOUT)
{
fprintf (stderr, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_FAILURE));
fprintf (stderr,
msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_OUT_OF_RANGE_CLASS_LOCK_TIMEOUT),
COMPACT_CLASS_MIN_LOCK_TIMEOUT,
COMPACT_CLASS_MAX_LOCK_TIMEOUT);
return ER_GENERIC_ERROR;
}
delete_old_repr_flag =
utility_get_option_bool_value (arg_map, COMPACT_DELETE_OLD_REPR_S);
maximum_processed_space = pages * DB_PAGESIZE;
if (table_size > 1)
{
tables = (char **) malloc (sizeof (char *) * table_size - 1);
for (i = 1; i < table_size; i++)
{
tables[i - 1] = utility_get_option_string_value
(arg_map, OPTION_STRING_TABLE, i);
}
}
sysprm_set_force (PRM_NAME_JAVA_STORED_PROCEDURE, "no");
AU_DISABLE_PASSWORDS ();
db_set_client_type (DB_CLIENT_TYPE_ADMIN_UTILITY);
if ((error = db_login ("dba", NULL))
|| (error = db_restart (arg->argv0, TRUE, database_name)))
{
fprintf (stderr, "%s: %s.\n\n", exec_name, db_error_string (3));
status = error;
}
else
{
status = db_set_isolation (TRAN_REP_CLASS_UNCOMMIT_INSTANCE);
if (status == NO_ERROR)
{
status = compactdb_start (verbose_flag, delete_old_repr_flag,
input_filename, tables, table_size - 1,
maximum_processed_space,
instance_lock_timeout,
class_lock_timeout,
TRAN_REP_CLASS_UNCOMMIT_INSTANCE);
if (status == ER_FAILED)
{
fprintf (stderr, msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_FAILURE));
}
}
db_shutdown ();
}
if (tables)
{
free (tables);
tables = NULL;
}
return status;
}
int
main (int argc, char **argv)
{
const char *pid_file = NULL;
const char *run_file = NULL;
const char *url = APTERYX_SERVER;
bool background = false;
pthread_mutexattr_t callback_recursive;
FILE *fp;
int i;
/* Parse options */
while ((i = getopt (argc, argv, "hdmbp:r:l:")) != -1)
{
switch (i)
{
case 'd':
apteryx_debug = true;
background = false;
break;
case 'b':
background = true;
break;
case 'p':
pid_file = optarg;
break;
case 'r':
run_file = optarg;
break;
case 'l':
url = optarg;
break;
case 'm':
g_mem_set_vtable (glib_mem_profiler_table);
break;
case '?':
case 'h':
default:
help ();
return 0;
}
}
/* Handle SIGTERM/SIGINT/SIGPIPE gracefully */
signal (SIGTERM, (__sighandler_t) termination_handler);
signal (SIGINT, (__sighandler_t) termination_handler);
signal (SIGPIPE, SIG_IGN);
/* Daemonize */
if (background && fork () != 0)
{
/* Parent */
return 0;
}
/* Create pid file */
if (background && pid_file)
{
fp = fopen (pid_file, "w");
if (!fp)
{
ERROR ("Failed to create PID file %s\n", pid_file);
goto exit;
}
fprintf (fp, "%d\n", getpid ());
fclose (fp);
}
/* Initialise the database */
db_init ();
/* Initialise callbacks to clients */
cb_init ();
/* Configuration Set/Get */
config_init ();
/* Create a lock for currently-validating */
pthread_mutexattr_init (&callback_recursive);
pthread_mutexattr_settype (&callback_recursive, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init (&validating, &callback_recursive);
/* Init the RPC for the server instance */
rpc = rpc_init ((ProtobufCService *)&apteryx_server_service, &apteryx__client__descriptor, RPC_TIMEOUT_US);
if (rpc == NULL)
{
ERROR ("Failed to initialise RPC service\n");
goto exit;
}
/* Create server and process requests */
if (!rpc_server_bind (rpc, url, url))
{
ERROR ("Failed to start rpc service\n");
goto exit;
}
/* Init the RPC for the proxy client */
proxy_rpc = rpc_init (NULL, &apteryx__server__descriptor, RPC_TIMEOUT_US);
if (proxy_rpc == NULL)
{
ERROR ("Failed to initialise proxy RPC service\n");
goto exit;
}
/* Create run file */
if (run_file)
{
fp = fopen (run_file, "w");
if (!fp)
{
ERROR ("Failed to create RUN file %s\n", run_file);
goto exit;
}
fclose (fp);
}
/* Loop while running */
while (running)
{
pause ();
}
exit:
DEBUG ("Exiting\n");
/* Cleanup callbacks */
cb_shutdown ();
db_shutdown ();
if (proxy_rpc)
{
rpc_shutdown (proxy_rpc);
}
if (rpc)
{
rpc_server_release (rpc, url);
rpc_shutdown (rpc);
}
/* Remove the pid file */
if (background && pid_file)
unlink (pid_file);
/* Remove the run file */
if (run_file)
unlink (run_file);
/* Memory profiling */
g_mem_profile ();
return 0;
}
int
main (int argc, char *argv[])
{
char *dbname, *uid, *passwd, *outfile, *errfile;
FILE *fp;
DB_OBJLIST *trigger_list, *temp;
DB_OBJECT *trigger_obj;
int errcode;
if (argc < 6)
{
return 1;
}
putenv ((char *) "CUBRID_ERROR_LOG=NULL");
close (2);
dbname = argv[1];
uid = argv[2];
passwd = argv[3];
outfile = argv[4];
errfile = argv[5];
db_login (uid, passwd);
if (db_restart (argv[0], 0, dbname) < 0)
{
write_err_msg (errfile, (char *) db_error_string (1));
return 0;
}
fp = fopen (outfile, "w+");
if (fp == NULL)
{
db_shutdown ();
return 0;
}
errcode = db_find_all_triggers (&trigger_list);
if (errcode)
{
write_err_msg (errfile, (char *) db_error_string (1));
db_shutdown ();
return 0;
}
fprintf (fp, MSGFMT, "open", "triggerlist");
temp = trigger_list;
while (temp)
{
trigger_obj = temp->op;
fprintf (fp, MSGFMT, "open", "triggerinfo");
get_trigger_information (fp, trigger_obj);
fprintf (fp, MSGFMT, "close", "triggerinfo");
temp = temp->next;
}
fprintf (fp, MSGFMT, "close", "triggerlist");
fclose (fp);
db_objlist_free (trigger_list);
db_shutdown ();
return 0;
}
static int
class_info (int argc, char *argv[], int opt_begin)
{
const char *dbname, *uid, *passwd, *outfile, *errfile;
FILE *fp;
DB_OBJLIST *objlist, *temp;
DB_OBJECT *classobj;
const char *ver_str;
if (argc < 8)
{
return 1;
}
putenv ((char *) "CUBRID_ERROR_LOG=NULL");
close (2);
dbname = argv[opt_begin++];
dbname = (dbname) ? dbname : "";
uid = argv[opt_begin++];
uid = (uid) ? uid : "";
passwd = argv[opt_begin++];
passwd = (passwd) ? passwd : "";
outfile = argv[opt_begin++];
outfile = (outfile) ? outfile : "";
errfile = argv[opt_begin++];
errfile = (errfile) ? errfile : "";
ver_str = argv[opt_begin++];
ver_str = (ver_str) ? ver_str : "";
db_login (uid, passwd);
if (db_restart (argv[0], 0, dbname) < 0)
{
write_err_msg (errfile, (char *) db_error_string (1));
return 0;
}
fp = fopen (outfile, "w");
if (fp == NULL)
{
db_shutdown ();
return 0;
}
fprintf (fp, MSGFMT, "open", "systemclass");
objlist = db_get_all_classes ();
for (temp = objlist; temp != NULL; temp = temp->next)
{
classobj = temp->op;
if (db_is_system_class (classobj))
write_class_info (fp, classobj);
}
db_objlist_free (objlist);
fprintf (fp, MSGFMT, "close", "systemclass");
fprintf (fp, MSGFMT, "open", "userclass");
objlist = db_get_all_classes ();
for (temp = objlist; temp != NULL; temp = temp->next)
{
classobj = temp->op;
if (!db_is_system_class (classobj))
write_class_info (fp, classobj);
}
db_objlist_free (objlist);
fprintf (fp, MSGFMT, "close", "userclass");
fclose (fp);
db_shutdown ();
return 0;
}
/*
* Spawns the initial bot process and waits for them all to exit.
*/
int
main(int argc, char *argv[])
{
char *pythonpath = getenv("PYTHONPATH");
if (pythonpath) {
char *str = (char*)xzmalloc(strlen(pythonpath) + strlen(":") + strlen("./libs") + 1);
sprintf(str, "%s:%s", "./libs", pythonpath);
setenv("PYTHONPATH", str, 1);
free(str);
} else {
setenv("PYTHONPATH", "./libs", 1);
}
Py_Initialize();
init_opencore();
PyObject *sysPath = PySys_GetObject("path");
PyObject *libDir = PyString_FromString(".");
PyList_Append(sysPath, libDir);
Py_DECREF(libDir);
if (pthread_key_create(&g_tls_key, NULL) != 0) {
Log(OP_SMOD, "Error creating thread-specific storage");
exit(-1);
}
pthread_setspecific(g_tls_key, NULL);
/* make directories */
mkdir("files", 0700);
/* setup packet handlers */
for (int i = 0; i < 256; ++i) {
g_pkt_core_handlers[i] = null_handler;
g_pkt_game_handlers[i] = null_handler;
}
g_pkt_core_handlers[0x02] = pkt_handle_core_0x02;
g_pkt_core_handlers[0x03] = pkt_handle_core_0x03;
g_pkt_core_handlers[0x04] = pkt_handle_core_0x04;
g_pkt_core_handlers[0x05] = pkt_handle_core_0x05;
g_pkt_core_handlers[0x06] = pkt_handle_core_0x06;
g_pkt_core_handlers[0x07] = pkt_handle_core_0x07;
g_pkt_core_handlers[0x08] = pkt_handle_core_0x08_0x09;
g_pkt_core_handlers[0x09] = pkt_handle_core_0x08_0x09;
g_pkt_core_handlers[0x0A] = pkt_handle_core_0x0A;
g_pkt_core_handlers[0x0E] = pkt_handle_core_0x0E;
g_pkt_game_handlers[0x02] = pkt_handle_game_0x02;
g_pkt_game_handlers[0x03] = pkt_handle_game_0x03;
g_pkt_game_handlers[0x04] = pkt_handle_game_0x04;
g_pkt_game_handlers[0x07] = pkt_handle_game_0x07;
g_pkt_game_handlers[0x06] = pkt_handle_game_0x06;
g_pkt_game_handlers[0x0A] = pkt_handle_game_0x0A;
g_pkt_game_handlers[0x0D] = pkt_handle_game_0x0D;
g_pkt_game_handlers[0x0E] = pkt_handle_game_0x0E;
g_pkt_game_handlers[0x14] = pkt_handle_game_0x14;
g_pkt_game_handlers[0x19] = pkt_handle_game_0x19;
g_pkt_game_handlers[0x1C] = pkt_handle_game_0x1C;
g_pkt_game_handlers[0x1D] = pkt_handle_game_0x1D;
g_pkt_game_handlers[0x27] = pkt_handle_game_0x27;
g_pkt_game_handlers[0x28] = pkt_handle_game_0x28;
g_pkt_game_handlers[0x29] = pkt_handle_game_0x29;
g_pkt_game_handlers[0x2E] = pkt_handle_game_0x2E;
g_pkt_game_handlers[0x2F] = pkt_handle_game_0x2F;
g_pkt_game_handlers[0x31] = pkt_handle_game_0x31;
struct utsname uts;
bzero(&uts, sizeof(struct utsname));
uname(&uts);
uint64_t hash = hash_buf(&uts, sizeof(struct utsname));
g_machineid = gen_valid_mid(hash & 0xFFFFFFFF);
g_permissionid = hash >> 32;
load_op_file();
static const char* const masterconfig = "types/master.conf";
log_init();
db_init(masterconfig);
botman_init();
/* run the master bot */
char arenaname[32] = { '\0' };
config_get_string("login.masterarena", arenaname, sizeof(arenaname), "#master", masterconfig);
LogFmt(OP_MOD, "Starting master into %s", arenaname);
char *err = StartBot("master", arenaname, NULL);
if (err) {
LogFmt(OP_MOD, "Error starting master bot: %s", err);
return -1;
}
/* become the bot management thread and loop */
botman_mainloop();
botman_shutdown();
db_shutdown();
log_shutdown();
pthread_key_delete(g_tls_key);
Py_Finalize();
return 0;
}
int
main (int argc, char *argv[])
{
float disk_compat_level = 0.0f;
char *prog_name;
const char *qp1 = "select db_user, password.password from db_user";
DB_VALUE user_val, password_val;
MOP user_class;
MOP user;
char *db_name;
char *password;
char *decoded_str;
char *encoded_str;
int retval, error;
DB_QUERY_RESULT *query_result;
DB_QUERY_ERROR query_error;
char out_buf[128];
if (argc < 2)
{
printf ("usage : %s databasename\n", argv[0]);
return 1;
}
prog_name = argv[0];
db_name = argv[1];
AU_DISABLE_PASSWORDS ();
db_set_client_type (DB_CLIENT_TYPE_ADMIN_UTILITY);
db_login ("dba", NULL);
db_restart (prog_name, 0, db_name);
error = db_execute (qp1, &query_result, &query_error);
if (error > 0)
{
error = db_query_first_tuple (query_result);
while (error == NO_ERROR)
{
retval = db_query_get_tuple_value (query_result, 0, &user_val);
if (retval != NO_ERROR)
{
printf ("%s\n", db_error_string (1));
return 1;
}
retval = db_query_get_tuple_value (query_result, 1, &password_val);
if (retval != NO_ERROR)
{
printf ("%s\n", db_error_string (1));
return 1;
}
if (DB_IS_NULL (&user_val) || DB_IS_NULL (&password_val))
{
error = db_query_next_tuple (query_result);
continue;
}
user = db_get_object (&user_val);
password = db_get_string (&password_val);
retval = io_relseek_old (password, 1, out_buf);
if (retval != NO_ERROR)
{
printf ("%s\n", db_error_string (1));
return 1;
}
retval = au_set_password (user, out_buf);
if (retval != NO_ERROR)
{
printf ("%s\n", db_error_string (1));
return 1;
}
error = db_query_next_tuple (query_result);
}
db_query_end (query_result);
}
db_commit_transaction ();
db_shutdown ();
return 0;
}
