incubator-jspwiki-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Janne Jalkanen <Janne.Jalka...@ecyrd.com>
Subject Re: JCR commit?
Date Thu, 05 Mar 2009 23:09:27 GMT

If I understood you correctly, you should be able to continue to use  
your current setup with respect to other-than-jspwiki-native data.

/Janne

On Mar 5, 2009, at 01:37 , Terry Steichen wrote:

> Let me try again.  I use Derby as my underlying datastore.  My  
> WikiPages
> are stored in Derby and accessed via the JDBCPageProvider.  I  
> understand
> that with the new JCR-enabled JSPWiki, I will have to export the
> WikiPages into the JCR.  I have no problem with that.
>
> But I have a lot of other content that's also stored in the Derby
> datastore, accessed through JDBC links from JSPWiki pages.  My  
> question
> is whether I have to move ALL my Derby content into the new JCR  
> storage,
> or can I just move the WikiPage stuff and still access the rest via  
> JDBC
> in the Derby database?  (It's not that I can't rewrite my code to move
> away from Derby - but I'm trying to figure out how much work to
> anticipate if I upgrade to this new version of JSPWiki.)
>
>
> On Wed, 2009-03-04 at 23:35 +0200, Janne Jalkanen wrote:
>
>> Still not clear enough. I don't understand your concern at all. Both
>> Priha and Jackrabbit support JDBC natively albeit the tables look
>> different than from the current JDBCProvider (I suspect, I've never
>> actually looked at it).
>>
>> /Janne
>>
>> On Mar 4, 2009, at 17:51 , Terry Steichen wrote:
>>
>>> I should have been more clear on the context for my question.  The
>>> task
>>> of exporting pages from one data store to another should, as you and
>>> others indicate, be fairly straightforward (providing an appropriate
>>> tool exists, which I'm sure it will).
>>>
>>> However, in addition to using the JDBCPageProvider for ordinary page
>>> actions, I also use the same JDBC mechanism to access dozens of  
>>> other
>>> tables.  Would all of these functions have to be completely  
>>> rewritten
>>> with JCR, or could a JDBC data store exist independently along with
>>> JCR?
>>>
>>> On Wed, 2009-03-04 at 06:33 +0100, Harry Metske wrote:
>>>
>>>> Terry,
>>>>
>>>> the general idea is that you eventually switch over to one of these
>>>> new JCR
>>>> repositories and that you export your "old pages" and import them
>>>> into the
>>>> JCR repo.
>>>>
>>>> See also https://issues.apache.org/jira/browse/JSPWIKI-454
>>>>
>>>> regards,
>>>> Harry
>>>>
>>>> 2009/3/4 Terry Steichen <terry@net-frame.com>
>>>>
>>>>> Janne,
>>>>>
>>>>> Please clarify for me what, in practical terms, this means for
>>>>> those of
>>>>> us that use (and have thousands of pages implemented in) the
>>>>> JDBCPageProvider (and other PageProvider implementations)?
>>>>>
>>>>> Terry
>>>>>
>>>>>
>>>>> On Wed, 2009-03-04 at 00:33 +0200, Janne Jalkanen wrote:
>>>>>
>>>>>> Folks,
>>>>>>
>>>>>> I'd like to make the commit which removes the PageProviders from
>>>>>> use
>>>>>> and replaces them with the JCR backend (I'm scared to keep it  
>>>>>> in my
>>>>>> hard drive for long).
>>>>>>
>>>>>> However, this will break about 150 unit tests, and I haven't yet
>>>>>> had
>>>>>> time to see which ones became obsolete and which ones are really
>>>>>> broken.  Also error handling is far from optimal (I don't want to
>>>>>> tweak it too hard until we decide if we want to change the way we
>>>>>> do
>>>>>> errors).  But it should give you a chance to start hacking on it.
>>>>>>
>>>>>> Any objections?  The patch is included, if you want to try it out
>>>>>> before having an opinion. It's against the SVN trunk as of now.
>>>>>>
>>>>>> /Janne
>>>>>>
>>>>>> ### Eclipse Workspace Patch 1.0
>>>>>> #P JSPWiki-trunk
>>>>>> Index: src/java/org/apache/wiki/WikiEngine.java
>>>>>> = 
>>>>>> = 
>>>>>> =================================================================
>>>>>> --- src/java/org/apache/wiki/WikiEngine.java  (revision 749743)
>>>>>> +++ src/java/org/apache/wiki/WikiEngine.java  (working copy)
>>>>>> @@ -1751,8 +1751,8 @@
>>>>>>         // If submitter is authenticated, any reject messages  
>>>>>> will
>>>>>> appear in his/her workflow inbox.
>>>>>>         WorkflowBuilder builder =
>>>>>> WorkflowBuilder.getBuilder( this );
>>>>>>         Principal submitter = context.getCurrentUser();
>>>>>> -        Task prepTask = new
>>>>>> PageManager.PreSaveWikiPageTask( context,
>>>>>> proposedText );
>>>>>> -        Task completionTask = new  
>>>>>> PageManager.SaveWikiPageTask();
>>>>>> +        Task prepTask = new
>>>>>> ContentManager.PreSaveWikiPageTask( context, proposedText );
>>>>>> +        Task completionTask = new
>>>>>> ContentManager.SaveWikiPageTask();
>>>>>>         String diffText = m_differenceManager.makeDiff( context,
>>>>>> oldText, proposedText );
>>>>>>         boolean isAuthenticated =
>>>>>> context.getWikiSession().isAuthenticated();
>>>>>>         Fact[] facts = new Fact[5];
>>>>>> Index: src/java/org/apache/wiki/PageManager.java
>>>>>> = 
>>>>>> = 
>>>>>> =================================================================
>>>>>> --- src/java/org/apache/wiki/PageManager.java (revision 749743)
>>>>>> +++ src/java/org/apache/wiki/PageManager.java (working copy)
>>>>>> @@ -20,35 +20,19 @@
>>>>>>  */
>>>>>> package org.apache.wiki;
>>>>>>
>>>>>> -import java.io.IOException;
>>>>>> -import java.security.Permission;
>>>>>> -import java.security.Principal;
>>>>>> -import java.util.*;
>>>>>> +import java.util.Collection;
>>>>>> +import java.util.List;
>>>>>> +import java.util.Properties;
>>>>>>
>>>>>> -import org.apache.commons.lang.ArrayUtils;
>>>>>> -import org.apache.wiki.api.FilterException;
>>>>>> import org.apache.wiki.api.WikiException;
>>>>>> import org.apache.wiki.api.WikiPage;
>>>>>> -import org.apache.wiki.auth.WikiPrincipal;
>>>>>> -import org.apache.wiki.auth.WikiSecurityException;
>>>>>> -import org.apache.wiki.auth.acl.Acl;
>>>>>> -import org.apache.wiki.auth.acl.AclEntry;
>>>>>> -import org.apache.wiki.auth.acl.AclEntryImpl;
>>>>>> -import org.apache.wiki.auth.user.UserProfile;
>>>>>> -import org.apache.wiki.event.*;
>>>>>> +import org.apache.wiki.content.ContentManager;
>>>>>> +import org.apache.wiki.content.WikiName;
>>>>>> import org.apache.wiki.log.Logger;
>>>>>> import org.apache.wiki.log.LoggerFactory;
>>>>>> import org.apache.wiki.modules.ModuleManager;
>>>>>> -import org.apache.wiki.providers.CachingProvider;
>>>>>> import org.apache.wiki.providers.ProviderException;
>>>>>> -import org.apache.wiki.providers.RepositoryModifiedException;
>>>>>> import org.apache.wiki.providers.WikiPageProvider;
>>>>>> -import org.apache.wiki.util.ClassUtil;
>>>>>> -import org.apache.wiki.util.TextUtil;
>>>>>> -import org.apache.wiki.util.WikiBackgroundThread;
>>>>>> -import org.apache.wiki.workflow.Outcome;
>>>>>> -import org.apache.wiki.workflow.Task;
>>>>>> -import org.apache.wiki.workflow.Workflow;
>>>>>>
>>>>>>
>>>>>> /**
>>>>>> @@ -64,7 +48,7 @@
>>>>>> // FIXME: This class currently only functions just as an extra
>>>>>> layer
>>>>>> over providers,
>>>>>> //        complicating things.  We need to move more provider-
>>>>>> specific functionality
>>>>>> //        from WikiEngine (which is too big now) into this class.
>>>>>> -public class PageManager extends ModuleManager implements
>>>>>> WikiEventListener
>>>>>> +public class PageManager extends ModuleManager
>>>>>> {
>>>>>>     private static final long serialVersionUID = 1L;
>>>>>>
>>>>>> @@ -117,14 +101,6 @@
>>>>>>
>>>>>>     private WikiPageProvider m_provider;
>>>>>>
>>>>>> -    protected HashMap<String,PageLock> m_pageLocks = new
>>>>>> HashMap<String,PageLock>();
>>>>>> -
>>>>>> -    private WikiEngine m_engine;
>>>>>> -
>>>>>> -    private int m_expiryTime = 60;
>>>>>> -
>>>>>> -    private LockReaper m_reaper = null;
>>>>>> -
>>>>>>     /**
>>>>>>      *  Creates a new PageManager.
>>>>>>      *
>>>>>> @@ -136,66 +112,6 @@
>>>>>>         throws WikiException
>>>>>>     {
>>>>>>         super( engine );
>>>>>> -
>>>>>> -        String classname;
>>>>>> -
>>>>>> -        m_engine = engine;
>>>>>> -
>>>>>> -        boolean useCache =
>>>>>> "true".equals(props.getProperty( PROP_USECACHE ));
>>>>>> -
>>>>>> -        m_expiryTime =
>>>>>> TextUtil.parseIntParameter( props.getProperty( PROP_LOCKEXPIRY ),
>>>>>> 60 );
>>>>>> -
>>>>>> -        //
>>>>>> -        //  If user wants to use a cache, then we'll use the
>>>>>> CachingProvider.
>>>>>> -        //
>>>>>> -        if( useCache )
>>>>>> -        {
>>>>>> -            classname =
>>>>>> "org.apache.wiki.providers.CachingProvider";
>>>>>> -        }
>>>>>> -        else
>>>>>> -        {
>>>>>> -            classname = WikiEngine.getRequiredProperty( props,
>>>>>> PROP_PAGEPROVIDER );
>>>>>> -        }
>>>>>> -
>>>>>> -        try
>>>>>> -        {
>>>>>> -            log.debug("Page provider class: '"+classname+"'");
>>>>>> -
>>>>>> -            Class providerclass =
>>>>>> ClassUtil.findClass( "org.apache.wiki.providers",
>>>>>> -
>>>>>> classname );
>>>>>> -
>>>>>> -            m_provider =
>>>>>> (WikiPageProvider)providerclass.newInstance();
>>>>>> -
>>>>>> -            log.debug("Initializing page provider class
>>>>>> "+m_provider);
>>>>>> -            m_provider.initialize( m_engine, props );
>>>>>> -        }
>>>>>> -        catch( ClassNotFoundException e )
>>>>>> -        {
>>>>>> -            log.error("Unable to locate provider class
>>>>>> '"+classname
>>>>>> +"'",e);
>>>>>> -            throw new WikiException("no provider class");
>>>>>> -        }
>>>>>> -        catch( InstantiationException e )
>>>>>> -        {
>>>>>> -            log.error("Unable to create provider class
>>>>>> '"+classname
>>>>>> +"'",e);
>>>>>> -            throw new WikiException("faulty provider class");
>>>>>> -        }
>>>>>> -        catch( IllegalAccessException e )
>>>>>> -        {
>>>>>> -            log.error("Illegal access to provider class
>>>>>> '"+classname
>>>>>> +"'",e);
>>>>>> -            throw new WikiException("illegal provider class");
>>>>>> -        }
>>>>>> -        catch( NoRequiredPropertyException e )
>>>>>> -        {
>>>>>> -            log.error("Provider did not found a property it was
>>>>>> looking for: "+e.getMessage(),
>>>>>> -                      e);
>>>>>> -            throw e;  // Same exception works.
>>>>>> -        }
>>>>>> -        catch( IOException e )
>>>>>> -        {
>>>>>> -            log.error("An I/O exception occurred while trying to
>>>>>> create a new page provider: "+classname, e );
>>>>>> -            throw new WikiException("Unable to start page
>>>>>> provider:
>>>>>> "+e.getMessage());
>>>>>> -        }
>>>>>> -
>>>>>>     }
>>>>>>
>>>>>>
>>>>>> @@ -220,7 +136,7 @@
>>>>>>     public Collection getAllPages()
>>>>>>         throws ProviderException
>>>>>>     {
>>>>>> -        return m_provider.getAllPages();
>>>>>> +        return m_engine.getContentManager().getAllPages(null);
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -236,49 +152,7 @@
>>>>>>     public String getPageText( String pageName, int version )
>>>>>>         throws ProviderException
>>>>>>     {
>>>>>> -        if( pageName == null || pageName.length() == 0 )
>>>>>> -        {
>>>>>> -            throw new ProviderException("Illegal page name");
>>>>>> -        }
>>>>>> -
>>>>>> -        String text = null;
>>>>>> -
>>>>>> -        try
>>>>>> -        {
>>>>>> -            text = m_provider.getPageText( pageName, version );
>>>>>> -        }
>>>>>> -        catch( RepositoryModifiedException e )
>>>>>> -        {
>>>>>> -            //
>>>>>> -            //  This only occurs with the latest version.
>>>>>> -            //
>>>>>> -            log.info("Repository has been modified externally
>>>>>> while
>>>>>> fetching page "+pageName );
>>>>>> -
>>>>>> -            //
>>>>>> -            //  Empty the references and yay, it shall be
>>>>>> recalculated
>>>>>> -            //
>>>>>> -            //WikiPage p = new WikiPage( pageName );
>>>>>> -            WikiPage p = m_provider.getPageInfo( pageName,
>>>>>> version );
>>>>>> -
>>>>>> -            m_engine.updateReferences( p );
>>>>>> -
>>>>>> -            if( p != null )
>>>>>> -            {
>>>>>> -                m_engine.getSearchManager().reindexPage( p );
>>>>>> -                text = m_provider.getPageText( pageName,
>>>>>> version );
>>>>>> -            }
>>>>>> -            else
>>>>>> -            {
>>>>>> -                //
>>>>>> -                //  Make sure that it no longer exists in  
>>>>>> internal
>>>>>> data structures either.
>>>>>> -                //
>>>>>> -                WikiPage dummy = m_engine.createPage(pageName);
>>>>>> -                m_engine.getSearchManager().pageRemoved(dummy);
>>>>>> -                 
>>>>>> m_engine.getReferenceManager().pageRemoved(dummy);
>>>>>> -            }
>>>>>> -        }
>>>>>> -
>>>>>> -        return text;
>>>>>> +        return
>>>>>> m_engine 
>>>>>> .getContentManager().getPage( WikiName.valueOf( pageName ),
>>>>>> version ).getContentAsString();
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -302,12 +176,14 @@
>>>>>>     public void putPageText( WikiPage page, String content )
>>>>>>         throws ProviderException
>>>>>>     {
>>>>>> -        if( page == null || page.getName() == null ||
>>>>>> page.getName().length() == 0 )
>>>>>> -        {
>>>>>> -            throw new ProviderException("Illegal page name");
>>>>>> -        }
>>>>>> -
>>>>>> -        m_provider.putPageText( page, content );
>>>>>> +        WikiPage p =
>>>>>> m_engine.getContentManager().getPage( page.getQualifiedName() );
>>>>>> +
>>>>>> +        if( p == null )
>>>>>> +            p =
>>>>>> m_engine.getContentManager().addPage( page.getQualifiedName(),
>>>>>> ContentManager.JSPWIKI_CONTENT_TYPE );
>>>>>> +
>>>>>> +        p.setContent(content);
>>>>>> +
>>>>>> +        p.save();
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -321,47 +197,7 @@
>>>>>>      */
>>>>>>     public PageLock lockPage( WikiPage page, String user )
>>>>>>     {
>>>>>> -        PageLock lock = null;
>>>>>> -
>>>>>> -        if( m_reaper == null )
>>>>>> -        {
>>>>>> -            //
>>>>>> -            //  Start the lock reaper lazily.  We don't want to
>>>>>> start
>>>>>> it in
>>>>>> -            //  the constructor, because starting threads in
>>>>>> constructors
>>>>>> -            //  is a bad idea when it comes to inheritance.
>>>>>> Besides,
>>>>>> -            //  laziness is a virtue.
>>>>>> -            //
>>>>>> -            m_reaper = new LockReaper( m_engine );
>>>>>> -            m_reaper.start();
>>>>>> -        }
>>>>>> -
>>>>>> -        synchronized( m_pageLocks )
>>>>>> -        {
>>>>>> -            fireEvent( WikiPageEvent.PAGE_LOCK,
>>>>>> page.getName() ); //
>>>>>> prior to or after actual lock?
>>>>>> -
>>>>>> -            lock = m_pageLocks.get( page.getName() );
>>>>>> -
>>>>>> -            if( lock == null )
>>>>>> -            {
>>>>>> -                //
>>>>>> -                //  Lock is available, so make a lock.
>>>>>> -                //
>>>>>> -                Date d = new Date();
>>>>>> -                lock = new PageLock( page, user, d,
>>>>>> -                                     new Date( d.getTime() +
>>>>>> m_expiryTime*60*1000L ) );
>>>>>> -
>>>>>> -                m_pageLocks.put( page.getName(), lock );
>>>>>> -
>>>>>> -                log.debug( "Locked page "+page.getName()+" for
>>>>>> "+user);
>>>>>> -            }
>>>>>> -            else
>>>>>> -            {
>>>>>> -                log.debug( "Page "+page.getName()+" already
>>>>>> locked by
>>>>>> "+lock.getLocker() );
>>>>>> -                lock = null; // Nothing to return
>>>>>> -            }
>>>>>> -        }
>>>>>> -
>>>>>> -        return lock;
>>>>>> +        return m_engine.getContentManager().lockPage( page,
>>>>>> user );
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -372,16 +208,7 @@
>>>>>>      */
>>>>>>     public void unlockPage( PageLock lock )
>>>>>>     {
>>>>>> -        if( lock == null ) return;
>>>>>> -
>>>>>> -        synchronized( m_pageLocks )
>>>>>> -        {
>>>>>> -            m_pageLocks.remove( lock.getPage() );
>>>>>> -
>>>>>> -            log.debug( "Unlocked page "+lock.getPage() );
>>>>>> -        }
>>>>>> -
>>>>>> -        fireEvent( WikiPageEvent.PAGE_UNLOCK, lock.getPage() );
>>>>>> +        m_engine.getContentManager().unlockPage( lock );
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -393,14 +220,7 @@
>>>>>>      */
>>>>>>     public PageLock getCurrentLock( WikiPage page )
>>>>>>     {
>>>>>> -        PageLock lock = null;
>>>>>> -
>>>>>> -        synchronized( m_pageLocks )
>>>>>> -        {
>>>>>> -            lock = m_pageLocks.get( page.getName() );
>>>>>> -        }
>>>>>> -
>>>>>> -        return lock;
>>>>>> +        return
>>>>>> m_engine.getContentManager().getCurrentLock( page );
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -413,17 +233,7 @@
>>>>>>      */
>>>>>>     public List getActiveLocks()
>>>>>>     {
>>>>>> -        ArrayList<PageLock> result = new ArrayList<PageLock>();
>>>>>> -
>>>>>> -        synchronized( m_pageLocks )
>>>>>> -        {
>>>>>> -            for( PageLock lock : m_pageLocks.values() )
>>>>>> -            {
>>>>>> -                result.add( lock );
>>>>>> -            }
>>>>>> -        }
>>>>>> -
>>>>>> -        return result;
>>>>>> +        return m_engine.getContentManager().getActiveLocks();
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -438,47 +248,7 @@
>>>>>>     public WikiPage getPageInfo( String pageName, int version )
>>>>>>         throws ProviderException
>>>>>>     {
>>>>>> -        if( pageName == null || pageName.length() == 0 )
>>>>>> -        {
>>>>>> -            throw new ProviderException("Illegal page name
>>>>>> '"+pageName
>>>>>> +"'");
>>>>>> -        }
>>>>>> -
>>>>>> -        WikiPage page = null;
>>>>>> -
>>>>>> -        try
>>>>>> -        {
>>>>>> -            page = m_provider.getPageInfo( pageName, version );
>>>>>> -        }
>>>>>> -        catch( RepositoryModifiedException e )
>>>>>> -        {
>>>>>> -            //
>>>>>> -            //  This only occurs with the latest version.
>>>>>> -            //
>>>>>> -            log.info("Repository has been modified externally
>>>>>> while
>>>>>> fetching info for "+pageName );
>>>>>> -
>>>>>> -            page = m_provider.getPageInfo( pageName, version );
>>>>>> -
>>>>>> -            if( page != null )
>>>>>> -            {
>>>>>> -                m_engine.updateReferences( page );
>>>>>> -            }
>>>>>> -            else
>>>>>> -            {
>>>>>> -
>>>>>> m_engine
>>>>>> .getReferenceManager
>>>>>> ().pageRemoved( m_engine.createPage(pageName) );
>>>>>> -            }
>>>>>> -        }
>>>>>> -
>>>>>> -        //
>>>>>> -        //  Should update the metadata.
>>>>>> -        //
>>>>>> -        /*
>>>>>> -        if( page != null && !page.hasMetadata() )
>>>>>> -        {
>>>>>> -            WikiContext ctx = new WikiContext(m_engine,page);
>>>>>> -            m_engine.textToHTML( ctx,
>>>>>> getPageText(pageName,version) );
>>>>>> -        }
>>>>>> -        */
>>>>>> -        return page;
>>>>>> +        return
>>>>>> m_engine 
>>>>>> .getContentManager().getPage( WikiName.valueOf( pageName ),
>>>>>> version );
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -493,12 +263,7 @@
>>>>>>     public List getVersionHistory( String pageName )
>>>>>>         throws ProviderException
>>>>>>     {
>>>>>> -        if( pageExists( pageName ) )
>>>>>> -        {
>>>>>> -            return m_provider.getVersionHistory( pageName );
>>>>>> -        }
>>>>>> -
>>>>>> -        return null;
>>>>>> +        return
>>>>>> m_engine
>>>>>> .getContentManager
>>>>>> ().getVersionHistory( WikiName.valueOf( pageName ) );
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -508,7 +273,7 @@
>>>>>>      */
>>>>>>     public String getProviderDescription()
>>>>>>     {
>>>>>> -        return m_provider.getProviderInfo();
>>>>>> +        return
>>>>>> m_engine.getContentManager().getProviderDescription();
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -521,15 +286,7 @@
>>>>>>      */
>>>>>>     public int getTotalPageCount()
>>>>>>     {
>>>>>> -        try
>>>>>> -        {
>>>>>> -            return m_provider.getAllPages().size();
>>>>>> -        }
>>>>>> -        catch( ProviderException e )
>>>>>> -        {
>>>>>> -            log.error( "Unable to count pages: ",e );
>>>>>> -            return -1;
>>>>>> -        }
>>>>>> +        return
>>>>>> m_engine.getContentManager().getTotalPageCount( null );
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -542,12 +299,7 @@
>>>>>>     public boolean pageExists( String pageName )
>>>>>>         throws ProviderException
>>>>>>     {
>>>>>> -        if( pageName == null || pageName.length() == 0 )
>>>>>> -        {
>>>>>> -            throw new ProviderException("Illegal page name");
>>>>>> -        }
>>>>>> -
>>>>>> -        return m_provider.pageExists( pageName );
>>>>>> +        return
>>>>>> m_engine
>>>>>> .getContentManager().pageExists( WikiName.valueOf( pageName ) );
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -562,20 +314,7 @@
>>>>>>     public boolean pageExists( String pageName, int version )
>>>>>>         throws ProviderException
>>>>>>     {
>>>>>> -        if( pageName == null || pageName.length() == 0 )
>>>>>> -        {
>>>>>> -            throw new ProviderException("Illegal page name");
>>>>>> -        }
>>>>>> -
>>>>>> -        if( version == WikiProvider.LATEST_VERSION )
>>>>>> -            return pageExists( pageName );
>>>>>> -
>>>>>> -        if( m_provider instanceof CachingProvider )
>>>>>> -        {
>>>>>> -            return
>>>>>> ((CachingProvider)m_provider).pageExists( pageName , version );
>>>>>> -        }
>>>>>> -
>>>>>> -        return m_provider.getPageInfo( pageName, version ) !=
>>>>>> null;
>>>>>> +        return
>>>>>> m_engine
>>>>>> .getContentManager().pageExists( WikiName.valueOf( pageName ),
>>>>>> version );
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -587,10 +326,7 @@
>>>>>>     public void deleteVersion( WikiPage page )
>>>>>>         throws ProviderException
>>>>>>     {
>>>>>> -        m_provider.deleteVersion( page.getName(),
>>>>>> page.getVersion() );
>>>>>> -
>>>>>> -        // FIXME: If this was the latest, reindex Lucene
>>>>>> -        // FIXME: Update RefMgr
>>>>>> +        m_engine.getContentManager().deleteVersion( page );
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -602,190 +338,10 @@
>>>>>>     public void deletePage( WikiPage page )
>>>>>>         throws ProviderException
>>>>>>     {
>>>>>> -        fireEvent( WikiPageEvent.PAGE_DELETE_REQUEST,
>>>>>> page.getName() );
>>>>>> -
>>>>>> -        m_provider.deletePage( page.getName() );
>>>>>> -
>>>>>> -        fireEvent( WikiPageEvent.PAGE_DELETED, page.getName() );
>>>>>> +        m_engine.getContentManager().deletePage( page );
>>>>>>     }
>>>>>>
>>>>>> -    /**
>>>>>> -     *  This is a simple reaper thread that runs roughly every
>>>>>> minute
>>>>>> -     *  or so (it's not really that important, as long as it
>>>>>> runs),
>>>>>> -     *  and removes all locks that have expired.
>>>>>> -     */
>>>>>> -    private class LockReaper extends WikiBackgroundThread
>>>>>> -    {
>>>>>> -        /**
>>>>>> -         *  Create a LockReaper for a given engine.
>>>>>> -         *
>>>>>> -         *  @param engine WikiEngine to own this thread.
>>>>>> -         */
>>>>>> -        public LockReaper( WikiEngine engine )
>>>>>> -        {
>>>>>> -            super( engine, 60 );
>>>>>> -            setName("JSPWiki Lock Reaper");
>>>>>> -        }
>>>>>> -
>>>>>> -        public void backgroundTask() throws Exception
>>>>>> -        {
>>>>>> -            synchronized( m_pageLocks )
>>>>>> -            {
>>>>>> -                Collection entries = m_pageLocks.values();
>>>>>> -
>>>>>> -                Date now = new Date();
>>>>>> -
>>>>>> -                for( Iterator i = entries.iterator();
>>>>>> i.hasNext(); )
>>>>>> -                {
>>>>>> -                    PageLock p = (PageLock) i.next();
>>>>>> -
>>>>>> -                    if( now.after( p.getExpiryTime() ) )
>>>>>> -                    {
>>>>>> -                        i.remove();
>>>>>> -
>>>>>> -                        log.debug( "Reaped lock: "+p.getPage()+
>>>>>> -                                   " by "+p.getLocker()+
>>>>>> -                                   ", acquired
>>>>>> "+p.getAcquisitionTime()+
>>>>>> -                                   ", and expired
>>>>>> "+p.getExpiryTime() );
>>>>>> -                    }
>>>>>> -                }
>>>>>> -            }
>>>>>> -        }
>>>>>> -    }
>>>>>> -
>>>>>> -    // workflow task inner
>>>>>> classes....................................................
>>>>>> -
>>>>>> -    /**
>>>>>> -     * Inner class that handles the page pre-save actions. If  
>>>>>> the
>>>>>> proposed page
>>>>>> -     * text is the same as the current version, the {@link
>>>>>> #execute()} method
>>>>>> -     * returns {@link
>>>>>> org.apache.wiki.workflow.Outcome#STEP_ABORT}. Any
>>>>>> -     * WikiExceptions thrown by page filters will be re-thrown,
>>>>>> and
>>>>>> the workflow
>>>>>> -     * will abort.
>>>>>> -     *
>>>>>> -     * @author Andrew Jaquith
>>>>>> -     */
>>>>>> -    public static class PreSaveWikiPageTask extends Task
>>>>>> -    {
>>>>>> -        private static final long serialVersionUID =
>>>>>> 6304715570092804615L;
>>>>>> -        private final WikiContext m_context;
>>>>>> -        private final String m_proposedText;
>>>>>> -
>>>>>> -        /**
>>>>>> -         *  Creates the task.
>>>>>> -         *
>>>>>> -         *  @param context The WikiContext
>>>>>> -         *  @param proposedText The text that was just saved.
>>>>>> -         */
>>>>>> -        public PreSaveWikiPageTask( WikiContext context, String
>>>>>> proposedText )
>>>>>> -        {
>>>>>> -            super( PRESAVE_TASK_MESSAGE_KEY );
>>>>>> -            m_context = context;
>>>>>> -            m_proposedText = proposedText;
>>>>>> -        }
>>>>>> -
>>>>>> -        /**
>>>>>> -         *  {@inheritDoc}
>>>>>> -         */
>>>>>> -        @Override
>>>>>> -        public Outcome execute() throws WikiException
>>>>>> -        {
>>>>>> -            // Retrieve attributes
>>>>>> -            WikiEngine engine = m_context.getEngine();
>>>>>> -            Workflow workflow = getWorkflow();
>>>>>> -
>>>>>> -            // Get the wiki page
>>>>>> -            WikiPage page = m_context.getPage();
>>>>>> -
>>>>>> -            // Figure out who the author was. Prefer the author
>>>>>> -            // set programmatically; otherwise get from the
>>>>>> -            // current logged in user
>>>>>> -            if ( page.getAuthor() == null )
>>>>>> -            {
>>>>>> -                Principal wup = m_context.getCurrentUser();
>>>>>> -
>>>>>> -                if ( wup != null )
>>>>>> -                    page.setAuthor( wup.getName() );
>>>>>> -            }
>>>>>> -
>>>>>> -            // Run the pre-save filters. If any exceptions, add
>>>>>> error
>>>>>> to list, abort, and redirect
>>>>>> -            String saveText;
>>>>>> -            try
>>>>>> -            {
>>>>>> -                saveText =
>>>>>> engine.getFilterManager().doPreSaveFiltering( m_context,
>>>>>> m_proposedText );
>>>>>> -            }
>>>>>> -            catch ( FilterException e )
>>>>>> -            {
>>>>>> -                throw e;
>>>>>> -            }
>>>>>> -
>>>>>> -            // Stash the wiki context, old and new text as
>>>>>> workflow
>>>>>> attributes
>>>>>> -            workflow.setAttribute( PRESAVE_WIKI_CONTEXT,
>>>>>> m_context );
>>>>>> -            workflow.setAttribute( FACT_PROPOSED_TEXT,  
>>>>>> saveText );
>>>>>> -            return Outcome.STEP_COMPLETE;
>>>>>> -        }
>>>>>> -    }
>>>>>> -
>>>>>> -    /**
>>>>>> -     * Inner class that handles the actual page save and post- 
>>>>>> save
>>>>>> actions. Instances
>>>>>> -     * of this class are assumed to have been added to an  
>>>>>> approval
>>>>>> workflow via
>>>>>> -     * {@link
>>>>>> org
>>>>>> .apache
>>>>>> .wiki.workflow.WorkflowBuilder#buildApprovalWorkflow(Principal,
>>>>>> String, Task, String, org.apache.wiki.workflow.Fact[], Task,
>>>>>> String)};
>>>>>> -     * they will not function correctly otherwise.
>>>>>> -     *
>>>>>> -     * @author Andrew Jaquith
>>>>>> -     */
>>>>>> -    public static class SaveWikiPageTask extends Task
>>>>>> -    {
>>>>>> -        private static final long serialVersionUID =
>>>>>> 3190559953484411420L;
>>>>>> -
>>>>>> -        /**
>>>>>> -         *  Creates the Task.
>>>>>> -         */
>>>>>> -        public SaveWikiPageTask()
>>>>>> -        {
>>>>>> -            super( SAVE_TASK_MESSAGE_KEY );
>>>>>> -        }
>>>>>> -
>>>>>> -        /** {@inheritDoc} */
>>>>>> -        @Override
>>>>>> -        public Outcome execute() throws WikiException
>>>>>> -        {
>>>>>> -            // Retrieve attributes
>>>>>> -            WikiContext context = (WikiContext)
>>>>>> getWorkflow().getAttribute( PRESAVE_WIKI_CONTEXT );
>>>>>> -            String proposedText = (String)
>>>>>> getWorkflow().getAttribute( FACT_PROPOSED_TEXT );
>>>>>> -
>>>>>> -            WikiEngine engine = context.getEngine();
>>>>>> -            WikiPage page = context.getPage();
>>>>>> -
>>>>>> -            // Let the rest of the engine handle actual saving.
>>>>>> -            engine.getPageManager().putPageText( page,
>>>>>> proposedText );
>>>>>> -
>>>>>> -            // Refresh the context for post save filtering.
>>>>>> -            engine.getPage( page.getName() );
>>>>>> -            engine.textToHTML( context, proposedText );
>>>>>> -
>>>>>> engine.getFilterManager().doPostSaveFiltering( context,
>>>>>> proposedText );
>>>>>> -
>>>>>> -            return Outcome.STEP_COMPLETE;
>>>>>> -        }
>>>>>> -    }
>>>>>> -
>>>>>> -    // events
>>>>>> processing 
>>>>>>  .......................................................
>>>>>> -
>>>>>> -    /**
>>>>>> -     *  Fires a WikiPageEvent of the provided type and page name
>>>>>> -     *  to all registered listeners.
>>>>>> -     *
>>>>>> -     * @see org.apache.wiki.event.WikiPageEvent
>>>>>> -     * @param type       the event type to be fired
>>>>>> -     * @param pagename   the wiki page name as a String
>>>>>> -     */
>>>>>> -    protected final void fireEvent( int type, String pagename )
>>>>>> -    {
>>>>>> -        if ( WikiEventManager.isListening(this) )
>>>>>> -        {
>>>>>> -            WikiEventManager.fireEvent(this,new
>>>>>> WikiPageEvent(m_engine,type,pagename));
>>>>>> -        }
>>>>>> -    }
>>>>>> -
>>>>>> +
>>>>>>     /**
>>>>>>      *  {@inheritDoc}
>>>>>>      */
>>>>>> @@ -796,117 +352,4 @@
>>>>>>         return null;
>>>>>>     }
>>>>>>
>>>>>> -
>>>>>> -    /**
>>>>>> -     *  Listens for {@link
>>>>>> org.apache.wiki.event.WikiSecurityEvent#PROFILE_NAME_CHANGED}
>>>>>> -     *  events. If a user profile's name changes, each page  
>>>>>> ACL is
>>>>>> inspected. If an entry contains
>>>>>> -     *  a name that has changed, it is replaced with the new
>>>>>> one. No
>>>>>> events are emitted
>>>>>> -     *  as a consequence of this method, because the page  
>>>>>> contents
>>>>>> are still the same; it is
>>>>>> -     *  only the representations of the names within the ACL
>>>>>> that are
>>>>>> changing.
>>>>>> -     *
>>>>>> -     *  @param event The event
>>>>>> -     */
>>>>>> -    public void actionPerformed(WikiEvent event)
>>>>>> -    {
>>>>>> -        if (! ( event instanceof WikiSecurityEvent ) )
>>>>>> -        {
>>>>>> -            return;
>>>>>> -        }
>>>>>> -
>>>>>> -        WikiSecurityEvent se = (WikiSecurityEvent)event;
>>>>>> -        if ( se.getType() ==
>>>>>> WikiSecurityEvent.PROFILE_NAME_CHANGED )
>>>>>> -        {
>>>>>> -            UserProfile[] profiles =
>>>>>> (UserProfile[])se.getTarget();
>>>>>> -            Principal[] oldPrincipals = new Principal[]
>>>>>> -                { new  
>>>>>> WikiPrincipal( profiles[0].getLoginName() ),
>>>>>> -                  new  
>>>>>> WikiPrincipal( profiles[0].getFullname() ),
>>>>>> -                  new
>>>>>> WikiPrincipal( profiles[0].getWikiName() ) };
>>>>>> -            Principal newPrincipal = new
>>>>>> WikiPrincipal( profiles[1].getFullname() );
>>>>>> -
>>>>>> -            // Examine each page ACL
>>>>>> -            try
>>>>>> -            {
>>>>>> -                int pagesChanged = 0;
>>>>>> -                Collection pages = getAllPages();
>>>>>> -                for ( Iterator it = pages.iterator();
>>>>>> it.hasNext(); )
>>>>>> -                {
>>>>>> -                    WikiPage page = (WikiPage)it.next();
>>>>>> -                    boolean aclChanged = changeAcl( page,
>>>>>> oldPrincipals, newPrincipal );
>>>>>> -                    if ( aclChanged )
>>>>>> -                    {
>>>>>> -                        // If the Acl needed changing, change it
>>>>>> now
>>>>>> -                        try
>>>>>> -                        {
>>>>>> -
>>>>>> m_engine.getAclManager().setPermissions( page, page.getAcl() );
>>>>>> -                        }
>>>>>> -                        catch ( WikiSecurityException e )
>>>>>> -                        {
>>>>>> -                            log.error( "Could not change page
>>>>>> ACL for
>>>>>> page " + page.getName() + ": " + e.getMessage() );
>>>>>> -                        }
>>>>>> -                        pagesChanged++;
>>>>>> -                    }
>>>>>> -                }
>>>>>> -                log.info( "Profile name change for '" +
>>>>>> newPrincipal.toString() +
>>>>>> -                          "' caused " + pagesChanged + " page
>>>>>> ACLs to
>>>>>> change also." );
>>>>>> -            }
>>>>>> -            catch ( ProviderException e )
>>>>>> -            {
>>>>>> -                // Oooo! This is really bad...
>>>>>> -                log.error( "Could not change user name in Page
>>>>>> ACLs
>>>>>> because of Provider error:" + e.getMessage() );
>>>>>> -            }
>>>>>> -        }
>>>>>> -    }
>>>>>> -
>>>>>> -    /**
>>>>>> -     *  For a single wiki page, replaces all Acl entries
>>>>>> matching a
>>>>>> supplied array of Principals
>>>>>> -     *  with a new Principal.
>>>>>> -     *
>>>>>> -     *  @param page the wiki page whose Acl is to be modified
>>>>>> -     *  @param oldPrincipals an array of Principals to replace;
>>>>>> all
>>>>>> AclEntry objects whose
>>>>>> -     *   {@link AclEntry#getPrincipal()} method returns one of
>>>>>> these
>>>>>> Principals will be replaced
>>>>>> -     *  @param newPrincipal the Principal that should receive
>>>>>> the old
>>>>>> Principals' permissions
>>>>>> -     *  @return <code>true</code> if the Acl was actually  
>>>>>> changed;
>>>>>> <code>false</code> otherwise
>>>>>> -     */
>>>>>> -    protected boolean changeAcl( WikiPage page, Principal[]
>>>>>> oldPrincipals, Principal newPrincipal )
>>>>>> -    {
>>>>>> -        Acl acl = page.getAcl();
>>>>>> -        boolean pageChanged = false;
>>>>>> -        if ( acl != null )
>>>>>> -        {
>>>>>> -            Enumeration entries = acl.entries();
>>>>>> -            Collection<AclEntry> entriesToAdd    = new
>>>>>> ArrayList<AclEntry>();
>>>>>> -            Collection<AclEntry> entriesToRemove = new
>>>>>> ArrayList<AclEntry>();
>>>>>> -            while ( entries.hasMoreElements() )
>>>>>> -            {
>>>>>> -                AclEntry entry =  
>>>>>> (AclEntry)entries.nextElement();
>>>>>> -                if ( ArrayUtils.contains( oldPrincipals,
>>>>>> entry.getPrincipal() ) )
>>>>>> -                {
>>>>>> -                    // Create new entry
>>>>>> -                    AclEntry newEntry = new AclEntryImpl();
>>>>>> -                    newEntry.setPrincipal( newPrincipal );
>>>>>> -                    Enumeration permissions =  
>>>>>> entry.permissions();
>>>>>> -                    while ( permissions.hasMoreElements() )
>>>>>> -                    {
>>>>>> -                        Permission permission =
>>>>>> (Permission)permissions.nextElement();
>>>>>> -                        newEntry.addPermission(permission);
>>>>>> -                    }
>>>>>> -                    pageChanged = true;
>>>>>> -                    entriesToRemove.add( entry );
>>>>>> -                    entriesToAdd.add( newEntry );
>>>>>> -                }
>>>>>> -            }
>>>>>> -            for ( Iterator ix = entriesToRemove.iterator();
>>>>>> ix.hasNext(); )
>>>>>> -            {
>>>>>> -                AclEntry entry = (AclEntry)ix.next();
>>>>>> -                acl.removeEntry( entry );
>>>>>> -            }
>>>>>> -            for ( Iterator ix = entriesToAdd.iterator();
>>>>>> ix.hasNext(); )
>>>>>> -            {
>>>>>> -                AclEntry entry = (AclEntry)ix.next();
>>>>>> -                acl.addEntry( entry );
>>>>>> -            }
>>>>>> -        }
>>>>>> -        return pageChanged;
>>>>>> -    }
>>>>>> -
>>>>>> }
>>>>>> Index: src/java/org/apache/wiki/JCRWikiPage.java
>>>>>> = 
>>>>>> = 
>>>>>> =================================================================
>>>>>> --- src/java/org/apache/wiki/JCRWikiPage.java (revision 749743)
>>>>>> +++ src/java/org/apache/wiki/JCRWikiPage.java (working copy)
>>>>>> @@ -20,13 +20,14 @@
>>>>>>  */
>>>>>> package org.apache.wiki;
>>>>>>
>>>>>> -import java.io.InputStream;
>>>>>> +import java.io.*;
>>>>>> import java.util.*;
>>>>>>
>>>>>> -import javax.jcr.Node;
>>>>>> -import javax.jcr.PathNotFoundException;
>>>>>> -import javax.jcr.Property;
>>>>>> -import javax.jcr.RepositoryException;
>>>>>> +import javax.jcr.*;
>>>>>> +import javax.jcr.lock.LockException;
>>>>>> +import javax.jcr.nodetype.ConstraintViolationException;
>>>>>> +import javax.jcr.version.Version;
>>>>>> +import javax.jcr.version.VersionException;
>>>>>>
>>>>>> import org.apache.wiki.api.WikiException;
>>>>>> import org.apache.wiki.api.WikiPage;
>>>>>> @@ -35,12 +36,12 @@
>>>>>> import org.apache.wiki.auth.acl.AclImpl;
>>>>>> import org.apache.wiki.content.ContentManager;
>>>>>> import org.apache.wiki.content.WikiName;
>>>>>> +import org.apache.wiki.providers.ProviderException;
>>>>>> import org.apache.wiki.providers.WikiPageProvider;
>>>>>>
>>>>>>
>>>>>> /**
>>>>>> - *  Simple wrapper class for the Wiki page attributes.  The Wiki
>>>>>> page
>>>>>> - *  content is moved around in Strings, though.
>>>>>> + *  JCR-backed implementation of the WikiPage.
>>>>>>  *
>>>>>>  *  @since 3.0
>>>>>>  */
>>>>>> @@ -55,16 +56,15 @@
>>>>>> {
>>>>>>     private static final long serialVersionUID = 1L;
>>>>>>
>>>>>> +    private static final String LASTMODIFIED =
>>>>>> "wiki:lastModified";
>>>>>> +
>>>>>> +    private static final String AUTHOR       = "wiki:author";
>>>>>> +
>>>>>> +    private static final String ACL = "wiki:acl";
>>>>>> +
>>>>>>     private       WikiName   m_name;
>>>>>>     private       WikiEngine m_engine;
>>>>>> -    private Date             m_lastModified;
>>>>>> -    private long             m_fileSize = -1;
>>>>>> -    private int              m_version =
>>>>>> WikiPageProvider.LATEST_VERSION;
>>>>>> -    private String           m_author = null;
>>>>>> -    private final HashMap<String,Object> m_attributes = new
>>>>>> HashMap<String,Object>();
>>>>>> -    private Node             m_node;
>>>>>> -
>>>>>> -    private Acl m_accessList = null;
>>>>>> +    private String           m_jcrPath = null;
>>>>>>
>>>>>>     /**
>>>>>>      *  Use {@link WikiEngine#createPage(String)} instead.
>>>>>> @@ -72,8 +72,7 @@
>>>>>>      */
>>>>>>     public JCRWikiPage( WikiEngine engine, String path )
>>>>>>     {
>>>>>> -        m_engine = engine;
>>>>>> -        m_name   = WikiName.valueOf( path );
>>>>>> +        this( engine, WikiName.valueOf( path ) );
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -82,22 +81,22 @@
>>>>>>      */
>>>>>>     public JCRWikiPage( WikiEngine engine, WikiName name )
>>>>>>     {
>>>>>> -        m_engine = engine;
>>>>>> -        m_name   = name;
>>>>>> +        m_engine  = engine;
>>>>>> +        m_name    = name;
>>>>>> +        m_jcrPath = ContentManager.getJCRPath( name );
>>>>>>     }
>>>>>>
>>>>>>     public JCRWikiPage(WikiEngine engine, Node node)
>>>>>> -        throws RepositoryException, WikiException
>>>>>> +        throws RepositoryException, ProviderException
>>>>>>     {
>>>>>> -        m_engine = engine;
>>>>>> -        m_node   = node;
>>>>>> -        m_name   = ContentManager.getWikiPath( node.getPath() );
>>>>>> +        m_engine  = engine;
>>>>>> +        m_jcrPath = node.getPath();
>>>>>> +        m_name    =  
>>>>>> ContentManager.getWikiPath( node.getPath() );
>>>>>>     }
>>>>>> -
>>>>>> -
>>>>>> -    public Node getJCRNode()
>>>>>> +
>>>>>> +    public Node getJCRNode() throws RepositoryException
>>>>>>     {
>>>>>> -        return m_node;
>>>>>> +        return  
>>>>>> m_engine.getContentManager().getJCRNode(m_jcrPath);
>>>>>>     }
>>>>>>
>>>>>>     /* (non-Javadoc)
>>>>>> @@ -111,9 +110,9 @@
>>>>>>     /* (non-Javadoc)
>>>>>>      * @see org.apache.wiki.WikiPage#getQualifiedName()
>>>>>>      */
>>>>>> -    public String getQualifiedName()
>>>>>> +    public WikiName getQualifiedName()
>>>>>>     {
>>>>>> -        return m_name.toString();
>>>>>> +        return m_name;
>>>>>>     }
>>>>>>
>>>>>>     /* (non-Javadoc)
>>>>>> @@ -121,23 +120,58 @@
>>>>>>      */
>>>>>>     public Object getAttribute( String key )
>>>>>>     {
>>>>>> -        return m_attributes.get( key );
>>>>>> +        try
>>>>>> +        {
>>>>>> +            Property property = getJCRNode().getProperty( key );
>>>>>> +
>>>>>> +            return getValue( property );
>>>>>> +        }
>>>>>> +        catch( ItemNotFoundException e ) {}
>>>>>> +        catch( RepositoryException e ) {} // FIXME: Should log
>>>>>> this
>>>>>> at least.
>>>>>> +
>>>>>> +        return null;
>>>>>> +    }
>>>>>> +
>>>>>> +    private Object getValue( Property property ) throws
>>>>>> RepositoryException, ValueFormatException
>>>>>> +    {
>>>>>> +        switch( property.getType() )
>>>>>> +        {
>>>>>> +            case PropertyType.STRING:
>>>>>> +                return property.getString();
>>>>>> +        }
>>>>>> +
>>>>>> +        return property.getString();
>>>>>>     }
>>>>>>
>>>>>>     /* (non-Javadoc)
>>>>>>      * @see
>>>>>> org.apache.wiki.WikiPage#setAttribute(java.lang.String,
>>>>>> java.lang.Object)
>>>>>>      */
>>>>>> -    public void setAttribute( String key, Object attribute )
>>>>>> +    public void setAttribute( String key, String attribute )
>>>>>>     {
>>>>>> -        m_attributes.put( key, attribute );
>>>>>> +        try
>>>>>> +        {
>>>>>> +            getJCRNode().setProperty( key, attribute );
>>>>>> +        }
>>>>>> +        catch(RepositoryException e) {} // FIXME: Should log
>>>>>>     }
>>>>>>
>>>>>> +    public void setAttribute( String key, Date attribute )
>>>>>> +    {
>>>>>> +        try
>>>>>> +        {
>>>>>> +            Calendar c = Calendar.getInstance();
>>>>>> +            c.setTime( attribute );
>>>>>> +            getJCRNode().setProperty( key, c );
>>>>>> +        }
>>>>>> +        catch(RepositoryException e) {} // FIXME: Should log
>>>>>> +    }
>>>>>> +
>>>>>>     /* (non-Javadoc)
>>>>>>      * @see org.apache.wiki.WikiPage#getAttributes()
>>>>>>      */
>>>>>>     public Map getAttributes()
>>>>>>     {
>>>>>> -        return m_attributes;
>>>>>> +        return null; // FIXME: m_attributes;
>>>>>>     }
>>>>>>
>>>>>>     /* (non-Javadoc)
>>>>>> @@ -145,7 +179,18 @@
>>>>>>      */
>>>>>>     public Object removeAttribute( String key )
>>>>>>     {
>>>>>> -        return m_attributes.remove( key );
>>>>>> +        try
>>>>>> +        {
>>>>>> +            Property p = getJCRNode().getProperty( key );
>>>>>> +
>>>>>> +            Object value = getValue(p);
>>>>>> +            p.remove();
>>>>>> +
>>>>>> +            return value;
>>>>>> +        }
>>>>>> +        catch(RepositoryException e) {}
>>>>>> +
>>>>>> +        return null;
>>>>>>     }
>>>>>>
>>>>>>     /* (non-Javadoc)
>>>>>> @@ -153,7 +198,15 @@
>>>>>>      */
>>>>>>     public Date getLastModified()
>>>>>>     {
>>>>>> -        return m_lastModified;
>>>>>> +        try
>>>>>> +        {
>>>>>> +            return
>>>>>> getJCRNode().getProperty( LASTMODIFIED ).getDate().getTime();
>>>>>> +        }
>>>>>> +        catch( RepositoryException e )
>>>>>> +        {
>>>>>> +            // FIXME: Should rethrow
>>>>>> +        }
>>>>>> +        return null;
>>>>>>     }
>>>>>>
>>>>>>     /* (non-Javadoc)
>>>>>> @@ -161,15 +214,7 @@
>>>>>>      */
>>>>>>     public void setLastModified( Date date )
>>>>>>     {
>>>>>> -        m_lastModified = date;
>>>>>> -    }
>>>>>> -
>>>>>> -    /* (non-Javadoc)
>>>>>> -     * @see org.apache.wiki.WikiPage#setVersion(int)
>>>>>> -     */
>>>>>> -    public void setVersion( int version )
>>>>>> -    {
>>>>>> -        m_version = version;
>>>>>> +        setAttribute( LASTMODIFIED, date );
>>>>>>     }
>>>>>>
>>>>>>     /* (non-Javadoc)
>>>>>> @@ -177,7 +222,8 @@
>>>>>>      */
>>>>>>     public int getVersion()
>>>>>>     {
>>>>>> -        return m_version;
>>>>>> +        return -1;
>>>>>> +        //return getJCRNode().getBaseVersion().
>>>>>>     }
>>>>>>
>>>>>>     /* (non-Javadoc)
>>>>>> @@ -185,15 +231,13 @@
>>>>>>      */
>>>>>>     public long getSize()
>>>>>>     {
>>>>>> -        return m_fileSize;
>>>>>> -    }
>>>>>> -
>>>>>> -    /* (non-Javadoc)
>>>>>> -     * @see org.apache.wiki.WikiPage#setSize(long)
>>>>>> -     */
>>>>>> -    public void setSize( long size )
>>>>>> -    {
>>>>>> -        m_fileSize = size;
>>>>>> +        try
>>>>>> +        {
>>>>>> +            return
>>>>>> getJCRNode().getProperty( ATTR_CONTENT ).getLength();
>>>>>> +        }
>>>>>> +        catch(RepositoryException e){}
>>>>>> +
>>>>>> +        return -1;
>>>>>>     }
>>>>>>
>>>>>>     /* (non-Javadoc)
>>>>>> @@ -201,7 +245,50 @@
>>>>>>      */
>>>>>>     public Acl getAcl()
>>>>>>     {
>>>>>> -        return m_accessList;
>>>>>> +        ObjectInputStream in = null;
>>>>>> +
>>>>>> +        try
>>>>>> +        {
>>>>>> +            Property acl = getJCRNode().getProperty( ACL );
>>>>>> +
>>>>>> +            in = new ObjectInputStream( acl.getStream() );
>>>>>> +
>>>>>> +            Acl a = (Acl) in.readObject();
>>>>>> +
>>>>>> +            return a;
>>>>>> +        }
>>>>>> +        catch( PathNotFoundException e )
>>>>>> +        {
>>>>>> +            // No ACL, so this is ok.
>>>>>> +        }
>>>>>> +        catch( RepositoryException e )
>>>>>> +        {
>>>>>> +            // TODO Auto-generated catch block
>>>>>> +            e.printStackTrace();
>>>>>> +        }
>>>>>> +        catch( IOException e )
>>>>>> +        {
>>>>>> +            // TODO Auto-generated catch block
>>>>>> +            e.printStackTrace();
>>>>>> +        }
>>>>>> +        catch( ClassNotFoundException e )
>>>>>> +        {
>>>>>> +            // TODO Auto-generated catch block
>>>>>> +            e.printStackTrace();
>>>>>> +        }
>>>>>> +        finally
>>>>>> +        {
>>>>>> +            if( in != null )
>>>>>> +                try
>>>>>> +                {
>>>>>> +                    in.close();
>>>>>> +                }
>>>>>> +                catch( IOException e )
>>>>>> +                {
>>>>>> +                }
>>>>>> +        }
>>>>>> +
>>>>>> +        return null;
>>>>>>     }
>>>>>>
>>>>>>     /* (non-Javadoc)
>>>>>> @@ -209,7 +296,49 @@
>>>>>>      */
>>>>>>     public void setAcl( Acl acl )
>>>>>>     {
>>>>>> -        m_accessList = acl;
>>>>>> +        ByteArrayOutputStream out = new ByteArrayOutputStream();
>>>>>> +
>>>>>> +        ObjectOutputStream oout;
>>>>>> +        try
>>>>>> +        {
>>>>>> +            oout = new ObjectOutputStream(out);
>>>>>> +            oout.writeObject( acl );
>>>>>> +
>>>>>> +            oout.close();
>>>>>> +
>>>>>> +            getJCRNode().setProperty( ACL, new
>>>>>> ByteArrayInputStream(out.toByteArray()) );
>>>>>> +        }
>>>>>> +        catch( IOException e )
>>>>>> +        {
>>>>>> +            // TODO Auto-generated catch block
>>>>>> +            e.printStackTrace();
>>>>>> +        }
>>>>>> +        catch( ValueFormatException e )
>>>>>> +        {
>>>>>> +            // TODO Auto-generated catch block
>>>>>> +            e.printStackTrace();
>>>>>> +        }
>>>>>> +        catch( VersionException e )
>>>>>> +        {
>>>>>> +            // TODO Auto-generated catch block
>>>>>> +            e.printStackTrace();
>>>>>> +        }
>>>>>> +        catch( LockException e )
>>>>>> +        {
>>>>>> +            // TODO Auto-generated catch block
>>>>>> +            e.printStackTrace();
>>>>>> +        }
>>>>>> +        catch( ConstraintViolationException e )
>>>>>> +        {
>>>>>> +            // TODO Auto-generated catch block
>>>>>> +            e.printStackTrace();
>>>>>> +        }
>>>>>> +        catch( RepositoryException e )
>>>>>> +        {
>>>>>> +            // TODO Auto-generated catch block
>>>>>> +            e.printStackTrace();
>>>>>> +        }
>>>>>> +
>>>>>>     }
>>>>>>
>>>>>>     /* (non-Javadoc)
>>>>>> @@ -217,7 +346,7 @@
>>>>>>      */
>>>>>>     public void setAuthor( String author )
>>>>>>     {
>>>>>> -        m_author = author;
>>>>>> +        setAttribute( AUTHOR, author );
>>>>>>     }
>>>>>>
>>>>>>     /* (non-Javadoc)
>>>>>> @@ -225,7 +354,7 @@
>>>>>>      */
>>>>>>     public String getAuthor()
>>>>>>     {
>>>>>> -        return m_author;
>>>>>> +        return (String)getAttribute( AUTHOR );
>>>>>>     }
>>>>>>
>>>>>>     /* (non-Javadoc)
>>>>>> @@ -238,39 +367,11 @@
>>>>>>     }
>>>>>>
>>>>>>     /* (non-Javadoc)
>>>>>> -     * @see org.apache.wiki.WikiPage#invalidateMetadata()
>>>>>> -     */
>>>>>> -    public void invalidateMetadata()
>>>>>> -    {
>>>>>> -        m_hasMetadata = false;
>>>>>> -        setAcl( null );
>>>>>> -        m_attributes.clear();
>>>>>> -    }
>>>>>> -
>>>>>> -    private boolean m_hasMetadata = false;
>>>>>> -
>>>>>> -    /* (non-Javadoc)
>>>>>> -     * @see org.apache.wiki.WikiPage#hasMetadata()
>>>>>> -     */
>>>>>> -    public boolean hasMetadata()
>>>>>> -    {
>>>>>> -        return m_hasMetadata;
>>>>>> -    }
>>>>>> -
>>>>>> -    /* (non-Javadoc)
>>>>>> -     * @see org.apache.wiki.WikiPage#setHasMetadata()
>>>>>> -     */
>>>>>> -    public void setHasMetadata()
>>>>>> -    {
>>>>>> -        m_hasMetadata = true;
>>>>>> -    }
>>>>>> -
>>>>>> -    /* (non-Javadoc)
>>>>>>      * @see org.apache.wiki.WikiPage#toString()
>>>>>>      */
>>>>>>     public String toString()
>>>>>>     {
>>>>>> -        return "WikiPage ["+m_name+",ver="+m_version
>>>>>> +",mod="+m_lastModified+"]";
>>>>>> +        return "WikiPage ["+m_name+",ver="+getVersion()
>>>>>> +",mod="+getLastModified()+"]";
>>>>>>     }
>>>>>>
>>>>>>     /* (non-Javadoc)
>>>>>> @@ -280,30 +381,6 @@
>>>>>>     {
>>>>>>         JCRWikiPage p = new JCRWikiPage( m_engine, m_name );
>>>>>>
>>>>>> -        p.m_author       = m_author;
>>>>>> -        p.m_version      = m_version;
>>>>>> -        p.m_lastModified = m_lastModified != null ?
>>>>>> (Date)m_lastModified.clone() : null;
>>>>>> -
>>>>>> -        p.m_fileSize     = m_fileSize;
>>>>>> -
>>>>>> -        for( Map.Entry<String,Object> entry :
>>>>>> m_attributes.entrySet() )
>>>>>> -        {
>>>>>> -            p.m_attributes.put( entry.getKey(),
>>>>>> -                                entry.getValue() );
>>>>>> -        }
>>>>>> -
>>>>>> -        if( m_accessList != null )
>>>>>> -        {
>>>>>> -            p.m_accessList = new AclImpl();
>>>>>> -
>>>>>> -            for( Enumeration entries = m_accessList.entries();
>>>>>> entries.hasMoreElements(); )
>>>>>> -            {
>>>>>> -                AclEntry e = (AclEntry)entries.nextElement();
>>>>>> -
>>>>>> -                p.m_accessList.addEntry( e );
>>>>>> -            }
>>>>>> -        }
>>>>>> -
>>>>>>         return p;
>>>>>>     }
>>>>>>
>>>>>> @@ -356,7 +433,7 @@
>>>>>>      */
>>>>>>     public int hashCode()
>>>>>>     {
>>>>>> -        return m_name.hashCode() * m_version;
>>>>>> +        return m_name.hashCode() * getVersion();
>>>>>>     }
>>>>>>
>>>>>>     public InputStream getContentAsStream()
>>>>>> @@ -381,7 +458,7 @@
>>>>>>     {
>>>>>>         try
>>>>>>         {
>>>>>> -            m_node.setProperty( ATTR_CONTENT, in );
>>>>>> +            getJCRNode().setProperty( ATTR_CONTENT, in );
>>>>>>         }
>>>>>>         catch( RepositoryException e )
>>>>>>         {
>>>>>> @@ -395,28 +472,29 @@
>>>>>>
>>>>>>     }
>>>>>>
>>>>>> -    public void save() throws WikiException
>>>>>> +    public void save() throws ProviderException
>>>>>>     {
>>>>>>         try
>>>>>>         {
>>>>>> -            if( m_node.isNew() )
>>>>>> -                m_node.getParent().save();
>>>>>> +            Node nd = getJCRNode();
>>>>>> +            if( nd.isNew() )
>>>>>> +                nd.getParent().save();
>>>>>>             else
>>>>>> -                m_node.save();
>>>>>> +                nd.save();
>>>>>>         }
>>>>>>         catch( RepositoryException e )
>>>>>>         {
>>>>>> -            throw new WikiException("Save failed",e);
>>>>>> +            throw new ProviderException("Save failed",e);
>>>>>>         }
>>>>>>     }
>>>>>>
>>>>>>     private static final String ATTR_CONTENT = "wiki:content";
>>>>>>
>>>>>> -    public String getContentAsString() throws WikiException
>>>>>> +    public String getContentAsString() throws ProviderException
>>>>>>     {
>>>>>>         try
>>>>>>         {
>>>>>> -            Property p = m_node.getProperty( ATTR_CONTENT );
>>>>>> +            Property p =  
>>>>>> getJCRNode().getProperty( ATTR_CONTENT );
>>>>>>
>>>>>>             return p.getString();
>>>>>>         }
>>>>>> @@ -425,22 +503,59 @@
>>>>>>         }
>>>>>>         catch( RepositoryException e )
>>>>>>         {
>>>>>> -            throw new WikiException("Unable to get property",e);
>>>>>> +            throw new ProviderException("Unable to get
>>>>>> property",e);
>>>>>>         }
>>>>>>
>>>>>>         return null;
>>>>>>     }
>>>>>>
>>>>>> -    public void setContent( String content ) throws  
>>>>>> WikiException
>>>>>> +    public void setContent( String content ) throws
>>>>>> ProviderException
>>>>>>     {
>>>>>>         try
>>>>>>         {
>>>>>> -            m_node.setProperty( ATTR_CONTENT, content );
>>>>>> +            getJCRNode().setProperty( ATTR_CONTENT, content );
>>>>>>         }
>>>>>>         catch( RepositoryException e )
>>>>>>         {
>>>>>> -            throw new WikiException("Unable to set content",e);
>>>>>> +            throw new ProviderException("Unable to set
>>>>>> content",e);
>>>>>>         }
>>>>>>     }
>>>>>>
>>>>>> +    // FIXME: The following are obsolete and must go.
>>>>>> +    public boolean hasMetadata()
>>>>>> +    {
>>>>>> +        // TODO Auto-generated method stub
>>>>>> +        return false;
>>>>>> +    }
>>>>>> +
>>>>>> +    public void invalidateMetadata()
>>>>>> +    {
>>>>>> +        // TODO Auto-generated method stub
>>>>>> +
>>>>>> +    }
>>>>>> +
>>>>>> +    public void setAttribute( String key, Object attribute )
>>>>>> +    {
>>>>>> +        // TODO Auto-generated method stub
>>>>>> +
>>>>>> +    }
>>>>>> +
>>>>>> +    public void setHasMetadata()
>>>>>> +    {
>>>>>> +        // TODO Auto-generated method stub
>>>>>> +
>>>>>> +    }
>>>>>> +
>>>>>> +    public void setSize( long size )
>>>>>> +    {
>>>>>> +        // TODO Auto-generated method stub
>>>>>> +
>>>>>> +    }
>>>>>> +
>>>>>> +    public void setVersion( int version )
>>>>>> +    {
>>>>>> +        // TODO Auto-generated method stub
>>>>>> +
>>>>>> +    }
>>>>>> +
>>>>>> }
>>>>>> Index: src/java/org/apache/wiki/auth/UserManager.java
>>>>>> = 
>>>>>> = 
>>>>>> =================================================================
>>>>>> --- src/java/org/apache/wiki/auth/UserManager.java    (revision
>>>>>> 749743)
>>>>>> +++ src/java/org/apache/wiki/auth/UserManager.java    (working
>>>>>> copy)
>>>>>> @@ -117,7 +117,7 @@
>>>>>>
>>>>>>         // Attach the PageManager as a listener
>>>>>>         // TODO: it would be better if we did this in PageManager
>>>>>> directly
>>>>>> -        addWikiEventListener( engine.getPageManager() );
>>>>>> +        addWikiEventListener( engine.getContentManager() );
>>>>>>
>>>>>>         JSONRPCManager.registerGlobalObject( "users", new
>>>>>> JSONUserModule(this), new AllPermission(null) );
>>>>>>     }
>>>>>> Index: tests/java/org/apache/wiki/content/ContentManagerTest.java
>>>>>> = 
>>>>>> = 
>>>>>> =================================================================
>>>>>> --- tests/java/org/apache/wiki/content/ContentManagerTest.java
>>>>>> (revision 749743)
>>>>>> +++ tests/java/org/apache/wiki/content/ContentManagerTest.java
>>>>>> (working copy)
>>>>>> @@ -17,7 +17,6 @@
>>>>>> {
>>>>>>     ContentManager m_mgr;
>>>>>>     TestEngine     m_engine;
>>>>>> -    Object         m_owner;
>>>>>>
>>>>>>     @Override
>>>>>>     protected void setUp() throws Exception
>>>>>> @@ -30,7 +29,6 @@
>>>>>>         m_engine = new TestEngine(props);
>>>>>>
>>>>>>         m_mgr = m_engine.getContentManager();
>>>>>> -        m_owner = m_mgr.acquire();
>>>>>>     }
>>>>>>
>>>>>>     @Override
>>>>>> @@ -40,7 +38,6 @@
>>>>>>
>>>>>>         if( p != null ) m_mgr.deletePage( p );
>>>>>>
>>>>>> -        m_mgr.release( m_owner );
>>>>>>         super.tearDown();
>>>>>>     }
>>>>>>
>>>>>>
>>>>>> Property changes on: etc
>>>>>> ___________________________________________________________________
>>>>>> Modified: svn:ignore
>>>>>>   - jspwiki.properties
>>>>>> jspwiki.jks
>>>>>> classes
>>>>>>
>>>>>>   + jspwiki.properties
>>>>>> jspwiki.jks
>>>>>> classes
>>>>>> i18n
>>>>>>
>>>>>>
>>>>>> Index: src/java/org/apache/wiki/content/ContentManager.java
>>>>>> = 
>>>>>> = 
>>>>>> =================================================================
>>>>>> --- src/java/org/apache/wiki/content/ContentManager.java
>>>>>> (revision
>>>>>> 749743)
>>>>>> +++ src/java/org/apache/wiki/content/ContentManager.java
>>>>>> (working
>>>>> copy)
>>>>>> @@ -46,10 +46,7 @@
>>>>>> import org.apache.wiki.auth.acl.AclEntry;
>>>>>> import org.apache.wiki.auth.acl.AclEntryImpl;
>>>>>> import org.apache.wiki.auth.user.UserProfile;
>>>>>> -import org.apache.wiki.event.WikiEvent;
>>>>>> -import org.apache.wiki.event.WikiEventManager;
>>>>>> -import org.apache.wiki.event.WikiPageEvent;
>>>>>> -import org.apache.wiki.event.WikiSecurityEvent;
>>>>>> +import org.apache.wiki.event.*;
>>>>>> import org.apache.wiki.log.Logger;
>>>>>> import org.apache.wiki.log.LoggerFactory;
>>>>>> import org.apache.wiki.providers.ProviderException;
>>>>>> @@ -85,7 +82,7 @@
>>>>>>  *  @since 3.0
>>>>>>  */
>>>>>>
>>>>>> -public class ContentManager
>>>>>> +public class ContentManager implements WikiEventListener
>>>>>> {
>>>>>>     /**
>>>>>>      *  The name of the default WikiSpace.
>>>>>> @@ -166,6 +163,7 @@
>>>>>>      *  @param engine WikiEngine instance
>>>>>>      *  @throws WikiException If anything goes wrong, you get
>>>>>> this.
>>>>>>      */
>>>>>> +    @SuppressWarnings("unchecked")
>>>>>>     public ContentManager( WikiEngine engine )
>>>>>>         throws WikiException
>>>>>>     {
>>>>>> @@ -238,14 +236,14 @@
>>>>>>
>>>>>>         try
>>>>>>         {
>>>>>> -            Object foo = acquire();
>>>>>>             initialize();
>>>>>> -            release(foo);
>>>>>>         }
>>>>>>         catch( RepositoryException e )
>>>>>>         {
>>>>>>             throw new WikiException("Failed to initialize the
>>>>>> repository content",e);
>>>>>>         }
>>>>>> +
>>>>>> +        log.info("ContentManager initialized!");
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -286,6 +284,17 @@
>>>>>>
>>>>>>     }
>>>>>>
>>>>>> +    /**
>>>>>> +     *  Discards all unsaved modifications made to this
>>>>>> repository.
>>>>>> +     *
>>>>>> +     *  @throws RepositoryException
>>>>>> +     */
>>>>>> +    public void discardModifications() throws  
>>>>>> RepositoryException
>>>>>> +    {
>>>>>> +        m_sessionManager.getSession().refresh( false );
>>>>>> +    }
>>>>>> +
>>>>>> +    /*
>>>>>>     public Object acquire() throws ProviderException
>>>>>>     {
>>>>>>         try
>>>>>> @@ -302,6 +311,7 @@
>>>>>>     {
>>>>>>         m_sessionManager.destroySession( id );
>>>>>>     }
>>>>>> +    */
>>>>>>
>>>>>>     /**
>>>>>>      *  Returns all pages in some random order.  If you need just
>>>>>> the page names,
>>>>>> @@ -549,10 +559,10 @@
>>>>>>         List<WikiPage> result = new ArrayList<WikiPage>();
>>>>>>         JCRWikiPage base = getPage(path);
>>>>>>
>>>>>> -        Node baseNode = base.getJCRNode();
>>>>>> -
>>>>>>         try
>>>>>>         {
>>>>>> +            Node baseNode = base.getJCRNode();
>>>>>> +
>>>>>>             VersionHistory vh = baseNode.getVersionHistory();
>>>>>>
>>>>>>             for( VersionIterator vi = vh.getAllVersions();
>>>>>> vi.hasNext(); )
>>>>>> @@ -648,11 +658,11 @@
>>>>>>      *  @throws WikiException If the backend fails or the  
>>>>>> wikiPath
>>>>>> is illegal.
>>>>>>      */
>>>>>>     public boolean pageExists( WikiName wikiPath, int version )
>>>>>> -        throws WikiException
>>>>>> +        throws ProviderException
>>>>>>     {
>>>>>>         if( wikiPath == null )
>>>>>>         {
>>>>>> -            throw new WikiException("Illegal page name");
>>>>>> +            throw new ProviderException("Illegal page name");
>>>>>>         }
>>>>>>
>>>>>>         try
>>>>>> @@ -663,7 +673,7 @@
>>>>>>         }
>>>>>>         catch( RepositoryException e )
>>>>>>         {
>>>>>> -            throw new WikiException("Unable to check for page
>>>>>> existence",e);
>>>>>> +            throw new ProviderException("Unable to check for  
>>>>>> page
>>>>>> existence",e);
>>>>>>         }
>>>>>>     }
>>>>>>
>>>>>> @@ -674,7 +684,7 @@
>>>>>>      *  @throws WikiException if the page fails
>>>>>>      */
>>>>>>     public void deleteVersion( WikiPage page )
>>>>>> -        throws WikiException
>>>>>> +        throws ProviderException
>>>>>>     {
>>>>>>         fireEvent( WikiPageEvent.PAGE_DELETE_REQUEST,
>>>>>> page.getName() );
>>>>>>
>>>>>> @@ -688,7 +698,7 @@
>>>>>>         }
>>>>>>         catch( RepositoryException e )
>>>>>>         {
>>>>>> -            throw new WikiException("Unable to delete a  
>>>>>> page",e);
>>>>>> +            throw new ProviderException("Unable to delete a
>>>>>> page",e);
>>>>>>         }
>>>>>>     }
>>>>>>
>>>>>> @@ -700,7 +710,7 @@
>>>>>>      */
>>>>>>
>>>>>>     public void deletePage( WikiPage page )
>>>>>> -        throws WikiException
>>>>>> +        throws ProviderException
>>>>>>     {
>>>>>>         fireEvent( WikiPageEvent.PAGE_DELETE_REQUEST,
>>>>>> page.getName() );
>>>>>>
>>>>>> @@ -733,7 +743,7 @@
>>>>>>         }
>>>>>>         catch( RepositoryException e )
>>>>>>         {
>>>>>> -            throw new WikiException("Deletion of pages
>>>>>> failed.",e);
>>>>>> +            throw new ProviderException("Deletion of pages
>>>>>> failed.",e);
>>>>>>         }
>>>>>>     }
>>>>>>
>>>>>> @@ -921,7 +931,7 @@
>>>>>>      *  @param wikiName The WikiName.
>>>>>>      *  @return A full JCR path
>>>>>>      */
>>>>>> -    protected static String getJCRPath( WikiName wikiName )
>>>>>> +    public static String getJCRPath( WikiName wikiName )
>>>>>>     {
>>>>>>         String spaceName;
>>>>>>         String spacePath;
>>>>>> @@ -940,7 +950,7 @@
>>>>>>      *  @throws WikiException If the backend fails.
>>>>>>      */
>>>>>>     // FIXME: Should be protected - fix once WikiPage moves to
>>>>>> content-package
>>>>>> -    public static WikiName getWikiPath( String jcrpath ) throws
>>>>>> WikiException
>>>>>> +    public static WikiName getWikiPath( String jcrpath ) throws
>>>>>> ProviderException
>>>>>>     {
>>>>>>         if( jcrpath.startsWith("/"+JCR_PAGES_NODE+"/") )
>>>>>>         {
>>>>>> @@ -955,7 +965,7 @@
>>>>>>             }
>>>>>>         }
>>>>>>
>>>>>> -        throw new WikiException("This is not a valid JSPWiki JCR
>>>>>> path: "+jcrpath);
>>>>>> +        throw new ProviderException("This is not a valid JSPWiki
>>>>>> JCR
>>>>>> path: "+jcrpath);
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>> @@ -967,7 +977,7 @@
>>>>>>      *  @return the {@link JCRWikiPage}
>>>>>>      *  @throws WikiException If the backend fails.
>>>>>>      */
>>>>>> -    public JCRWikiPage addPage( WikiName path, String
>>>>>> contentType )
>>>>>> throws WikiException
>>>>>> +    public JCRWikiPage addPage( WikiName path, String
>>>>>> contentType )
>>>>>> throws ProviderException
>>>>>>     {
>>>>>>         try
>>>>>>         {
>>>>>> @@ -981,7 +991,7 @@
>>>>>>         }
>>>>>>         catch( RepositoryException e )
>>>>>>         {
>>>>>> -            throw new WikiException( "Unable to add a page",  
>>>>>> e );
>>>>>> +            throw new ProviderException( "Unable to add a page",
>>>>>> e );
>>>>>>         }
>>>>>>     }
>>>>>>
>>>>>> @@ -1017,25 +1027,36 @@
>>>>>>         }
>>>>>>     }
>>>>>>
>>>>>> -    public JCRWikiPage getPage( WikiName path, int version )
>>>>>> throws
>>>>>> WikiException
>>>>>> +    public JCRWikiPage getPage( WikiName path, int version )
>>>>>> throws
>>>>>> ProviderException
>>>>>>     {
>>>>>>         try
>>>>>>         {
>>>>>> +            JCRWikiPage page = null;
>>>>>>             Session session = m_sessionManager.getSession();
>>>>>>
>>>>>>             Node nd =
>>>>>> session.getRootNode().getNode( getJCRPath(path) );
>>>>>>
>>>>>> -            VersionHistory vh = nd.getVersionHistory();
>>>>>> +            try
>>>>>> +            {
>>>>>> +                VersionHistory vh = nd.getVersionHistory();
>>>>>>
>>>>>> -            Version v =
>>>>>> vh.getVersion( Integer.toString( version ) );
>>>>>> +                Version v =
>>>>>> vh.getVersion( Integer.toString( version ) );
>>>>>>
>>>>>> -            JCRWikiPage page = new JCRWikiPage(m_engine, v);
>>>>>> +                page = new JCRWikiPage(m_engine, v);
>>>>>> +            }
>>>>>> +            catch( UnsupportedRepositoryOperationException e )
>>>>>> +            {
>>>>>> +                // No version history yet
>>>>>> +
>>>>>> +                if( version == WikiProvider.LATEST_VERSION ||
>>>>>> version
>>>>>> == 1)
>>>>>> +                    page = new JCRWikiPage( m_engine, nd );
>>>>>> +            }
>>>>>>
>>>>>>             return page;
>>>>>>         }
>>>>>>         catch( RepositoryException e )
>>>>>>         {
>>>>>> -            throw new WikiException( "Unable to get a page",  
>>>>>> e );
>>>>>> +            throw new ProviderException( "Unable to get a page",
>>>>>> e );
>>>>>>         }
>>>>>>     }
>>>>>>
>>>>>> @@ -1221,12 +1242,18 @@
>>>>>>          *
>>>>>>          *  @return A valid Session object, if called between
>>>>>> createSession and destroySession().
>>>>>>          *  @throws IllegalStateException If the object has not
>>>>>> been
>>>>>> acquired with createSession()
>>>>>> +         * @throws RepositoryException
>>>>>> +         * @throws LoginException
>>>>>>          */
>>>>>> -        public Session getSession() throws IllegalStateException
>>>>>> +        public Session getSession() throws LoginException,
>>>>>> RepositoryException
>>>>>>         {
>>>>>>             Session s = m_currentSession.get();
>>>>>>
>>>>>> -            if( s == null ) throw new IllegalStateException("You
>>>>>> have
>>>>>> not yet opened a Session");
>>>>>> +            if( s == null )
>>>>>> +            {
>>>>>> +                createSession();
>>>>>> +                s = m_currentSession.get();
>>>>>> +            }
>>>>>>
>>>>>>             return s;
>>>>>>         }
>>>>>> @@ -1245,4 +1272,9 @@
>>>>>>         }
>>>>>>         boolean m_identity = false;
>>>>>>     }
>>>>>> +
>>>>>> +    public Node getJCRNode( String path ) throws
>>>>>> RepositoryException
>>>>>> +    {
>>>>>> +        return
>>>>>> (Node)m_sessionManager.getSession().getItem( path );
>>>>>> +    }
>>>>>> }
>>>>>> Index: src/java/org/apache/wiki/api/WikiPage.java
>>>>>> = 
>>>>>> = 
>>>>>> =================================================================
>>>>>> --- src/java/org/apache/wiki/api/WikiPage.java        (revision
>>>>>> 749743)
>>>>>> +++ src/java/org/apache/wiki/api/WikiPage.java        (working
>>>>>> copy)
>>>>>> @@ -24,6 +24,8 @@
>>>>>> import java.util.Map;
>>>>>>
>>>>>> import org.apache.wiki.auth.acl.Acl;
>>>>>> +import org.apache.wiki.content.WikiName;
>>>>>> +import org.apache.wiki.providers.ProviderException;
>>>>>>
>>>>>>
>>>>>> /**
>>>>>> @@ -65,7 +67,7 @@
>>>>>>      * {@link org.apache.wiki.ui.stripes.HandlerPermission}
>>>>>> annotations.
>>>>>>      * @return the qualified page name, for example
>>>>>> <code>mywiki:Main</code>
>>>>>>      */
>>>>>> -    public String getQualifiedName();
>>>>>> +    public WikiName getQualifiedName();
>>>>>>
>>>>>>     /**
>>>>>>      *  A WikiPage may have a number of attributes, which might  
>>>>>> or
>>>>>> might not be
>>>>>> @@ -233,9 +235,9 @@
>>>>>>      */
>>>>>>     public int compareTo( Object o );
>>>>>>
>>>>>> -    public String getContentAsString() throws WikiException;
>>>>>> +    public String getContentAsString() throws ProviderException;
>>>>>>
>>>>>> -    public void save() throws WikiException;
>>>>>> +    public void save() throws ProviderException;
>>>>>>
>>>>>> -    public void setContent(String content) throws WikiException;
>>>>>> +    public void setContent(String content) throws
>>>>>> ProviderException;
>>>>>> }
>>>>>> Index: src/java/org/apache/wiki/ReferenceManager.java
>>>>>> = 
>>>>>> = 
>>>>>> =================================================================
>>>>>> --- src/java/org/apache/wiki/ReferenceManager.java    (revision
>>>>>> 749743)
>>>>>> +++ src/java/org/apache/wiki/ReferenceManager.java    (working
>>>>>> copy)
>>>>>> @@ -412,157 +412,21 @@
>>>>>>     /**
>>>>>>      *  Reads the serialized data from the disk back to memory.
>>>>>>      *  Returns the date when the data was last written on disk
>>>>>> +     *  @deprecated to be removed
>>>>>>      */
>>>>>>     private synchronized long unserializeAttrsFromDisk(WikiPage  
>>>>>> p)
>>>>>>         throws IOException,
>>>>>>                ClassNotFoundException
>>>>>>     {
>>>>>> -        ObjectInputStream in = null;
>>>>>> -        long saved = 0L;
>>>>>> -
>>>>>> -        try
>>>>>> -        {
>>>>>> -            StopWatch sw = new StopWatch();
>>>>>> -            sw.start();
>>>>>> -
>>>>>> -            //
>>>>>> -            //  Find attribute cache, and check if it exists
>>>>>> -            //
>>>>>> -            File f = new File( m_engine.getWorkDir(),
>>>>>> SERIALIZATION_DIR );
>>>>>> -
>>>>>> -            f = new File( f, getHashFileName(p.getName()) );
>>>>>> -
>>>>>> -            if( !f.exists() )
>>>>>> -            {
>>>>>> -                return 0L;
>>>>>> -            }
>>>>>> -
>>>>>> -            log.debug("Deserializing attributes for
>>>>>> "+p.getName());
>>>>>> -
>>>>>> -            in = new ObjectInputStream( new
>>>>>> BufferedInputStream(new
>>>>>> FileInputStream(f)) );
>>>>>> -
>>>>>> -            long ver     = in.readLong();
>>>>>> -
>>>>>> -            if( ver != serialVersionUID )
>>>>>> -            {
>>>>>> -                log.debug("File format has changed; cannot
>>>>>> deserialize.");
>>>>>> -                return 0L;
>>>>>> -            }
>>>>>> -
>>>>>> -            saved        = in.readLong();
>>>>>> -
>>>>>> -            String name  = in.readUTF();
>>>>>> -
>>>>>> -            if( !name.equals(p.getName()) )
>>>>>> -            {
>>>>>> -                log.debug("File name does not match ("+name+"),
>>>>>> skipping...");
>>>>>> -                return 0L; // Not here
>>>>>> -            }
>>>>>> -
>>>>>> -            long entries = in.readLong();
>>>>>> -
>>>>>> -            for( int i = 0; i < entries; i++ )
>>>>>> -            {
>>>>>> -                String key   = in.readUTF();
>>>>>> -                Object value = in.readObject();
>>>>>> -
>>>>>> -                p.setAttribute( key, value );
>>>>>> -
>>>>>> -                log.debug("   attr: "+key+"="+value);
>>>>>> -            }
>>>>>> -
>>>>>> -            in.close();
>>>>>> -
>>>>>> -            sw.stop();
>>>>>> -            log.debug("Read serialized data for "+name+"
>>>>>> successfully
>>>>>> in "+sw);
>>>>>> -            p.setHasMetadata();
>>>>>> -        }
>>>>>> -        catch( NoSuchAlgorithmException e )
>>>>>> -        {
>>>>>> -            log.error("No MD5!?!");
>>>>>> -        }
>>>>>> -        finally
>>>>>> -        {
>>>>>> -            if( in != null ) in.close();
>>>>>> -        }
>>>>>> -
>>>>>> -        return saved;
>>>>>> +        return 0L;
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>>      *  Serializes hashmaps to disk.  The format is private,  
>>>>>> don't
>>>>>> touch it.
>>>>>> +     *  @deprecated To be removed
>>>>>>      */
>>>>>>     private synchronized void serializeAttrsToDisk( WikiPage p )
>>>>>>     {
>>>>>> -        ObjectOutputStream out = null;
>>>>>> -        StopWatch sw = new StopWatch();
>>>>>> -        sw.start();
>>>>>> -
>>>>>> -        try
>>>>>> -        {
>>>>>> -            File f = new File( m_engine.getWorkDir(),
>>>>>> SERIALIZATION_DIR );
>>>>>> -
>>>>>> -            if( !f.exists() ) f.mkdirs();
>>>>>> -
>>>>>> -            //
>>>>>> -            //  Create a digest for the name
>>>>>> -            //
>>>>>> -            f = new File( f, getHashFileName(p.getName()) );
>>>>>> -
>>>>>> -            // FIXME: There is a concurrency issue here...
>>>>>> -            Set entries = p.getAttributes().entrySet();
>>>>>> -
>>>>>> -            if( entries.size() == 0 )
>>>>>> -            {
>>>>>> -                //  Nothing to serialize, therefore we will just
>>>>>> simply remove the
>>>>>> -                //  serialization file so that the next time we
>>>>>> boot,
>>>>>> we don't
>>>>>> -                //  deserialize old data.
>>>>>> -                f.delete();
>>>>>> -                return;
>>>>>> -            }
>>>>>> -
>>>>>> -            out = new ObjectOutputStream( new
>>>>>> BufferedOutputStream(new FileOutputStream(f)) );
>>>>>> -
>>>>>> -            out.writeLong( serialVersionUID );
>>>>>> -            out.writeLong( System.currentTimeMillis() ); //
>>>>>> Timestamp
>>>>>> -
>>>>>> -            out.writeUTF( p.getName() );
>>>>>> -            out.writeLong( entries.size() );
>>>>>> -
>>>>>> -            for( Iterator i = entries.iterator(); i.hasNext(); )
>>>>>> -            {
>>>>>> -                Map.Entry e = (Map.Entry) i.next();
>>>>>> -
>>>>>> -                if( e.getValue() instanceof Serializable )
>>>>>> -                {
>>>>>> -                    out.writeUTF( (String)e.getKey() );
>>>>>> -                    out.writeObject( e.getValue() );
>>>>>> -                }
>>>>>> -            }
>>>>>> -
>>>>>> -            out.close();
>>>>>> -
>>>>>> -        }
>>>>>> -        catch( IOException e )
>>>>>> -        {
>>>>>> -            log.error("Unable to serialize!");
>>>>>> -
>>>>>> -            try
>>>>>> -            {
>>>>>> -                if( out != null ) out.close();
>>>>>> -            }
>>>>>> -            catch( IOException ex ) {}
>>>>>> -        }
>>>>>> -        catch( NoSuchAlgorithmException e )
>>>>>> -        {
>>>>>> -            log.error("No MD5 algorithm!?!");
>>>>>> -        }
>>>>>> -        finally
>>>>>> -        {
>>>>>> -            sw.stop();
>>>>>> -
>>>>>> -            log.debug("serialization for "+p.getName()+" done -
>>>>>> took
>>>>>> "+sw);
>>>>>> -        }
>>>>>>     }
>>>>>>
>>>>>>     /**
>>>>>


Mime
View raw message