gitorious.org Git - online-glom:gwt-glom.git/blob - src/test/java/org/glom/web/server/SelfHoster.java

1 /*

3 *

4 * This file is part of GWT-Glom.

5 *

6 * GWT-Glom is free software: you can redistribute it and/or modify it

7 * under the terms of the GNU Lesser General Public License as published by the

8 * Free Software Foundation, either version 3 of the License, or (at your

9 * option) any later version.

10 *

11 * GWT-Glom is distributed in the hope that it will be useful, but WITHOUT

12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License

14 * for more details.

15 *

16 * You should have received a copy of the GNU Lesser General Public License

17 * along with GWT-Glom. If not, see <http://www.gnu.org/licenses/>.

18 */

19

20 package org.glom.web.server;

21

22 import java.io.BufferedReader;

23 import java.io.File;

24 import java.io.FileNotFoundException;

25 import java.io.FileOutputStream;

26 import java.io.IOException;

27 import java.io.InputStream;

28 import java.io.InputStreamReader;

29 import java.net.ServerSocket;

30 import java.sql.Connection;

31 import java.sql.DriverManager;

32 import java.sql.SQLException;

33 import java.util.ArrayList;

34 import java.util.List;

35 import java.util.Locale;

36 import java.util.Map;

37 import java.util.Map.Entry;

38 import java.util.Properties;

39

40 import org.apache.commons.lang3.StringUtils;

41 import org.glom.web.server.libglom.Document;

42 import org.glom.web.shared.DataItem;

43 import org.glom.web.shared.libglom.Field;

44 import org.jooq.InsertResultStep;

45 import org.jooq.InsertSetStep;

46 import org.jooq.Record;

47 import org.jooq.SQLDialect;

48 import org.jooq.Table;

49 import org.jooq.exception.DataAccessException;

50 import org.jooq.impl.Factory;

51

52 import com.google.common.io.Files;

53 import com.ibm.icu.text.NumberFormat;

54

55 /**

56 * @author Murray Cumming <murrayc@murrayc.com>

57 *

58 */

59 public class SelfHoster {

60 // private String tempFilepathDir = "";

61 private boolean selfHostingActive = false;

62 private Document document = null;

63 private String username = "";

64 private String password = "";

65

66 SelfHoster(final Document document) {

67 this.document = document;

68 }

69

70 private static final int PORT_POSTGRESQL_SELF_HOSTED_START = 5433;

71 private static final int PORT_POSTGRESQL_SELF_HOSTED_END = 5500;

72

73 private static final String DEFAULT_CONFIG_PG_HBA_LOCAL_8p4 = "# TYPE DATABASE USER CIDR-ADDRESS METHOD\n"

74 + "\n"

75 + "# local is for Unix domain socket connections only\n"

76 + "# trust allows connection from the current PC without a password:\n"

77 + "local all all trust\n"

78 + "local all all ident\n"

79 + "local all all md5\n"

80 + "\n"

81 + "# TCP connections from the same computer, with a password:\n"

82 + "host all all 127.0.0.1 255.255.255.255 md5\n"

83 + "# IPv6 local connections:\n"

84 + "host all all ::1/128 md5\n";

85

86 private static final String DEFAULT_CONFIG_PG_IDENT = "";

87 private static final String FILENAME_DATA = "data";

88

89 public boolean createAndSelfHostFromExample(final Document.HostingMode hostingMode) {

90

91 if (!createAndSelfHostNewEmpty(hostingMode)) {

92 // std::cerr << G_STRFUNC << ": test_create_and_selfhost_new_empty() failed." << std::endl;

93 return false;

94 }

95

96 final boolean recreated = recreateDatabaseFromDocument(); /* TODO: Progress callback */

97 if (!recreated) {

98 if(!cleanup()) {

99 return false;

100 }

101 }

102

103 return recreated;

104 }

105

106 /**

107 * @param document

108 * @param

109 * @param subDirectoryPath

110 * @return

111 */

112 private boolean createAndSelfHostNewEmpty(final Document.HostingMode hostingMode) {

113 if (hostingMode != Document.HostingMode.HOSTING_MODE_POSTGRES_SELF) {

114 // TODO: std::cerr << G_STRFUNC << ": This test function does not support the specified hosting_mode: " <<

115 // hosting_mode << std::endl;

116 return false;

117 }

118

119 // Save a copy, specifying the path to file in a directory:

120 // For instance, /tmp/testglom/testglom.glom");

121 final String tempFilename = "testglom";

122 final File tempFolder = Files.createTempDir();

123 final File tempDir = new File(tempFolder, tempFilename);

124

125 final String tempDirPath = tempDir.getPath();

126 final String tempFilePath = tempDirPath + File.separator + tempFilename;

127 final File file = new File(tempFilePath);

128

129 // Make sure that the file does not exist yet:

130 {

131 tempDir.delete();

132 }

133

134 // Save the example as a real file:

135 document.setFileURI(file.getPath());

136

137 document.setHostingMode(hostingMode);

138 document.setIsExampleFile(false);

139 final boolean saved = document.save();

140 if (!saved) {

141 System.out.println("createAndSelfHostNewEmpty(): Document.save() failed.");

142 return false; // TODO: Delete the directory.

143 }

144

145 // We must specify a default username and password:

146 final String user = "glom_default_developer_user";

147 final String password = "glom_default_developer_password";

148

149 // Create the self-hosting files:

150 if (!initialize(user, password)) {

151 System.out.println("createAndSelfHostNewEmpty(): initialize failed.");

152 // TODO: Delete directory.

153 }

154

155 // Check that it really created some files:

156 if (!tempDir.exists()) {

157 System.out.println("createAndSelfHostNewEmpty(): tempDir does not exist.");

158 // TODO: Delete directory.

159 }

160

161 return selfHost(user, password);

162 }

163

164 /**

165 * @param document

166 * @param user

167 * @param password

168 * @return

169 */

170 private boolean selfHost(final String user, final String password) {

171 // TODO: m_network_shared = network_shared;

172

173 if (getSelfHostingActive()) {

174 // TODO: std::cerr << G_STRFUNC << ": Already started." << std::endl;

175 return false; // STARTUPERROR_NONE; //Just do it once.

176 }

177

178 final String dbDirData = getSelfHostingDataPath(false);

179 if (StringUtils.isEmpty(dbDirData) || !fileExists(dbDirData)) {

180 /*

181 * final String dbDirBackup = dbDir + File.separator + FILENAME_BACKUP;

182 *

183 * if(fileExists(dbDirBackup)) { //TODO: std::cerr << G_STRFUNC <<

184 * ": There is no data, but there is backup data." << std::endl; //Let the caller convert the backup to real

185 * data and then try again: return false; // STARTUPERROR_FAILED_NO_DATA_HAS_BACKUP_DATA; } else {

186 */

187 // TODO: std::cerr << "ConnectionPool::create_self_hosting(): The data sub-directory could not be found." <<

188 // dbdir_data_uri << std::endl;

189 return false; // STARTUPERROR_FAILED_NO_DATA;

190 // }

191 }

192

193 final int availablePort = discoverFirstFreePort(PORT_POSTGRESQL_SELF_HOSTED_START,

194 PORT_POSTGRESQL_SELF_HOSTED_END);

195 // std::cout << "debug: " << G_STRFUNC << ":() : debug: Available port for self-hosting: " << available_port <<

196 // std::endl;

197 if (availablePort == 0) {

198 // TODO: Use a return enum or exception so we can tell the user about this:

199 // TODO: std::cerr << G_STRFUNC << ": No port was available between " << PORT_POSTGRESQL_SELF_HOSTED_START

200 // << " and " << PORT_POSTGRESQL_SELF_HOSTED_END << std::endl;

201 return false; // STARTUPERROR_FAILED_UNKNOWN_REASON;

202 }

203

204 final NumberFormat format = NumberFormat.getInstance(Locale.US);

205 format.setGroupingUsed(false); // TODO: Does this change it system-wide?

206 final String portAsText = format.format(availablePort);

207

208 // -D specifies the data directory.

209 // -c config_file= specifies the configuration file

210 // -k specifies a directory to use for the socket. This must be writable by us.

211 // Make sure to use double quotes for the executable path, because the

212 // CreateProcess() API used on Windows does not support single quotes.

213 final String dbDir = getSelfHostingPath("", false);

214 final String dbDirConfig = getSelfHostingPath("config", false);

215 final String dbDirHba = dbDirConfig + File.separator + "pg_hba.conf";

216 final String dbDirIdent = dbDirConfig + File.separator + "pg_ident.conf";

217 final String dbDirPid = getSelfHostingPath("pid", false);

218

219 // Note that postgres returns this error if we split the arguments more,

220 // for instance splitting -D and dbDirData into separate strings:

221 // too many command-line arguments (first is "(null)")

222 // Note: If we use "-D " instead of "-D" then the initdb seems to make the space part of the filepath,

223 // though that does not happen with the normal command line.

224 // However, we must have a space after -k.

225 // Also, the c hba_file=path argument must be split after -c, or postgres will get a " hba_file" configuration

226 // parameter instead of "hba_file".

227 final String commandPathStart = getPathToPostgresExecutable("postgres");

228 if(StringUtils.isEmpty(commandPathStart)) {

229 System.out.println("selfHost(): getPathToPostgresExecutable(postgres) failed.");

230 return false;

231 }

232 final ProcessBuilder commandPostgresStart = new ProcessBuilder(commandPathStart, "-D"

233 + shellQuote(dbDirData), "-p", portAsText, "-i", // Equivalent to -h "*", which in turn is equivalent

234 // to

235 // listen_addresses in postgresql.conf. Listen to all IP addresses,

236 // so any client can connect (with a username+password)

237 "-c", "hba_file=" + shellQuote(dbDirHba), "-c", "ident_file=" + shellQuote(dbDirIdent), "-k"

238 + shellQuote(dbDir), "--external_pid_file=" + shellQuote(dbDirPid));

239 // std::cout << G_STRFUNC << ": debug: " << command_postgres_start << std::endl;

240

241 // Make sure to use double quotes for the executable path, because the

242 // CreateProcess() API used on Windows does not support single quotes.

243 //

244 // Note that postgres returns this error if we split the arguments more,

245 // for instance splitting -D and dbDirData into separate strings:

246 // too many command-line arguments (first is "(null)")

247 // Note: If we use "-D " instead of "-D" then the initdb seems to make the space part of the filepath,

248 // though that does not happen with the normal command line.

249 final String commandPathCheck = getPathToPostgresExecutable("pg_ctl");

250 if(StringUtils.isEmpty(commandPathCheck)) {

251 System.out.println("selfHost(): getPathToPostgresExecutable(pg_ctl) failed.");

252 return false;

253 }

254 final ProcessBuilder commandCheckPostgresHasStarted = new ProcessBuilder(commandPathCheck,

255 "status", "-D" + shellQuote(dbDirData));

256

257 // For postgres 8.1, this is "postmaster is running".

258 // For postgres 8.2, this is "server is running".

259 // This is a big hack that we should avoid. murrayc.

260 //

261 // pg_ctl actually seems to return a 0 result code for "is running" and a 1 for not running, at least with

262 // Postgres 8.2,

263 // so maybe we can avoid this in future.

264 // Please do test it with your postgres version, using "echo $?" to see the result code of the last command.

265 final String secondCommandSuccessText = "is running"; // TODO: This is not a stable API. Also, watch out for

266 // localisation.

267

268 // The first command does not return, but the second command can check whether it succeeded:

269 // TODO: Progress

270 final boolean result = executeCommandLineAndWaitUntilSecondCommandReturnsSuccess(commandPostgresStart,

271 commandCheckPostgresHasStarted, secondCommandSuccessText);

272 if (!result) {

273 System.out.println("selfHost(): Error while attempting to self-host a database.");

274 return false; // STARTUPERROR_FAILED_UNKNOWN_REASON;

275 }

276

277 // Remember the port for later:

278 document.setConnectionPort(availablePort);

279

280 //Check that we can really connect:

281

282 //pg_ctl sometimes reports success before it is really ready to let us connect,

283 //so in this case we can just keep trying until it works, for a while:

284 for(int i = 0; i < 10; i++) {

285

286 try {

287 Thread.sleep(1000);

288 } catch (InterruptedException e) {

289 // TODO Auto-generated catch block

290 e.printStackTrace();

291 }

292

293 final String dbName = document.getConnectionDatabase();

294 document.setConnectionDatabase(""); //We have not created the database yet.

295 final Connection connection = createConnection();

296 document.setConnectionDatabase(dbName);

297 if(connection != null) {

298 return true; // STARTUPERROR_NONE;

299 }

300

301 System.out.println("selfHost(): Waiting and retrying the connection due to suspected too-early success of pg_ctl. retries=" + i);

302 }

303

304 System.out.println("selfHost(): Test connection failed after multiple retries.");

305 return false;

306 }

307

308 /**

309 * @param dbDirData

310 * @return

311 */

312 private String shellQuote(final String str) {

313 // TODO: If we add the quotes then they seem to be used as part of the path, though that is not a problem with

314 // the normal command line.

315 return str;

316

317 // TODO: Escape.

318 // return "'" + str + "'";

319 }

320

321 private String getSelfHostingPath(final String subpath, final boolean create) {

322 final String dbDir = document.getSelfHostedDirectoryPath();

323 if (StringUtils.isEmpty(subpath)) {

324 return dbDir;

325 }

326

327 final String dbDirData = dbDir + File.separator + subpath;

328 final File file = new File(dbDirData);

329

330 // Return the path regardless of whether it exists:

331 if (!create) {

332 return dbDirData;

333 }

334

335 if (!file.exists()) {

336 try {

337 Files.createParentDirs(file);

338 } catch (final IOException e) {

339 // TODO Auto-generated catch block

340 e.printStackTrace();

341 return "";

342 }

343

344 if (!file.mkdir()) {

345 return "";

346 }

347 }

348

349 return dbDirData;

350 }

351

352 private String getSelfHostingDataPath(final boolean create) {

353 return getSelfHostingPath(FILENAME_DATA, create);

354 }

355

356 private boolean executeCommandLineAndWait(final ProcessBuilder command) {

357

358 command.redirectErrorStream(true);

359

360 // Run the first command, and wait for it to return:

361 Process process = null;

362 try {

363 process = command.start();

364 } catch (final IOException e) {

365 // TODO Auto-generated catch block

366 e.printStackTrace();

367 return false;

368 }

369

370 final InputStream stderr = process.getInputStream();

371 final InputStreamReader isr = new InputStreamReader(stderr);

372 final BufferedReader br = new BufferedReader(isr);

373 String output = "";

374 String line;

375 /*

376 * try { //TODO: readLine() can hang, waiting for an end of line that never comes. while ((line = br.readLine())

377 * != null) { output += line + "\n"; } } catch (final IOException e1) { e1.printStackTrace(); return false; }

378 */

379

380 int result = 0;

381 try {

382 result = process.waitFor();

383 } catch (final InterruptedException e) {

384 // TODO Auto-generated catch block

385 e.printStackTrace();

386 return false;

387 }

388

389 if (result != 0) {

390 System.out.println("executeCommandLineAndWait(): Command failed: " + command.command().toString());

391 System.out.print(" Output: " + output);

392 return false;

393 }

394

395 return true;

396 }

397

398 private boolean executeCommandLineAndWaitUntilSecondCommandReturnsSuccess(final ProcessBuilder command,

399 final ProcessBuilder commandSecond, final String secondCommandSuccessText) {

400 command.redirectErrorStream(true);

401

402 // Run the first command, and do not wait for it to return:

403 Process process = null;

404 try {

405 process = command.start();

406 } catch (final IOException e) {

407 // TODO Auto-generated catch block

408 e.printStackTrace();

409 return false;

410 }

411

412 final InputStream stderr = process.getInputStream();

413 final InputStreamReader isr = new InputStreamReader(stderr);

414 final BufferedReader br = new BufferedReader(isr);

415

416 /*

417 * We do not wait, because this (postgres, for instance), does not return: final int result = process.waitFor();

418 * if (result != 0) { // TODO: Warn. return false; }

419 */

420

421 // Now run the second command, usually to verify that the first command has really done its work:

422 // We run this repeatedly until it succeeds, to show that the first command has finished.

423 boolean result = false;

424 while (true) {

425 result = executeCommandLineAndWait(commandSecond);

426 if (result) {

427 System.out.println("executeCommandLineAndWait(): second command succeeded.");

428 return true;

429 } else {

430 try {

431 Thread.sleep(1000);

432 } catch (InterruptedException e) {

433 // TODO Auto-generated catch block

434 e.printStackTrace();

435 return false;

436 }

437

438 System.out.println("executeCommandLineAndWait(): Trying the second command again.");

439 }

440 }

441

442 // Try to get the output:

443 /*

444 * if (!result) { String output = ""; /* String line; try { // TODO: readLine() can hang, waiting for an end of

445 * line that never comes. while ((line = br.readLine()) != null) { output += line + "\n";

446 * System.out.println(line); } } catch (final IOException e1) { // TODO Auto-generated catch block

447 * e1.printStackTrace(); return false; }

448 */

449

450 // System.out.println(" Output of first command: " + output);

451 // System.out.println(" first command: " + command.command().toString());

452 // System.out.println(" second command: " + commandSecond.command().toString());

453 // }

454 }

455

456 /**

457 * @param string

458 * @return

459 */

460 private static String getPathToPostgresExecutable(final String string) {

461 final List<String> dirPaths = new ArrayList<String>();

462 dirPaths.add("/usr/bin");

463 dirPaths.add("/usr/lib/postgresql/9.1/bin");

464 dirPaths.add("/usr/lib/postgresql/9.0/bin");

465 dirPaths.add("/usr/lib/postgresql/8.4/bin");

466

467 for(String dir : dirPaths) {

468 final String path = dir + File.separator + string;

469 if(fileExistsAndIsExecutable(path)) {

470 return path;

471 }

472 }

473

474 return "";

475 }

476

477 /**

478 * @param path

479 * @return

480 */

481 private static boolean fileExistsAndIsExecutable(String path) {

482 final File file = new File(path);

483 if(!file.exists()) {

484 return false;

485 }

486

487 if(!file.canExecute()) {

488 return false;

489 }

490

491 return true;

492 }

493

494 /**

495 * @param start

496 * @param end

497 * @return

498 */

499 private static int discoverFirstFreePort(final int start, final int end) {

500 for (int port = start; port <= end; ++port) {

501 try {

502 final ServerSocket socket = new ServerSocket(port);

503

504 // If the instantiation succeeded then the port was free:

505 return socket.getLocalPort(); // This must equal port.

506 } catch (final IOException ex) {

507 continue; // try next port

508 }

509 }

510

511 return 0;

512 }

513

514 /**

515 * @param dbDir

516 * @return

517 */

518 private static boolean fileExists(final String filePath) {

519 final File file = new File(filePath);

520 return file.exists();

521 }

522

523 /**

524 * @return

525 */

526 private boolean getSelfHostingActive() {

527 return selfHostingActive;

528 }

529

530 /**

531 * @param cpds

532 * @return

533 */

534 private boolean initialize(final String initialUsername, final String initialPassword) {

535 if (!initializeConfFiles()) {

536 System.out.println("initialize(): initializeConfFiles() failed.");

537 return false;

538 }

539

540 // initdb creates a new postgres database cluster:

541

542 // Get file:// URI for the tmp/ directory:

543 File filePwFile = null;

544 try {

545 filePwFile = File.createTempFile("glom_initdb_pwfile", "");

546 } catch (final IOException e) {

547 // TODO Auto-generated catch block

548 e.printStackTrace();

549 }

550 final String tempPwFile = filePwFile.getPath();

551

552 final boolean pwfileCreationSucceeded = createTextFile(tempPwFile, initialPassword);

553 if (!pwfileCreationSucceeded) {

554 System.out.println("initialize(): createTextFile() failed.");

555 return false;

556 }

557

558 // Make sure to use double quotes for the executable path, because the

559 // CreateProcess() API used on Windows does not support single quotes.

560 final String dbDirData = getSelfHostingDataPath(false /* create */);

561

562 // Note that initdb returns this error if we split the arguments more,

563 // for instance splitting -D and dbDirData into separate strings:

564 // too many command-line arguments (first is "(null)")

565 // TODO: If we quote tempPwFile then initdb says that it cannot find it.

566 // Note: If we use "-D " instead of "-D" then the initdb seems to make the space part of the filepath,

567 // though that does not happen with the normal command line.

568 boolean result = false;

569 final String commandPath = getPathToPostgresExecutable("initdb");

570 if(StringUtils.isEmpty(commandPath)) {

571 System.out.println("initialize(): getPathToPostgresExecutable(initdb) failed.");

572 } else {

573 final ProcessBuilder commandInitdb = new ProcessBuilder(commandPath, "-D"

574 + shellQuote(dbDirData), "-U", initialUsername, "--pwfile=" + tempPwFile);

575

576 // Note that --pwfile takes the password from the first line of a file. It's an alternative to supplying it when

577 // prompted on stdin.

578 result = executeCommandLineAndWait(commandInitdb);

579 }

580

581 // Of course, we don't want this to stay around. It would be a security risk.

582 final File fileTempPwFile = new File(tempPwFile);

583 if (!fileTempPwFile.delete()) {

584 System.out.println("initialize(): Failed to delete the password file.");

585 }

586

587 if (!result) {

588 System.out.println("initialize(): Error while attempting to create self-hosting database.");

589 return false;

590 }

591

592 // Save the username and password for later;

593 this.username = initialUsername;

594 this.password = initialPassword;

595

596 return result; // ? INITERROR_NONE : INITERROR_COULD_NOT_START_SERVER;

597

598 }

599

600 private boolean initializeConfFiles() {

601 final String dataDirPath = document.getSelfHostedDirectoryPath();

602

603 final String dbDirConfig = dataDirPath + File.separator + "config";

604 // String defaultConfContents = "";

605

606 // Choose the configuration contents based on the postgresql version

607 // and whether we want to be network-shared:

608 // final float postgresqlVersion = 9.0f; //TODO: get_postgresql_utils_version_as_number(slot_progress);

609 // final boolean networkShared = true;

610 // std::cout << "DEBUG: postgresql_version=" << postgresql_version << std::endl;

611

612 // TODO: Support the other configurations, as in libglom.

613 final String defaultConfContents = DEFAULT_CONFIG_PG_HBA_LOCAL_8p4;

614

615 // std::cout << "DEBUG: default_conf_contents=" << default_conf_contents << std::endl;

616

617 final boolean hbaConfCreationSucceeded = createTextFile(dbDirConfig + File.separator + "pg_hba.conf",

618 defaultConfContents);

619 if (!hbaConfCreationSucceeded) {

620 System.out.println("initialize(): createTextFile() failed.");

621 return false;

622 }

623

624 final boolean identConfCreationSucceeded = createTextFile(dbDirConfig + File.separator + "pg_ident.conf",

625 DEFAULT_CONFIG_PG_IDENT);

626 if (!identConfCreationSucceeded) {

627 System.out.println("initialize(): createTextFile() failed.");

628 return false;

629 }

630

631 return true;

632 }

633

634 /**

635 * @param path

636 * @param contents

637 * @return

638 */

639 private static boolean createTextFile(final String path, final String contents) {

640 final File file = new File(path);

641 final File parent = file.getParentFile();

642 if (parent == null) {

643 System.out.println("initialize(): getParentFile() failed.");

644 return false;

645 }

646

647 parent.mkdirs();

648 try {

649 file.createNewFile();

650 } catch (final IOException e) {

651 // TODO Auto-generated catch block

652 e.printStackTrace();

653 return false;

654 }

655

656 FileOutputStream output = null;

657 try {

658 output = new FileOutputStream(file);

659 } catch (final FileNotFoundException e) {

660 // TODO Auto-generated catch block

661 e.printStackTrace();

662 return false;

663 }

664

665 try {

666 output.write(contents.getBytes());

667 } catch (final IOException e) {

668 // TODO Auto-generated catch block

669 e.printStackTrace();

670 return false;

671 }

672

673 return true;

674 }

675

676 /**

677 * @param document

678 * @return

679 */

680 private boolean recreateDatabaseFromDocument() {

681 // Check whether the database exists already.

682 final String dbName = document.getConnectionDatabase();

683 if (StringUtils.isEmpty(dbName)) {

684 return false;

685 }

686

687 document.setConnectionDatabase(dbName);

688 Connection connection = createConnection();

689 if (connection != null) {

690 // Connection to the database succeeded, so the database

691 // exists already.

692 try {

693 connection.close();

694 } catch (final SQLException e) {

695 // TODO Auto-generated catch block

696 e.printStackTrace();

697 }

698 return false;

699 }

700

701 // Create the database:

702 progress();

703 document.setConnectionDatabase("");

704

705 connection = createConnection();

706 if (connection == null) {

707 System.out.println("recreatedDatabase(): createConnection() failed, before creating the database.");

708 return false;

709 }

710

711 final boolean dbCreated = createDatabase(connection, dbName);

712

713 if (!dbCreated) {

714 return false;

715 }

716

717 progress();

718

719 // Check that we can connect:

720 try {

721 connection.close();

722 } catch (final SQLException e) {

723 // TODO Auto-generated catch block

724 e.printStackTrace();

725 }

726 connection = null;

727

728 document.setConnectionDatabase(dbName);

729 connection = createConnection();

730 if (connection == null) {

731 System.out.println("recreatedDatabase(): createConnection() failed, after creating the database.");

732 return false;

733 }

734

735 progress();

736

737 // Create each table:

738 final List<String> tables = document.getTableNames();

739 for (final String tableName : tables) {

740

741 // Create SQL to describe all fields in this table:

742 final List<Field> fields = document.getTableFields(tableName);

743

744 progress();

745 final boolean tableCreationSucceeded = createTable(connection, document, tableName, fields);

746 progress();

747 if (!tableCreationSucceeded) {

748 // TODO: std::cerr << G_STRFUNC << ": CREATE TABLE failed with the newly-created database." <<

749 // std::endl;

750 return false;

751 }

752 }

753

754 // Note that create_database() has already called add_standard_tables() and add_standard_groups(document).

755

756 // Add groups from the document:

757 progress();

758 if (!addGroupsFromDocument(document)) {

759 // TODO: std::cerr << G_STRFUNC << ": add_groups_from_document() failed." << std::endl;

760 return false;

761 }

762

763 // Set table privileges, using the groups we just added:

764 progress();

765 if (!setTablePrivilegesGroupsFromDocument(document)) {

766 // TODO: std::cerr << G_STRFUNC << ": set_table_privileges_groups_from_document() failed." << std::endl;

767 return false;

768 }

769

770 for (final String tableName : tables) {

771 // Add any example data to the table:

772 progress();

773

774 // try

775 // {

776 progress();

777 final boolean tableInsertSucceeded = insertExampleData(connection, document, tableName);

778

779 if (!tableInsertSucceeded) {

780 // TODO: std::cerr << G_STRFUNC << ": INSERT of example data failed with the newly-created database." <<

781 // std::endl;

782 return false;

783 }

784 // }

785 // catch(final std::exception& ex)

786 // {

787 // std::cerr << G_STRFUNC << ": exception: " << ex.what() << std::endl;

788 // HandleError(ex);

789 // }

790

791 } // for(tables)

792

793 return true; // All tables created successfully.

794 }

795

796 /**

797 * @return

798 * @throws SQLException

799 */

800 private Connection createConnection() {

801 final Properties connectionProps = new Properties();

802 connectionProps.put("user", this.username);

803 connectionProps.put("password", this.password);

804

805 String jdbcURL = "jdbc:postgresql://" + document.getConnectionServer() + ":" + document.getConnectionPort();

806 String db = document.getConnectionDatabase();

807 if (StringUtils.isEmpty(db)) {

808 // Use the default PostgreSQL database, because ComboPooledDataSource.connect() fails otherwise.

809 db = "template1";

810 }

811 jdbcURL += "/" + db; // TODO: Quote the database name?

812

813 Connection conn = null;

814 try {

815 conn = DriverManager.getConnection(jdbcURL + "/", connectionProps);

816 } catch (final SQLException e) {

817 //e.printStackTrace();

818 return null;

819 }

820

821 return conn;

822 }

823

824 /**

825 *

826 */

827 private void progress() {

828 // TODO Auto-generated method stub

829

830 }

831

832 /**

833 * @param document

834 * @param tableName

835 * @return

836 */

837 private boolean insertExampleData(final Connection connection, final Document document, final String tableName) {

838

839 final Factory factory = new Factory(connection, SQLDialect.POSTGRES);

840 final Table<Record> table = Factory.tableByName(tableName);

841

842 final List<Map<String, DataItem>> exampleRows = document.getExampleRows(tableName);

843 for (final Map<String, DataItem> row : exampleRows) {

844 InsertSetStep<Record> insertStep = factory.insertInto(table);

845

846 for (final Entry<String, DataItem> entry : row.entrySet()) {

847 final String fieldName = entry.getKey();

848 final DataItem value = entry.getValue();

849 if (value == null) {

850 continue;

851 }

852

853 final Field field = document.getField(tableName, fieldName);

854 if (field == null) {

855 continue;

856 }

857

858 final org.jooq.Field<Object> jooqField = Factory.fieldByName(field.getName());

859 if (jooqField == null) {

860 continue;

861 }

862

863 final Object fieldValue = value.getValue(field.getGlomType());

864 insertStep = insertStep.set(jooqField, fieldValue);

865 }

866

867 if (!(insertStep instanceof InsertResultStep<?>)) {

868 continue;

869 }

870

871 // We suppress the warning because we _do_ check the cast above.

872 @SuppressWarnings("unchecked")

873 final InsertResultStep<Record> insertResultStep = (InsertResultStep<Record>) insertStep;

874

875 try {

876 insertResultStep.fetchOne();

877 } catch (final DataAccessException e) {

878 // e.printStackTrace();

879 return false;

880 }

881 // TODO: Check that it worked.

882 }

883

884 return true;

885 }

886

887 /**

888 * @param document2

889 * @return

890 */

891 private boolean setTablePrivilegesGroupsFromDocument(final Document document2) {

892 // TODO Auto-generated method stub

893 return true;

894 }

895

896 /**

897 * @param document2

898 * @return

899 */

900 private boolean addGroupsFromDocument(final Document document2) {

901 // TODO Auto-generated method stub

902 return true;

903 }

904

905 /**

906 * @param document

907 * @param tableName

908 * @param fields

909 * @return

910 */

911 private boolean createTable(final Connection connection, final Document document, final String tableName,

912 final List<Field> fields) {

913 boolean tableCreationSucceeded = false;

914

915 /*

916 * TODO: //Create the standard field too: //(We don't actually use this yet) if(std::find_if(fields.begin(),

917 * fields.end(), predicate_FieldHasName<Field>(GLOM_STANDARD_FIELD_LOCK)) == fields.end()) { sharedptr<Field>

918 * field = sharedptr<Field>::create(); field->set_name(GLOM_STANDARD_FIELD_LOCK);

919 * field->set_glom_type(Field::TYPE_TEXT); fields.push_back(field); }

920 */

921

922 // Create SQL to describe all fields in this table:

923 String sqlFields = "";

924 for (final Field field : fields) {

925 // Create SQL to describe this field:

926 String sqlFieldDescription = escapeSqlId(field.getName()) + " " + field.getSqlType();

927

928 if (field.getPrimaryKey()) {

929 sqlFieldDescription += " NOT NULL PRIMARY KEY";

930 }

931

932 // Append it:

933 if (!StringUtils.isEmpty(sqlFields)) {

934 sqlFields += ", ";

935 }

936

937 sqlFields += sqlFieldDescription;

938 }

939

940 if (StringUtils.isEmpty(sqlFields)) {

941 // TODO: std::cerr << G_STRFUNC << ": sql_fields is empty." << std::endl;

942 }

943

944 // Actually create the table

945 final String query = "CREATE TABLE " + escapeSqlId(tableName) + " (" + sqlFields + ");";

946 final Factory factory = new Factory(connection, SQLDialect.POSTGRES);

947 factory.execute(query);

948 tableCreationSucceeded = true;

949 if (!tableCreationSucceeded) {

950 System.out.println("recreatedDatabase(): CREATE TABLE() failed.");

951 }

952

953 return tableCreationSucceeded;

954 }

955

956 /**

957 * @param name

958 * @return

959 */

960 private String escapeSqlId(final String name) {

961 // TODO:

962 return "\"" + name + "\"";

963 }

964

965 /**

966 * @return

967 */

968 private static boolean createDatabase(final Connection connection, final String databaseName) {

969

970 final String query = "CREATE DATABASE \"" + databaseName + "\""; // TODO: Escaping.

971 final Factory factory = new Factory(connection, SQLDialect.POSTGRES);

972

973 factory.execute(query);

974

975 return true;

976 }

977

978 /**

979 *

980 */

981 public boolean cleanup() {

982 boolean result = true;

983

984 // Stop the server:

985 if ((document != null) && (document.getConnectionPort() != 0)) {

986 final String dbDirData = getSelfHostingDataPath(false);

987

988 // -D specifies the data directory.

989 // -c config_file= specifies the configuration file

990 // -k specifies a directory to use for the socket. This must be writable by us.

991 // We use "-m fast" instead of the default "-m smart" because that waits for clients to disconnect (and

992 // sometimes never succeeds).

993 // TODO: Warn about connected clients on other computers? Warn those other users?

994 // Make sure to use double quotes for the executable path, because the

995 // CreateProcess() API used on Windows does not support single quotes.

996 final String commandPath = getPathToPostgresExecutable("pg_ctl");

997 if(StringUtils.isEmpty(commandPath)) {

998 System.out.println("cleanup(): getPathToPostgresExecutable(pg_ctl) failed.");

999 } else {

1000 final ProcessBuilder commandPostgresStop = new ProcessBuilder(commandPath, "-D"

1001 + shellQuote(dbDirData), "stop", "-m", "fast");

1002 result = executeCommandLineAndWait(commandPostgresStop);

1003 if (!result) {

1004 System.out.println("cleanup(): Failed to stop the PostgreSQL server.");

1005 }

1006 }

1007

1008 document.setConnectionPort(0);

1009 }

1010

1011 // Delete the files:

1012 final String selfhostingPath = getSelfHostingPath("", false);

1013 final File fileSelfHosting = new File(selfhostingPath);

1014 fileSelfHosting.delete();

1015

1016 final String docPath = document.getFileURI();

1017 final File fileDoc = new File(docPath);

1018 fileDoc.delete();

1019

1020 return result;

1021 }

1022 }