/*
 * Copyright (C) 2009 eXo Platform SAS.
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */
package org.exoplatform.services.jcr.ext.replication;

import org.exoplatform.commons.utils.PrivilegedFileHelper;
import org.exoplatform.container.xml.InitParams;
import org.exoplatform.container.xml.PropertiesParam;
import org.exoplatform.container.xml.ValuesParam;
import org.exoplatform.management.ManagementAware;
import org.exoplatform.management.ManagementContext;
import org.exoplatform.management.annotations.Managed;
import org.exoplatform.management.annotations.ManagedDescription;
import org.exoplatform.management.jmx.annotations.NameTemplate;
import org.exoplatform.management.jmx.annotations.Property;
import org.exoplatform.services.jcr.RepositoryService;
import org.exoplatform.services.jcr.config.RepositoryConfigurationException;
import org.exoplatform.services.jcr.config.WorkspaceEntry;
import org.exoplatform.services.jcr.core.ManageableRepository;
import org.exoplatform.services.jcr.core.WorkspaceContainerFacade;
import org.exoplatform.services.jcr.dataflow.PersistentDataManager;
import org.exoplatform.services.jcr.ext.common.SessionProvider;
import org.exoplatform.services.jcr.ext.registry.RegistryEntry;
import org.exoplatform.services.jcr.ext.registry.RegistryService;
import org.exoplatform.services.jcr.ext.replication.recovery.ConnectionFailDetector;
import org.exoplatform.services.jcr.ext.replication.recovery.RecoveryManager;
import org.exoplatform.services.jcr.ext.replication.recovery.backup.BackupCreator;
import org.exoplatform.services.jcr.impl.WorkspaceContainer;
import org.exoplatform.services.jcr.impl.core.RepositoryImpl;
import org.exoplatform.services.jcr.impl.dataflow.serialization.ReaderSpoolFileHolder;
import org.exoplatform.services.jcr.impl.util.io.FileCleaner;
import org.exoplatform.services.jcr.impl.util.io.FileCleanerHolder;
import org.exoplatform.services.jcr.storage.WorkspaceDataContainer;
import org.exoplatform.services.jcr.util.IdGenerator;
import org.exoplatform.services.log.ExoLogger;
import org.exoplatform.services.log.Log;
import org.jgroups.ChannelException;
import org.jgroups.JChannel;
import org.jgroups.stack.Protocol;
import org.picocontainer.Startable;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import javax.jcr.RepositoryException;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

/**
 * Created by The eXo Platform SAS.
 * 
 * @author <a href="mailto:alex.reshetnyak@exoplatform.com.ua">Alex Reshetnyak</a>
 * @version $Id: ReplicationService.java 34445 2009-07-24 07:51:18Z dkatayev $
 */
@Managed
@ManagedDescription("JCR replication service")
@NameTemplate(@Property(key = "service", value = "replication"))
public class ReplicationService implements Startable, ManagementAware
{

   /**
    * The apache logger.
    */
   private static Log log = ExoLogger.getLogger("exo.jcr.component.ext.ReplicationService");

   /**
    * The service name.
    */
   private static final String SERVICE_NAME = "Replication";

   /**
    * The template for ip-address in configuration.
    */
   private static final String IP_ADRESS_TEMPLATE = "[$]bind-ip-address";

   /**
    * The persistent mode to replication.
    */
   private static final String PERSISTENT_MODE = "persistent";

   /**
    * The proxy mode to replication.
    */
   private static final String PROXY_MODE = "proxy";

   /**
    * Definition the static type for priority mechanism.
    */
   public static final String PRIORITY_STATIC_TYPE = "static";

   /**
    * Definition the dynamic type for priority mechanism.
    */
   public static final String PRIORITY_DYNAMIC_TYPE = "dynamic";

   /**
    * Definition the generic type for priority mechanism.
    */
   public static final String PRIORITY_GENERIC_TYPE = "generic";

   /**
    * Definition the timeout to FileCLeaner.
    */
   public static final int FILE_CLEANRE_TIMEOUT = 30030;

   /**
    * The RepositorySerice.
    */
   private RepositoryService repoService;

   /**
    * The RegistryService.
    */
   private RegistryService registryService;

   /**
    * Parameters to initialize.
    */
   private InitParams initParams;

   /**
    * The testMode using only for testing.
    */
   private String testMode;

   /**
    * If 'enabled' is false then ReplicationServis not started.
    */
   private String enabled;

   /**
    * The replication mode (persistent or proxy).
    */
   private String mode;

   /**
    * Bind to IP address.
    */
   private String bindIPAddress;

   /**
    * The channel configuration.
    */
   private String channelConfig;

   /**
    * The channel name.
    */
   private String channelName;

   /**
    * The list of repositories. Fore this repositories will be worked replication.
    */
   private List<String> repoNamesList;

   /**
    * If ChangesLog was not delivered, then ChangesLog will be saved in this folder.
    */
   private File recoveryDir;

   /**
    * If ChangesLog was not delivered, then ChangesLog will be saved in this folder.
    */
   private String recDir;

   /**
    * The name of cluster node.
    */
   private String ownName;

   /**
    * The list of names other participants.
    */
   private List<String> participantsClusterList;

   /**
    * The names other participants.
    */
   private String participantsCluster;

   /**
    * The definition timeout, how many time will be waited for successful save the Changeslog.
    */
   private long waitConfirmation;

   /**
    * The definition timeout, how many time will be waited for successful save the Changeslog.
    */
   private String sWaitConfirmation;

   /**
    * Will be started full backup if 'backupEnabled' is 'true'.
    */
   private boolean backupEnabled;

   /**
    * Will be started full backup if 'backupEnabled' is 'true'.
    */
   private String sBackupEnabled;

   /**
    * The definition of backup folder.
    */
   private File backupDir;

   /**
    * The definition of backup folder.
    */
   private String sBackupDir;

   /**
    * The definition of backup delay. Will be waited 'backupDelayTime' milliseconds before start full
    * backup.
    */
   private long backupDelayTime = 0;

   /**
    * The definition of backup delay. Will be waited 'backupDelayTime' milliseconds before start full
    * backup.
    */
   private String sDelayTime;

   /**
    * The list of BackupCreators. The BackupCreator will be started full backup.
    */
   private List<BackupCreator> backupCreatorList;

   /**
    * If 'started' is true then ReplicationServis was successful started.
    */
   private boolean started;

   /**
    * The definition of priority type. (PRIORITY_STATIC_TYPE or PRIORITY_DYNAMIC_TYPE)
    */
   private String priprityType;

   /**
    * The definition of priority value.
    */
   private int ownPriority;

   /**
    * The definition of priority value.
    */
   private String ownValue;

   /**
    * The management context.
    */
   private ManagementContext managementContext;

   /**
    * ReplicationService constructor.
    * 
    * @param repoService
    *          the RepositoryService
    * @param params
    *          the configuration parameters
    * @throws RepositoryConfigurationException
    *           will be generated RepositoryConfigurationException
    */
   public ReplicationService(RepositoryService repoService, InitParams params) throws RepositoryConfigurationException
   {
      this(repoService, params, null);
   }

   /**
    * ReplicationService constructor.
    * 
    * @param repoService
    *          the RepositoryService
    * @param params
    *          the configuration parameters
    * @param registryService
    *          the RegistryService
    * @throws RepositoryConfigurationException
    *           will be generated RepositoryConfigurationException
    */
   public ReplicationService(RepositoryService repoService, InitParams params, RegistryService registryService)
      throws RepositoryConfigurationException
   {
      started = false;

      this.repoService = repoService;
      this.registryService = registryService;
      this.initParams = params;
   }

   /**
    * {@inheritDoc}
    */
   public void start()
   {
      if (registryService != null && !registryService.getForceXMLConfigurationValue(initParams))
      {
         SessionProvider sessionProvider = SessionProvider.createSystemProvider();
         try
         {
            readParamsFromRegistryService(sessionProvider);
         }
         catch (Exception e)
         {
            readParamsFromFile();
            try
            {
               writeParamsToRegistryService(sessionProvider);
            }
            catch (Exception exc)
            {
               log.error("Cannot write init configuration to RegistryService.", exc);
            }
         }
         finally
         {
            sessionProvider.close();
         }
      }
      else
      {
         readParamsFromFile();
      }

      try
      {
         for (int rIndex = 0; rIndex < repoNamesList.size(); rIndex++)
         {
            RepositoryImpl jcrRepository = (RepositoryImpl)repoService.getRepository(repoNamesList.get(rIndex));

            String[] workspaces = jcrRepository.getWorkspaceNames();

            if (enabled.equals("true"))
            {
               // set ownName & participantsClusterList for test mode
               if (testMode != null && "true".equals(testMode))
               {
                  ownName = (rIndex == 0 ? "cluster_node_1" : "cluster_node_2");
                  participantsClusterList = new ArrayList<String>();

                  if (rIndex == 0)
                  {
                     ownPriority = 100;
                     participantsClusterList.add("cluster_node_2");
                  }
                  else
                  {
                     ownPriority = 50;
                     participantsClusterList.add("cluster_node_1");
                  }
               }

               for (int wIndex = 0; wIndex < workspaces.length; wIndex++)
                  try
                  {
                     // create the recovery for workspace
                     File dir =
                        new File(PrivilegedFileHelper.getAbsolutePath(recoveryDir) + File.separator
                           + repoNamesList.get(rIndex) + "_" + workspaces[wIndex]);
                     PrivilegedFileHelper.mkdirs(dir);

                     String systemId = IdGenerator.generate();
                     String props = channelConfig.replaceAll(IP_ADRESS_TEMPLATE, bindIPAddress);

                     // get workspace container
                     WorkspaceContainer wContainer =
                        (WorkspaceContainer)jcrRepository.getSystemSession(workspaces[wIndex]).getContainer();

                     String uniqueNoame = jcrRepository.getName() + "_" + workspaces[wIndex];
                     if (testMode != null && "true".equals(testMode))
                        uniqueNoame = "Test_Channel234";

                     ReplicationChannelManager channelManager =
                        new ReplicationChannelManager(props, channelName + (channelName.equals("") ? "" : "_")
                           + uniqueNoame);

                     WorkspaceContainerFacade wsFacade = jcrRepository.getWorkspaceContainer(workspaces[wIndex]);
                     WorkspaceEntry wconf = (WorkspaceEntry)wsFacade.getComponent(WorkspaceEntry.class);

                     int maxBufferSize =
                        wconf.getContainer().getParameterInteger(WorkspaceDataContainer.MAXBUFFERSIZE_PROP,
                           WorkspaceDataContainer.DEF_MAXBUFFERSIZE);

                     FileCleanerHolder wfcleaner =
                        (FileCleanerHolder)wsFacade.getComponent(FileCleanerHolder.class);
                     FileCleaner fileCleaner = wfcleaner.getFileCleaner();

                     // create the RecoveryManager
                     RecoveryManager recoveryManager =
                        new RecoveryManager(dir, ownName, systemId, participantsClusterList, waitConfirmation,
                           jcrRepository.getName(), workspaces[wIndex], channelManager, fileCleaner, maxBufferSize,
                           new ReaderSpoolFileHolder());

                     PersistentDataManager dataManager =
                        (PersistentDataManager)wsFacade.getComponent(PersistentDataManager.class);

                     ConnectionFailDetector failDetector =
                        new ConnectionFailDetector(channelManager, dataManager, recoveryManager, ownPriority,
                           participantsClusterList, ownName, priprityType, workspaces[wIndex]);
                     channelManager.addStateListener(failDetector);

                     // add data transmitter
                     wContainer.registerComponentImplementation(WorkspaceDataTransmitter.class);
                     WorkspaceDataTransmitter dataTransmitter =
                        (WorkspaceDataTransmitter)wContainer.getComponentInstanceOfType(WorkspaceDataTransmitter.class);
                     dataTransmitter.init(/* disp */channelManager, systemId, ownName, recoveryManager);

                     // add data receiver
                     AbstractWorkspaceDataReceiver dataReceiver = null;

                     if (mode.equals(PROXY_MODE))
                     {
                        wContainer.registerComponentImplementation(WorkspaceDataManagerProxy.class);
                        wContainer.registerComponentImplementation(ProxyWorkspaceDataReceiver.class);
                        dataReceiver =
                           (ProxyWorkspaceDataReceiver)wContainer
                              .getComponentInstanceOfType(ProxyWorkspaceDataReceiver.class);
                     }
                     else if (mode.equals(PERSISTENT_MODE))
                     {
                        wContainer.registerComponentImplementation(PersistentWorkspaceDataReceiver.class);
                        dataReceiver =
                           (PersistentWorkspaceDataReceiver)wContainer
                              .getComponentInstanceOfType(PersistentWorkspaceDataReceiver.class);
                     }

                     recoveryManager.setDataKeeper(dataReceiver.getDataKeeper());
                     dataReceiver.init(channelManager, systemId, ownName, recoveryManager);

                     channelManager.connect();

                     // Register for management
                     if (managementContext != null)
                        managementContext.register(recoveryManager);

                     dataReceiver.start();
                  }
                  catch (Exception e)
                  {
                     log.error("Can not start replication on " + repoNamesList.get(rIndex) + "_" + workspaces[wIndex]
                        + " \n" + e, e);
                  }
            }

            if (backupEnabled)
               for (int wIndex = 0; wIndex < workspaces.length; wIndex++)
                  backupCreatorList.add(initWorkspaceBackup(repoNamesList.get(rIndex), workspaces[wIndex]));
         }
      }
      catch (RepositoryException re)
      {
         log.error("Can not start ReplicationService \n" + re, re);
      }
      catch (RepositoryConfigurationException e)
      {
         log.error("Can not start ReplicationService \n" + e, e);
      }

      started = true;
   }

   /**
    * initWorkspaceBackup. Will be initialized BackupCreator.
    * 
    * @param repositoryName
    *          the name of repository
    * @param workspaceName
    *          the name of workspace
    * @return BackupCreator return the BackupCreator
    * @throws RepositoryException
    *           will be generated RepositoryException
    * @throws RepositoryConfigurationException
    *           will be generated RepositoryConfigurationException
    */
   private BackupCreator initWorkspaceBackup(String repositoryName, String workspaceName) throws RepositoryException,
      RepositoryConfigurationException
   {
      ManageableRepository manageableRepository = repoService.getRepository(repositoryName);
      BackupCreator backupCreator = new BackupCreator(backupDelayTime, workspaceName, backupDir, manageableRepository);
      return backupCreator;
   }

   /**
    * {@inheritDoc}
    */
   public void stop()
   {
   }

   /**
    * isStarted.
    * 
    * @return boolean return the isStarted
    */
   public boolean isStarted()
   {
      return started;
   }

   /**
    * Write parameters to RegistryService..
    *
    * @param sessionProvider
    *          SessionProvider, the session provider
    * @throws ParserConfigurationException
    *           will be generate the exception ParserConfigurationException
    * @throws RepositoryException
    *           will be generate the exception RepositoryException 
    */
   private void writeParamsToRegistryService(SessionProvider sessionProvider) throws ParserConfigurationException,
      RepositoryException
   {
      Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
      Element root = doc.createElement(SERVICE_NAME);
      doc.appendChild(root);

      StringBuilder reps = new StringBuilder();
      for (String rep : repoNamesList)
      {
         reps.append(rep).append(";");
      }
      Element element = doc.createElement("repositories");
      setAttributeSmart(element, "repositories", reps.toString());
      root.appendChild(element);

      element = doc.createElement("replication-properties");
      setAttributeSmart(element, "test-mode", testMode);
      setAttributeSmart(element, "enabled", enabled);
      setAttributeSmart(element, "mode", mode);
      setAttributeSmart(element, "bind-ip-address", bindIPAddress);
      setAttributeSmart(element, "channel-config", channelConfig);
      setAttributeSmart(element, "channel-name", channelName);
      setAttributeSmart(element, "recovery-dir", recDir);
      setAttributeSmart(element, "node-name", ownName);
      setAttributeSmart(element, "other-participants", participantsCluster);
      setAttributeSmart(element, "wait-confirmation", sWaitConfirmation);
      root.appendChild(element);

      element = doc.createElement("replication-snapshot-properties");
      setAttributeSmart(element, "snapshot-enabled", sBackupEnabled);
      setAttributeSmart(element, "snapshot-enabled", sBackupDir);
      setAttributeSmart(element, "snapshot-enabled", sDelayTime);
      root.appendChild(element);

      element = doc.createElement("replication-priority-properties");
      setAttributeSmart(element, "priority-type", priprityType);
      setAttributeSmart(element, "node-priority", ownValue);
      root.appendChild(element);

      RegistryEntry serviceEntry = new RegistryEntry(doc);
      registryService.createEntry(sessionProvider, RegistryService.EXO_SERVICES, serviceEntry);
   }

   /**
    * Read parameters to RegistryService.
    * 
    * @param sessionProvider
    *          SessionProvider, the session provider
    * @throws RepositoryException
    *           will be generate the exception RepositoryException 
    */
   private void readParamsFromRegistryService(SessionProvider sessionProvider) throws RepositoryException
   {
      // initialize repositories
      String entryPath = RegistryService.EXO_SERVICES + "/" + SERVICE_NAME + "/" + "repositories";
      RegistryEntry entry = registryService.getEntry(sessionProvider, entryPath);
      Document doc = entry.getDocument();
      Element element = doc.getDocumentElement();

      String repositories = getAttributeSmart(element, "repositories");
      repoNamesList = new ArrayList<String>();
      String reps[] = repositories.split(";");
      for (String rep : reps)
      {
         if (!rep.equals(""))
         {
            repoNamesList.add(rep);
         }
      }

      // initialize replication params;
      entryPath = RegistryService.EXO_SERVICES + "/" + SERVICE_NAME + "/" + "replication-properties";
      entry = registryService.getEntry(sessionProvider, entryPath);
      doc = entry.getDocument();
      element = doc.getDocumentElement();

      testMode = getAttributeSmart(element, "test-mode");
      enabled = getAttributeSmart(element, "enabled");
      mode = getAttributeSmart(element, "mode");
      bindIPAddress = getAttributeSmart(element, "bind-ip-address");
      channelConfig = getAttributeSmart(element, "channel-config");
      channelName = getAttributeSmart(element, "channel-name");
      recDir = getAttributeSmart(element, "recovery-dir");
      ownName = getAttributeSmart(element, "node-name");
      participantsCluster = getAttributeSmart(element, "other-participants");
      sWaitConfirmation = getAttributeSmart(element, "wait-confirmation");

      // initialize snapshot params;
      entryPath = RegistryService.EXO_SERVICES + "/" + SERVICE_NAME + "/" + "replication-snapshot-properties";
      entry = registryService.getEntry(sessionProvider, entryPath);
      doc = entry.getDocument();
      element = doc.getDocumentElement();

      sBackupEnabled = getAttributeSmart(element, "snapshot-enabled");
      sBackupDir = getAttributeSmart(element, "snapshot-dir");
      sDelayTime = getAttributeSmart(element, "delay-time");

      // initialize priority params;
      entryPath = RegistryService.EXO_SERVICES + "/" + SERVICE_NAME + "/" + "replication-priority-properties";
      entry = registryService.getEntry(sessionProvider, entryPath);
      doc = entry.getDocument();
      element = doc.getDocumentElement();

      priprityType = getAttributeSmart(element, "priority-type");
      ownValue = getAttributeSmart(element, "node-priority");

      log.info("Params is read from RegistryService");

      checkParams();
   }

   /**
    * Get attribute value.
    * 
    * @param element
    *          The element to get attribute value
    * @param attr
    *          The attribute name
    * @return Value of attribute if present and null in other case
    */
   private String getAttributeSmart(Element element, String attr)
   {
      return element.hasAttribute(attr) ? element.getAttribute(attr) : null;
   }

   /**
    * Set attribute value. If value is null the attribute will be removed.
    * 
    * @param element
    *          The element to set attribute value
    * @param attr
    *          The attribute name
    * @param value
    *          The value of attribute
    */
   private void setAttributeSmart(Element element, String attr, String value)
   {
      if (value == null)
      {
         element.removeAttribute(attr);
      }
      else
      {
         element.setAttribute(attr, value);
      }
   }

   /**
    * Read parameters from file.
    * 
    * @throws RepositoryConfigurationException
    */
   private void readParamsFromFile()
   {
      PropertiesParam pps = initParams.getPropertiesParam("replication-properties");

      // initialize replication params;
      testMode = pps.getProperty("test-mode");
      enabled = pps.getProperty("enabled");
      mode = pps.getProperty("mode");
      bindIPAddress = pps.getProperty("bind-ip-address");
      channelConfig = pps.getProperty("channel-config");
      channelName = pps.getProperty("channel-name");
      recDir = pps.getProperty("recovery-dir");
      ownName = pps.getProperty("node-name");
      participantsCluster = pps.getProperty("other-participants");
      sWaitConfirmation = pps.getProperty("wait-confirmation");

      // initialize repositories
      ValuesParam vp = initParams.getValuesParam("repositories");
      repoNamesList = vp.getValues();
      if (vp == null || vp.getValues().size() == 0)
         throw new RuntimeException("repositories not specified");

      // initialize snapshot params;
      PropertiesParam backuParams = initParams.getPropertiesParam("replication-snapshot-properties");

      if (backuParams != null)
      {
         sBackupEnabled = backuParams.getProperty("snapshot-enabled");
         sBackupDir = backuParams.getProperty("snapshot-dir");
         sDelayTime = backuParams.getProperty("delay-time");
      }
      else
      {
         backupEnabled = false;
      }

      // initialize priority params;
      PropertiesParam priorityParams = initParams.getPropertiesParam("replication-priority-properties");

      if (priorityParams != null)
      {
         priprityType = priorityParams.getProperty("priority-type");
         ownValue = priorityParams.getProperty("node-priority");
      }

      log.info("Params is read from configuration file");

      checkParams();
   }

   /**
    * Check read params and initialize.
    * 
    * @throws RepositoryConfigurationException
    */
   private void checkParams()
   {
      // replication params;
      if (enabled == null)
         throw new RuntimeException("enabled not specified");

      if (mode == null)
         throw new RuntimeException("mode not specified");
      else if (!mode.equals(PERSISTENT_MODE) && !mode.equals(PROXY_MODE))
         throw new RuntimeException("Parameter 'mode' (persistent|proxy) required for replication configuration");

      if (bindIPAddress == null)
         throw new RuntimeException("bind-ip-address not specified");

      if (channelConfig == null)
         throw new RuntimeException("channel-config not specified");

      if (channelName == null)
         channelName = "";

      if (testMode != null && "true".equals(testMode))
         channelName = IdGenerator.generate();

      if (recDir == null)
         throw new RuntimeException("Recovery dir not specified");

      recoveryDir = new File(recDir);
      if (!PrivilegedFileHelper.exists(recoveryDir))
      {
         PrivilegedFileHelper.mkdirs(recoveryDir);
      }

      if (mode.equals(PERSISTENT_MODE))
      {
         if (ownName == null)
            throw new RuntimeException("Node name not specified");

         if (participantsCluster == null)
            throw new RuntimeException("Other participants not specified");

         participantsClusterList = new ArrayList<String>();
         String[] pc = participantsCluster.split(";");
         for (int i = 0; i < pc.length; i++)
            if (!pc[i].equals(""))
               participantsClusterList.add(pc[i]);
      }
      else
      {
         // for PROXY mode :
         boolean isMPing = isMPingConfigured();
         boolean isTCPPing = isTCPPingConfigured();

         if (!(isMPing | isTCPPing))
            throw new RuntimeException("The discovery protocol should be configured MPING or TCPPING protocol.");

         if (ownName == null && isMPing)
            throw new RuntimeException("Node name not specified");

         if (participantsCluster == null && isMPing)
            throw new RuntimeException("Other participants not specified");

         participantsClusterList = new ArrayList<String>();

         if (isMPing)
         {
            String[] pc = participantsCluster.split(";");
            for (int i = 0; i < pc.length; i++)
               if (!pc[i].equals(""))
                  participantsClusterList.add(pc[i]);
         }
         else
         {
            // node-name == binf-ip-address
            // other-participants == initial_hosts

            List<String> initialHosts = getInitialHosts();

            if (participantsCluster != null)
               log.warn("The perameter 'other-participants' not use for TCPPING.");
            if (ownName != null)
               log.warn("The perameter 'node-name' not use for TCPPING.");

            for (String host : initialHosts)
               if (!host.equals(bindIPAddress))
                  participantsClusterList.add(host);

            ownName = bindIPAddress;
         }
      }

      if (sWaitConfirmation == null)
         throw new RuntimeException("Wait confirmation not specified");

      waitConfirmation = Long.valueOf(sWaitConfirmation);

      // snapshot params;
      backupEnabled = (sBackupEnabled == null ? false : Boolean.valueOf(sBackupEnabled));
      if (backupEnabled)
      {
         if (sBackupDir == null && backupEnabled)
            throw new RuntimeException("Backup dir not specified");
         else if (backupEnabled)
         {
            backupDir = new File(sBackupDir);
            if (!PrivilegedFileHelper.exists(backupDir))
            {
               PrivilegedFileHelper.mkdirs(backupDir);
            }
         }

         if (sDelayTime == null && backupEnabled)
            throw new RuntimeException("Backup dir not specified");
         else if (backupEnabled)
            backupDelayTime = Long.parseLong(sDelayTime);

         backupCreatorList = new ArrayList<BackupCreator>();
      }

      // priority params;
      if (mode.equals(PERSISTENT_MODE))
      {
         if (priprityType == null)
            throw new RuntimeException("Priority type not specified");
         else if (!priprityType.equals(PRIORITY_STATIC_TYPE) && !priprityType.equals(PRIORITY_DYNAMIC_TYPE))
            throw new RuntimeException(
               "Parameter 'priority-type' (static|dynamic) required for replication configuration");

         if (ownValue == null)
            throw new RuntimeException("Own Priority not specified");
         ownPriority = Integer.valueOf(ownValue);
      }
      else
      {
         if (priprityType != null && !priprityType.equals(PRIORITY_GENERIC_TYPE))
            log.warn("The parameter 'replication-priority-properties' not use for proxy replication.");

         priprityType = PRIORITY_GENERIC_TYPE;
      }

   }

   /**
    * getInitialHosts.
    *
    * @return List
    *           return list of initial hosts.
    */
   private List<String> getInitialHosts()
   {
      JChannel jChannel = null;
      try
      {
         jChannel = new JChannel(channelConfig.replaceAll(IP_ADRESS_TEMPLATE, bindIPAddress));
      }
      catch (ChannelException e)
      {
         throw new RuntimeException("Can not initialize the JChannel form 'channel-config'.", e);
      }

      String initial_hosts = null;

      for (Protocol p : jChannel.getProtocolStack().getProtocols())
      {
         if (p.getName().equals("TCPPING"))
         {
            Properties props = p.getProperties();
            initial_hosts = props.getProperty("initial_hosts");
         }
      }

      if (initial_hosts == null)
         throw new RuntimeException("The propery 'initial_hosts' not specified in TCPPING ");

      List<String> initialHosts = new ArrayList<String>();

      for (String host : initial_hosts.split(","))
         initialHosts.add(host.substring(0, host.indexOf("[")));

      return initialHosts;
   }

   /**
    * isTCPPingConfigured.
    *
    * @return boolean
    *           return 'true' if configured TCPPING. 
    */
   private boolean isTCPPingConfigured()
   {
      return channelConfig.contains("TCPPING");
   }

   /**
    * isMPingConfigured.
    *
    * @return boolean
    *           return 'true' if configured MPING.
    */
   private boolean isMPingConfigured()
   {
      return channelConfig.contains("MPING");
   }

   /**
    * {@inheritDoc}
    */
   public void setContext(ManagementContext context)
   {
      this.managementContext = context;
   }
}
