cmsbackupdriver.java

cms是开源的框架

                    mappingType = -1;
                    value = null;
                    id = null;

                    if (i == 0) {
                        // write the structure value on the first cycle
                        value = property.getStructureValue();
                        mappingType = CmsProperty.STRUCTURE_RECORD_MAPPING;
                        id = resource.getStructureId();

                        if (CmsStringUtil.isEmpty(value)) {
                            continue;
                        }
                    } else {
                        // write the resource value on the second cycle
                        value = property.getResourceValue();
                        mappingType = CmsProperty.RESOURCE_RECORD_MAPPING;
                        id = resource.getResourceId();

                        if (CmsStringUtil.isEmpty(value)) {
                            break;
                        }
                    }

                    stmt = m_sqlManager.getPreparedStatement(conn, "C_PROPERTIES_CREATE_BACKUP");

                    stmt.setString(1, backupId.toString());
                    stmt.setString(2, new CmsUUID().toString());
                    stmt.setString(3, propDef.getId().toString());
                    stmt.setString(4, id.toString());
                    stmt.setInt(5, mappingType);
                    stmt.setString(6, m_sqlManager.validateEmpty(value));
                    stmt.setInt(7, tagId);
                    stmt.setInt(8, versionId);

                    stmt.executeUpdate();
                    m_sqlManager.closeAll(dbc, null, stmt, null);
                }
            }
        } catch (SQLException e) {
            throw new CmsDbSqlException(Messages.get().container(
                Messages.ERR_GENERIC_SQL_1,
                CmsDbSqlException.getErrorQuery(stmt)), e);
        } finally {
            m_sqlManager.closeAll(dbc, conn, stmt, null);
        }
    }

    /**
     * @see org.opencms.db.I_CmsBackupDriver#writeBackupResource(org.opencms.db.CmsDbContext, org.opencms.file.CmsResource, java.util.List, int, long, int)
     */
    public void writeBackupResource(
        CmsDbContext dbc,
        CmsResource resource,
        List properties,
        int tagId,
        long publishDate,
        int maxVersions) throws CmsDataAccessException {

        Connection conn = null;
        PreparedStatement stmt = null;
        CmsUUID backupPkId = new CmsUUID();
        int versionId = -1;

        String lastModifiedName = "";
        String createdName = "";
        try {
            CmsUser lastModified = m_driverManager.getUserDriver().readUser(dbc, resource.getUserLastModified());
            lastModifiedName = lastModified.getName();
            CmsUser created = m_driverManager.getUserDriver().readUser(dbc, resource.getUserCreated());
            createdName = created.getName();
        } catch (CmsDataAccessException e) {
            lastModifiedName = resource.getUserCreated().toString();
            createdName = resource.getUserLastModified().toString();
        }

        try {
            conn = m_sqlManager.getConnection(dbc);

            // now get the new version id for this resource
            versionId = internalReadNextVersionId(dbc, resource);

            if (resource.isFile()) {

                if (!this.internalValidateBackupResource(dbc, resource, tagId)) {

                    // write the file content if any
                    internalWriteBackupFileContent(dbc, backupPkId, resource, tagId, versionId);

                    // write the resource
                    stmt = m_sqlManager.getPreparedStatement(conn, "C_RESOURCES_WRITE_BACKUP");
                    stmt.setString(1, resource.getResourceId().toString());
                    stmt.setInt(2, resource.getTypeId());
                    stmt.setInt(3, resource.getFlags());
                    stmt.setLong(4, publishDate);
                    stmt.setString(5, resource.getUserCreated().toString());
                    stmt.setLong(6, resource.getDateLastModified());
                    stmt.setString(7, resource.getUserLastModified().toString());
                    stmt.setInt(8, resource.getState());
                    stmt.setInt(9, resource.getLength());
                    stmt.setInt(10, dbc.currentProject().getId());
                    stmt.setInt(11, 1);
                    stmt.setInt(12, tagId);
                    stmt.setInt(13, versionId);
                    stmt.setString(14, backupPkId.toString());
                    stmt.setString(15, createdName);
                    stmt.setString(16, lastModifiedName);
                    stmt.executeUpdate();

                    m_sqlManager.closeAll(dbc, null, stmt, null);
                }
            }

            // write the structure
            stmt = m_sqlManager.getPreparedStatement(conn, "C_STRUCTURE_WRITE_BACKUP");
            stmt.setString(1, resource.getStructureId().toString());
            stmt.setString(2, resource.getResourceId().toString());
            stmt.setString(3, resource.getRootPath());
            stmt.setInt(4, resource.getState());
            stmt.setLong(5, resource.getDateReleased());
            stmt.setLong(6, resource.getDateExpired());
            stmt.setInt(7, tagId);
            stmt.setInt(8, versionId);
            stmt.setString(9, backupPkId.toString());
            stmt.executeUpdate();

            writeBackupProperties(dbc, resource, properties, backupPkId, tagId, versionId);

            // now check if there are old backup versions to delete
            List existingBackups = readBackupFileHeaders(dbc, resource.getRootPath(), resource.getStructureId());
            if (existingBackups.size() > maxVersions) {
                // delete redundant backups
                deleteBackups(dbc, existingBackups, maxVersions);
            }

        } catch (SQLException e) {
            throw new CmsDbSqlException(Messages.get().container(
                Messages.ERR_GENERIC_SQL_1,
                CmsDbSqlException.getErrorQuery(stmt)), e);
        } finally {
            m_sqlManager.closeAll(dbc, conn, stmt, null);
        }

    }

    /**
     * Releases any allocated resources during garbage collection.<p>
     * 
     * @see java.lang.Object#finalize()
     */
    protected void finalize() throws Throwable {

        try {
            m_sqlManager = null;
            m_driverManager = null;
        } catch (Throwable t) {
            // ignore
        }
        super.finalize();
    }

    /**
     * Returns the amount of properties for a propertydefinition.<p>
     * 
     * @param dbc the current database context
     * @param metadef the propertydefinition to test
     * @param projectId the ID of the current project
     * 
     * @return the amount of properties for a propertydefinition
     * @throws CmsDataAccessException if something goes wrong
     */
    protected int internalCountProperties(CmsDbContext dbc, CmsPropertyDefinition metadef, int projectId)
    throws CmsDataAccessException {

        ResultSet res = null;
        PreparedStatement stmt = null;
        Connection conn = null;

        int returnValue;
        try {
            // create statement
            conn = m_sqlManager.getConnection(dbc);
            stmt = m_sqlManager.getPreparedStatement(conn, projectId, "C_PROPERTIES_READALL_COUNT");
            stmt.setString(1, metadef.getId().toString());
            res = stmt.executeQuery();

            if (res.next()) {
                returnValue = res.getInt(1);
            } else {
                throw new CmsDbConsistencyException(Messages.get().container(
                    Messages.ERR_NO_PROPERTIES_FOR_PROPERTYDEF_1,
                    metadef.getName()));
            }
        } catch (SQLException e) {
            throw new CmsDbSqlException(Messages.get().container(
                Messages.ERR_GENERIC_SQL_1,
                CmsDbSqlException.getErrorQuery(stmt)), e);
        } finally {
            m_sqlManager.closeAll(dbc, conn, stmt, res);
        }
        return returnValue;
    }

    /**
     * Internal method to write the backup content.<p>
     * 
     * @param dbc the current database context
     * @param backupId the backup id
     * @param resource the resource to backup
     * @param tagId the tag revision
     * @param versionId the version revision
     * 
     * @throws CmsDataAccessException if something goes wrong
     */
    protected void internalWriteBackupFileContent(
        CmsDbContext dbc,
        CmsUUID backupId,
        CmsResource resource,
        int tagId,
        int versionId) throws CmsDataAccessException {

        Connection conn = null;
        PreparedStatement stmt = null;

        CmsUUID contentId;
        byte[] fileContent;
        if (resource instanceof CmsFile) {
            contentId = ((CmsFile)resource).getContentId();
            fileContent = ((CmsFile)resource).getContents();
        } else {
            contentId = CmsUUID.getNullUUID();
            fileContent = new byte[0];
        }

        try {
            conn = m_sqlManager.getConnection(dbc);
            stmt = m_sqlManager.getPreparedStatement(conn, "C_CONTENTS_WRITE_BACKUP");
            stmt.setString(1, contentId.toString());
            stmt.setString(2, resource.getResourceId().toString());

            if (fileContent.length < 2000) {
                stmt.setBytes(3, fileContent);
            } else {
                stmt.setBinaryStream(3, new ByteArrayInputStream(fileContent), fileContent.length);
            }

            stmt.setInt(4, tagId);
            stmt.setInt(5, versionId);
            stmt.setString(6, backupId.toString());

            stmt.executeUpdate();
            fileContent = null;
        } catch (SQLException e) {
            throw new CmsDbSqlException(Messages.get().container(
                Messages.ERR_GENERIC_SQL_1,
                CmsDbSqlException.getErrorQuery(stmt)), e);
        } finally {
            m_sqlManager.closeAll(dbc, conn, stmt, null);
        }
    }

    /**
     * Gets the next version id for a given backup resource. <p>
     * 
     * @param dbc the current database context
     * @param resource the resource to get the next version from
     * 
     * @return next version id
     */
    private int internalReadNextVersionId(CmsDbContext dbc, CmsResource resource) {

        PreparedStatement stmt = null;
        Connection conn = null;
        ResultSet res = null;
        int versionId = 1;

        try {
            // get the max version id
            conn = m_sqlManager.getConnection(dbc);
            stmt = m_sqlManager.getPreparedStatement(conn, "C_RESOURCES_BACKUP_MAXVER");
            stmt.setString(1, resource.getRootPath());
            res = stmt.executeQuery();
            if (res.next()) {
                versionId = res.getInt(1) + 1;
            }

            return versionId;
        } catch (SQLException exc) {
            return 1;
        } finally {
            m_sqlManager.closeAll(dbc, conn, stmt, res);
        }
    }

    /**
     * Tests is a backup resource does exist.<p>
     * 
     * @param dbc the current database context
     * @param resource the resource to test
     * @param tagId the tadId of the resource to test
     * 
     * @return true if the resource already exists, false otherweise
     * @throws CmsDataAccessException if something goes wrong.
     */
    private boolean internalValidateBackupResource(CmsDbContext dbc, CmsResource resource, int tagId)
    throws CmsDataAccessException {

        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet res = null;
        boolean exists = false;

        try {
            conn = m_sqlManager.getConnection(dbc);
            stmt = m_sqlManager.getPreparedStatement(conn, "C_BACKUP_EXISTS_RESOURCE");
            stmt.setString(1, resource.getResourceId().toString());
            stmt.setInt(2, tagId);
            res = stmt.executeQuery();

            exists = res.next();

        } catch (SQLException e) {
            throw new CmsDbSqlException(Messages.get().container(
                Messages.ERR_GENERIC_SQL_1,
                CmsDbSqlException.getErrorQuery(stmt)), e);
        } finally {
            m_sqlManager.closeAll(dbc, conn, stmt, res);
        }
        return exists;
    }

}