package com.atlassian.cache.hazelcast;
   
   import com.atlassian.hazelcast.serialization.OsgiClassLoaderRegistry;
   import com.atlassian.hazelcast.serialization.OsgiSafe;
   import com.atlassian.hazelcast.serialization.OsgiSafeStreamSerializer;
   import com.atlassian.hazelcast.test.DefaultNodeConfigurer;
   import com.atlassian.hazelcast.test.HazelcastCluster;
   import com.hazelcast.config.Config;
   import com.hazelcast.config.SerializerConfig;
  import com.hazelcast.core.HazelcastInstance;
  
  import java.util.concurrent.atomic.AtomicInteger;
  
  /**
   * JUnit rule to set up a Hazelcast cluster for testing.
   */
  public class InitOnceHazelcastCluster extends HazelcastCluster
  {
      private static final InitOnceHazelcastCluster INSTANCE = new Builder().size(2).nodeConfigurer(new DefaultNodeConfigurer()
      {
          @Override
          public Config createConfig(int nodeIndex)
          {
              Config config = super.createConfig(nodeIndex);
              config.getSerializationConfig().addSerializerConfig(
                      new SerializerConfig()
                              .setTypeClass(OsgiSafe.class)
                              .setImplementation(new OsgiSafeStreamSerializer(new OsgiClassLoaderRegistry()))
              );
              return config;
          }
  
          @Override
          public void onReset(HazelcastInstance instance)
          {
              //Make sure we clear any mapConfigs too
              super.onReset(instance);
          }
      }).build();
  
      // counter to keep track of the 'active users' of the HazelcastCluster. This is used to be able to set up the
      // cluster only once for a set of tests (see HazelcastTestSuite)
      private final AtomicInteger activeCount = new AtomicInteger();
  
      protected InitOnceHazelcastCluster(Builder builder)
      {
          super(builder);
      }
  
      public int size()
      {
          return getNodes().size();
      }
  
      @Override
      protected void after()
      {
          if (activeCount.decrementAndGet() == 0)
          {
              // only truly shut down when the active count reaches zero
              super.after();
          } else {
              super.reset();
          }
      }
  
      @Override
      protected void before() throws Throwable
      {
          if (activeCount.getAndIncrement() == 0)
          {
              // only initialize when the active count is at zero
              super.before();
          } else {
              super.reset();
          }
      }
  
      public static InitOnceHazelcastCluster getInstance()
      {
          return INSTANCE;
      }
  
      public static class Builder extends AbstractBuilder<Builder, InitOnceHazelcastCluster>
      {
          @Override
          public InitOnceHazelcastCluster build()
          {
              return new InitOnceHazelcastCluster(this);
          }
  
          @Override
          protected Builder self()
          {
              return this;
          }
      }
  }