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

34 import java.util.Locale;

35 import java.util.Map;

36 import java.util.Map.Entry;

37 import java.util.Properties;

38

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

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

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

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

43 import org.jooq.InsertResultStep;

44 import org.jooq.InsertSetStep;

45 import org.jooq.Record;

46 import org.jooq.SQLDialect;

47 import org.jooq.Table;

48 import org.jooq.exception.DataAccessException;

49 import org.jooq.impl.Factory;

50

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

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

53

54 /**

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

56 *

57 */

58 public class SelfHoster {

59 // private String tempFilepathDir = "";

60 private boolean selfHostingActive = false;

61 private Document document = null;

62 private String username = "";

63 private String password = "";

64

65 SelfHoster(final Document document) {

66 this.document = document;

67 }

68

69 private static final int PORT_POSTGRESQL_SELF_HOSTED_START = 5433;

70 private static final int PORT_POSTGRESQL_SELF_HOSTED_END = 5500;

71

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

73 + "\n"

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

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

76 + "local all all trust\n"

77 + "local all all ident\n"

78 + "local all all md5\n"

79 + "\n"

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

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

82 + "# IPv6 local connections:\n"

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

84

85 private static final String DEFAULT_CONFIG_PG_IDENT = "";

86 private static final String FILENAME_DATA = "data";

87

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

89

90 if (!createAndSelfHostNewEmpty(hostingMode)) {

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

92 return false;

93 }

94

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

96 if (!recreated) {

97 cleanup();

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 // TODO: Warn

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 // TODO: Warn.

149 // TODO: Delete directory.

150 }

151

152 // Check that it really created some files:

153 if (!tempDir.exists()) {

154 // TODO: Warn

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 ProcessBuilder commandPostgresStart = new ProcessBuilder(getPathToPostgresExecutable("postgres"), "-D"

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

226 // to

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

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

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

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

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

232

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

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

235 //

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

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

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

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

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

241 final ProcessBuilder commandCheckPostgresHasStarted = new ProcessBuilder(getPathToPostgresExecutable("pg_ctl"),

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

243

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

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

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

247 //

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

249 // Postgres 8.2,

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

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

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

253 // localisation.

254

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

256 // TODO: Progress

257 final boolean result = executeCommandLineAndWaitUntilSecondCommandReturnsSuccess(commandPostgresStart,

258 commandCheckPostgresHasStarted, secondCommandSuccessText);

259 if (!result) {

260 // TODO: std::cerr << "Error while attempting to self-host a database." << std::endl;

261 return false; // STARTUPERROR_FAILED_UNKNOWN_REASON;

262 }

263

264 // Remember the port for later:

265 document.setConnectionPort(availablePort);

266

267 return true; // STARTUPERROR_NONE;

268 }

269

270 /**

271 * @param dbDirData

272 * @return

273 */

274 private String shellQuote(final String str) {

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

276 // the normal command line.

277 return str;

278

279 // TODO: Escape.

280 // return "'" + str + "'";

281 }

282

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

284 final String dbDir = document.getSelfHostedDirectoryPath();

285 if (StringUtils.isEmpty(subpath)) {

286 return dbDir;

287 }

288

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

290 final File file = new File(dbDirData);

291

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

293 if (!create) {

294 return dbDirData;

295 }

296

297 if (!file.exists()) {

298 try {

299 Files.createParentDirs(file);

300 } catch (final IOException e) {

301 // TODO Auto-generated catch block

302 e.printStackTrace();

303 return "";

304 }

305

306 if (!file.mkdir()) {

307 return "";

308 }

309 }

310

311 return dbDirData;

312 }

313

314 private String getSelfHostingDataPath(final boolean create) {

315 return getSelfHostingPath(FILENAME_DATA, create);

316 }

317

318 private boolean executeCommandLineAndWait(final ProcessBuilder command) {

319

320 command.redirectErrorStream(true);

321

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

323 Process process = null;

324 try {

325 process = command.start();

326 } catch (final IOException e) {

327 // TODO Auto-generated catch block

328 e.printStackTrace();

329 return false;

330 }

331

332 final InputStream stderr = process.getInputStream();

333 final InputStreamReader isr = new InputStreamReader(stderr);

334 final BufferedReader br = new BufferedReader(isr);

335 String output = "";

336 String line;

337 try {

338 while ((line = br.readLine()) != null) {

339 output += line + "\n";

340 }

341 } catch (final IOException e1) {

342 e1.printStackTrace();

343 return false;

344 }

345

346 int result = 0;

347 try {

348 result = process.waitFor();

349 } catch (final InterruptedException e) {

350 // TODO Auto-generated catch block

351 e.printStackTrace();

352 return false;

353 }

354

355 if (result != 0) {

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

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

358 return false;

359 }

360

361 return true;

362 }

363

364 private boolean executeCommandLineAndWaitUntilSecondCommandReturnsSuccess(final ProcessBuilder command,

365 final ProcessBuilder commandSecond, final String secondCommandSuccessText) {

366 command.redirectErrorStream(true);

367

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

369 Process process = null;

370 try {

371 process = command.start();

372 } catch (final IOException e) {

373 // TODO Auto-generated catch block

374 e.printStackTrace();

375 return false;

376 }

377

378 final InputStream stderr = process.getInputStream();

379 final InputStreamReader isr = new InputStreamReader(stderr);

380 final BufferedReader br = new BufferedReader(isr);

381

382 /*

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

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

385 */

386

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

388 final boolean result = executeCommandLineAndWait(commandSecond);

389

390 // Try to get the output:

391 if (!result) {

392 String output = "";

393 String line;

394 try {

395 while ((line = br.readLine()) != null) {

396 output += line + "\n";

397 System.out.println(line);

398 }

399 } catch (final IOException e1) {

400 // TODO Auto-generated catch block

401 e1.printStackTrace();

402 return false;

403 }

404

405 System.out.print("Output of first command: " + output);

406 }

407

408 return result;

409 }

410

411 /**

412 * @param string

413 * @return

414 */

415 private static String getPathToPostgresExecutable(final String string) {

416 // TODO: Test other locations.

417 return "/usr/bin/" + string;

418 }

419

420 /**

421 * @param start

422 * @param end

423 * @return

424 */

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

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

427 try {

428 final ServerSocket socket = new ServerSocket(port);

429

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

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

432 } catch (final IOException ex) {

433 continue; // try next port

434 }

435 }

436

437 return 0;

438 }

439

440 /**

441 * @param dbDir

442 * @return

443 */

444 private static boolean fileExists(final String filePath) {

445 final File file = new File(filePath);

446 return file.exists();

447 }

448

449 /**

450 * @return

451 */

452 private boolean getSelfHostingActive() {

453 return selfHostingActive;

454 }

455

456 /**

457 * @param cpds

458 * @return

459 */

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

461 if (!initializeConfFiles()) {

462 // TODO: Warn

463 return false;

464 }

465

466 // initdb creates a new postgres database cluster:

467

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

469 File filePwFile = null;

470 try {

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

472 } catch (final IOException e) {

473 // TODO Auto-generated catch block

474 e.printStackTrace();

475 }

476 final String tempPwFile = filePwFile.getPath();

477

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

479 if (!pwfileCreationSucceeded) {

480 // TODO: Warn.

481 return false;

482 }

483

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

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

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

487

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

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

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

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

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

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

494 final ProcessBuilder commandInitdb = new ProcessBuilder(getPathToPostgresExecutable("initdb"), "-D"

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

496

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

498 // prompted on stdin.

499 final boolean result = executeCommandLineAndWait(commandInitdb);

500 if (!result) {

501 // TODO: std::cerr << "Error while attempting to create self-hosting database." << std::endl;

502 return false;

503 }

504

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

506 final File fileTempPwFile = new File(tempPwFile);

507 if (!fileTempPwFile.delete()) {

508 // TODO: Warn.

509 }

510

511 // Save the username and password for later;

512 this.username = initialUsername;

513 this.password = initialPassword;

514

515 return result; // ? INITERROR_NONE : INITERROR_COULD_NOT_START_SERVER;

516

517 }

518

519 private boolean initializeConfFiles() {

520 final String dataDirPath = document.getSelfHostedDirectoryPath();

521

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

523 // String defaultConfContents = "";

524

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

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

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

528 // final boolean networkShared = true;

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

530

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

532 final String defaultConfContents = DEFAULT_CONFIG_PG_HBA_LOCAL_8p4;

533

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

535

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

537 defaultConfContents);

538 if (!hbaConfCreationSucceeded) {

539 // TODO: Warn

540 return false;

541 }

542

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

544 DEFAULT_CONFIG_PG_IDENT);

545 if (!identConfCreationSucceeded) {

546 // TODO: Warn

547 return false;

548 }

549

550 return true;

551 }

552

553 /**

554 * @param path

555 * @param contents

556 * @return

557 */

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

559 final File file = new File(path);

560 final File parent = file.getParentFile();

561 if (parent == null) {

562 // TODO: Warn.

563 return false;

564 }

565

566 parent.mkdirs();

567 try {

568 file.createNewFile();

569 } catch (final IOException e) {

570 // TODO Auto-generated catch block

571 e.printStackTrace();

572 return false;

573 }

574

575 FileOutputStream output = null;

576 try {

577 output = new FileOutputStream(file);

578 } catch (final FileNotFoundException e) {

579 // TODO Auto-generated catch block

580 e.printStackTrace();

581 return false;

582 }

583

584 try {

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

586 } catch (final IOException e) {

587 // TODO Auto-generated catch block

588 e.printStackTrace();

589 return false;

590 }

591

592 return true;

593 }

594

595 /**

596 * @param document

597 * @return

598 */

599 private boolean recreateDatabaseFromDocument() {

600 // Check whether the database exists already.

601 final String dbName = document.getConnectionDatabase();

602 if (StringUtils.isEmpty(dbName)) {

603 return false;

604 }

605

606 document.setConnectionDatabase(dbName);

607 Connection connection = createConnection();

608 if (connection != null) {

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

610 // exists already.

611 try {

612 connection.close();

613 } catch (final SQLException e) {

614 // TODO Auto-generated catch block

615 e.printStackTrace();

616 }

617 return false;

618 }

619

620 // Create the database:

621 progress();

622 document.setConnectionDatabase("");

623

624 connection = createConnection();

625 if (connection == null) {

626 // TODO: Warn.

627 return false;

628 }

629

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

631

632 if (!dbCreated) {

633 return false;

634 }

635

636 progress();

637

638 // Check that we can connect:

639 try {

640 connection.close();

641 } catch (final SQLException e) {

642 // TODO Auto-generated catch block

643 e.printStackTrace();

644 }

645 connection = null;

646

647 document.setConnectionDatabase(dbName);

648 connection = createConnection();

649 if (connection == null) {

650 // TODO: Warn

651 return false;

652 }

653

654 progress();

655

656 // Create each table:

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

658 for (final String tableName : tables) {

659

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

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

662

663 progress();

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

665 progress();

666 if (!tableCreationSucceeded) {

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

668 // std::endl;

669 return false;

670 }

671 }

672

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

674

675 // Add groups from the document:

676 progress();

677 if (!addGroupsFromDocument(document)) {

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

679 return false;

680 }

681

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

683 progress();

684 if (!setTablePrivilegesGroupsFromDocument(document)) {

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

686 return false;

687 }

688

689 for (final String tableName : tables) {

690 // Add any example data to the table:

691 progress();

692

693 // try

694 // {

695 progress();

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

697

698 if (!tableInsertSucceeded) {

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

700 // std::endl;

701 return false;

702 }

703 // }

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

705 // {

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

707 // HandleError(ex);

708 // }

709

710 } // for(tables)

711

712 return true; // All tables created successfully.

713 }

714

715 /**

716 * @return

717 * @throws SQLException

718 */

719 private Connection createConnection() {

720 final Properties connectionProps = new Properties();

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

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

723

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

725 String db = document.getConnectionDatabase();

726 if (StringUtils.isEmpty(db)) {

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

728 db = "template1";

729 }

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

731

732 Connection conn = null;

733 try {

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

735 } catch (final SQLException e) {

736 // TODO Auto-generated catch block

737 // e.printStackTrace();

738 return null;

739 }

740

741 return conn;

742 }

743

744 /**

745 *

746 */

747 private void progress() {

748 // TODO Auto-generated method stub

749

750 }

751

752 /**

753 * @param document

754 * @param tableName

755 * @return

756 */

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

758

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

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

761

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

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

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

765

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

767 final String fieldName = entry.getKey();

768 final DataItem value = entry.getValue();

769 if (value == null) {

770 continue;

771 }

772

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

774 if (field == null) {

775 continue;

776 }

777

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

779 if (jooqField == null) {

780 continue;

781 }

782

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

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

785 }

786

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

788 continue;

789 }

790

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

792 @SuppressWarnings("unchecked")

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

794

795 try {

796 insertResultStep.fetchOne();

797 } catch (final DataAccessException e) {

798 // e.printStackTrace();

799 return false;

800 }

801 // TODO: Check that it worked.

802 }

803

804 return true;

805 }

806

807 /**

808 * @param document2

809 * @return

810 */

811 private boolean setTablePrivilegesGroupsFromDocument(final Document document2) {

812 // TODO Auto-generated method stub

813 return true;

814 }

815

816 /**

817 * @param document2

818 * @return

819 */

820 private boolean addGroupsFromDocument(final Document document2) {

821 // TODO Auto-generated method stub

822 return true;

823 }

824

825 /**

826 * @param document

827 * @param tableName

828 * @param fields

829 * @return

830 */

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

832 final List<Field> fields) {

833 boolean tableCreationSucceeded = false;

834

835 /*

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

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

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

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

840 */

841

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

843 String sqlFields = "";

844 for (final Field field : fields) {

845 // Create SQL to describe this field:

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

847

848 if (field.getPrimaryKey()) {

849 sqlFieldDescription += " NOT NULL PRIMARY KEY";

850 }

851

852 // Append it:

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

854 sqlFields += ", ";

855 }

856

857 sqlFields += sqlFieldDescription;

858 }

859

860 if (StringUtils.isEmpty(sqlFields)) {

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

862 }

863

864 // Actually create the table

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

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

867 factory.execute(query);

868 tableCreationSucceeded = true;

869 if (!tableCreationSucceeded) {

870 // TODO: Warn: std::cerr << G_STRFUNC << ": CREATE TABLE failed." << std::endl;

871 }

872

873 return tableCreationSucceeded;

874 }

875

876 /**

877 * @param name

878 * @return

879 */

880 private String escapeSqlId(final String name) {

881 // TODO:

882 return "\"" + name + "\"";

883 }

884

885 /**

886 * @return

887 */

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

889

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

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

892

893 factory.execute(query);

894

895 return true;

896 }

897

898 /**

899 *

900 */

901 public void cleanup() {

902

903 // Stop the server:

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

905 final String dbDirData = getSelfHostingDataPath(false);

906

907 // -D specifies the data directory.

908 // -c config_file= specifies the configuration file

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

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

911 // sometimes never succeeds).

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

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

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

915 final ProcessBuilder commandPostgresStop = new ProcessBuilder(getPathToPostgresExecutable("pg_ctl"), "-D"

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

917 final boolean result = executeCommandLineAndWait(commandPostgresStop);

918 if (!result) {

919 // TODO: Warn

920 // return;

921 }

922

923 document.setConnectionPort(0);

924 }

925

926 // Delete the files:

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

928 final File fileSelfHosting = new File(selfhostingPath);

929 fileSelfHosting.delete();

930

931 final String docPath = document.getFileURI();

932 final File fileDoc = new File(docPath);

933 fileDoc.delete();

934 }

935 }