How do I get my Storage Extension to call the 'update' method when republishing a Dynamic Component Presentation?

Question

When a DCP is Published, the create method is called.

When aDCP is unPublished, the remove method is called.

But when a DCP is rePublished, the update method is not called.

I don't know why the update method isn't called, when a DCP is rePublished.

my source is shown below:

package com.tridion.storage.extension;
import java.util.Collection;
import java.io.*;
import javax.persistence.*;
import com.tridion.storage.annotations.*;
import com.tridion.broker.StorageException;
import org.springframework.context.annotation.*;
import org.springframework.stereotype.Component;
import com.tridion.storage.dao.ComponentPresentationDAO;
import com.tridion.storage.persistence.*;
import com.tridion.storage.util.ComponentPresentationTypeEnum;
import com.tridion.storage.*;

@Component("JPAComponentPresentationDAOImpl")
@Scope("prototype")

public class JPAComponentPresentationDAOImpl extends 
        JPAComponentPresentationDAO implements ComponentPresentationDAO {

    public JPAComponentPresentationDAOImpl(String storageId,
            EntityManagerFactory entityManagerFactory,
            EntityManager entityManager, String storageName) {
        super(storageId, entityManagerFactory, entityManager, storageName);
        outputLog("JPAComponentPresentationDAOImplコンストラクタ１");
    }

    public JPAComponentPresentationDAOImpl(String storageId,
            EntityManagerFactory entityManagerFactory, String storageName) {
        super(storageId, entityManagerFactory, storageName);
        outputLog("JPAComponentPresentationDAOImplコンストラクタ２");
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO 自動生成されたメソッド・スタブ
    }

    public void create(ComponentPresentation componentPresentation,
            ComponentPresentationTypeEnum type) throws StorageException {
        super.create(componentPresentation, type);
        outputLog("JPAComponentPresentationDAOImpl create");
        connectDB(componentPresentation);
    }

    public Collection<ComponentPresentation> findAll(int publicationId,
            int componentId,
            ComponentPresentationTypeEnum componentPresentationType)
            throws StorageException {
        outputLog("findAll");
        return super.findAll(publicationId, componentId,
                componentPresentationType);
    }

    public ComponentPresentation getComponentPresentation(int publicationId,
            int componentId, int templateId,
            ComponentPresentationTypeEnum componentPresentationType)
            throws StorageException {
        outputLog("getComponentPresentation");
        return super.getComponentPresentation(publicationId, componentId,
                templateId, componentPresentationType);
        // return null;
    }

    public void remove(ComponentPresentation componentPresentation,
            ComponentPresentationTypeEnum type) throws StorageException {
        outputLog("Remove1");
        super.remove(componentPresentation, type);
    }

    public void remove(int publicationId, int componentId, int templateId,
            ComponentPresentationTypeEnum componentPresentationType)
            throws StorageException {
        outputLog("Remove2");
        super.remove(publicationId, componentId, templateId,
                componentPresentationType);
    }    

    // I think this method is called when DCP is republished. but not called.
    public void update(ComponentPresentation componentPresentation,
                ComponentPresentationTypeEnum componentPresentationType)
                throws StorageException {
        outputLog("update");
        super.update(componentPresentation, componentPresentationType);
    }

    // custom code
    // output logfile
    private static void outputLog(String msg) {
        try {
            File f = new File("/tmp/output.log");
            BufferedWriter bw = new BufferedWriter(new FileWriter(f, true));
            bw.write(msg);
            bw.newLine();
            bw.close();
        } catch (IOException e) {
        }
    }
}

Answer 1

As far as my experience with Storage Extension (in SDL Tridion 2011) is concerned, the update method never got called. Whether you publish a dynamic component presentation or re-publish it, it is always be the create method that got called.

My wild guess is that the super class - JPAComponentPresentationDAO have this update method but it is not in use by the Storage Layer.

Now to your requirement, isn;t it possible for you to update the Stored Procedure in your custom DB to handle the Insert or Update operation at the DB level instead of the deciding on it during the Publishing Transaction.

Update based on comment below:

For resolution of your problem, I can suggest that modify your custom java code which will be interacting with your custom DB and I hope it will be consuming some Stored Procedure in the Custom DB to Insert or Update (If it is not and instead firing direct Insert and Update sql queries, then I am afraid that you are already on a wrong path). Now in the Stored Procedure itself, you can write this conditional logic if the composite key (componentID and PublicationID) exists then update else insert.

Answer 2

I assume your storage extension is called by the Deployer. Please specify.

When an existing DCP was re-published, the Deployer used to call a remove followed by a create. This was in an older version of Tridion (i.e. 2009 IIRC). I believe this is still the behaviour that you are seeing.

Could you check to see if instead of the update method, the methods remove and create are called?

UPDATE - based on your comment below, I don't think there is a good way of using update at all. You basically can't know if a delete will be followed by a create. Hence you cannot fake the update by first checking if the DCP exists already. I'm afraid you have to use the delete then create path.

Answer 3

The only methods that are called for a ComponentPresentationDAO are remove and create. This is probably a bug, but you will need to work around it. This means you must treat the create method as if it were a create/update.

You are responsible yourself for checking if the CP has already been deployed, e.g. by checking in the broker before the super.create is called. You could use the ComponentPresentationFactory for this purpose.