server.c Source File (original) (raw)

29{

33 {

39 printf(_("Failure, exiting\n"));

40 exit(1);

41 }

46}

58{

70 {

73 }

78}

91char *

93{

96 if (buf == NULL)

98 else

100

102 {

106 }

109

110 return buf->data;

111}

112

113

114

115

116

117

118

119

120

123{

125 va_list args;

128

129 va_start(args, fmt);

131 va_end(args);

132

136

138 {

143 printf(_("Failure, exiting\n"));

144 exit(1);

145 }

146 else

147 return result;

148}

149

150

151

152

153

154

155

156

157

160{

161 FILE *version_fd;

163 int v1 = 0,

164 v2 = 0;

165

166 snprintf(ver_filename, sizeof(ver_filename), "%s/PG_VERSION",

168 if ((version_fd = fopen(ver_filename, "r")) == NULL)

169 pg_fatal("could not open version file \"%s\": %m", ver_filename);

170

171 if (fscanf(version_fd, "%63s", cluster->major_version_str) == 0 ||

172 sscanf(cluster->major_version_str, "%d.%d", &v1, &v2) < 1)

173 pg_fatal("could not parse version file \"%s\"", ver_filename);

174

175 fclose(version_fd);

176

177 if (v1 < 10)

178 {

179

180 return v1 * 10000 + v2 * 100;

181 }

182 else

183 {

184

185 return v1 * 10000;

186 }

187}

188

189

190static void

192{

194}

195

196

197bool

199{

202 bool pg_ctl_return = false;

203 char socket_string[MAXPGPATH + 200];

205

206 static bool exit_hook_registered = false;

207

208 if (!exit_hook_registered)

209 {

211 exit_hook_registered = true;

212 }

213

214 socket_string[0] = '\0';

215

216#if !defined(WIN32)

217

218 strcat(socket_string,

219 " -c listen_addresses='' -c unix_socket_permissions=0700");

220

221

223 snprintf(socket_string + strlen(socket_string),

224 sizeof(socket_string) - strlen(socket_string),

225 " -c %s='%s'",

227 "unix_socket_directory" : "unix_socket_directories",

229#endif

230

232

233

234

235

236

237

238

239

240

242 appendPQExpBufferStr(&pgoptions, " -c synchronous_commit=off -c fsync=off -c full_page_writes=off");

243

244

245

246

247

248

249

250

251

254

255

256

257

258

261

262

263

264

265

267 "\"%s/pg_ctl\" -w -l \"%s/%s\" -D \"%s\" -o \"-p %d -b%s %s%s\" start",

271 pgoptions.data,

272 cluster->pgopts ? cluster->pgopts : "", socket_string);

273

275

276

277

278

279

281

285 report_and_exit_on_error, false,

286 "%s", cmd);

287

288

289 if (!pg_ctl_return && !report_and_exit_on_error)

290 return false;

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305 if (pg_ctl_return)

307

308

309

310

311

312

313

316 {

321 pg_fatal("could not connect to source postmaster started with the command:\n"

322 "%s",

323 cmd);

324 else

325 pg_fatal("could not connect to target postmaster started with the command:\n"

326 "%s",

327 cmd);

328 }

330

331

332

333

334

335

336 if (!pg_ctl_return)

337 {

339 pg_fatal("pg_ctl failed to start the source server, or connection failed");

340 else

341 pg_fatal("pg_ctl failed to start the target server, or connection failed");

342 }

343

344 return true;

345}

346

347

348void

350{

352

357 else

358 return;

359

361 "\"%s/pg_ctl\" -w -D \"%s\" -o \"%s\" %s stop",

364 in_atexit ? "-m fast" : "-m smart");

365

367}

368

369

370

371

372

373

374

375void

377{

380

381

382

384

387

389 {

390 if (option->envvar && (strcmp(option->envvar, "PGHOST") == 0 ||

391 strcmp(option->envvar, "PGHOSTADDR") == 0))

392 {

393 const char *value = getenv(option->envvar);

394

396

397 (strcmp(value, "localhost") != 0 && strcmp(value, "127.0.0.1") != 0 &&

399 pg_fatal("libpq environment variable %s has a non-local server value: %s",

401 }

402 }

403

404

406}

bool exec_prog(const char *log_filename, const char *opt_log_file, bool report_error, bool exit_on_error, const char *fmt,...)

void cluster(ParseState *pstate, ClusterStmt *stmt, bool isTopLevel)

#define ALWAYS_SECURE_SEARCH_PATH_SQL

PGconn * PQconnectdb(const char *conninfo)

void PQconninfoFree(PQconninfoOption *connOptions)

ConnStatusType PQstatus(const PGconn *conn)

void PQfinish(PGconn *conn)

PQconninfoOption * PQconndefaults(void)

char * PQerrorMessage(const PGconn *conn)

ExecStatusType PQresultStatus(const PGresult *res)

void PQclear(PGresult *res)

PGresult * PQexec(PGconn *conn, const char *query)

#define SERVER_START_LOG_FILE

#define SERVER_STOP_LOG_FILE

void void pg_log(eLogType type, const char *fmt,...) pg_attribute_printf(2

#define GET_MAJOR_VERSION(v)

static bool is_unixsock_path(const char *path)

PQExpBuffer createPQExpBuffer(void)

void initPQExpBuffer(PQExpBuffer str)

void resetPQExpBuffer(PQExpBuffer str)

void appendPQExpBuffer(PQExpBuffer str, const char *fmt,...)

void appendPQExpBufferChar(PQExpBuffer str, char ch)

void appendPQExpBufferStr(PQExpBuffer str, const char *data)

void termPQExpBuffer(PQExpBuffer str)

static PGconn * get_db_conn(ClusterInfo *cluster, const char *db_name)

void check_pghost_envvar(void)

bool start_postmaster(ClusterInfo *cluster, bool report_and_exit_on_error)

PGresult * executeQueryOrDie(PGconn *conn, const char *fmt,...)

PGconn * connectToServer(ClusterInfo *cluster, const char *db_name)

void stop_postmaster(bool in_atexit)

uint32 get_major_server_version(ClusterInfo *cluster)

char * cluster_conn_opts(ClusterInfo *cluster)

static void stop_postmaster_atexit(void)

void appendShellString(PQExpBuffer buf, const char *str)

void appendConnStrVal(PQExpBuffer buf, const char *str)

ClusterInfo * running_cluster