package com.atlassian.cache.ehcache.cluster;
   
   import java.io.IOException;
   import java.io.StringWriter;
   import java.net.InetAddress;
   import java.net.URL;
   import java.net.UnknownHostException;
   import java.util.Properties;
   
  import net.sf.ehcache.config.Configuration;
  import net.sf.ehcache.config.ConfigurationFactory;
  import net.sf.ehcache.config.FactoryConfiguration;
  import net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory;
  
  
  /**
   * Builds configuration details for ehcache.
   */
  public class EhCacheConfigurationFactory
  {
      public static final String LOCALHOST = getLocalHostName();
      public static final int BASE_PORT = 40000;
      public static final int SOCKET_TIMEOUT_MILLIS = 5000;
  
      public static Configuration newConfiguration(final int thisNodeId, final int maxNodeId)
      {
          final FactoryConfiguration<?> peerListenerFactory = buildPeerListenerFactory(thisNodeId);
          final FactoryConfiguration<?> peerProviderFactory = buildPeerProviderFactory(thisNodeId, maxNodeId);
  
          final URL configXml = EhCacheConfigurationFactory.class.getClassLoader().getResource("ehcache.xml");
          if (configXml == null)
          {
              throw new AssertionError("Failed to load ehcache.xml");
          }
  
          return ConfigurationFactory.parseConfiguration(configXml)
                  .name("node" + thisNodeId)
                  .cacheManagerPeerProviderFactory(peerProviderFactory)
                  .cacheManagerPeerListenerFactory(peerListenerFactory);
      }
  
      private static FactoryConfiguration<?> buildPeerListenerFactory(final int thisNodeId)
      {
          final Properties properties = new Properties();
          properties.setProperty("hostName", LOCALHOST);
          properties.setProperty("port", String.valueOf(BASE_PORT + thisNodeId));
          properties.setProperty("socketTimeoutMillis", String.valueOf(SOCKET_TIMEOUT_MILLIS));
  
          return new FactoryConfiguration()
                  .className(RMICacheManagerPeerListenerFactory.class.getName())
                  .properties(propertiesToString(properties));
      }
  
      private static FactoryConfiguration<?> buildPeerProviderFactory(final int thisNodeId, final int maxNodeId)
      {
          final Properties properties = new Properties();
          properties.setProperty(EhCachePeerProvider.THIS_NODE_ID, String.valueOf(thisNodeId));
          properties.setProperty(EhCachePeerProvider.MAX_NODE_ID, String.valueOf(maxNodeId));
  
          return new FactoryConfiguration()
                  .className(EhCachePeerProviderFactory.class.getName())
                  .properties(propertiesToString(properties));
      }
  
      private static String propertiesToString(final Properties properties)
      {
          final StringWriter out = new StringWriter();
          try
          {
              properties.store(out, null);
          }
          catch (IOException e)
          {
              // Nothing should go wrong with a String Writer
              throw new RuntimeException(e);
          }
          return out.toString();
      }
  
      private static String getLocalHostName()
      {
          try
          {
              final InetAddress host = InetAddress.getLocalHost();
              final String hostname = host.getHostName();
              return (hostname != null && !hostname.equals("localhost")) ? hostname : host.getCanonicalHostName();
          }
          catch (UnknownHostException e)
          {
              throw new AssertionError(e);
          }
      }
  }