Question

My implemented methods are not getting called from DAO Class.

I created bundle xml with name search_dao_bundle.xml as below and placed on same location i.e. tridion_home/config where my cd_storage_xml is placed.

<?xml version="1.0" encoding="UTF-8"?>
<StorageDAOBundles>
<StorageDAOBundle type="persistence">
    <StorageDAO typeMapping="PublishAction" class="com.tridion.storage.extension.search.JPAPublishActionDAO" />
</StorageDAOBundle>
</StorageDAOBundles>

After that I added my bundle entries into my cd_storage_conf.xml as below:

<StorageBindings>
    <Bundle src="search_dao_bundle.xml"/>
</StorageBindings>

and down under I created my new storage type as below:

<Storage Type="persistence" Id="searchdb" dialect="MSSQL" Class="com.tridion.storage.persistence.JPADAOFactory">
    <Pool Type="jdbc" Size="5" MonitorInterval="60" IdleTimeout="120" CheckoutTimeout="120" />
    <DataSource Class="com.microsoft.sqlserver.jdbc.SQLServerDataSource">
        <Property Name="serverName" Value="********" />
        <!--Property Name="portNumber" Value="1433" /-->
        <Property Name="databaseName" Value="********" />
        <Property Name="user" Value="********" />
        <Property Name="password" Value="********" />
    </DataSource>
</Storage>

After that for itemmapping I did below

<ItemTypes defaultStorageId="defaultdb" cached="false"> 
    <Item typeMapping="PublishAction" cached="false" storageId="searchdb" />
</ItemTypes>

I restarted my deployer service got below exception in my core logs

Below is my sample DAO class taken from Mihai Code:

package com.tridion.storage.extension.search;

import java.util.HashMap;
import java.util.Map;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import com.tridion.broker.StorageException;
import com.tridion.storage.extension.search.PublishActionDAO;
import com.tridion.storage.persistence.JPABaseDAO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component("JPAPublishActionDAO")
@Scope("prototype")
public class JPAPublishActionDAO extends JPABaseDAO implements PublishActionDAO
{
    private static Logger log = LoggerFactory.getLogger(JPAPublishActionDAO.class);
    public JPAPublishActionDAO(String storageId, EntityManagerFactory entityManagerFactory, String storageName) 
    {
        super(storageId, entityManagerFactory, storageName);        
        log.debug("Constructor of JPAPublishActionDAO- storageId:"+storageId);
        log.debug("Constructor of JPAPublishActionDAO- entityManagerFactory:"+entityManagerFactory.isOpen());       
        log.debug("Constructor of JPAPublishActionDAO- storageName:"+storageName);
    }

     public JPAPublishActionDAO(String storageId, EntityManagerFactory entityManagerFactory, EntityManager entityManager, String storageName) 
     {       
            super(storageId, entityManagerFactory, entityManager, storageName);         
     }

     public PublishAction store(PublishAction publishAction) throws StorageException 
     {
         log.debug("JPAPublishActionDAO store");
         //System.out.println("\n******************** From Store *************************************");
            PublishAction entity = (PublishAction) super.create(publishAction);
            return entity;
     }

     @SuppressWarnings("unchecked")
    public PublishAction findByPrimaryKey(long publishActionId) throws StorageException 
     {
            log.debug("JPAPublishActionDAO findByPrimaryKey");
            StringBuilder queryBuilder = new StringBuilder();
            queryBuilder.append("select c from PublishAction c where c.id = :id");

            @SuppressWarnings("rawtypes")
            Map queryParams = new HashMap();
            queryParams.put("id", Long.valueOf(publishActionId));
            log.debug("JPAPublishActionDAO findByPrimaryKey -> queryBuilder- " +queryBuilder.toString());
            return (PublishAction) super.executeQuerySingleResult(queryBuilder.toString(), queryParams);
     }

     @SuppressWarnings("unused")
    public PublishAction update(PublishAction publishAction) throws StorageException 
     {
            log.debug("JPAPublishActionDAO update");
            PublishAction existingPublishAction = findByPrimaryKey(publishAction.getId());

            log.debug("JPAPublishActionDAO update -> existingPublishAction- " +existingPublishAction.toString());
            if (existingPublishAction != null) 
            {
                   return (PublishAction) super.update(publishAction);
            } 
            else 
            {
                   throw new StorageException("Could not find publish action in storage to update!!!");
            }
     }

     public void remove(long publishActionId) throws StorageException 
     {
            log.debug("JPAPublishActionDAO remove");
            PublishAction foundPublishAction = findByPrimaryKey(publishActionId);
            log.debug("JPAPublishActionDAO remove -> foundPublishAction- " +foundPublishAction.toString());
            if (foundPublishAction != null) 
            {
                   super.remove(foundPublishAction);
            }
     }
}

I am able to see that my constructor is getting called i.e. I am getting these logs in my core file logs

log.debug("Constructor of JPAPublishActionDAO- storageId:"+storageId);
log.debug("Constructor of JPAPublishActionDAO- entityManagerFactory:"+entityManagerFactory.isOpen());       
log.debug("Constructor of JPAPublishActionDAO- storageName:"+storageName);

However I am not getting any logs written in other methods like in method public PublishAction store
log.debug(“JPAPublishActionDAO store”);

log.debug(“JPAPublishActionDAO findByPrimaryKey”);

log.debug(“JPAPublishActionDAO update”);

What could be the reason, I have entity class with name (PublishAction.java) and Interface class (PublishActionDAO.java) same as in sample code given.

Answer 1

I cannot post formatted code in a comment, hence this new answer.

@sea_gull is right – you need indeed to call the new DAO. The reason for it being this is a new type, so the Content Delivery storage mechanism won’t know what to do with it. You have to call it somehow (potentially from a deployer module, but not necessarily). I used a unit test for calling it (just to provie that it works).

This is my sample unit test code I use to call the storage extension with:

package com.tridion.extension.search.test;

import static org.junit.Assert.fail;

import java.util.Date;

import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.tridion.broker.StorageException;
import com.tridion.storage.StorageManagerFactory;
import com.tridion.storage.extension.search.PublishAction;
import com.tridion.storage.extension.search.PublishActionDAO;

/**
 * @author Mihai Cadariu
 */
public class DAOTestCase {

    private final Logger log = LoggerFactory.getLogger(DAOTestCase.class);

    /**
     * Test method for
     * {@link com.tridion.storage.extension.search.PublishActionDAO#store(com.tridion.storage.search.PublishAction)}.
     */
    @Test
    public void testDAO() {
        try {
            log.debug("Get PublishActionDAO");
            PublishActionDAO publishActionDAO = (PublishActionDAO) StorageManagerFactory.getDefaultDAO("PublishAction");

            log.debug("Create new PublishAction bean");
            PublishAction publishAction = new PublishAction();
            publishAction.setAction("testStore action");
            publishAction.setContent("testStore content");
            publishAction.setTcmUri("testStore tcmUri");
            publishAction.setUrl("testStore url");
            publishAction.setCreationDate(new Date());

            // Store
            log.debug("Store bean");
            publishAction = publishActionDAO.store(publishAction);
            log.debug("Stored bean " + publishAction);
            long id = publishAction.getId();

            // FindByPrimaryKey
            log.debug("Find PublishAction by PK=" + id);
            publishAction = publishActionDAO.findByPrimaryKey(id);
            log.debug("Found bean " + publishAction);

            if (publishAction == null) {
                log.error("Cannot find bean");
                fail("TestFindByPrimaryKey failed: cannot retrieve object with pk " + id);
            }

            log.debug("Modifying bean content");
            String content = publishAction.getContent();
            content += "\r\nMODIFIED " + new Date();
            publishAction.setContent(content);

            // Update
            log.debug("Update bean");
            publishActionDAO.update(publishAction);

            // Remove
            log.debug("Remove bean");
            publishActionDAO.remove(id);
        } catch (StorageException se) {
            log.debug("TestDAO failed: Exception occurred " + se);
            fail("TestDAO failed: Exception occurred " + se);
            se.printStackTrace();
        }
    }
}

If you call the code from a Deployer extension, this is the sample code I used:

public class PageDeployModule extends PageDeploy {

    private final Logger log = LoggerFactory.getLogger(PageDeployModule.class);

    public PageDeployModule(Configuration config, Processor processor) throws ConfigurationException {
        super(config, processor);
    }

    /**
     * Process the page to be published
     */
    @Override
    protected void processPage(Page page, File pageFile) throws ProcessingException {
        log.debug("Called processPage");

        super.processPage(page, pageFile);
        processItem(page);
    }

    private void processItem(Page page) {
        log.debug("Called processItem");
        try {
            SearchConfiguration config = SearchConfiguration.getInstance();
            String externalUrl = config.getExternalAccessUrl() + page.getURLPath();
            String internalUrl = config.getInternalAccessUrl() + page.getURLPath();

            PublishAction publishAction = new PublishAction();
            publishAction.setAction("Publish");
            publishAction.setTcmUri(page.getId().toString());
            publishAction.setUrl(externalUrl);
            publishAction.setContent(Utils.getPageContent(internalUrl));

            PublishActionDAO publishActionDAO = (PublishActionDAO) StorageManagerFactory.getDefaultDAO("PublishAction");
            publishAction = publishActionDAO.store(publishAction);
            log.debug("Stored bean " + publishAction);
        } catch (StorageException se) {
            log.error("Exception occurred " + se);
        }
    }
}

You can use the same approach for the PageUndeploy, where you mark the action as “Unpublish”.