1 31 32 package org.opencms.db.generic; 33 34 import org.opencms.configuration.CmsConfigurationManager; 35 import org.opencms.db.CmsDbConsistencyException; 36 import org.opencms.db.CmsDbContext; 37 import org.opencms.db.CmsDbEntryNotFoundException; 38 import org.opencms.db.CmsDbSqlException; 39 import org.opencms.db.CmsDbUtil; 40 import org.opencms.db.CmsDriverManager; 41 import org.opencms.db.I_CmsBackupDriver; 42 import org.opencms.db.I_CmsDriver; 43 import org.opencms.file.CmsBackupProject; 44 import org.opencms.file.CmsBackupResource; 45 import org.opencms.file.CmsDataAccessException; 46 import org.opencms.file.CmsFile; 47 import org.opencms.file.CmsProject; 48 import org.opencms.file.CmsProperty; 49 import org.opencms.file.CmsPropertyDefinition; 50 import org.opencms.file.CmsResource; 51 import org.opencms.file.CmsUser; 52 import org.opencms.file.CmsVfsResourceNotFoundException; 53 import org.opencms.main.CmsLog; 54 import org.opencms.util.CmsStringUtil; 55 import org.opencms.util.CmsUUID; 56 57 import java.io.ByteArrayInputStream ; 58 import java.sql.Connection ; 59 import java.sql.PreparedStatement ; 60 import java.sql.ResultSet ; 61 import java.sql.SQLException ; 62 import java.sql.Timestamp ; 63 import java.util.ArrayList ; 64 import java.util.HashMap ; 65 import java.util.HashSet ; 66 import java.util.Iterator ; 67 import java.util.List ; 68 import java.util.Map ; 69 import java.util.Set ; 70 71 import org.apache.commons.logging.Log; 72 73 84 public class CmsBackupDriver implements I_CmsDriver, I_CmsBackupDriver { 85 86 87 private static final Log LOG = CmsLog.getLog(org.opencms.db.generic.CmsBackupDriver.class); 88 89 90 protected CmsDriverManager m_driverManager; 91 92 93 protected org.opencms.db.generic.CmsSqlManager m_sqlManager; 94 95 98 public CmsPropertyDefinition createBackupPropertyDefinition(CmsDbContext dbc, String name) 99 throws CmsDataAccessException { 100 101 Connection conn = null; 102 PreparedStatement stmt = null; 103 104 try { 105 conn = m_sqlManager.getConnection(dbc); 106 stmt = m_sqlManager.getPreparedStatement(conn, "C_PROPERTYDEF_CREATE_BACKUP"); 107 stmt.setString(1, new CmsUUID().toString()); 108 stmt.setString(2, name); 109 stmt.executeUpdate(); 110 } catch (SQLException e) { 111 throw new CmsDbSqlException(Messages.get().container( 112 Messages.ERR_GENERIC_SQL_1, 113 CmsDbSqlException.getErrorQuery(stmt)), e); 114 115 } finally { 116 m_sqlManager.closeAll(dbc, conn, stmt, null); 117 } 118 119 return readBackupPropertyDefinition(dbc, name); 120 } 121 122 125 public CmsBackupResource createBackupResource(ResultSet res, boolean hasContent) throws SQLException { 126 127 byte[] content = null; 128 129 CmsUUID backupId = new CmsUUID(res.getString(m_sqlManager.readQuery("C_RESOURCES_BACKUP_ID"))); 130 int versionId = res.getInt(m_sqlManager.readQuery("C_RESOURCES_VERSION_ID")); 131 int tagId = res.getInt(m_sqlManager.readQuery("C_RESOURCES_PUBLISH_TAG")); 132 CmsUUID structureId = new CmsUUID(res.getString(m_sqlManager.readQuery("C_RESOURCES_STRUCTURE_ID"))); 133 CmsUUID resourceId = new CmsUUID(res.getString(m_sqlManager.readQuery("C_RESOURCES_RESOURCE_ID"))); 134 String resourcePath = res.getString(m_sqlManager.readQuery("C_RESOURCES_RESOURCE_PATH")); 135 int resourceType = res.getInt(m_sqlManager.readQuery("C_RESOURCES_RESOURCE_TYPE")); 136 int resourceFlags = res.getInt(m_sqlManager.readQuery("C_RESOURCES_RESOURCE_FLAGS")); 137 int projectLastModified = res.getInt(m_sqlManager.readQuery("C_RESOURCES_PROJECT_LASTMODIFIED")); 138 int state = res.getInt(m_sqlManager.readQuery("C_RESOURCES_STATE")); 139 long dateCreated = res.getLong(m_sqlManager.readQuery("C_RESOURCES_DATE_CREATED")); 140 long dateLastModified = res.getLong(m_sqlManager.readQuery("C_RESOURCES_DATE_LASTMODIFIED")); 141 long dateReleased = res.getLong(m_sqlManager.readQuery("C_RESOURCES_DATE_RELEASED")); 142 long dateExpired = res.getLong(m_sqlManager.readQuery("C_RESOURCES_DATE_EXPIRED")); 143 int resourceSize = res.getInt(m_sqlManager.readQuery("C_RESOURCES_SIZE")); 144 CmsUUID userLastModified = new CmsUUID(res.getString(m_sqlManager.readQuery("C_RESOURCES_USER_LASTMODIFIED"))); 145 String userLastModifiedName = res.getString(m_sqlManager.readQuery("C_RESOURCES_LASTMODIFIED_BY_NAME")); 146 CmsUUID userCreated = new CmsUUID(res.getString(m_sqlManager.readQuery("C_RESOURCES_USER_CREATED"))); 147 String userCreatedName = res.getString(m_sqlManager.readQuery("C_RESOURCES_USER_CREATED_NAME")); 148 149 CmsUUID contentId; 150 if (hasContent) { 151 content = m_sqlManager.getBytes(res, m_sqlManager.readQuery("C_RESOURCES_FILE_CONTENT")); 152 contentId = new CmsUUID(res.getString(m_sqlManager.readQuery("C_RESOURCES_CONTENT_ID"))); 153 } else { 154 content = new byte[0]; 155 contentId = CmsUUID.getNullUUID(); 156 } 157 return new CmsBackupResource( 158 backupId, 159 tagId, 160 versionId, 161 structureId, 162 resourceId, 163 contentId, 164 resourcePath, 165 resourceType, 166 resourceFlags, 167 projectLastModified, 168 state, 169 dateCreated, 170 userCreated, 171 userCreatedName, 172 dateLastModified, 173 userLastModified, 174 userLastModifiedName, 175 dateReleased, 176 dateExpired, 177 resourceSize, 178 content); 179 } 180 181 184 public void deleteBackup(CmsDbContext dbc, CmsBackupResource resource, int tag, int versions) 185 throws CmsDataAccessException { 186 187 ResultSet res = null; 188 PreparedStatement stmt = null; 189 PreparedStatement stmt1 = null; 190 PreparedStatement stmt2 = null; 191 PreparedStatement stmt3 = null; 192 PreparedStatement stmt4 = null; 193 Connection conn = null; 194 List backupIds = new ArrayList (); 195 196 try { 198 conn = m_sqlManager.getConnection(dbc); 199 stmt = m_sqlManager.getPreparedStatement(conn, "C_BACKUP_READ_BACKUPID_FOR_DELETION"); 200 stmt.setString(1, resource.getStructureId().toString()); 201 stmt.setString(2, resource.getResourceId().toString()); 202 stmt.setInt(3, versions); 203 stmt.setInt(4, tag); 204 res = stmt.executeQuery(); 205 while (res.next()) { 207 backupIds.add(res.getString(1)); 208 } 209 stmt1 = m_sqlManager.getPreparedStatement(conn, "C_BACKUP_DELETE_STRUCTURE_BYBACKUPID"); 211 stmt2 = m_sqlManager.getPreparedStatement(conn, "C_BACKUP_DELETE_RESOURCES_BYBACKUPID"); 212 stmt3 = m_sqlManager.getPreparedStatement(conn, "C_BACKUP_DELETE_CONTENTS_BYBACKUPID"); 213 stmt4 = m_sqlManager.getPreparedStatement(conn, "C_BACKUP_DELETE_PROPERTIES_BYBACKUPID"); 214 Iterator i = backupIds.iterator(); 215 while (i.hasNext()) { 216 String backupId = (String )i.next(); 217 stmt1.setString(1, backupId); 219 stmt1.addBatch(); 220 stmt2.setString(1, backupId); 222 stmt2.addBatch(); 223 stmt3.setString(1, backupId); 225 stmt3.addBatch(); 226 stmt4.setString(1, backupId); 228 stmt4.addBatch(); 229 } 230 stmt1.executeBatch(); 232 stmt2.executeBatch(); 233 stmt3.executeBatch(); 234 stmt4.executeBatch(); 235 236 } catch (SQLException e) { 237 throw new CmsDbSqlException(Messages.get().container( 238 Messages.ERR_GENERIC_SQL_1, 239 CmsDbSqlException.getErrorQuery(stmt)), e); 240 } finally { 241 m_sqlManager.closeAll(dbc, conn, stmt, res); 242 m_sqlManager.closeAll(dbc, null, stmt1, null); 243 m_sqlManager.closeAll(dbc, null, stmt2, null); 244 m_sqlManager.closeAll(dbc, null, stmt3, null); 245 m_sqlManager.closeAll(dbc, null, stmt4, null); 246 } 247 } 248 249 252 public void deleteBackupPropertyDefinition(CmsDbContext dbc, CmsPropertyDefinition metadef) 253 throws CmsDataAccessException { 254 255 Connection conn = null; 256 PreparedStatement stmt = null; 257 258 try { 259 if (internalCountProperties(dbc, metadef, CmsProject.ONLINE_PROJECT_ID) != 0 260 || internalCountProperties(dbc, metadef, Integer.MAX_VALUE) != 0) { 261 262 throw new CmsDbConsistencyException(Messages.get().container( 263 Messages.ERR_ERROR_DELETING_PROPERTYDEF_1, 264 metadef.getName())); 265 } 266 267 conn = m_sqlManager.getConnection(dbc); 269 stmt = m_sqlManager.getPreparedStatement(conn, "C_PROPERTYDEF_DELETE_BACKUP"); 270 stmt.setString(1, metadef.getId().toString()); 271 stmt.executeUpdate(); 272 } catch (SQLException e) { 273 throw new CmsDbSqlException(Messages.get().container( 274 Messages.ERR_GENERIC_SQL_1, 275 CmsDbSqlException.getErrorQuery(stmt)), e); 276 } finally { 277 m_sqlManager.closeAll(dbc, conn, stmt, null); 278 } 279 } 280 281 284 public void deleteBackups(CmsDbContext dbc, List existingBackups, int maxVersions) throws CmsDataAccessException { 285 286 PreparedStatement stmt1 = null; 287 PreparedStatement stmt2 = null; 288 PreparedStatement stmt3 = null; 289 PreparedStatement stmt4 = null; 290 Connection conn = null; 291 CmsBackupResource currentResource = null; 292 int count = existingBackups.size() - maxVersions; 293 294 try { 295 conn = m_sqlManager.getConnection(dbc); 296 stmt1 = m_sqlManager.getPreparedStatement(conn, "C_BACKUP_DELETE_CONTENTS_BYBACKUPID"); 297 stmt2 = m_sqlManager.getPreparedStatement(conn, "C_BACKUP_DELETE_STRUCTURE_BYBACKUPID"); 298 stmt3 = m_sqlManager.getPreparedStatement(conn, "C_BACKUP_DELETE_RESOURCES_BYBACKUPID"); 299 stmt4 = m_sqlManager.getPreparedStatement(conn, "C_PROPERTIES_DELETEALL_BACKUP"); 300 301 for (int i = 0; i < count; i++) { 302 currentResource = (CmsBackupResource)existingBackups.get(i); 303 stmt1.setString(1, currentResource.getBackupId().toString()); 305 stmt1.addBatch(); 306 stmt2.setString(1, currentResource.getBackupId().toString()); 307 stmt2.addBatch(); 308 stmt3.setString(1, currentResource.getBackupId().toString()); 309 stmt3.addBatch(); 310 311 stmt4.setString(1, currentResource.getBackupId().toString()); 313 stmt4.setInt(2, currentResource.getTagId()); 314 stmt4.setString(3, currentResource.getStructureId().toString()); 315 stmt4.setInt(4, CmsProperty.STRUCTURE_RECORD_MAPPING); 316 stmt4.setString(5, currentResource.getResourceId().toString()); 317 stmt4.setInt(6, CmsProperty.RESOURCE_RECORD_MAPPING); 318 stmt4.addBatch(); 319 } 320 321 if (count > 0) { 322 stmt1.executeBatch(); 323 stmt2.executeBatch(); 324 stmt3.executeBatch(); 325 stmt4.executeBatch(); 326 } 327 328 } catch (SQLException e) { 329 throw new CmsDbSqlException(Messages.get().container(Messages.ERR_GENERIC_SQL_0), e); 330 } finally { 331 m_sqlManager.closeAll(dbc, conn, stmt1, null); 332 m_sqlManager.closeAll(dbc, null, stmt2, null); 333 m_sqlManager.closeAll(dbc, null, stmt3, null); 334 m_sqlManager.closeAll(dbc, null, stmt4, null); 335 } 336 } 337 338 341 public void destroy() throws Throwable { 342 343 finalize(); 344 if (CmsLog.INIT.isInfoEnabled()) { 345 CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_SHUTDOWN_DRIVER_1, getClass().getName())); 346 } 347 } 348 349 352 public CmsSqlManager getSqlManager() { 353 354 return m_sqlManager; 355 } 356 357 360 public void init( 361 CmsDbContext dbc, 362 CmsConfigurationManager configurationManager, 363 List successiveDrivers, 364 CmsDriverManager driverManager) { 365 366 Map configuration = configurationManager.getConfiguration(); 367 String poolUrl = configuration.get("db.backup.pool").toString(); 368 String classname = configuration.get("db.backup.sqlmanager").toString(); 369 m_sqlManager = this.initSqlManager(classname); 370 m_sqlManager.init(I_CmsBackupDriver.DRIVER_TYPE_ID, poolUrl); 371 372 m_driverManager = driverManager; 373 374 if (CmsLog.INIT.isInfoEnabled()) { 375 CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_ASSIGNED_POOL_1, poolUrl)); 376 } 377 378 if (successiveDrivers != null && !successiveDrivers.isEmpty()) { 379 if (LOG.isWarnEnabled()) { 380 LOG.warn(Messages.get().getBundle().key(Messages.LOG_SUCCESSIVE_DRIVERS_UNSUPPORTED_1, getClass().getName())); 381 } 382 } 383 } 384 385 388 public org.opencms.db.generic.CmsSqlManager initSqlManager(String classname) { 389 390 return CmsSqlManager.getInstance(classname); 391 } 392 393 396 public CmsBackupResource readBackupFile(CmsDbContext dbc, int tagId, String resourcePath) 397 throws CmsDataAccessException { 398 399 CmsBackupResource file = null; 400 PreparedStatement stmt = null; 401 ResultSet res = null; 402 Connection conn = null; 403 404 try { 405 conn = m_sqlManager.getConnection(dbc); 406 stmt = m_sqlManager.getPreparedStatement(conn, "C_FILES_READ_BACKUP"); 407 stmt.setString(1, resourcePath); 408 stmt.setInt(2, tagId); 409 res = stmt.executeQuery(); 410 if (res.next()) { 411 file = createBackupResource(res, true); 412 while (res.next()) { 413 } 415 } else { 416 throw new CmsVfsResourceNotFoundException(Messages.get().container( 417 Messages.ERR_BACKUP_FILE_NOT_FOUND_1, 418 resourcePath.toString())); 419 } 420 } catch (SQLException e) { 421 throw new CmsDbSqlException(Messages.get().container( 422 Messages.ERR_GENERIC_SQL_1, 423 CmsDbSqlException.getErrorQuery(stmt)), e); 424 } finally { 425 m_sqlManager.closeAll(dbc, conn, stmt, res); 426 } 427 428 return file; 429 } 430 431 434 public List readBackupFileHeaders(CmsDbContext dbc) throws CmsDataAccessException { 435 436 CmsBackupResource currentBackupResource = null; 437 ResultSet res = null; 438 List allHeaders = new ArrayList (); 439 PreparedStatement stmt = null; 440 Connection conn = null; 441 Set storage = new HashSet (); 442 443 try { 444 conn = m_sqlManager.getConnection(dbc); 445 stmt = m_sqlManager.getPreparedStatement(conn, "C_RESOURCES_READ_ALL_BACKUP"); 446 res = stmt.executeQuery(); 447 while (res.next()) { 448 currentBackupResource = createBackupResource(res, false); 449 String key = currentBackupResource.getStructureId().toString() 451 + currentBackupResource.getResourceId().toString(); 452 if (!storage.contains(key)) { 453 allHeaders.add(currentBackupResource); 455 storage.add(key); 456 } 457 } 458 } catch (SQLException e) { 459 throw new CmsDbSqlException(Messages.get().container( 460 Messages.ERR_GENERIC_SQL_1, 461 CmsDbSqlException.getErrorQuery(stmt)), e); 462 } finally { 463 m_sqlManager.closeAll(dbc, conn, stmt, res); 464 storage = null; 465 } 466 467 return allHeaders; 468 } 469 470 473 public List readBackupFileHeaders(CmsDbContext dbc, String resourcePath, CmsUUID id) throws CmsDataAccessException { 474 475 CmsBackupResource currentBackupResource = null; 476 ResultSet res = null; 477 List allHeaders = new ArrayList (); 478 PreparedStatement stmt = null; 479 Connection conn = null; 480 481 try { 482 conn = m_sqlManager.getConnection(dbc); 483 stmt = m_sqlManager.getPreparedStatement(conn, "C_RESOURCES_READ_ALL_VERSIONS_BACKUP"); 484 stmt.setString(1, resourcePath); 485 stmt.setString(2, id.toString()); 486 res = stmt.executeQuery(); 487 while (res.next()) { 488 currentBackupResource = createBackupResource(res, false); 489 allHeaders.add(currentBackupResource); 490 } 491 } catch (SQLException e) { 492 throw new CmsDbSqlException(Messages.get().container( 493 Messages.ERR_GENERIC_SQL_1, 494 CmsDbSqlException.getErrorQuery(stmt)), e); 495 } finally { 496 m_sqlManager.closeAll(dbc, conn, stmt, res); 497 } 498 499 return allHeaders; 500 } 501 502 505 public int readBackupMaxVersion(CmsDbContext dbc, CmsUUID resourceId) throws CmsDataAccessException { 506 507 PreparedStatement stmt = null; 508 Connection conn = null; 509 ResultSet res = null; 510 int maxBackupVersion = 0; 511 512 try { 513 conn = m_sqlManager.getConnection(dbc); 514 stmt = m_sqlManager.getPreparedStatement(conn, "C_HISTORY_RESOURCE_MAX_BACKUP_VERSION"); 515 stmt.setString(1, resourceId.toString()); 516 res = stmt.executeQuery(); 517 518 if (res.next()) { 519 maxBackupVersion = res.getInt(1); 520 } else { 521 maxBackupVersion = 0; 522 } 523 } catch (SQLException e) { 524 throw new CmsDbSqlException(Messages.get().container( 525 Messages.ERR_GENERIC_SQL_1, 526 CmsDbSqlException.getErrorQuery(stmt)), e); 527 } finally { 528 m_sqlManager.closeAll(dbc, conn, stmt, res); 529 } 530 531 return maxBackupVersion; 532 } 533 534 537 public CmsBackupProject readBackupProject(CmsDbContext dbc, int tagId) throws CmsDataAccessException { 538 539 PreparedStatement stmt = null; 540 CmsBackupProject project = null; 541 ResultSet res = null; 542 Connection conn = null; 543 try { 544 conn = m_sqlManager.getConnection(dbc); 545 stmt = m_sqlManager.getPreparedStatement(conn, "C_PROJECTS_READBYVERSION_BACKUP"); 546 547 stmt.setInt(1, tagId); 548 res = stmt.executeQuery(); 549 550 if (res.next()) { 551 List projectresources = readBackupProjectResources(dbc, tagId); 552 project = new CmsBackupProject( 553 res.getInt("PUBLISH_TAG"), 554 res.getInt(m_sqlManager.readQuery("C_PROJECTS_PROJECT_ID")), 555 res.getString(m_sqlManager.readQuery("C_PROJECTS_PROJECT_NAME")), 556 res.getString(m_sqlManager.readQuery("C_PROJECTS_PROJECT_DESCRIPTION")), 557 res.getInt(m_sqlManager.readQuery("C_PROJECTS_TASK_ID")), 558 new CmsUUID(res.getString(m_sqlManager.readQuery("C_PROJECTS_USER_ID"))), 559 new CmsUUID(res.getString(m_sqlManager.readQuery("C_PROJECTS_GROUP_ID"))), 560 new CmsUUID(res.getString(m_sqlManager.readQuery("C_PROJECTS_MANAGERGROUP_ID"))), 561 res.getLong(m_sqlManager.readQuery("C_PROJECTS_DATE_CREATED")), 562 res.getInt(m_sqlManager.readQuery("C_PROJECTS_PROJECT_TYPE")), 563 CmsDbUtil.getTimestamp(res, "PROJECT_PUBLISHDATE"), 564 new CmsUUID(res.getString("PROJECT_PUBLISHED_BY")), 565 res.getString("PROJECT_PUBLISHED_BY_NAME"), 566 res.getString("USER_NAME"), 567 res.getString("GROUP_NAME"), 568 res.getString("MANAGERGROUP_NAME"), 569 projectresources); 570 } else { 571 throw new CmsDbEntryNotFoundException(Messages.get().container( 572 Messages.ERR_NO_BACKUP_PROJECT_WITH_TAG_ID_1, 573 new Integer (tagId))); 574 } 575 } catch (SQLException e) { 576 throw new CmsDbSqlException(Messages.get().container( 577 Messages.ERR_GENERIC_SQL_1, 578 CmsDbSqlException.getErrorQuery(stmt)), e); 579 } finally { 580 m_sqlManager.closeAll(dbc, conn, stmt, res); 581 } 582 return project; 583 } 584 585 588 public List readBackupProjectResources(CmsDbContext dbc, int tagId) throws CmsDataAccessException { 589 590 PreparedStatement stmt = null; 591 Connection conn = null; 592 ResultSet res = null; 593 List projectResources = new ArrayList (); 594 595 try { 596 conn = m_sqlManager.getConnection(dbc); 597 stmt = m_sqlManager.getPreparedStatement(conn, "C_PROJECTRESOURCES_READ_BACKUP"); 598 stmt.setInt(1, tagId); 599 res = stmt.executeQuery(); 600 while (res.next()) { 601 projectResources.add(res.getString("RESOURCE_PATH")); 602 } 603 } catch (SQLException e) { 604 throw new CmsDbSqlException(Messages.get().container( 605 Messages.ERR_GENERIC_SQL_1, 606 CmsDbSqlException.getErrorQuery(stmt)), e); 607 } finally { 608 m_sqlManager.closeAll(dbc, conn, stmt, res); 609 } 610 611 return projectResources; 612 } 613 614 617 public List readBackupProjects(CmsDbContext dbc) throws CmsDataAccessException { 618 619 List projects = new ArrayList (); 620 ResultSet res = null; 621 PreparedStatement stmt = null; 622 Connection conn = null; 623 624 try { 625 conn = m_sqlManager.getConnection(dbc); 627 stmt = m_sqlManager.getPreparedStatement(conn, "C_PROJECTS_READLAST_BACKUP"); 628 res = stmt.executeQuery(); 629 int i = 0; 630 int max = 300; 631 632 while (res.next() && (i < max)) { 633 List resources = readBackupProjectResources(dbc, res.getInt("PUBLISH_TAG")); 634 projects.add(new CmsBackupProject( 635 res.getInt("PUBLISH_TAG"), 636 res.getInt("PROJECT_ID"), 637 res.getString("PROJECT_NAME"), 638 res.getString("PROJECT_DESCRIPTION"), 639 res.getInt("TASK_ID"), 640 new CmsUUID(res.getString("USER_ID")), 641 new CmsUUID(res.getString("GROUP_ID")), 642 new CmsUUID(res.getString("MANAGERGROUP_ID")), 643 res.getLong("DATE_CREATED"), 644 res.getInt("PROJECT_TYPE"), 645 CmsDbUtil.getTimestamp(res, "PROJECT_PUBLISHDATE"), 646 new CmsUUID(res.getString("PROJECT_PUBLISHED_BY")), 647 res.getString("PROJECT_PUBLISHED_BY_NAME"), 648 res.getString("USER_NAME"), 649 res.getString("GROUP_NAME"), 650 res.getString("MANAGERGROUP_NAME"), 651 resources)); 652 i++; 653 } 654 } catch (SQLException e) { 655 throw new CmsDbSqlException(Messages.get().container( 656 Messages.ERR_GENERIC_SQL_1, 657 CmsDbSqlException.getErrorQuery(stmt)), e); 658 } finally { 659 m_sqlManager.closeAll(dbc, conn, stmt, res); 660 } 661 return (projects); 662 } 663 664 667 public int readBackupProjectTag(CmsDbContext dbc, long maxdate) throws CmsDataAccessException { 668 669 ResultSet res = null; 670 PreparedStatement stmt = null; 671 Connection conn = null; 672 int maxVersion = 0; 673 674 try { 675 conn = m_sqlManager.getConnection(dbc); 676 stmt = m_sqlManager.getPreparedStatement(conn, "C_BACKUP_READ_MAXVERSION"); 677 stmt.setTimestamp(1, new Timestamp (maxdate)); 678 res = stmt.executeQuery(); 679 if (res.next()) { 680 maxVersion = res.getInt(1); 681 } 682 } catch (SQLException e) { 683 throw new CmsDbSqlException(Messages.get().container( 684 Messages.ERR_GENERIC_SQL_1, 685 CmsDbSqlException.getErrorQuery(stmt)), e); 686 } finally { 687 m_sqlManager.closeAll(dbc, conn, stmt, res); 688 } 689 return maxVersion; 690 } 691 692 695 public List readBackupProperties(CmsDbContext dbc, CmsBackupResource resource) throws CmsDataAccessException { 696 697 ResultSet res = null; 698 PreparedStatement stmt = null; 699 Connection conn = null; 700 String propertyKey = null; 701 String propertyValue = null; 702 int mappingType = -1; 703 Map propertyMap = new HashMap (); 704 CmsProperty property = null; 705 706 try { 707 conn = m_sqlManager.getConnection(dbc); 708 stmt = m_sqlManager.getPreparedStatement(conn, "C_PROPERTIES_READALL_BACKUP"); 709 stmt.setString(1, resource.getStructureId().toString()); 710 stmt.setString(2, resource.getResourceId().toString()); 711 stmt.setInt(3, resource.getTagId()); 712 res = stmt.executeQuery(); 713 714 while (res.next()) { 715 propertyKey = res.getString(1); 716 propertyValue = res.getString(2); 717 mappingType = res.getInt(3); 718 719 property = (CmsProperty)propertyMap.get(propertyKey); 720 if (property != null) { 721 723 switch (mappingType) { 724 case CmsProperty.STRUCTURE_RECORD_MAPPING: 725 property.setStructureValue(propertyValue); 727 break; 728 case CmsProperty.RESOURCE_RECORD_MAPPING: 729 property.setResourceValue(propertyValue); 731 break; 732 default: 733 throw new CmsDbConsistencyException(Messages.get().container( 734 Messages.ERR_UNKNOWN_PROPERTY_VALUE_MAPPING_3, 735 resource.getRootPath(), 736 new Integer (mappingType), 737 propertyKey)); 738 } 739 } else { 740 property = new CmsProperty(); 742 property.setName(propertyKey); 743 744 switch (mappingType) { 745 case CmsProperty.STRUCTURE_RECORD_MAPPING: 746 property.setStructureValue(propertyValue); 748 property.setResourceValue(null); 749 break; 750 case CmsProperty.RESOURCE_RECORD_MAPPING: 751 property.setStructureValue(null); 753 property.setResourceValue(propertyValue); 754 break; 755 default: 756 throw new CmsDbConsistencyException(Messages.get().container( 757 Messages.ERR_UNKNOWN_PROPERTY_VALUE_MAPPING_3, 758 resource.getRootPath(), 759 new Integer (mappingType), 760 propertyKey)); 761 } 762 763 propertyMap.put(propertyKey, property); 764 } 765 } 766 } catch (SQLException e) { 767 throw new CmsDbSqlException(Messages.get().container( 768 Messages.ERR_GENERIC_SQL_1, 769 CmsDbSqlException.getErrorQuery(stmt)), e); 770 } finally { 771 m_sqlManager.closeAll(dbc, conn, stmt, res); 772 } 773 774 return new ArrayList (propertyMap.values()); 775 } 776 777 780 public CmsPropertyDefinition readBackupPropertyDefinition(CmsDbContext dbc, String name) 781 throws CmsDataAccessException { 782 783 CmsPropertyDefinition propDef = null; 784 ResultSet res = null; 785 PreparedStatement stmt = null; 786 Connection conn = null; 787 788 try { 789 conn = m_sqlManager.getConnection(dbc); 790 stmt = m_sqlManager.getPreparedStatement(conn, "C_PROPERTYDEF_READ_BACKUP"); 791 stmt.setString(1, name); 792 res = stmt.executeQuery(); 793 794 if (res.next()) { 795 propDef = new CmsPropertyDefinition( 796 new CmsUUID(res.getString(m_sqlManager.readQuery("C_PROPERTYDEF_ID"))), 797 res.getString(m_sqlManager.readQuery("C_PROPERTYDEF_NAME"))); 798 } else { 799 throw new CmsDbEntryNotFoundException(Messages.get().container( 800 Messages.ERR_NO_PROPERTYDEF_WITH_NAME_1, 801 name)); 802 } 803 } catch (SQLException e) { 804 throw new CmsDbSqlException(Messages.get().container( 805 Messages.ERR_GENERIC_SQL_1, 806 CmsDbSqlException.getErrorQuery(stmt)), e); 807 } finally { 808 m_sqlManager.closeAll(dbc, conn, stmt, res); 809 } 810 811 return propDef; 812 } 813 814 817 public int readMaxTagId(CmsDbContext dbc, CmsResource resource) throws CmsDataAccessException { 818 819 PreparedStatement stmt = null; 820 Connection conn = null; 821 ResultSet res = null; 822 int result = 0; 823 824 try { 825 conn = m_sqlManager.getConnection(dbc); 826 stmt = m_sqlManager.getPreparedStatement(conn, "C_RESOURCES_READ_MAX_PUBLISH_TAG"); 827 stmt.setString(1, resource.getResourceId().toString()); 828 res = stmt.executeQuery(); 829 830 if (res.next()) { 831 result = res.getInt(1); 832 } 833 } catch (SQLException e) { 834 throw new CmsDbSqlException(Messages.get().container( 835 Messages.ERR_GENERIC_SQL_1, 836 CmsDbSqlException.getErrorQuery(stmt)), e); 837 } finally { 838 m_sqlManager.closeAll(dbc, conn, stmt, res); 839 } 840 841 return result; 842 } 843 844 847 public int readNextBackupTagId(CmsDbContext dbc) { 848 849 PreparedStatement stmt = null; 850 Connection conn = null; 851 ResultSet res = null; 852 int projectBackupTagId = 1; 853 int resourceBackupTagId = 1; 854 855 try { 856 conn = m_sqlManager.getConnection(dbc); 858 stmt = m_sqlManager.getPreparedStatement(conn, "C_RESOURCES_BACKUP_MAXTAG"); 859 res = stmt.executeQuery(); 860 861 if (res.next()) { 862 projectBackupTagId = res.getInt(1) + 1; 863 } 864 865 m_sqlManager.closeAll(dbc, null, stmt, res); 866 867 stmt = m_sqlManager.getPreparedStatement(conn, "C_RESOURCES_BACKUP_MAXTAG_RESOURCE"); 868 res = stmt.executeQuery(); 869 870 if (res.next()) { 871 resourceBackupTagId = res.getInt(1) + 1; 872 } 873 874 if (resourceBackupTagId > projectBackupTagId) { 875 projectBackupTagId = resourceBackupTagId; 876 } 877 } catch (SQLException exc) { 878 return 1; 879 } finally { 880 m_sqlManager.closeAll(dbc, conn, stmt, res); 881 } 882 883 return projectBackupTagId; 884 } 885 886 889 public void writeBackupProject(CmsDbContext dbc, int tagId, long publishDate) throws CmsDataAccessException { 890 891 Connection conn = null; 892 PreparedStatement stmt = null; 893 String group = null; 894 String managerGroup = null; 895 896 CmsProject currentProject = dbc.currentProject(); 897 CmsUser currentUser = dbc.currentUser(); 898 899 CmsUser owner = m_driverManager.getUserDriver().readUser(dbc, currentProject.getOwnerId()); 900 901 StringBuffer buf = new StringBuffer (); 902 buf.append(owner.getName()).append(" ").append(owner.getFirstname()).append(" ").append(owner.getLastname()); 903 String ownerName = buf.toString(); 904 905 try { 906 group = m_driverManager.getUserDriver().readGroup(dbc, currentProject.getGroupId()).getName(); 907 } catch (CmsDbEntryNotFoundException e) { 908 group = ""; 910 } 911 912 try { 913 managerGroup = m_driverManager.getUserDriver().readGroup(dbc, currentProject.getManagerGroupId()).getName(); 914 } catch (CmsDbEntryNotFoundException e) { 915 managerGroup = ""; 917 } 918 919 List projectresources = m_driverManager.getProjectDriver().readProjectResources(dbc, currentProject); 920 921 try { 923 conn = m_sqlManager.getConnection(dbc); 924 925 stmt = m_sqlManager.getPreparedStatement(conn, "C_PROJECTS_CREATE_BACKUP"); 926 stmt.setInt(1, tagId); 928 stmt.setInt(2, currentProject.getId()); 929 stmt.setString(3, currentProject.getName()); 930 stmt.setTimestamp(4, new Timestamp (publishDate)); 931 stmt.setString(5, currentUser.getId().toString()); 932 stmt.setString(6, currentUser.getName() 933 + " " 934 + currentUser.getFirstname() 935 + " " 936 + currentUser.getLastname()); 937 stmt.setString(7, currentProject.getOwnerId().toString()); 938 stmt.setString(8, ownerName); 939 stmt.setString(9, currentProject.getGroupId().toString()); 940 stmt.setString(10, group); 941 stmt.setString(11, currentProject.getManagerGroupId().toString()); 942 stmt.setString(12, managerGroup); 943 stmt.setString(13, currentProject.getDescription()); 944 stmt.setLong(14, currentProject.getDateCreated()); 945 stmt.setInt(15, currentProject.getType()); 946 stmt.setInt(16, currentProject.getTaskId()); 947 stmt.executeUpdate(); 948 949 m_sqlManager.closeAll(dbc, null, stmt, null); 950 951 stmt = m_sqlManager.getPreparedStatement(conn, "C_PROJECTRESOURCES_CREATE_BACKUP"); 953 Iterator i = projectresources.iterator(); 954 while (i.hasNext()) { 955 stmt.setInt(1, tagId); 956 stmt.setInt(2, currentProject.getId()); 957 stmt.setString(3, (String )i.next()); 958 stmt.executeUpdate(); 959 stmt.clearParameters(); 960 } 961 } catch (SQLException e) { 962 throw new CmsDbSqlException(Messages.get().container( 963 Messages.ERR_GENERIC_SQL_1, 964 CmsDbSqlException.getErrorQuery(stmt)), e); 965 } finally { 966 m_sqlManager.closeAll(dbc, conn, stmt, null); 967 } 968 } 969 970 973 public void writeBackupProperties( 974 CmsDbContext dbc, 975 CmsResource resource, 976 List properties, 977 CmsUUID backupId, 978 int tagId, 979 int versionId) throws CmsDataAccessException { 980 981 Connection conn = null; 982 PreparedStatement stmt = null; 983 String propDefName = null; 984 CmsProperty property = null; 985 int mappingType = -1; 986 String value = null; 987 CmsUUID id = null; 988 CmsPropertyDefinition propDef = null; 989 990 try { 991 conn = m_sqlManager.getConnection(dbc); 992 993 Iterator dummy = properties.iterator(); 994 while (dummy.hasNext()) { 995 property = (CmsProperty)dummy.next(); 996 propDefName = property.getName(); 997 propDef = readBackupPropertyDefinition(dbc, propDefName); 998 999 for (int i = 0; i < 2; i++) { 1000 mappingType = -1; 1001 value = null; 1002 id = null; 1003 1004 if (i == 0) { 1005 value = property.getStructureValue(); 1007 mappingType = CmsProperty.STRUCTURE_RECORD_MAPPING; 1008 id = resource.getStructureId(); 1009 1010 if (CmsStringUtil.isEmpty(value)) { 1011 continue; 1012 } 1013 } else { 1014 value = property.getResourceValue(); 1016 mappingType = CmsProperty.RESOURCE_RECORD_MAPPING; 1017 id = resource.getResourceId(); 1018 1019 if (CmsStringUtil.isEmpty(value)) { 1020 break; 1021 } 1022 } 1023 1024 stmt = m_sqlManager.getPreparedStatement(conn, "C_PROPERTIES_CREATE_BACKUP"); 1025 1026 stmt.setString(1, backupId.toString()); 1027 stmt.setString(2, new CmsUUID().toString()); 1028 stmt.setString(3, propDef.getId().toString()); 1029 stmt.setString(4, id.toString()); 1030 stmt.setInt(5, mappingType); 1031 stmt.setString(6, m_sqlManager.validateEmpty(value)); 1032 stmt.setInt(7, tagId); 1033 stmt.setInt(8, versionId); 1034 1035 stmt.executeUpdate(); 1036 m_sqlManager.closeAll(dbc, null, stmt, null); 1037 } 1038 } 1039 } catch (SQLException e) { 1040 throw new CmsDbSqlException(Messages.get().container( 1041 Messages.ERR_GENERIC_SQL_1, 1042 CmsDbSqlException.getErrorQuery(stmt)), e); 1043 } finally { 1044 m_sqlManager.closeAll(dbc, conn, stmt, null); 1045 } 1046 } 1047 1048 1051 public void writeBackupResource( 1052 CmsDbContext dbc, 1053 CmsResource resource, 1054 List properties, 1055 int tagId, 1056 long publishDate, 1057 int maxVersions) throws CmsDataAccessException { 1058 1059 Connection conn = null; 1060 PreparedStatement stmt = null; 1061 CmsUUID backupPkId = new CmsUUID(); 1062 int versionId = -1; 1063 1064 String lastModifiedName = ""; 1065 String createdName = ""; 1066 try { 1067 CmsUser lastModified = m_driverManager.getUserDriver().readUser(dbc, resource.getUserLastModified()); 1068 lastModifiedName = lastModified.getName(); 1069 CmsUser created = m_driverManager.getUserDriver().readUser(dbc, resource.getUserCreated()); 1070 createdName = created.getName(); 1071 } catch (CmsDataAccessException e) { 1072 lastModifiedName = resource.getUserCreated().toString(); 1073 createdName = resource.getUserLastModified().toString(); 1074 } 1075 1076 try { 1077 conn = m_sqlManager.getConnection(dbc); 1078 1079 versionId = internalReadNextVersionId(dbc, resource); 1081 1082 if (resource.isFile()) { 1083 1084 if (!this.internalValidateBackupResource(dbc, resource, tagId)) { 1085 1086 internalWriteBackupFileContent(dbc, backupPkId, resource, tagId, versionId); 1088 1089 stmt = m_sqlManager.getPreparedStatement(conn, "C_RESOURCES_WRITE_BACKUP"); 1091 stmt.setString(1, resource.getResourceId().toString()); 1092 stmt.setInt(2, resource.getTypeId()); 1093 stmt.setInt(3, resource.getFlags()); 1094 stmt.setLong(4, publishDate); 1095 stmt.setString(5, resource.getUserCreated().toString()); 1096 stmt.setLong(6, resource.getDateLastModified()); 1097 stmt.setString(7, resource.getUserLastModified().toString()); 1098 stmt.setInt(8, resource.getState()); 1099 stmt.setInt(9, resource.getLength()); 1100 stmt.setInt(10, dbc.currentProject().getId()); 1101 stmt.setInt(11, 1); 1102 stmt.setInt(12, tagId); 1103 stmt.setInt(13, versionId); 1104 stmt.setString(14, backupPkId.toString()); 1105 stmt.setString(15, createdName); 1106 stmt.setString(16, lastModifiedName); 1107 stmt.executeUpdate(); 1108 1109 m_sqlManager.closeAll(dbc, null, stmt, null); 1110 } 1111 } 1112 1113 stmt = m_sqlManager.getPreparedStatement(conn, "C_STRUCTURE_WRITE_BACKUP"); 1115 stmt.setString(1, resource.getStructureId().toString()); 1116 stmt.setString(2, resource.getResourceId().toString()); 1117 stmt.setString(3, resource.getRootPath()); 1118 stmt.setInt(4, resource.getState()); 1119 stmt.setLong(5, resource.getDateReleased()); 1120 stmt.setLong(6, resource.getDateExpired()); 1121 stmt.setInt(7, tagId); 1122 stmt.setInt(8, versionId); 1123 stmt.setString(9, backupPkId.toString()); 1124 stmt.executeUpdate(); 1125 1126 writeBackupProperties(dbc, resource, properties, backupPkId, tagId, versionId); 1127 1128 List existingBackups = readBackupFileHeaders(dbc, resource.getRootPath(), resource.getStructureId()); 1130 if (existingBackups.size() > maxVersions) { 1131 deleteBackups(dbc, existingBackups, maxVersions); 1133 } 1134 1135 } catch (SQLException e) { 1136 throw new CmsDbSqlException(Messages.get().container( 1137 Messages.ERR_GENERIC_SQL_1, 1138 CmsDbSqlException.getErrorQuery(stmt)), e); 1139 } finally { 1140 m_sqlManager.closeAll(dbc, conn, stmt, null); 1141 } 1142 1143 } 1144 1145 1150 protected void finalize() throws Throwable { 1151 1152 try { 1153 m_sqlManager = null; 1154 m_driverManager = null; 1155 } catch (Throwable t) { 1156 } 1158 super.finalize(); 1159 } 1160 1161 1171 protected int internalCountProperties(CmsDbContext dbc, CmsPropertyDefinition metadef, int projectId) 1172 throws CmsDataAccessException { 1173 1174 ResultSet res = null; 1175 PreparedStatement stmt = null; 1176 Connection conn = null; 1177 1178 int returnValue; 1179 try { 1180 conn = m_sqlManager.getConnection(dbc); 1182 stmt = m_sqlManager.getPreparedStatement(conn, projectId, "C_PROPERTIES_READALL_COUNT"); 1183 stmt.setString(1, metadef.getId().toString()); 1184 res = stmt.executeQuery(); 1185 1186 if (res.next()) { 1187 returnValue = res.getInt(1); 1188 } else { 1189 throw new CmsDbConsistencyException(Messages.get().container( 1190 Messages.ERR_NO_PROPERTIES_FOR_PROPERTYDEF_1, 1191 metadef.getName())); 1192 } 1193 } catch (SQLException e) { 1194 throw new CmsDbSqlException(Messages.get().container( 1195 Messages.ERR_GENERIC_SQL_1, 1196 CmsDbSqlException.getErrorQuery(stmt)), e); 1197 } finally { 1198 m_sqlManager.closeAll(dbc, conn, stmt, res); 1199 } 1200 return returnValue; 1201 } 1202 1203 1214 protected void internalWriteBackupFileContent( 1215 CmsDbContext dbc, 1216 CmsUUID backupId, 1217 CmsResource resource, 1218 int tagId, 1219 int versionId) throws CmsDataAccessException { 1220 1221 Connection conn = null; 1222 PreparedStatement stmt = null; 1223 1224 CmsUUID contentId; 1225 byte[] fileContent; 1226 if (resource instanceof CmsFile) { 1227 contentId = ((CmsFile)resource).getContentId(); 1228 fileContent = ((CmsFile)resource).getContents(); 1229 } else { 1230 contentId = CmsUUID.getNullUUID(); 1231 fileContent = new byte[0]; 1232 } 1233 1234 try { 1235 conn = m_sqlManager.getConnection(dbc); 1236 stmt = m_sqlManager.getPreparedStatement(conn, "C_CONTENTS_WRITE_BACKUP"); 1237 stmt.setString(1, contentId.toString()); 1238 stmt.setString(2, resource.getResourceId().toString()); 1239 1240 if (fileContent.length < 2000) { 1241 stmt.setBytes(3, fileContent); 1242 } else { 1243 stmt.setBinaryStream(3, new ByteArrayInputStream (fileContent), fileContent.length); 1244 } 1245 1246 stmt.setInt(4, tagId); 1247 stmt.setInt(5, versionId); 1248 stmt.setString(6, backupId.toString()); 1249 1250 stmt.executeUpdate(); 1251 fileContent = null; 1252 } catch (SQLException e) { 1253 throw new CmsDbSqlException(Messages.get().container( 1254 Messages.ERR_GENERIC_SQL_1, 1255 CmsDbSqlException.getErrorQuery(stmt)), e); 1256 } finally { 1257 m_sqlManager.closeAll(dbc, conn, stmt, null); 1258 } 1259 } 1260 1261 1269 private int internalReadNextVersionId(CmsDbContext dbc, CmsResource resource) { 1270 1271 PreparedStatement stmt = null; 1272 Connection conn = null; 1273 ResultSet res = null; 1274 int versionId = 1; 1275 1276 try { 1277 conn = m_sqlManager.getConnection(dbc); 1279 stmt = m_sqlManager.getPreparedStatement(conn, "C_RESOURCES_BACKUP_MAXVER"); 1280 stmt.setString(1, resource.getRootPath()); 1281 res = stmt.executeQuery(); 1282 if (res.next()) { 1283 versionId = res.getInt(1) + 1; 1284 } 1285 1286 return versionId; 1287 } catch (SQLException exc) { 1288 return 1; 1289 } finally { 1290 m_sqlManager.closeAll(dbc, conn, stmt, res); 1291 } 1292 } 1293 1294 1304 private boolean internalValidateBackupResource(CmsDbContext dbc, CmsResource resource, int tagId) 1305 throws CmsDataAccessException { 1306 1307 Connection conn = null; 1308 PreparedStatement stmt = null; 1309 ResultSet res = null; 1310 boolean exists = false; 1311 1312 try { 1313 conn = m_sqlManager.getConnection(dbc); 1314 stmt = m_sqlManager.getPreparedStatement(conn, "C_BACKUP_EXISTS_RESOURCE"); 1315 stmt.setString(1, resource.getResourceId().toString()); 1316 stmt.setInt(2, tagId); 1317 res = stmt.executeQuery(); 1318 1319 exists = res.next(); 1320 1321 } catch (SQLException e) { 1322 throw new CmsDbSqlException(Messages.get().container( 1323 Messages.ERR_GENERIC_SQL_1, 1324 CmsDbSqlException.getErrorQuery(stmt)), e); 1325 } finally { 1326 m_sqlManager.closeAll(dbc, conn, stmt, res); 1327 } 1328 return exists; 1329 } 1330 1331} 1332 | Popular Tags |