void CDlgSAPrefs6::OnBnClickedPtTest()
{
CString conn_str = "", ip_addr = "", port = "", user = "", pass = "", dbname = "", e = "";
CMainFrame *pMyMainWnd = (CMainFrame *) (theApp.m_pMainWnd);
m_pt_ip.GetWindowText(ip_addr);
m_pt_port.GetWindowText(port);
m_pt_user.GetWindowText(user);
m_pt_pass.GetWindowText(pass);
m_pt_dbname.GetWindowText(dbname);
conn_str = "host=" + ip_addr;
conn_str += " port=" + port;
conn_str += " user="******" password="******" dbname='" + dbname;
conn_str += "'";
// Set busy cursor
pMyMainWnd->set_wait_cursor(true);
pMyMainWnd->BeginWaitCursor();
// Test the connection parameters
PGconn *pgconn = PQconnectdb(conn_str.GetString());
// Unset busy cursor
pMyMainWnd->EndWaitCursor();
pMyMainWnd->set_wait_cursor(false);
if (PQstatus(pgconn) == CONNECTION_OK)
{
write_log_pokertracker(1, "Test: PostgreSQL DB opened successfully <%s/%s/%s>\n", ip_addr, port, dbname);
if (PQisthreadsafe())
{
write_log_pokertracker(1, "Test: PostgreSQL library is thread safe.\n\n");
OH_MessageBox_Interactive("PostgreSQL DB opened successfully", "Success", MB_OK);
}
else
{
write_log_pokertracker(1, "Test: PostgreSQL library is *NOT* thread safe! This is a problem!\n\n");
OH_MessageBox_Interactive("PostgreSQL DB opened successfully, but\nPostgreSQL library is *NOT* thread safe!\nThis is a problem!",
"Success (partial)", MB_OK);
}
PQfinish(pgconn);
}
else
{
write_log_pokertracker(1, "Test: ERROR opening PostgreSQL DB: %s\n\n", PQerrorMessage(pgconn));
e = "ERROR opening PostgreSQL DB:\n";
e += PQerrorMessage(pgconn);
e += "\nConn string:";
e += conn_str;
OH_MessageBox_Interactive(e.GetString(), "ERROR", MB_OK);
PQfinish(pgconn);
}
}
DatabasePostgre::DatabasePostgre()
{
// before first connection
if (db_count++ == 0)
{
if (!PQisthreadsafe())
{
sLog.outError("FATAL ERROR: PostgreSQL libpq isn't thread-safe.");
exit(1);
}
}
}
postgresql_connection_impl::postgresql_connection_impl(const string &conninfo)
:conn(NULL)
{
if (PQisthreadsafe()!=1)
throw database_error("PostgreSQL is not threadsafe");
conn=PQconnectdb(conninfo.c_str());
if (conn==NULL)
throw database_error("cannot create connection");
if (PQstatus(conn)!=CONNECTION_OK){
PQfinish(conn);
throw database_error("fail to connect database");
}
}
DatabasePostgre::DatabasePostgre()
{
// before first connection
if( db_count++ == 0 && !PQisthreadsafe() )
poco_bugcheck_msg("FATAL ERROR: PostgreSQL libpq isn't thread-safe.");
}
/* ----------
* main
* ----------
*/
int
main(int argc, char *const argv[])
{
char *cp1;
char *cp2;
int c;
int errors = 0;
extern int optind;
extern char *optarg;
#ifdef WIN32
WSADATA wsaData;
int err;
#endif
#ifdef WIN32
if (argc >= 2 && !strcmp(argv[1], "-service"))
{
win32_servicestart();
exit(0);
}
if (argc >= 2 && !strcmp(argv[1], "-subservice"))
{
win32_isservice = 1;
argc--;
argv++;
}
if (argc >= 2 && argc <= 4 && (
!strcmp(argv[1], "-regservice") ||
!strcmp(argv[1], "-unregservice") ||
!strcmp(argv[1], "-addengine") ||
!strcmp(argv[1], "-delengine") ||
!strcmp(argv[1], "-listengines")))
{
win32_serviceconfig(argc, argv);
}
#endif
InitializeConfOptions();
while ((c = getopt(argc, argv, "f:a:d:s:t:g:c:p:o:q:r:l:x:hv?")) != EOF)
{
switch (c)
{
case '?':
Usage(argv);
case 'q':
set_config_option("quit_sync_provider", optarg);
break;
case 'r':
set_config_option("quit_sync_finalsync", optarg);
break;
case 'f':
ProcessConfigFile(optarg);
break;
case 'a':
set_config_option("archive_dir", optarg);
break;
case 'd':
set_config_option("log_level", optarg);
break;
case 's':
set_config_option("sync_interval", optarg);
break;
case 't':
set_config_option("sync_interval_timeout", optarg);
break;
case 'g':
set_config_option("sync_group_maxsize", optarg);
break;
case 'c':
set_config_option("vac_frequency", optarg);
break;
case 'p':
set_config_option("pid_file", optarg);
break;
case 'o':
set_config_option("desired_sync_time", optarg);
break;
case 'l':
set_config_option("lag_interval", optarg);
break;
case 'h':
errors++;
break;
case 'v':
printf("slon version %s\n", SLONY_I_VERSION_STRING);
exit(0);
break;
case 'x':
set_config_option("command_on_logarchive", optarg);
break;
default:
fprintf(stderr, "unknown option '%c'\n", c);
errors++;
break;
}
}
/*
* Make sure the sync interval timeout isn't too small.
*/
if (sync_interval_timeout != 0 && sync_interval_timeout <= sync_interval)
sync_interval_timeout = sync_interval * 2;
/*
* Remember the cluster name and build the properly quoted namespace
* identifier
*/
slon_pid = getpid();
#ifndef WIN32
if (pthread_mutex_init(&slon_watchdog_lock, NULL) < 0)
{
slon_log(SLON_FATAL, "slon: pthread_mutex_init() - %s\n",
strerror(errno));
exit(-1);
}
slon_watchdog_pid = slon_pid;
slon_worker_pid = -1;
#endif
main_argv = argv;
if ((char *) argv[optind])
{
set_config_option("cluster_name", (char *) argv[optind]);
set_config_option("conn_info", (char *) argv[++optind]);
}
if (rtcfg_cluster_name != NULL)
{
rtcfg_namespace = malloc(strlen(rtcfg_cluster_name) * 2 + 4);
cp2 = rtcfg_namespace;
*cp2++ = '"';
*cp2++ = '_';
for (cp1 = (char *) rtcfg_cluster_name; *cp1; cp1++)
{
if (*cp1 == '"')
*cp2++ = '"';
*cp2++ = *cp1;
}
*cp2++ = '"';
*cp2 = '\0';
}
else
{
errors++;
}
slon_log(SLON_CONFIG, "main: slon version %s starting up\n",
SLONY_I_VERSION_STRING);
/*
* Remember the connection information for the local node.
*/
if (rtcfg_conninfo == NULL)
{
errors++;
}
if (errors != 0)
{
Usage(argv);
}
#ifdef WIN32
/*
* Startup the network subsystem, in case our libpq doesn't
*/
err = WSAStartup(MAKEWORD(1, 1), &wsaData);
if (err != 0)
{
slon_log(SLON_FATAL, "main: Cannot start the network subsystem - %d\n", err);
exit(-1);
}
#endif
if (pid_file)
{
FILE *pidfile;
pidfile = fopen(pid_file, "w");
if (pidfile)
{
fprintf(pidfile, "%d\n", slon_pid);
fclose(pidfile);
}
else
{
slon_log(SLON_FATAL, "Cannot open pid_file \"%s\"\n", pid_file);
exit(-1);
}
}
/*
* Create the pipe used to kick the workers scheduler thread
*/
if (pgpipe(sched_wakeuppipe) < 0)
{
slon_log(SLON_FATAL, "slon: sched_wakeuppipe create failed -(%d) %s\n", errno, strerror(errno));
slon_exit(-1);
}
if (!PQisthreadsafe())
{
slon_log(SLON_FATAL, "slon: libpq was not compiled with thread safety enabled (normally: --enable-thread-safety). slon is a multithreaded application requiring thread-safe libpq\n");
slon_exit(-1);
}
if (!PQisthreadsafe())
{
slon_log(SLON_FATAL, "slon: libpq was not compiled with --enable-thread-safety. Slony-I requires a thread enabled libpq\n");
slon_exit(-1);
}
/*
* There is no watchdog process on win32. We delegate restarting and other
* such tasks to the Service Control Manager. And win32 doesn't support
* signals, so we don't need to catch them...
*/
#ifndef WIN32
SlonWatchdog();
#else
SlonMain();
#endif
exit(0);
}
/*
* call-seq:
* PG.isthreadsafe -> Boolean
* PG.is_threadsafe? -> Boolean
* PG.threadsafe? -> Boolean
*
* Returns +true+ if libpq is thread-safe, +false+ otherwise.
*/
static VALUE
pg_s_threadsafe_p(VALUE self)
{
UNUSED( self );
return PQisthreadsafe() ? Qtrue : Qfalse;
}