KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > opencms > db > generic > CmsBackupDriver


1 /*
2  * File : $Source: /usr/local/cvs/opencms/src/org/opencms/db/generic/CmsBackupDriver.java,v $
3  * Date : $Date: 2006/03/27 14:52:54 $
4  * Version: $Revision: 1.141 $
5  *
6  * This library is part of OpenCms -
7  * the Open Source Content Mananagement System
8  *
9  * Copyright (c) 2005 Alkacon Software GmbH (http://www.alkacon.com)
10  *
11  * This library is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * This library is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * For further information about Alkacon Software GmbH, please see the
22  * company website: http://www.alkacon.com
23  *
24  * For further information about OpenCms, please see the
25  * project website: http://www.opencms.org
26  *
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30  */

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 JavaDoc;
58 import java.sql.Connection JavaDoc;
59 import java.sql.PreparedStatement JavaDoc;
60 import java.sql.ResultSet JavaDoc;
61 import java.sql.SQLException JavaDoc;
62 import java.sql.Timestamp JavaDoc;
63 import java.util.ArrayList JavaDoc;
64 import java.util.HashMap JavaDoc;
65 import java.util.HashSet JavaDoc;
66 import java.util.Iterator JavaDoc;
67 import java.util.List JavaDoc;
68 import java.util.Map JavaDoc;
69 import java.util.Set JavaDoc;
70
71 import org.apache.commons.logging.Log;
72
73 /**
74  * Generic (ANSI-SQL) database server implementation of the backup driver methods.<p>
75  *
76  * @author Thomas Weckert
77  * @author Michael Emmerich
78  * @author Carsten Weinholz
79  *
80  * @version $Revision: 1.141 $
81  *
82  * @since 6.0.0
83  */

84 public class CmsBackupDriver implements I_CmsDriver, I_CmsBackupDriver {
85
86     /** The log object for this class. */
87     private static final Log LOG = CmsLog.getLog(org.opencms.db.generic.CmsBackupDriver.class);
88
89     /** The driver manager instance. */
90     protected CmsDriverManager m_driverManager;
91
92     /** The SQL manager instance. */
93     protected org.opencms.db.generic.CmsSqlManager m_sqlManager;
94
95     /**
96      * @see org.opencms.db.I_CmsBackupDriver#createBackupPropertyDefinition(org.opencms.db.CmsDbContext, java.lang.String)
97      */

98     public CmsPropertyDefinition createBackupPropertyDefinition(CmsDbContext dbc, String JavaDoc name)
99     throws CmsDataAccessException {
100
101         Connection JavaDoc conn = null;
102         PreparedStatement JavaDoc 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 JavaDoc 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     /**
123      * @see org.opencms.db.I_CmsBackupDriver#createBackupResource(java.sql.ResultSet, boolean)
124      */

125     public CmsBackupResource createBackupResource(ResultSet JavaDoc res, boolean hasContent) throws SQLException JavaDoc {
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 JavaDoc 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 JavaDoc 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 JavaDoc 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     /**
182      * @see org.opencms.db.I_CmsBackupDriver#deleteBackup(org.opencms.db.CmsDbContext, org.opencms.file.CmsBackupResource, int, int)
183      */

184     public void deleteBackup(CmsDbContext dbc, CmsBackupResource resource, int tag, int versions)
185     throws CmsDataAccessException {
186
187         ResultSet JavaDoc res = null;
188         PreparedStatement JavaDoc stmt = null;
189         PreparedStatement JavaDoc stmt1 = null;
190         PreparedStatement JavaDoc stmt2 = null;
191         PreparedStatement JavaDoc stmt3 = null;
192         PreparedStatement JavaDoc stmt4 = null;
193         Connection JavaDoc conn = null;
194         List JavaDoc backupIds = new ArrayList JavaDoc();
195
196         // first get all backup ids of the entries which should be deleted
197
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             // now collect all backupId's for deletion
206
while (res.next()) {
207                 backupIds.add(res.getString(1));
208             }
209             // we have all the nescessary information, so we can delete the old backups
210
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 JavaDoc i = backupIds.iterator();
215             while (i.hasNext()) {
216                 String JavaDoc backupId = (String JavaDoc)i.next();
217                 //delete the structure
218
stmt1.setString(1, backupId);
219                 stmt1.addBatch();
220                 //delete the resource
221
stmt2.setString(1, backupId);
222                 stmt2.addBatch();
223                 //delete the file
224
stmt3.setString(1, backupId);
225                 stmt3.addBatch();
226                 //delete the properties
227
stmt4.setString(1, backupId);
228                 stmt4.addBatch();
229             }
230             // excecute them
231
stmt1.executeBatch();
232             stmt2.executeBatch();
233             stmt3.executeBatch();
234             stmt4.executeBatch();
235
236         } catch (SQLException JavaDoc 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     /**
250      * @see org.opencms.db.I_CmsBackupDriver#deleteBackupPropertyDefinition(org.opencms.db.CmsDbContext, org.opencms.file.CmsPropertyDefinition)
251      */

252     public void deleteBackupPropertyDefinition(CmsDbContext dbc, CmsPropertyDefinition metadef)
253     throws CmsDataAccessException {
254
255         Connection JavaDoc conn = null;
256         PreparedStatement JavaDoc 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             // delete the backup propertydef
268
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 JavaDoc 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     /**
282      * @see org.opencms.db.I_CmsBackupDriver#deleteBackups(org.opencms.db.CmsDbContext, java.util.List, int)
283      */

284     public void deleteBackups(CmsDbContext dbc, List JavaDoc existingBackups, int maxVersions) throws CmsDataAccessException {
285
286         PreparedStatement JavaDoc stmt1 = null;
287         PreparedStatement JavaDoc stmt2 = null;
288         PreparedStatement JavaDoc stmt3 = null;
289         PreparedStatement JavaDoc stmt4 = null;
290         Connection JavaDoc 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                 // delete the resource
304
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                 // delete the properties
312
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 JavaDoc 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     /**
339      * @see org.opencms.db.I_CmsBackupDriver#destroy()
340      */

341     public void destroy() throws Throwable JavaDoc {
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     /**
350      * @see org.opencms.db.I_CmsBackupDriver#getSqlManager()
351      */

352     public CmsSqlManager getSqlManager() {
353
354         return m_sqlManager;
355     }
356
357     /**
358      * @see org.opencms.db.I_CmsDriver#init(org.opencms.db.CmsDbContext, org.opencms.configuration.CmsConfigurationManager, java.util.List, org.opencms.db.CmsDriverManager)
359      */

360     public void init(
361         CmsDbContext dbc,
362         CmsConfigurationManager configurationManager,
363         List JavaDoc successiveDrivers,
364         CmsDriverManager driverManager) {
365
366         Map JavaDoc configuration = configurationManager.getConfiguration();
367         String JavaDoc poolUrl = configuration.get("db.backup.pool").toString();
368         String JavaDoc 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     /**
386      * @see org.opencms.db.I_CmsBackupDriver#initSqlManager(String)
387      */

388     public org.opencms.db.generic.CmsSqlManager initSqlManager(String JavaDoc classname) {
389
390         return CmsSqlManager.getInstance(classname);
391     }
392
393     /**
394      * @see org.opencms.db.I_CmsBackupDriver#readBackupFile(CmsDbContext, int, String)
395      */

396     public CmsBackupResource readBackupFile(CmsDbContext dbc, int tagId, String JavaDoc resourcePath)
397     throws CmsDataAccessException {
398
399         CmsBackupResource file = null;
400         PreparedStatement JavaDoc stmt = null;
401         ResultSet JavaDoc res = null;
402         Connection JavaDoc 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                     // do nothing only move through all rows because of mssql odbc driver
414
}
415             } else {
416                 throw new CmsVfsResourceNotFoundException(Messages.get().container(
417                     Messages.ERR_BACKUP_FILE_NOT_FOUND_1,
418                     resourcePath.toString()));
419             }
420         } catch (SQLException JavaDoc 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     /**
432      * @see org.opencms.db.I_CmsBackupDriver#readBackupFileHeaders(org.opencms.db.CmsDbContext)
433      */

434     public List JavaDoc readBackupFileHeaders(CmsDbContext dbc) throws CmsDataAccessException {
435
436         CmsBackupResource currentBackupResource = null;
437         ResultSet JavaDoc res = null;
438         List JavaDoc allHeaders = new ArrayList JavaDoc();
439         PreparedStatement JavaDoc stmt = null;
440         Connection JavaDoc conn = null;
441         Set JavaDoc storage = new HashSet JavaDoc();
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                 // only add each structureId x resourceId combination once
450
String JavaDoc key = currentBackupResource.getStructureId().toString()
451                     + currentBackupResource.getResourceId().toString();
452                 if (!storage.contains(key)) {
453                     // no entry found, so add it
454
allHeaders.add(currentBackupResource);
455                     storage.add(key);
456                 }
457             }
458         } catch (SQLException JavaDoc 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     /**
471      * @see org.opencms.db.I_CmsBackupDriver#readBackupFileHeaders(org.opencms.db.CmsDbContext, java.lang.String, org.opencms.util.CmsUUID)
472      */

473     public List JavaDoc readBackupFileHeaders(CmsDbContext dbc, String JavaDoc resourcePath, CmsUUID id) throws CmsDataAccessException {
474
475         CmsBackupResource currentBackupResource = null;
476         ResultSet JavaDoc res = null;
477         List JavaDoc allHeaders = new ArrayList JavaDoc();
478         PreparedStatement JavaDoc stmt = null;
479         Connection JavaDoc 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 JavaDoc 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     /**
503      * @see org.opencms.db.I_CmsBackupDriver#readBackupMaxVersion(org.opencms.db.CmsDbContext, org.opencms.util.CmsUUID)
504      */

505     public int readBackupMaxVersion(CmsDbContext dbc, CmsUUID resourceId) throws CmsDataAccessException {
506
507         PreparedStatement JavaDoc stmt = null;
508         Connection JavaDoc conn = null;
509         ResultSet JavaDoc 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 JavaDoc 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     /**
535      * @see org.opencms.db.I_CmsBackupDriver#readBackupProject(org.opencms.db.CmsDbContext, int)
536      */

537     public CmsBackupProject readBackupProject(CmsDbContext dbc, int tagId) throws CmsDataAccessException {
538
539         PreparedStatement JavaDoc stmt = null;
540         CmsBackupProject project = null;
541         ResultSet JavaDoc res = null;
542         Connection JavaDoc 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 JavaDoc 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 JavaDoc(tagId)));
574             }
575         } catch (SQLException JavaDoc 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     /**
586      * @see org.opencms.db.I_CmsBackupDriver#readBackupProjectResources(org.opencms.db.CmsDbContext, int)
587      */

588     public List JavaDoc readBackupProjectResources(CmsDbContext dbc, int tagId) throws CmsDataAccessException {
589
590         PreparedStatement JavaDoc stmt = null;
591         Connection JavaDoc conn = null;
592         ResultSet JavaDoc res = null;
593         List JavaDoc projectResources = new ArrayList JavaDoc();
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 JavaDoc 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     /**
615      * @see org.opencms.db.I_CmsBackupDriver#readBackupProjects(org.opencms.db.CmsDbContext)
616      */

617     public List JavaDoc readBackupProjects(CmsDbContext dbc) throws CmsDataAccessException {
618
619         List JavaDoc projects = new ArrayList JavaDoc();
620         ResultSet JavaDoc res = null;
621         PreparedStatement JavaDoc stmt = null;
622         Connection JavaDoc conn = null;
623
624         try {
625             // create the statement
626
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 JavaDoc 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 JavaDoc 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     /**
665      * @see org.opencms.db.I_CmsBackupDriver#readBackupProjectTag(org.opencms.db.CmsDbContext, long)
666      */

667     public int readBackupProjectTag(CmsDbContext dbc, long maxdate) throws CmsDataAccessException {
668
669         ResultSet JavaDoc res = null;
670         PreparedStatement JavaDoc stmt = null;
671         Connection JavaDoc 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 JavaDoc(maxdate));
678             res = stmt.executeQuery();
679             if (res.next()) {
680                 maxVersion = res.getInt(1);
681             }
682         } catch (SQLException JavaDoc 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     /**
693      * @see org.opencms.db.I_CmsBackupDriver#readBackupProperties(org.opencms.db.CmsDbContext, org.opencms.file.CmsBackupResource)
694      */

695     public List JavaDoc readBackupProperties(CmsDbContext dbc, CmsBackupResource resource) throws CmsDataAccessException {
696
697         ResultSet JavaDoc res = null;
698         PreparedStatement JavaDoc stmt = null;
699         Connection JavaDoc conn = null;
700         String JavaDoc propertyKey = null;
701         String JavaDoc propertyValue = null;
702         int mappingType = -1;
703         Map JavaDoc propertyMap = new HashMap JavaDoc();
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                     // there exists already a property for this key in the result
722

723                     switch (mappingType) {
724                         case CmsProperty.STRUCTURE_RECORD_MAPPING:
725                             // this property value is mapped to a structure record
726
property.setStructureValue(propertyValue);
727                             break;
728                         case CmsProperty.RESOURCE_RECORD_MAPPING:
729                             // this property value is mapped to a resource record
730
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 JavaDoc(mappingType),
737                                 propertyKey));
738                     }
739                 } else {
740                     // there doesn't exist a property for this key yet
741
property = new CmsProperty();
742                     property.setName(propertyKey);
743
744                     switch (mappingType) {
745                         case CmsProperty.STRUCTURE_RECORD_MAPPING:
746                             // this property value is mapped to a structure record
747
property.setStructureValue(propertyValue);
748                             property.setResourceValue(null);
749                             break;
750                         case CmsProperty.RESOURCE_RECORD_MAPPING:
751                             // this property value is mapped to a resource record
752
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 JavaDoc(mappingType),
760                                 propertyKey));
761                     }
762
763                     propertyMap.put(propertyKey, property);
764                 }
765             }
766         } catch (SQLException JavaDoc 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 JavaDoc(propertyMap.values());
775     }
776
777     /**
778      * @see org.opencms.db.I_CmsBackupDriver#readBackupPropertyDefinition(org.opencms.db.CmsDbContext, java.lang.String)
779      */

780     public CmsPropertyDefinition readBackupPropertyDefinition(CmsDbContext dbc, String JavaDoc name)
781     throws CmsDataAccessException {
782
783         CmsPropertyDefinition propDef = null;
784         ResultSet JavaDoc res = null;
785         PreparedStatement JavaDoc stmt = null;
786         Connection JavaDoc 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 JavaDoc 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     /**
815      * @see org.opencms.db.I_CmsBackupDriver#readMaxTagId(org.opencms.db.CmsDbContext, org.opencms.file.CmsResource)
816      */

817     public int readMaxTagId(CmsDbContext dbc, CmsResource resource) throws CmsDataAccessException {
818
819         PreparedStatement JavaDoc stmt = null;
820         Connection JavaDoc conn = null;
821         ResultSet JavaDoc 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 JavaDoc 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     /**
845      * @see org.opencms.db.I_CmsBackupDriver#readNextBackupTagId(org.opencms.db.CmsDbContext)
846      */

847     public int readNextBackupTagId(CmsDbContext dbc) {
848
849         PreparedStatement JavaDoc stmt = null;
850         Connection JavaDoc conn = null;
851         ResultSet JavaDoc res = null;
852         int projectBackupTagId = 1;
853         int resourceBackupTagId = 1;
854
855         try {
856             // get the max version id
857
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 JavaDoc exc) {
878             return 1;
879         } finally {
880             m_sqlManager.closeAll(dbc, conn, stmt, res);
881         }
882
883         return projectBackupTagId;
884     }
885
886     /**
887      * @see org.opencms.db.I_CmsBackupDriver#writeBackupProject(org.opencms.db.CmsDbContext, int, long)
888      */

889     public void writeBackupProject(CmsDbContext dbc, int tagId, long publishDate) throws CmsDataAccessException {
890
891         Connection JavaDoc conn = null;
892         PreparedStatement JavaDoc stmt = null;
893         String JavaDoc group = null;
894         String JavaDoc 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 JavaDoc buf = new StringBuffer JavaDoc();
902         buf.append(owner.getName()).append(" ").append(owner.getFirstname()).append(" ").append(owner.getLastname());
903         String JavaDoc ownerName = buf.toString();
904
905         try {
906             group = m_driverManager.getUserDriver().readGroup(dbc, currentProject.getGroupId()).getName();
907         } catch (CmsDbEntryNotFoundException e) {
908             // the group could not be read
909
group = "";
910         }
911
912         try {
913             managerGroup = m_driverManager.getUserDriver().readGroup(dbc, currentProject.getManagerGroupId()).getName();
914         } catch (CmsDbEntryNotFoundException e) {
915             // the group could not be read
916
managerGroup = "";
917         }
918
919         List JavaDoc projectresources = m_driverManager.getProjectDriver().readProjectResources(dbc, currentProject);
920
921         // write backup project to the database
922
try {
923             conn = m_sqlManager.getConnection(dbc);
924
925             stmt = m_sqlManager.getPreparedStatement(conn, "C_PROJECTS_CREATE_BACKUP");
926             // first write the project
927
stmt.setInt(1, tagId);
928             stmt.setInt(2, currentProject.getId());
929             stmt.setString(3, currentProject.getName());
930             stmt.setTimestamp(4, new Timestamp JavaDoc(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             // now write the projectresources
952
stmt = m_sqlManager.getPreparedStatement(conn, "C_PROJECTRESOURCES_CREATE_BACKUP");
953             Iterator JavaDoc i = projectresources.iterator();
954             while (i.hasNext()) {
955                 stmt.setInt(1, tagId);
956                 stmt.setInt(2, currentProject.getId());
957                 stmt.setString(3, (String JavaDoc)i.next());
958                 stmt.executeUpdate();
959                 stmt.clearParameters();
960             }
961         } catch (SQLException JavaDoc 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     /**
971      * @see org.opencms.db.I_CmsBackupDriver#writeBackupProperties(org.opencms.db.CmsDbContext, org.opencms.file.CmsResource, java.util.List, org.opencms.util.CmsUUID, int, int)
972      */

973     public void writeBackupProperties(
974         CmsDbContext dbc,
975         CmsResource resource,
976         List JavaDoc properties,
977         CmsUUID backupId,
978         int tagId,
979         int versionId) throws CmsDataAccessException {
980
981         Connection JavaDoc conn = null;
982         PreparedStatement JavaDoc stmt = null;
983         String JavaDoc propDefName = null;
984         CmsProperty property = null;
985         int mappingType = -1;
986         String JavaDoc value = null;
987         CmsUUID id = null;
988         CmsPropertyDefinition propDef = null;
989
990         try {
991             conn = m_sqlManager.getConnection(dbc);
992
993             Iterator JavaDoc 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                        // write the structure value on the first cycle
1006
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                        // write the resource value on the second cycle
1015
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 JavaDoc 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    /**
1049     * @see org.opencms.db.I_CmsBackupDriver#writeBackupResource(org.opencms.db.CmsDbContext, org.opencms.file.CmsResource, java.util.List, int, long, int)
1050     */

1051    public void writeBackupResource(
1052        CmsDbContext dbc,
1053        CmsResource resource,
1054        List JavaDoc properties,
1055        int tagId,
1056        long publishDate,
1057        int maxVersions) throws CmsDataAccessException {
1058
1059        Connection JavaDoc conn = null;
1060        PreparedStatement JavaDoc stmt = null;
1061        CmsUUID backupPkId = new CmsUUID();
1062        int versionId = -1;
1063
1064        String JavaDoc lastModifiedName = "";
1065        String JavaDoc 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            // now get the new version id for this resource
1080
versionId = internalReadNextVersionId(dbc, resource);
1081
1082            if (resource.isFile()) {
1083
1084                if (!this.internalValidateBackupResource(dbc, resource, tagId)) {
1085
1086                    // write the file content if any
1087
internalWriteBackupFileContent(dbc, backupPkId, resource, tagId, versionId);
1088
1089                    // write the resource
1090
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            // write the structure
1114
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            // now check if there are old backup versions to delete
1129
List JavaDoc existingBackups = readBackupFileHeaders(dbc, resource.getRootPath(), resource.getStructureId());
1130            if (existingBackups.size() > maxVersions) {
1131                // delete redundant backups
1132
deleteBackups(dbc, existingBackups, maxVersions);
1133            }
1134
1135        } catch (SQLException JavaDoc 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    /**
1146     * Releases any allocated resources during garbage collection.<p>
1147     *
1148     * @see java.lang.Object#finalize()
1149     */

1150    protected void finalize() throws Throwable JavaDoc {
1151
1152        try {
1153            m_sqlManager = null;
1154            m_driverManager = null;
1155        } catch (Throwable JavaDoc t) {
1156            // ignore
1157
}
1158        super.finalize();
1159    }
1160
1161    /**
1162     * Returns the amount of properties for a propertydefinition.<p>
1163     *
1164     * @param dbc the current database context
1165     * @param metadef the propertydefinition to test
1166     * @param projectId the ID of the current project
1167     *
1168     * @return the amount of properties for a propertydefinition
1169     * @throws CmsDataAccessException if something goes wrong
1170     */

1171    protected int internalCountProperties(CmsDbContext dbc, CmsPropertyDefinition metadef, int projectId)
1172    throws CmsDataAccessException {
1173
1174        ResultSet JavaDoc res = null;
1175        PreparedStatement JavaDoc stmt = null;
1176        Connection JavaDoc conn = null;
1177
1178        int returnValue;
1179        try {
1180            // create statement
1181
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 JavaDoc 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    /**
1204     * Internal method to write the backup content.<p>
1205     *
1206     * @param dbc the current database context
1207     * @param backupId the backup id
1208     * @param resource the resource to backup
1209     * @param tagId the tag revision
1210     * @param versionId the version revision
1211     *
1212     * @throws CmsDataAccessException if something goes wrong
1213     */

1214    protected void internalWriteBackupFileContent(
1215        CmsDbContext dbc,
1216        CmsUUID backupId,
1217        CmsResource resource,
1218        int tagId,
1219        int versionId) throws CmsDataAccessException {
1220
1221        Connection JavaDoc conn = null;
1222        PreparedStatement JavaDoc 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 JavaDoc(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 JavaDoc 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    /**
1262     * Gets the next version id for a given backup resource. <p>
1263     *
1264     * @param dbc the current database context
1265     * @param resource the resource to get the next version from
1266     *
1267     * @return next version id
1268     */

1269    private int internalReadNextVersionId(CmsDbContext dbc, CmsResource resource) {
1270
1271        PreparedStatement JavaDoc stmt = null;
1272        Connection JavaDoc conn = null;
1273        ResultSet JavaDoc res = null;
1274        int versionId = 1;
1275
1276        try {
1277            // get the max version id
1278
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 JavaDoc exc) {
1288            return 1;
1289        } finally {
1290            m_sqlManager.closeAll(dbc, conn, stmt, res);
1291        }
1292    }
1293
1294    /**
1295     * Tests is a backup resource does exist.<p>
1296     *
1297     * @param dbc the current database context
1298     * @param resource the resource to test
1299     * @param tagId the tadId of the resource to test
1300     *
1301     * @return true if the resource already exists, false otherweise
1302     * @throws CmsDataAccessException if something goes wrong.
1303     */

1304    private boolean internalValidateBackupResource(CmsDbContext dbc, CmsResource resource, int tagId)
1305    throws CmsDataAccessException {
1306
1307        Connection JavaDoc conn = null;
1308        PreparedStatement JavaDoc stmt = null;
1309        ResultSet JavaDoc 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 JavaDoc 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