Package com.priint.pubserver.plugin

Class PluginControlDefault

java.lang.Object
com.priint.pubserver.plugin.PluginControlDefault
All Implemented Interfaces:
PluginControl
Direct Known Subclasses:
AbstractConnector, CometPublicationPluginDefault, ProductDataMappingDefault, PublicationUtils, SearchAfterBucketsAbstractPlugin
public abstract class PluginControlDefault extends Object implements PluginControl
Default implementation of PluginControl. Plug-ins are expected to be sub-classed from this abstract super class.

  • Constructor Details

    • PluginControlDefault

      public PluginControlDefault()

  • Method Details

    • initInstance

      public void initInstance(String mappedName, String instanceName) throws PluginException
      Description copied from interface: PluginControl
      Will be called when a plug-in is created by the plugin manager.

      Typically used with stateful beans, e.g. connectors, that provide named instances.

      Do not use with stateless beans. For stateless beans use @PostConstruct instead.

      Specified by:
      initInstance in interface PluginControl
      Parameters:
      mappedName - Mapped name as defined in the @Stateful bean annotation of the plugin class.
      instanceName - Name of the specific instance of the plug-in, if multiple instances are allowed. e.g. if you have variant of a connector running alternatively with database schema 1 and schema 2 of a content system, or a viewer plug-in supporting legacy web-browsers and mobile browser, etc.
      Throws:
      PluginException

    • loadServerConfig

      public void loadServerConfig() throws PluginException
      Description copied from interface: PluginControl
      Called by plug-in manager or other modules if they intend a (re)load of configuration files to be done by the plug-in. Implementation details are up to the plug-in.
      Specified by:
      loadServerConfig in interface PluginControl
      Throws:
      PluginException

    • updateConfigurations

      public PluginConfigCollection updateConfigurations(String sessionId, PluginConfigCollection updatedConfigs) throws PluginException
      Description copied from interface: PluginControl

      Called by the ConfigManager before configurations in the domain of this plugin are created or updated.

      This method allows plugin developers to react to configuration changes. If the plugin is derived from PluginControlDefault, there is usually no need to override the default implementation.
      You can override this method, to

      • change the application status (e.g. clean caches etc.), depending on the items being updated
      • pre-process files (e.g. calculate fields or dependencies) of items being updated
      • add configuration files to the set of files, which are to be updated or created
      • remove files from the set of files, which are to be updated or created

      This method is called at the beginning of the update processing chain, i.e. before calculating dependencies and before persisting items in the repository. Items contained in the updateConfig collection do not necessarily exist in the repository at this stage. By removing items from the collection, you can prevent certain files from being updated or created at all.

      If the method returns null, the return value is ignored and the collection passed to the method as parameter is used for further processing.

      Note: this method is called outside of the checkin transaction. If you perform checkin or delete operations in your updateConfigurations implementation, these are run as separate transactions. If the main transaction fails, these transactions will not be rolled back.

      Note: starting with Version 4.1 / Revision 12465, there are two important changes to the behavior of this method:

      1. this method may be called several times during an update process:
        • the first call contains the list of files requested for update, which was provided by the client
        • the second call contains additional dependent files found for the list of files returned by the first call
        • subsequent calls contain additional dependent files found for the list of files obtained from the previous call
      2. this method may be called during a delete process, if deletion of certain configurations triggers changes in dependent files. The method is not called for files, which are to be deleted anyway.
      One more important note: notification for each file is send only once during one transaction or transaction branch, so PluginControl implementations do not need to bother about circular dependencies / nested transactions, which trigger the same dependencies etc.

      The default implementation is: 

       public PluginConfigCollection updateConfigurations(
           String sessionId,
           PluginConfigCollection updateConfigs) throws PluginException {
        return updateConfigs;
 }

      This would have the same effect: 

       public PluginConfigCollection updateConfigurations(
           String sessionId,
           PluginConfigCollection updateConfigs) throws PluginException {
        return null;
 }

      To process and return all configurations, use this code skeleton: 

       public PluginConfigCollection updateConfigurations(
           String sessionId
           PluginConfigCollection updateConfigs) throws PluginException {
        for (String path : updateConfigs.getKeySet()) {
            PluginConfigDataHandler config = updateConfigs.getConfigDataHandler(path);
            //
            // TODO: your pre-processing...
            //
         }
         return updatedConfigs; // returning null would have the same effect
 }

      Disallow any configuration changes: 

       public PluginConfigCollection updateConfigurations(
           String sessionId,
           PluginConfigCollection updateConfigs) throws PluginException {
         return PluginConfigCollection.createEmptySet();
 }

      Specified by:
      updateConfigurations in interface PluginControl
      Parameters:
      sessionId - Identifier of the current session
      updatedConfigs - the configurations currently being updated
      Returns:
      the pre-processed or filtered configuration items or null, if the updateConfigs collection should be used for further processing.
      Throws:
      PluginException

    • deleteConfigurations

      public PluginConfigCollection deleteConfigurations(String sessionId, PluginConfigCollection deletedConfigs) throws PluginException
      Description copied from interface: PluginControl

      Called by the ConfigManager before configurations in the domain of this plugin are deleted.

      This method allows plugin developers to react to configuration deletion. If the plugin is derived from PluginControlDefault, there is usually no need to override the default implementation.
      You can override this method, to

      • change the application status (e.g. clean caches etc.), depending on the items being deleted
      • pre-process files (e.g. calculate fields or dependencies) of items being deleted
      • add configuration files to the set of files, which are to be deleted
      • remove files from the set of files, which are to be deleted

      This method is called at the beginning of the delete processing chain, i.e. before calculating dependencies and before moving items to trash. By removing certain items from the collection, you can prevent certain files from being deleted at all.

      If the method returns null, the return value is ignored and the collection passed to the method as parameter is used for further processing.

      Note: this method is called outside of the delete transaction. If you perform checkin or delete operations in your deleteConfigurations implementation, these are run as separate transactions. If the main transaction fails, these transactions will not be rolled back.

      The default implementation is: 

       public PluginConfigCollection deleteConfigurations(
           String sessionId,
           PluginConfigCollection deleteConfigs) throws PluginException {
         return deleteConfigs;
 }

      This would have the same effect: 

       public PluginConfigCollection deleteConfigurations(
           String sessionId,
           PluginConfigCollection deleteConfigs) throws PluginException {
         return null;
 }

      To process and return all configurations, use this code skeleton: 

       public PluginConfigCollection deleteConfigurations(
           String sessionId
           PluginConfigCollection deleteConfigs) throws PluginException {
         for (String path : updateConfigs.getKeySet()) {
             PluginConfigDataHandler config = deleteConfigs.getConfigDataHandler(path);
             //
             // TODO: your pre-processing...
             //
         }
         return deleteConfigs; // returning null would have the same effect
 }

      Disallow any deletion: 

       public PluginConfigCollection deleteConfigurations(
           String sessionId,
           PluginConfigCollection deleteConfigs) throws PluginException {
         return PluginConfigCollection.createEmptySet();
 }

      Specified by:
      deleteConfigurations in interface PluginControl
      Parameters:
      sessionId - Identifier of the current session
      deletedConfigs - the configurations currently being deleted
      Returns:
      the pre-processed or filtered configuration items or null, if the deleteConfigs collection should be used for further processing.
      Throws:
      PluginException

    • createConfiguration

      public String createConfiguration(String sessionId, String customTypeName, Map<String,Object> initialValues) throws PluginException
      Description copied from interface: PluginControl

      Create a new config file of type customTypeName.

      The method must

      • create a PluginConfig object with a embedded customClazz element
      • check in the initial revision of this configuration
      • return the full repository path of the new configuration
      • throw an exception, if it's not possible to create a new configuration (e.g. illegal type name, invalid initialValues etc.)

      It's up to the implementation to

      • resolve the custom type name. This can be a qualified class name or XML type name
      • evaluate initialValues. There are no Kernel requirements for the initialValues Map, you can specify arbitrary key names and value semantics suitable for your requirements.

      Example: 

       public String createConfiguration(
           String sessionId,
           String customTypeName,
           Map<String,Object> initialValues) throws PluginException {
         if (customTypeName != null && customTypeName.equals("MyConfigClass")) {
             String path                = "calculated path";

             // instantiate and initialize cutom configuration object
             final String objectName = (initialValues.containsKey("name") ? initialValues.get("name") + "" : "untitled");
             Object customObject     = new Object() { public final String toString() { return objectName; } };

             // instantiate configuration wrapper
             PluginConfig config = new PluginConfig();
             config.setCustomConfig(customObject);
             config.setDescription("Object with name " + objectName);
             config.setName(objectName);
             config.setType("MyConfigClass");

             // add to new PluginConfig collection:
             PluginConfigCollection collection = PluginConfigCollection.createEmptySet(null);
             collection.addConfig(path, config);

             // lookup ConfigManager and call checkin
             ConfigManagerLocal configManager; // lookup etc.
             configManager.checkinListOfConfigFiles(sessionId, collection, false);

             // check, if the new configuration file really does exist in repository
             if (configManager.exists(path)) {
                 return path;
             }
             throw new PluginException (this, -1, "File does not exist in repository");
         }
         else {
             throw new InvalidArgumentException(
                         this,
                         "Custom type name '" + customTypeName + "' cannot be created in Plugin '" + this.getClass().getName() + "'");
         }
 }

      Specified by:
      createConfiguration in interface PluginControl
      Parameters:
      sessionId - Identifier of the current session
      Returns:
      full repository path of the new configuration.
      Throws:
      PluginException

    • afterUpdateConfigurations

      public void afterUpdateConfigurations(String sessionId, PluginConfigCollection updatedConfigs) throws PluginException
      Description copied from interface: PluginControl

      This method is called by the ConfigurationManager after the check-in of configuration files.

      Usually the implementation of this method will trigger the reload of the configuration.
      If your application caches configurations, this would be the right place to refresh caches.

      Note: starting with Version 4.1, Revision 12465, the list of files also contains all dependent files, which were updated.
      Furthermore, this method is also called after updating dependent files during a delete process.

      Specified by:
      afterUpdateConfigurations in interface PluginControl
      Parameters:
      sessionId - Identifier of the current session
      updatedConfigs - collection of configurations that have being updated
      Throws:
      PluginException

    • afterDeleteConfigurations

      public void afterDeleteConfigurations(String sessionId, PluginConfigCollection deletedConfigs) throws PluginException
      Description copied from interface: PluginControl

      This method is called by the ConfigurationManager after deleting configuration files.

      Usually the implementation of this method will trigger the reload of the configuration. If your application caches configurations, this would be the right place to refresh caches.

      Note: starting with Version 4.1, Revision 12465, the list of files also contains all dependent files, which were deleted.

      Specified by:
      afterDeleteConfigurations in interface PluginControl
      Parameters:
      sessionId - Identifier of the current session
      deletedConfigs - the configurations that have being deleted
      Throws:
      PluginException

    • afterCreateConfigurations

      public void afterCreateConfigurations(String sessionId, PluginConfigCollection createdConfigs) throws PluginException
      Description copied from interface: PluginControl

      This method is called by the ConfigurationManager after adding configuration files.

      Usually the implementation of this method will trigger the reload of the configuration.

      Specified by:
      afterCreateConfigurations in interface PluginControl
      Parameters:
      sessionId - Identifier of the current session
      createdConfigs - the configurations that have being created
      Throws:
      PluginException

    • ping

      public String ping()
      Specified by:
      ping in interface PluginControl

    • getSessionId

      public static String getSessionId()

    • getSession

      protected static org.apache.shiro.session.Session getSession()

    • readSessionAttribute

      protected static Object readSessionAttribute(String name) throws InvalidSessionException
      get a session attribute
      Parameters:
      name -
      Returns:
      Throws:
      InvalidSessionException

    • writeSessionAttribute

      protected static void writeSessionAttribute(String name, Serializable value) throws InvalidSessionException
      set a session attribute
      Parameters:
      name -
      value - must be serializable java object
      Throws:
      InvalidSessionException