filestaticpagedao.java

### File Source: filestaticpagedao.java

             /*
        P/P   *  Method: void net.sourceforge.pebble.dao.file.FileStaticPageDAO$1(FileStaticPageDAO)
              */
         1  package net.sourceforge.pebble.dao.file;
         2
         3  import net.sourceforge.pebble.dao.PersistenceException;
         4  import net.sourceforge.pebble.dao.StaticPageDAO;
         5  import net.sourceforge.pebble.domain.Blog;
         6  import net.sourceforge.pebble.domain.StaticPage;
         7  import net.sourceforge.pebble.util.SecurityUtils;
         8  import org.apache.commons.logging.Log;
         9  import org.apache.commons.logging.LogFactory;
        10
             /*
        P/P   *  Method: void net.sourceforge.pebble.dao.file.FileStaticPageDAO()
              *
              *  Presumptions:
              *    java.lang.Class:getPackage(...)@36 != null
              *    java.lang.Object:getClass(...)@36 != null
              *
              *  Postconditions:
              *    possibly_updated(this.jaxbContext)
              */
        11  import javax.xml.bind.JAXBContext;
        12  import javax.xml.bind.JAXBElement;
        13  import javax.xml.bind.Marshaller;
        14  import javax.xml.bind.Unmarshaller;
        15  import java.io.*;
        16  import java.text.SimpleDateFormat;
        17  import java.text.DateFormat;
        18  import java.text.ParseException;
        19  import java.util.*;
        20
        21  public class FileStaticPageDAO implements StaticPageDAO {
        22
        23    /**
        24     * the log used by this class
        25     */
               /*
        P/P     *  Method: Log access$0()
                *
                *  Preconditions:
                *    init'ed(log)
                *
                *  Postconditions:
                *    return_value == log
                *    init'ed(return_value)
                */
        26    private static Log log = LogFactory.getLog(FileStaticPageDAO.class);
        27
        28    private static final String STATIC_PAGES_DIRECTORY_NAME = "pages";
        29    private static final String STATIC_PAGE_FILE_EXTENSION = ".xml";
        30    private static final String STATIC_PAGE_LOCK_EXTENSION = ".lock";
        31
        32    private JAXBContext jaxbContext;
        33
        34    public FileStaticPageDAO() {
        35      try {
        36        jaxbContext = JAXBContext.newInstance(getClass().getPackage().getName());
        37      } catch (Exception e) {
        38        e.printStackTrace();
        39      }
        40    }
        41
        42    /** the date/time format used when persisting dates */
        43    static final String OLD_PERSISTENT_DATETIME_FORMAT = "dd MMM yyyy HH:mm:ss z";
        44    static final String NEW_PERSISTENT_DATETIME_FORMAT = "dd MMM yyyy HH:mm:ss:S Z";
        45    static final String REGEX_FOR_YEAR = "\\d\\d\\d\\d";
        46
        47    /**
        48     * Loads the static pages for a given blog.
        49     *
        50     * @param blog the owning Blog instance
        51     * @return a Collection of StaticPage instances
        52     * @throws net.sourceforge.pebble.dao.PersistenceException
        53     *          if static pages cannot be loaded
        54     */
               /*
        P/P     *  Method: Collection loadStaticPages(Blog)
                *
                *  Preconditions:
                *    blog != null
                *
                *  Presumptions:
                *    Local_8[Local_6]@58 != null
                *    files.length@58 <= 232-1
                *
                *  Postconditions:
                *    return_value == &new ArrayList(loadStaticPages#1)
                *    new ArrayList(loadStaticPages#1) num objects == 1
                *
                *  Test Vectors:
                *    java.io.File:listFiles(...)@58: Addr_Set{null}, Inverse{null}
                *    loadStaticPage(...)@88: Addr_Set{null}, Inverse{null}
                */
        55    public Collection<StaticPage> loadStaticPages(Blog blog) throws PersistenceException {
        56      List<StaticPage> list = new ArrayList<StaticPage>();
        57      File root = new File(blog.getRoot(), STATIC_PAGES_DIRECTORY_NAME);
        58      File files[] = root.listFiles(new FilenameFilter() {
        59          public boolean accept(File dir, String name) {
                       /*
        P/P             *  Method: bool accept(File, String)
                        *
                        *  Preconditions:
                        *    (soft) name != null
                        *
                        *  Postconditions:
                        *    init'ed(return_value)
                        *
                        *  Test Vectors:
                        *    java.io.File:isDirectory(...)@60: {0}, {1}
                        *    java.lang.String:matches(...)@60: {0}, {1}
                        */
        60            return new File(dir, name).isDirectory() && name.matches("\\d+");
        61          }
        62      });
        63
        64      if (files != null) {
        65        for (File file : files) {
        66          StaticPage staticPage = loadStaticPage(blog, file.getName());
        67          if (staticPage != null) {
        68            list.add(staticPage);
        69          }
        70        }
        71      }
        72
        73      return list;
        74    }
        75
        76    /**
        77     * Loads a specific static page.
        78     *
        79     * @param blog   the owning Blog
        80     * @param pageId the page ID
        81     * @return a StaticPage instance
        82     * @throws net.sourceforge.pebble.dao.PersistenceException
        83     *          if the static page cannot be loaded
        84     */
               /*
        P/P     *  Method: StaticPage loadStaticPage(Blog, String)
                *
                *  Preconditions:
                *    blog != null
                *
                *  Postconditions:
                *    init'ed(return_value)
                */
        85    public StaticPage loadStaticPage(Blog blog, String pageId) throws PersistenceException {
        86      File path = new File(getPath(blog, pageId));
        87      File file = new File(path, pageId + STATIC_PAGE_FILE_EXTENSION);
        88      return loadStaticPage(blog, file);
        89    }
        90
        91    /**
        92     * Loads a static page from the specified file.
        93     *
        94     * @param blog      the Blog to which the static page belongs
        95     * @param source    the File pointing to the source
        96     * @return    a StaticPage instance
        97     * @throws net.sourceforge.pebble.dao.PersistenceException
        98     *          if the static page can't be loaded
        99     */
       100    private StaticPage loadStaticPage(Blog blog, File source) throws PersistenceException {
       101      if (source.exists()) {
       102        log.debug("Loading static page from " + source.getAbsolutePath());
       103        StaticPage staticPage = new StaticPage(blog);
       104
       105        try {
       106          Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
       107          JAXBElement<StaticPageType> controller = (JAXBElement)unmarshaller.unmarshal(source);
       108          StaticPageType spt = controller.getValue();
       109
       110          staticPage.setTitle(spt.getTitle());
       111          staticPage.setSubtitle(spt.getSubtitle());
       112          staticPage.setBody(spt.getBody());
       113          staticPage.setTags(spt.getTags());
       114          staticPage.setAuthor(spt.getAuthor());
       115          staticPage.setOriginalPermalink(spt.getOriginalPermalink());
       116          staticPage.setName(spt.getStaticName());
       117          StaticPageDateConverter converter = new StaticPageDateConverter(staticPage);
       118          staticPage.setDate(converter.parse(spt.getDate()));
       119          staticPage.setTemplate(spt.getTemplate());
       120
       121        } catch (Exception e) {
       122          log.error(e.getMessage(), e);
       123          e.printStackTrace();
       124          throw new PersistenceException(e.getMessage());
       125        }
       126
       127        // and is the page locked?
       128        staticPage.setLockedBy(getUsernameHoldingLock(staticPage));
       129
       130        return staticPage;
       131      } else {
       132        return null;
       133      }
       134    }
       135
       136    /**
       137     * Stores the specified static page.
       138     *
       139     * @param staticPage the static page to store
       140     * @throws net.sourceforge.pebble.dao.PersistenceException
       141     *          if something goes wrong storing the static page
       142     */
               /*
        P/P     *  Method: void storeStaticPage(StaticPage)
                *
                *  Preconditions:
                *    staticPage != null
                *    staticPage.blog != null
                *    init'ed(staticPage.id)
                *
                *  Test Vectors:
                *    java.io.File:exists(...)@145: {1}, {0}
                */
       143    public void storeStaticPage(StaticPage staticPage) throws PersistenceException {
       144      File outputDir = new File(getPath(staticPage.getBlog(), staticPage.getId()));
       145      if (!outputDir.exists()) {
       146        outputDir.mkdirs();
       147      }
       148
       149      File outputFile = new File(outputDir, staticPage.getId() + STATIC_PAGE_FILE_EXTENSION);
       150      storeStaticPage(staticPage, outputFile);
       151    }
       152
       153    /**
       154     * Stores a static page to the specified file.
       155     *
       156     * @param staticPage    the StaticPage that is being stored
       157     * @param destination the File pointing to the destination
       158     * @throws PersistenceException if something goes wrong storing the static page
       159     */
       160    private void storeStaticPage(StaticPage staticPage, File destination) throws PersistenceException {
       161      try {
       162        Marshaller marshaller = jaxbContext.createMarshaller();
       163        StaticPageType type = new StaticPageType();
       164
       165        type.setTitle(staticPage.getTitle());
       166        type.setSubtitle(staticPage.getSubtitle());
       167        type.setBody(staticPage.getBody());
       168        type.setTags(staticPage.getTags());
       169        type.setAuthor(staticPage.getAuthor());
       170        type.setStaticName(staticPage.getName());
       171        type.setOriginalPermalink(staticPage.getOriginalPermalink());
       172        type.setState(ContentState.PUBLISHED);
       173        type.setTitle(staticPage.getTitle());
       174        type.setTemplate(staticPage.getTemplate());
       175
       176        StaticPageDateConverter converter = new StaticPageDateConverter(staticPage);
       177        type.setDate(converter.format(staticPage.getDate()));
       178
       179        // now take a backup of the correct file
       180        if (destination.exists() && destination.length() > 0) {
       181          removeStaticPage(staticPage); // this archives the current version
       182        }
       183
       184        log.debug("Saving to " + destination.getAbsolutePath());
       185        ObjectFactory objectFactory = new ObjectFactory();
       186        JAXBElement jaxbElement = objectFactory.createStaticPage(type);
       187
       188        marshaller.setProperty("jaxb.formatted.output", true);
       189        marshaller.setProperty("jaxb.encoding", staticPage.getBlog().getCharacterEncoding());
       190        FileWriter writer = new FileWriter(destination);
       191        marshaller.marshal(jaxbElement, writer);
       192        writer.flush();
       193        writer.close();
       194      } catch (Exception e) {
       195        log.error(e.getMessage(), e);
       196        e.printStackTrace();
       197        throw new PersistenceException(e.getMessage());
       198      }
       199    }
       200
       201    /**
       202     * Removes the specified static page.
       203     *
       204     * @param staticPage the static page to remove
       205     * @throws net.sourceforge.pebble.dao.PersistenceException
       206     *          if something goes wrong removing the page
       207     */
               /*
        P/P     *  Method: void removeStaticPage(StaticPage)
                *
                *  Preconditions:
                *    log != null
                *    staticPage != null
                *    staticPage.blog != null
                *    init'ed(staticPage.blog.id)
                *    init'ed(staticPage.id)
                *
                *  Presumptions:
                *    java.io.File:renameTo(...)@230 == 1
                *
                *  Test Vectors:
                *    java.io.File:exists(...)@218: {0}, {1}
                *    java.io.File:exists(...)@225: {0}, {1}
                */
       208    public void removeStaticPage(StaticPage staticPage) throws PersistenceException {
       209      File path = new File(getPath(staticPage.getBlog(), staticPage.getId()));
       210      File file = new File(path, staticPage.getId() + STATIC_PAGE_FILE_EXTENSION);
       211      log.debug("Removing " + staticPage.getGuid());
       212
       213      // for archive purposes, the current version of the file will be saved with
       214      // the timestamp as the extension
       215      SimpleDateFormat archiveFileExtension = new SimpleDateFormat("yyyyMMdd-HHmmss");
       216      archiveFileExtension.setTimeZone(staticPage.getBlog().getTimeZone());
       217      Date date = new Date();
       218      if (file.exists()) {
       219        date = new Date(file.lastModified());
       220      }
       221      File backupFile = new File(
       222          file.getParentFile(),
       223          file.getName() + "." + archiveFileExtension.format(date));
       224
       225      if (backupFile.exists()) {
       226        backupFile.delete();
       227      }
       228
       229      log.debug("Archiving current version to " + backupFile.getAbsolutePath());
       230      boolean success = file.renameTo(backupFile);
       231
       232      if (!success) {
       233        throw new PersistenceException("Deletion of " + staticPage.getGuid() + " failed");
       234      }
       235    }
       236
       237    /**
       238     * Given a blog and static page ID, this method determines the path where
       239     * that static page is stored.
       240     *
       241     * @param blog    the owning Blog
       242     * @param staticPageId   the ID of the static page
       243     * @return  a String of the form blogroot/yyyy/MM/dd
       244     */
               /*
        P/P     *  Method: String getPath(Blog, String)
                *
                *  Preconditions:
                *    blog != null
                *
                *  Presumptions:
                *    init'ed(java.io.File.separator)
                *
                *  Postconditions:
                *    return_value != null
                */
       245    private String getPath(Blog blog, String staticPageId) {
       246      StringBuffer buf = new StringBuffer();
       247      buf.append(blog.getRoot());
       248      buf.append(File.separator);
       249      buf.append("pages");
       250      buf.append(File.separator);
       251      buf.append(staticPageId);
       252
       253      return buf.toString();
       254    }
       255
       256    /**
       257     * Locks the specified static page.
       258     *
       259     * @param staticPage the static page to lock
       260     * @return  true if the page could be locked, false otherwise
       261     */
               /*
        P/P     *  Method: bool lock(StaticPage)
                *
                *  Preconditions:
                *    staticPage.blog != null
                *    init'ed(staticPage.id)
                *    (soft) log != null
                *    (soft) staticPage != null
                *    (soft) init'ed(staticPage.blog.id)
                *
                *  Postconditions:
                *    init'ed(return_value)
                *
                *  Test Vectors:
                *    java.io.File:createNewFile(...)@265: {0}, {1}
                *    java.lang.String:equals(...)@274: {0}, {1}
                */
       262    public boolean lock(StaticPage staticPage) {
       263      File lockFile = getLockFile(staticPage);
       264      try {
       265        boolean success = lockFile.createNewFile();
       266        if (success) {
       267          FileWriter writer = new FileWriter(lockFile);
       268          writer.write(SecurityUtils.getUsername());
       269          writer.flush();
       270          writer.close();
       271          return true;
       272        } else {
       273          String lockedBy = getUsernameHoldingLock(staticPage);
       274          return (lockedBy != null && lockedBy.equals(SecurityUtils.getUsername()));
       275        }
       276      } catch (IOException e) {
       277        log.warn("Exceptoin while attempting to lock static page " + staticPage.getGuid(), e);
       278      }
       279
       280      return false;
       281    }
       282
       283    /**
       284     * Unlocks the specified static page.
       285     *
       286     * @param staticPage the static page to unlock
       287     * @return true if the page could be unlocked, false otherwise
       288     */
               /*
        P/P     *  Method: bool unlock(StaticPage)
                *
                *  Preconditions:
                *    staticPage != null
                *    staticPage.blog != null
                *    init'ed(staticPage.id)
                *
                *  Postconditions:
                *    init'ed(return_value)
                *
                *  Test Vectors:
                *    java.io.File:exists(...)@291: {0}, {1}
                */
       289    public boolean unlock(StaticPage staticPage) {
       290      File lockFile = getLockFile(staticPage);
       291      if (lockFile.exists()) {
       292        return lockFile.delete();
       293      } else {
       294        return true;
       295      }
       296    }
       297
       298    /**
       299     * Given a static page, this method determines the path where
       300     * that static page is stored.
       301     *
       302     * @param staticPage    a StaticPage instance
       303     * @return  a File instance, representing a lock
       304     */
               /*
        P/P     *  Method: File getLockFile(StaticPage)
                *
                *  Preconditions:
                *    staticPage != null
                *    staticPage.blog != null
                *    init'ed(staticPage.id)
                *
                *  Presumptions:
                *    init'ed(java.io.File.separator)
                *
                *  Postconditions:
                *    return_value == &new File(getLockFile#2)
                *    new File(getLockFile#2) num objects == 1
                */
       305    private File getLockFile(StaticPage staticPage) {
       306      StringBuffer buf = new StringBuffer();
       307      buf.append(staticPage.getBlog().getRoot());
       308      buf.append(File.separator);
       309      buf.append(STATIC_PAGES_DIRECTORY_NAME);
       310      buf.append(File.separator);
       311      buf.append(staticPage.getId());
       312      buf.append(STATIC_PAGE_LOCK_EXTENSION);
       313
       314      return new File(buf.toString());
       315    }
       316
               /*
        P/P     *  Method: String getUsernameHoldingLock(StaticPage)
                *
                *  Preconditions:
                *    (soft) log != null
                *    (soft) staticPage != null
                *    (soft) staticPage.blog != null
                *    (soft) init'ed(staticPage.id)
                *
                *  Postconditions:
                *    init'ed(return_value)
                *
                *  Test Vectors:
                *    java.io.File:exists(...)@321: {0}, {1}
                */
       317    private String getUsernameHoldingLock(StaticPage staticPage) {
       318      String username = null;
       319      try {
       320        File lockFile = getLockFile(staticPage);
       321        if (lockFile.exists()) {
       322          BufferedReader reader = new BufferedReader(new FileReader(lockFile));
       323          username = reader.readLine();
       324          reader.close();
       325        }
       326      } catch (IOException ioe) {
       327        log.warn("Error reading lock file", ioe);
       328      }
       329
       330      return username;
       331    }
       332
       333    class StaticPageDateConverter {
       334
       335      private SimpleDateFormat dateTimeFormats[];
       336
       337      StaticPageDateConverter(StaticPage staticPage) {
       338        // create all date/time formats, for backwards compatibility
       339        SimpleDateFormat format;
       340        dateTimeFormats = new SimpleDateFormat[6];
       341
       342        format = new SimpleDateFormat(FileBlogEntryDAO.NEW_PERSISTENT_DATETIME_FORMAT, Locale.ENGLISH);
       343        format.setTimeZone(staticPage.getBlog().getTimeZone());
       344        dateTimeFormats[0] = format;
       345
       346        format = new SimpleDateFormat(FileBlogEntryDAO.NEW_PERSISTENT_DATETIME_FORMAT, staticPage.getBlog().getLocale());
       347        format.setTimeZone(staticPage.getBlog().getTimeZone());
       348        dateTimeFormats[1] = format;
       349
       350        format = new SimpleDateFormat(FileBlogEntryDAO.NEW_PERSISTENT_DATETIME_FORMAT);
       351        format.setTimeZone(staticPage.getBlog().getTimeZone());
       352        dateTimeFormats[2] = format;
       353
       354        format = new SimpleDateFormat(FileBlogEntryDAO.OLD_PERSISTENT_DATETIME_FORMAT, Locale.ENGLISH);
       355        format.setTimeZone(staticPage.getBlog().getTimeZone());
       356        dateTimeFormats[3] = format;
       357
       358        format = new SimpleDateFormat(FileBlogEntryDAO.OLD_PERSISTENT_DATETIME_FORMAT, staticPage.getBlog().getLocale());
       359        format.setTimeZone(staticPage.getBlog().getTimeZone());
       360        dateTimeFormats[4] = format;
       361
       362        format = new SimpleDateFormat(FileBlogEntryDAO.OLD_PERSISTENT_DATETIME_FORMAT);
       363        format.setTimeZone(staticPage.getBlog().getTimeZone());
       364        dateTimeFormats[5] = format;
       365      }
       366
                 /*
        P/P       *  Method: Date parse(String)
                  *
                  *  Preconditions:
                  *    this.dateTimeFormats != null
                  *    this.dateTimeFormats.length <= 232-1
                  *    (soft) net/sourceforge/pebble/dao/file/FileStaticPageDAO.log != null
                  *    (soft) this.dateTimeFormats[...] != null
                  *
                  *  Postconditions:
                  *    init'ed(return_value)
                  */
       367      Date parse(String s) {
       368        for (DateFormat dateTimeFormat : dateTimeFormats) {
       369          try {
       370            return dateTimeFormat.parse(s);
       371          } catch (ParseException pe) {
       372            // do nothing, just try the next one
       373          }
       374        }
       375
       376        log.error("Could not parse date of " + s);
       377        return null;
       378      }
       379
                 /*
        P/P       *  Method: String format(Date)
                  *
                  *  Preconditions:
                  *    this.dateTimeFormats != null
                  *    this.dateTimeFormats.length >= 1
                  *    this.dateTimeFormats[0] != null
                  *
                  *  Postconditions:
                  *    init'ed(return_value)
                  */
       380      String format(Date date) {
       381        return dateTimeFormats[0].format(date);
       382      }
       383
       384    }
       385
       386  }

SofCheck Inspector Build Version : 2.22510

filestaticpagedao.java | 2010-Jun-25 19:40:32
filestaticpagedao.class | 2010-Jul-19 20:23:40
filestaticpagedao$1.class | 2010-Jul-19 20:23:40
filestaticpagedao$staticpagedateconverter.class | 2010-Jul-19 20:23:40