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.File;

23 import java.io.FileNotFoundException;

24 import java.io.FileOutputStream;

25 import java.io.IOException;

26 import java.net.ServerSocket;

27 import java.sql.Connection;

28 import java.sql.DriverManager;

29 import java.sql.SQLException;

30 import java.util.ArrayList;

31 import java.util.List;

32 import java.util.Locale;

33 import java.util.Map;

34 import java.util.Map.Entry;

35 import java.util.Properties;

36

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

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

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

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

41 import org.jooq.InsertResultStep;

42 import org.jooq.InsertSetStep;

43 import org.jooq.Record;

44 import org.jooq.SQLDialect;

45 import org.jooq.Table;

46 import org.jooq.exception.DataAccessException;

47 import org.jooq.impl.Factory;

48

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

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

51

52 /**

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

54 *

55 */

56 public class SelfHoster {

57 // private String tempFilepathDir = "";

58 private boolean selfHostingActive = false;

59 private Document document = null;

60 private String username = "";

61 private String password = "";

62

63 SelfHoster(final Document document) {

64 this.document = document;

65 }

66

67 private static final int PORT_POSTGRESQL_SELF_HOSTED_START = 5433;

68 private static final int PORT_POSTGRESQL_SELF_HOSTED_END = 5500;

69

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

71 + "\n"

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

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

74 + "local all all trust\n"

75 + "local all all ident\n"

76 + "local all all md5\n"

77 + "\n"

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

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

80 + "# IPv6 local connections:\n"

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

82

83 private static final String DEFAULT_CONFIG_PG_IDENT = "";

84 private static final String FILENAME_DATA = "data";

85

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

87

88 if (!createAndSelfHostNewEmpty(hostingMode)) {

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

90 return false;

91 }

92

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

94 if (!recreated) {

95 if (!cleanup()) {

96 return false;

97 }

98 }

99

100 return recreated;

101 }

102

103 /**

104 * @param document

105 * @param

106 * @param subDirectoryPath

107 * @return

108 */

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

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

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

112 // hosting_mode << std::endl;

113 return false;

114 }

115

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

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

118 final String tempFilename = "testglom";

119 final File tempFolder = Files.createTempDir();

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

121

122 final String tempDirPath = tempDir.getPath();

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

124 final File file = new File(tempFilePath);

125

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

127 {

128 tempDir.delete();

129 }

130

131 // Save the example as a real file:

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

133

134 document.setHostingMode(hostingMode);

135 document.setIsExampleFile(false);

136 final boolean saved = document.save();

137 if (!saved) {

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

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

140 }

141

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

143 final String user = "glom_default_developer_user";

144 final String password = "glom_default_developer_password";

145

146 // Create the self-hosting files:

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

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

149 // TODO: Delete directory.

150 }

151

152 // Check that it really created some files:

153 if (!tempDir.exists()) {

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

155 // TODO: Delete directory.

156 }

157

158 return selfHost(user, password);

159 }

160

161 /**

162 * @param document

163 * @param user

164 * @param password

165 * @return

166 */

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

168 // TODO: m_network_shared = network_shared;

169

170 if (getSelfHostingActive()) {

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

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

173 }

174

175 final String dbDirData = getSelfHostingDataPath(false);

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

177 /*

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

179 *

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

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

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

183 */

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

185 // dbdir_data_uri << std::endl;

186 return false; // STARTUPERROR_FAILED_NO_DATA;

187 // }

188 }

189

190 final int availablePort = discoverFirstFreePort(PORT_POSTGRESQL_SELF_HOSTED_START,

191 PORT_POSTGRESQL_SELF_HOSTED_END);

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

193 // std::endl;

194 if (availablePort == 0) {

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

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

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

198 return false; // STARTUPERROR_FAILED_UNKNOWN_REASON;

199 }

200

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

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

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

204

205 // -D specifies the data directory.

206 // -c config_file= specifies the configuration file

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

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

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

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

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

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

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

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

215

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

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

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

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

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

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

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

223 // parameter instead of "hba_file".

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

225 if (StringUtils.isEmpty(commandPathStart)) {

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

227 return false;

228 }

229 final ProcessBuilder commandPostgresStart = new ProcessBuilder(commandPathStart, "-D" + shellQuote(dbDirData),

230 "-p", portAsText, "-i", // Equivalent to -h "*", which in turn is equivalent

231 // to

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

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

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

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

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

237

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

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

240 //

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

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

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

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

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

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

247 if (StringUtils.isEmpty(commandPathCheck)) {

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

249 return false;

250 }

251 final ProcessBuilder commandCheckPostgresHasStarted = new ProcessBuilder(commandPathCheck, "status", "-D"

252 + shellQuote(dbDirData));

253

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

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

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

257 //

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

259 // Postgres 8.2,

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

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

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

263 // localisation.

264

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

266 // TODO: Progress

267 final boolean result = executeCommandLineAndWaitUntilSecondCommandReturnsSuccess(commandPostgresStart,

268 commandCheckPostgresHasStarted, secondCommandSuccessText);

269 if (!result) {

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

271 return false; // STARTUPERROR_FAILED_UNKNOWN_REASON;

272 }

273

274 // Remember the port for later:

275 document.setConnectionPort(availablePort);

276

277 // Check that we can really connect:

278

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

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

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

282

283 try {

284 Thread.sleep(1000);

285 } catch (InterruptedException e) {

286 // TODO Auto-generated catch block

287 e.printStackTrace();

288 }

289

290 final String dbName = document.getConnectionDatabase();

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

292

293 //Check that we can connect:

294 final Connection connection = createConnection();

295 document.setConnectionDatabase(dbName);

296 if (connection != null) {

297 //Close the connection:

298 try {

299 connection.close();

300 } catch (SQLException e) {

301 // TODO Auto-generated catch block

302 e.printStackTrace();

303 }

304

305 return true; // STARTUPERROR_NONE;

306 }

307

308 System.out

309 .println("selfHost(): Waiting and retrying the connection due to suspected too-early success of pg_ctl. retries="

310 + i);

311 }

312

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

314 return false;

315 }

316

317 /**

318 * @param dbDirData

319 * @return

320 */

321 private String shellQuote(final String str) {

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

323 // the normal command line.

324 return str;

325

326 // TODO: Escape.

327 // return "'" + str + "'";

328 }

329

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

331 final String dbDir = document.getSelfHostedDirectoryPath();

332 if (StringUtils.isEmpty(subpath)) {

333 return dbDir;

334 }

335

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

337 final File file = new File(dbDirData);

338

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

340 if (!create) {

341 return dbDirData;

342 }

343

344 if (!file.exists()) {

345 try {

346 Files.createParentDirs(file);

347 } catch (final IOException e) {

348 // TODO Auto-generated catch block

349 e.printStackTrace();

350 return "";

351 }

352

353 if (!file.mkdir()) {

354 return "";

355 }

356 }

357

358 return dbDirData;

359 }

360

361 private String getSelfHostingDataPath(final boolean create) {

362 return getSelfHostingPath(FILENAME_DATA, create);

363 }

364

365 private boolean executeCommandLineAndWait(final ProcessBuilder command) {

366

367 command.redirectErrorStream(true);

368

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

370 Process process = null;

371 try {

372 process = command.start();

373 } catch (final IOException e) {

374 // TODO Auto-generated catch block

375 e.printStackTrace();

376 return false;

377 }

378

379 // final InputStream stderr = process.getInputStream();

380 // final InputStreamReader isr = new InputStreamReader(stderr);

381 // final BufferedReader br = new BufferedReader(isr);

382 // String output = "";

383 // String line;

384 /*

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

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

387 */

388

389 int result = 0;

390 try {

391 result = process.waitFor();

392 } catch (final InterruptedException e) {

393 // TODO Auto-generated catch block

394 e.printStackTrace();

395 return false;

396 }

397

398 if (result != 0) {

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

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

401 return false;

402 }

403

404 return true;

405 }

406

407 private boolean executeCommandLineAndWaitUntilSecondCommandReturnsSuccess(final ProcessBuilder command,

408 final ProcessBuilder commandSecond, final String secondCommandSuccessText) {

409 command.redirectErrorStream(true);

410

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

412 // Process process = null;

413 try {

414 // Process process =

415 command.start();

416 } catch (final IOException e) {

417 // TODO Auto-generated catch block

418 e.printStackTrace();

419 return false;

420 }

421

422 // final InputStream stderr = process.getInputStream();

423 // final InputStreamReader isr = new InputStreamReader(stderr);

424 // final BufferedReader br = new BufferedReader(isr);

425

426 /*

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

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

429 */

430

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

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

433 boolean result = false;

434 while (true) {

435 result = executeCommandLineAndWait(commandSecond);

436 if (result) {

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

438 return true;

439 } else {

440 try {

441 Thread.sleep(1000);

442 } catch (InterruptedException e) {

443 // TODO Auto-generated catch block

444 e.printStackTrace();

445 return false;

446 }

447

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

449 }

450 }

451

452 // Try to get the output:

453 /*

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

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

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

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

458 */

459

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

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

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

463 // }

464 }

465

466 /**

467 * @param string

468 * @return

469 */

470 private static String getPathToPostgresExecutable(final String string) {

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

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

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

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

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

476

477 for (String dir : dirPaths) {

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

479 if (fileExistsAndIsExecutable(path)) {

480 return path;

481 }

482 }

483

484 return "";

485 }

486

487 /**

488 * @param path

489 * @return

490 */

491 private static boolean fileExistsAndIsExecutable(String path) {

492 final File file = new File(path);

493 if (!file.exists()) {

494 return false;

495 }

496

497 if (!file.canExecute()) {

498 return false;

499 }

500

501 return true;

502 }

503

504 /**

505 * @param start

506 * @param end

507 * @return

508 */

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

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

511 try {

512 final ServerSocket socket = new ServerSocket(port);

513

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

515 final int result = socket.getLocalPort(); // This must equal port.

516 socket.close();

517 return result;

518 } catch (final IOException ex) {

519 continue; // try next port

520 }

521 }

522

523 return 0;

524 }

525

526 /**

527 * @param dbDir

528 * @return

529 */

530 private static boolean fileExists(final String filePath) {

531 final File file = new File(filePath);

532 return file.exists();

533 }

534

535 /**

536 * @return

537 */

538 private boolean getSelfHostingActive() {

539 return selfHostingActive;

540 }

541

542 /**

543 * @param cpds

544 * @return

545 */

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

547 if (!initializeConfFiles()) {

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

549 return false;

550 }

551

552 // initdb creates a new postgres database cluster:

553

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

555 File filePwFile = null;

556 try {

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

558 } catch (final IOException e) {

559 // TODO Auto-generated catch block

560 e.printStackTrace();

561 }

562 final String tempPwFile = filePwFile.getPath();

563

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

565 if (!pwfileCreationSucceeded) {

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

567 return false;

568 }

569

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

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

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

573

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

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

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

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

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

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

580 boolean result = false;

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

582 if (StringUtils.isEmpty(commandPath)) {

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

584 } else {

585 final ProcessBuilder commandInitdb = new ProcessBuilder(commandPath, "-D" + shellQuote(dbDirData), "-U",

586 initialUsername, "--pwfile=" + tempPwFile);

587

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

589 // when

590 // prompted on stdin.

591 result = executeCommandLineAndWait(commandInitdb);

592 }

593

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

595 final File fileTempPwFile = new File(tempPwFile);

596 if (!fileTempPwFile.delete()) {

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

598 }

599

600 if (!result) {

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

602 return false;

603 }

604

605 // Save the username and password for later;

606 this.username = initialUsername;

607 this.password = initialPassword;

608

609 return result; // ? INITERROR_NONE : INITERROR_COULD_NOT_START_SERVER;

610

611 }

612

613 private boolean initializeConfFiles() {

614 final String dataDirPath = document.getSelfHostedDirectoryPath();

615

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

617 // String defaultConfContents = "";

618

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

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

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

622 // final boolean networkShared = true;

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

624

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

626 final String defaultConfContents = DEFAULT_CONFIG_PG_HBA_LOCAL_8p4;

627

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

629

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

631 defaultConfContents);

632 if (!hbaConfCreationSucceeded) {

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

634 return false;

635 }

636

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

638 DEFAULT_CONFIG_PG_IDENT);

639 if (!identConfCreationSucceeded) {

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

641 return false;

642 }

643

644 return true;

645 }

646

647 /**

648 * @param path

649 * @param contents

650 * @return

651 */

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

653 final File file = new File(path);

654 final File parent = file.getParentFile();

655 if (parent == null) {

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

657 return false;

658 }

659

660 parent.mkdirs();

661 try {

662 file.createNewFile();

663 } catch (final IOException e) {

664 // TODO Auto-generated catch block

665 e.printStackTrace();

666 return false;

667 }

668

669 FileOutputStream output = null;

670 try {

671 output = new FileOutputStream(file);

672 } catch (final FileNotFoundException e) {

673 // TODO Auto-generated catch block

674 e.printStackTrace();

675 return false;

676 }

677

678 try {

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

680 } catch (final IOException e) {

681 // TODO Auto-generated catch block

682 e.printStackTrace();

683

684 //TODO: Avoid the duplicate close() here.

685 try {

686 output.close();

687 } catch (IOException e1) {

688 // TODO Auto-generated catch block

689 e1.printStackTrace();

690 }

691

692 return false;

693 }

694

695 try {

696 output.close();

697 } catch (IOException e) {

698 // TODO Auto-generated catch block

699 e.printStackTrace();

700 }

701

702 return true;

703 }

704

705 /**

706 * @param document

707 * @return

708 */

709 private boolean recreateDatabaseFromDocument() {

710 // Check whether the database exists already.

711 final String dbName = document.getConnectionDatabase();

712 if (StringUtils.isEmpty(dbName)) {

713 return false;

714 }

715

716 document.setConnectionDatabase(dbName);

717 Connection connection = createConnection();

718 if (connection != null) {

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

720 // exists already.

721 try {

722 connection.close();

723 } catch (final SQLException e) {

724 // TODO Auto-generated catch block

725 e.printStackTrace();

726 }

727 return false;

728 }

729

730 // Create the database:

731 progress();

732 document.setConnectionDatabase("");

733

734 connection = createConnection();

735 if (connection == null) {

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

737 return false;

738 }

739

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

741

742 if (!dbCreated) {

743 return false;

744 }

745

746 progress();

747

748 // Check that we can connect:

749 try {

750 connection.close();

751 } catch (final SQLException e) {

752 // TODO Auto-generated catch block

753 e.printStackTrace();

754 }

755 connection = null;

756

757 document.setConnectionDatabase(dbName);

758 connection = createConnection();

759 if (connection == null) {

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

761 return false;

762 }

763

764 progress();

765

766 // Create each table:

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

768 for (final String tableName : tables) {

769

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

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

772

773 progress();

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

775 progress();

776 if (!tableCreationSucceeded) {

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

778 // std::endl;

779 return false;

780 }

781 }

782

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

784

785 // Add groups from the document:

786 progress();

787 if (!addGroupsFromDocument(document)) {

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

789 return false;

790 }

791

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

793 progress();

794 if (!setTablePrivilegesGroupsFromDocument(document)) {

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

796 return false;

797 }

798

799 for (final String tableName : tables) {

800 // Add any example data to the table:

801 progress();

802

803 // try

804 // {

805 progress();

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

807

808 if (!tableInsertSucceeded) {

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

810 // std::endl;

811 return false;

812 }

813 // }

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

815 // {

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

817 // HandleError(ex);

818 // }

819

820 } // for(tables)

821

822 return true; // All tables created successfully.

823 }

824

825 /**

826 * @return

827 * @throws SQLException

828 */

829 private Connection createConnection() {

830 final Properties connectionProps = new Properties();

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

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

833

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

835 String db = document.getConnectionDatabase();

836 if (StringUtils.isEmpty(db)) {

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

838 db = "template1";

839 }

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

841

842 Connection conn = null;

843 try {

844 //TODO: Remove these debug prints when we figure out why getConnection sometimes hangs.

845 //System.out.println("debug: SelfHoster.createConnection(): before createConnection()");

846 DriverManager.setLoginTimeout(10);

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

848 //System.out.println("debug: SelfHoster.createConnection(): before createConnection()");

849 } catch (final SQLException e) {

850 e.printStackTrace();

851 return null;

852 }

853

854 return conn;

855 }

856

857 /**

858 *

859 */

860 private void progress() {

861 // TODO Auto-generated method stub

862

863 }

864

865 /**

866 * @param document

867 * @param tableName

868 * @return

869 */

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

871

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

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

874

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

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

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

878

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

880 final String fieldName = entry.getKey();

881 final DataItem value = entry.getValue();

882 if (value == null) {

883 continue;

884 }

885

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

887 if (field == null) {

888 continue;

889 }

890

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

892 if (jooqField == null) {

893 continue;

894 }

895

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

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

898 }

899

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

901 continue;

902 }

903

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

905 @SuppressWarnings("unchecked")

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

907

908 try {

909 insertResultStep.fetchOne();

910 } catch (final DataAccessException e) {

911 // e.printStackTrace();

912 return false;

913 }

914 // TODO: Check that it worked.

915 }

916

917 return true;

918 }

919

920 /**

921 * @param document2

922 * @return

923 */

924 private boolean setTablePrivilegesGroupsFromDocument(final Document document2) {

925 // TODO Auto-generated method stub

926 return true;

927 }

928

929 /**

930 * @param document2

931 * @return

932 */

933 private boolean addGroupsFromDocument(final Document document2) {

934 // TODO Auto-generated method stub

935 return true;

936 }

937

938 /**

939 * @param document

940 * @param tableName

941 * @param fields

942 * @return

943 */

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

945 final List<Field> fields) {

946 boolean tableCreationSucceeded = false;

947

948 /*

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

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

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

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

953 */

954

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

956 String sqlFields = "";

957 for (final Field field : fields) {

958 // Create SQL to describe this field:

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

960

961 if (field.getPrimaryKey()) {

962 sqlFieldDescription += " NOT NULL PRIMARY KEY";

963 }

964

965 // Append it:

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

967 sqlFields += ", ";

968 }

969

970 sqlFields += sqlFieldDescription;

971 }

972

973 if (StringUtils.isEmpty(sqlFields)) {

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

975 }

976

977 // Actually create the table

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

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

980 factory.execute(query);

981 tableCreationSucceeded = true;

982 if (!tableCreationSucceeded) {

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

984 }

985

986 return tableCreationSucceeded;

987 }

988

989 /**

990 * @param name

991 * @return

992 */

993 private String escapeSqlId(final String name) {

994 // TODO:

995 return "\"" + name + "\"";

996 }

997

998 /**

999 * @return

1000 */

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

1002

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

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

1005

1006 factory.execute(query);

1007

1008 return true;

1009 }

1010

1011 /**

1012 *

1013 */

1014 public boolean cleanup() {

1015 boolean result = true;

1016

1017 // Stop the server:

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

1019 final String dbDirData = getSelfHostingDataPath(false);

1020

1021 // -D specifies the data directory.

1022 // -c config_file= specifies the configuration file

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

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

1025 // sometimes never succeeds).

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

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

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

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

1030 if (StringUtils.isEmpty(commandPath)) {

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

1032 } else {

1033 final ProcessBuilder commandPostgresStop = new ProcessBuilder(commandPath,

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

1035 result = executeCommandLineAndWait(commandPostgresStop);

1036 if (!result) {

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

1038 }

1039 }

1040

1041 document.setConnectionPort(0);

1042 }

1043

1044 // Delete the files:

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

1046 final File fileSelfHosting = new File(selfhostingPath);

1047 fileSelfHosting.delete();

1048

1049 final String docPath = document.getFileURI();

1050 final File fileDoc = new File(docPath);

1051 fileDoc.delete();

1052

1053 return result;

1054 }

1055 }