@Test
 public void hazelcastCacheWithMainHazelcastAutoConfigurationAndSeparateCacheConfig()
     throws IOException {
   String mainConfig = "org/springframework/boot/autoconfigure/hazelcast/hazelcast-specific.xml";
   String cacheConfig = "org/springframework/boot/autoconfigure/cache/hazelcast-specific.xml";
   AnnotationConfigApplicationContext applicationContext =
       new AnnotationConfigApplicationContext();
   EnvironmentTestUtils.addEnvironment(
       applicationContext,
       "spring.cache.type=hazelcast",
       "spring.cache.hazelcast.config=" + cacheConfig,
       "spring.hazelcast.config=" + mainConfig);
   applicationContext.register(DefaultCacheConfiguration.class);
   applicationContext.register(HazelcastAndCacheConfiguration.class);
   applicationContext.refresh();
   this.context = applicationContext;
   HazelcastInstance hazelcastInstance = this.context.getBean(HazelcastInstance.class);
   HazelcastCacheManager cacheManager = validateCacheManager(HazelcastCacheManager.class);
   HazelcastInstance cacheHazelcastInstance = getHazelcastInstance(cacheManager);
   assertThat(cacheHazelcastInstance, not(hazelcastInstance)); // Our custom
   assertThat(
       hazelcastInstance.getConfig().getConfigurationFile(),
       equalTo(new ClassPathResource(mainConfig).getFile()));
   assertThat(
       cacheHazelcastInstance.getConfig().getConfigurationFile(),
       equalTo(new ClassPathResource(cacheConfig).getFile()));
 }
Ejemplo n.º 2
0
 @Test
 @Category(ProblematicTest.class)
 public void testTCPIPJoinWithManyNodesMultipleGroups()
     throws UnknownHostException, InterruptedException {
   final int count = 20;
   final int groupCount = 3;
   final CountDownLatch latch = new CountDownLatch(count);
   final ConcurrentHashMap<Integer, HazelcastInstance> mapOfInstances =
       new ConcurrentHashMap<Integer, HazelcastInstance>();
   final Random random = new Random();
   final Map<String, AtomicInteger> groups = new ConcurrentHashMap<String, AtomicInteger>();
   for (int i = 0; i < groupCount; i++) {
     groups.put("group" + i, new AtomicInteger(0));
   }
   final ExecutorService ex =
       Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);
   for (int i = 0; i < count; i++) {
     final int seed = i;
     ex.execute(
         new Runnable() {
           public void run() {
             try {
               Thread.sleep(random.nextInt(10) * 1000);
               final Config config = new Config();
               config.setProperty("hazelcast.wait.seconds.before.join", "5");
               String name = "group" + random.nextInt(groupCount);
               groups.get(name).incrementAndGet();
               config.getGroupConfig().setName(name);
               final NetworkConfig networkConfig = config.getNetworkConfig();
               networkConfig.getJoin().getMulticastConfig().setEnabled(false);
               TcpIpConfig tcpIpConfig = networkConfig.getJoin().getTcpIpConfig();
               tcpIpConfig.setEnabled(true);
               int port = 12301;
               networkConfig.setPortAutoIncrement(false);
               networkConfig.setPort(port + seed);
               for (int i = 0; i < count; i++) {
                 tcpIpConfig.addMember("127.0.0.1:" + (port + i));
               }
               HazelcastInstance h = Hazelcast.newHazelcastInstance(config);
               mapOfInstances.put(seed, h);
               latch.countDown();
             } catch (Exception e) {
               e.printStackTrace();
             }
           }
         });
   }
   try {
     latch.await(200, TimeUnit.SECONDS);
   } finally {
     ex.shutdown();
   }
   for (HazelcastInstance h : mapOfInstances.values()) {
     int clusterSize = h.getCluster().getMembers().size();
     int shouldBeClusterSize = groups.get(h.getConfig().getGroupConfig().getName()).get();
     assertEquals(
         h.getConfig().getGroupConfig().getName() + ": ", shouldBeClusterSize, clusterSize);
   }
 }
 private void initHzCacheMapConfig(HazelcastInstance hz) {
   Map<String, MapConfig> mapConfigs = hz.getConfig().getMapConfigs();
   if (mapConfigs == null) {
     mapConfigs = new HashMap<String, MapConfig>();
     hz.getConfig().setMapConfigs(mapConfigs);
   }
   MapConfig config = new MapConfig();
   config.setTimeToLiveSeconds(this.getCacheTimeoutSeconds());
   config.setMaxSizeConfig(new MaxSizeConfig(this.getCacheSizeBytes(), MaxSizePolicy.PER_NODE));
   mapConfigs.put(CACHE_MAP_NAME, config);
 }
Ejemplo n.º 4
0
  @Test
  public void setMapStoreConfigImplementationTest() {
    String mapName = "mapStoreImpObjTest";
    String xml =
        "<hazelcast xmlns=\"http://www.hazelcast.com/schema/config\">\n"
            + "<map name=\""
            + mapName
            + "\">\n"
            + "<map-store enabled=\"true\">\n"
            + "<class-name>com.hazelcast.config.helpers.DummyMapStore</class-name>\n"
            + "<write-delay-seconds>5</write-delay-seconds>\n"
            + "</map-store>\n"
            + "</map>\n"
            + "</hazelcast>\n";

    Config config = buildConfig(xml);
    HazelcastInstance hz = createHazelcastInstance(config);
    hz.getMap(mapName);

    MapConfig mapConfig = hz.getConfig().getMapConfig(mapName);
    MapStoreConfig mapStoreConfig = mapConfig.getMapStoreConfig();
    Object o = mapStoreConfig.getImplementation();

    assertNotNull(o);
    assertTrue(o instanceof DummyMapStore);
  }
 private static ClientConfig getClientConfig(HazelcastInstance instance) {
   ClientConfig clientConfig = new ClientConfig();
   Address address = getNode(instance).address;
   clientConfig.getNetworkConfig().addAddress(address.getHost() + ":" + address.getPort());
   clientConfig.getGroupConfig().setName(instance.getConfig().getGroupConfig().getName());
   return clientConfig;
 }
 @Override
 public String name() {
   try {
     if (cluster.getInstance() != null) {
       HazelcastInstance instance = cluster.getInstance();
       if (instance.getConfig() != null) {
         Config config = instance.getConfig();
         if (config.getGroupConfig() != null) {
           return "hazelcast/" + config.getGroupConfig().getName();
         }
       }
     }
   } catch (Exception ignore) {
   }
   return "hazelcast";
 }
 /**
  * Make a {@link MapConfig} for the given sessionMapName if one does not exist. Set Hazelcast's
  * maxIdleSeconds to maxInactiveIntervalInSeconds if set (not ""). Otherwise get the externally
  * configured maxIdleSeconds for the distributed sessions map.
  *
  * @param hazelcastInstance the {@link HazelcastInstance} to configure
  */
 private void configureSessionMap(HazelcastInstance hazelcastInstance) {
   MapConfig sessionMapConfig = hazelcastInstance.getConfig().getMapConfig(sessionMapName);
   if (this.maxInactiveIntervalInSeconds != null) {
     sessionMapConfig.setMaxIdleSeconds(this.maxInactiveIntervalInSeconds);
   } else {
     this.maxInactiveIntervalInSeconds = sessionMapConfig.getMaxIdleSeconds();
   }
 }
Ejemplo n.º 8
0
  private void start() throws IOException {

    if (logPath != null) {
      PropertyConfigurator.configure(logPath.getAbsolutePath());
    }

    if (!hazelcastFile.isFile()) {
      throw new RuntimeException("Could not find hazelcast configuration file : " + hazelcastFile);
    }

    /*
     * Start a lightweight http server, make sure it can only be accessed
     * from the machine it's running on (don't want to allow remote
     * shutdown).
     */
    server = HttpServer.create(new InetSocketAddress(host, port), port);
    server.createContext(baseContext + HazelcastServiceCommand.stop, new ShutdownHandler());
    server.createContext(baseContext + HazelcastServiceCommand.status, new StatusHandler());
    server.setExecutor(null);
    server.start();

    // Config config = new Config();
    // config.setConfigurationFile(hazelcastFile);
    // config.setConfigurationUrl(hazelcastFile.toURI().toURL());
    // hz = Hazelcast.newHazelcastInstance(config);

    /*
     * Creating a Config object (as commented out above) and setting the
     * file using setConfigurationFile doesn't seem to work at all. The
     * system property approach does.
     */
    String path = hazelcastFile.getAbsolutePath();
    logger.info("Setting configuration file " + path);
    System.setProperty("hazelcast.config", path);

    hz = Hazelcast.getDefaultInstance();

    logger.info(hz.getConfig().getConfigurationFile());
    logger.info(hz.getConfig().getGroupConfig().getName());

    monitor = new HazelcastMonitor();
    hz.addInstanceListener(monitor);

    if (testValues) {
      hz.getMap("tst").put("1", "1");
      hz.getMap("tst").put("2", "2");
      hz.getMap("tst").put("3", "3");

      logger.info(hz.getMap("tst").getId());
      logger.info(hz.getMap("tst").size());
    }

    System.out.println("-- HAZELCAST SERVICE WRAPPER READY --");
    System.out.println(
        String.format("To check status, request: '%s'.", url(HazelcastServiceCommand.status)));
    System.out.println(
        String.format("To shut it down, request: '%s'.", url(HazelcastServiceCommand.stop)));
  }
Ejemplo n.º 9
0
  private void testJoinWithManyNodesMultipleGroups(final boolean multicast)
      throws InterruptedException {
    final int nodeCount = 10;
    final int groupCount = 3;
    final int basePort = 12301;
    final CountDownLatch latch = new CountDownLatch(nodeCount);
    final AtomicReferenceArray<HazelcastInstance> instances =
        new AtomicReferenceArray<HazelcastInstance>(nodeCount);

    final Map<String, AtomicInteger> groups = new HashMap<String, AtomicInteger>(groupCount);
    for (int i = 0; i < groupCount; i++) {
      groups.put("group-" + i, new AtomicInteger(0));
    }

    ExecutorService ex =
        Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);
    for (int i = 0; i < nodeCount; i++) {
      final int portSeed = i;
      ex.execute(
          new Runnable() {
            public void run() {
              sleepRandom(1, 1000);

              Config config = new Config();
              String name = "group-" + (int) (Math.random() * groupCount);
              config.getGroupConfig().setName(name);

              groups.get(name).incrementAndGet();

              initNetworkConfig(
                  config.getNetworkConfig(), basePort, portSeed, multicast, nodeCount);

              HazelcastInstance h = Hazelcast.newHazelcastInstance(config);
              instances.set(portSeed, h);
              latch.countDown();
            }
          });
    }
    try {
      latch.await(200, TimeUnit.SECONDS);
    } finally {
      ex.shutdown();
    }

    for (int i = 0; i < nodeCount; i++) {
      HazelcastInstance hz = instances.get(i);
      assertNotNull(hz);

      int clusterSize = hz.getCluster().getMembers().size();
      String groupName = hz.getConfig().getGroupConfig().getName();
      int shouldBeClusterSize = groups.get(groupName).get();
      assertEquals(groupName + ": ", shouldBeClusterSize, clusterSize);
    }
  }
 @Test
 public void testProperties() {
   final Properties properties = config.getProperties();
   assertNotNull(properties);
   assertEquals("5", properties.get(GroupProperties.PROP_MERGE_FIRST_RUN_DELAY_SECONDS));
   assertEquals("5", properties.get(GroupProperties.PROP_MERGE_NEXT_RUN_DELAY_SECONDS));
   final Config config2 = instance.getConfig();
   final Properties properties2 = config2.getProperties();
   assertNotNull(properties2);
   assertEquals("5", properties2.get(GroupProperties.PROP_MERGE_FIRST_RUN_DELAY_SECONDS));
   assertEquals("5", properties2.get(GroupProperties.PROP_MERGE_NEXT_RUN_DELAY_SECONDS));
 }
  @Test
  public void testProperties() {
    Properties properties = config.getProperties();
    assertNotNull(properties);
    assertEquals("5", properties.get(MERGE_FIRST_RUN_DELAY_SECONDS.getName()));
    assertEquals("5", properties.get(MERGE_NEXT_RUN_DELAY_SECONDS.getName()));

    Config config2 = instance.getConfig();
    Properties properties2 = config2.getProperties();
    assertNotNull(properties2);
    assertEquals("5", properties2.get(MERGE_FIRST_RUN_DELAY_SECONDS.getName()));
    assertEquals("5", properties2.get(MERGE_NEXT_RUN_DELAY_SECONDS.getName()));
  }
 @Test
 public void hazelcastCacheWithConfig() throws IOException {
   load(
       DefaultCacheConfiguration.class,
       "spring.cache.type=hazelcast",
       "spring.cache.hazelcast.config=org/springframework/boot/autoconfigure/cache/hazelcast-specific.xml");
   HazelcastInstance hazelcastInstance = this.context.getBean(HazelcastInstance.class);
   HazelcastCacheManager cacheManager = validateCacheManager(HazelcastCacheManager.class);
   HazelcastInstance actual = getHazelcastInstance(cacheManager);
   assertThat(actual, sameInstance(hazelcastInstance));
   assertThat(
       actual.getConfig().getConfigurationUrl(),
       equalTo(
           new ClassPathResource(
                   "org/springframework/boot/autoconfigure/cache/hazelcast-specific.xml")
               .getURL()));
   cacheManager.getCache("foobar");
   assertThat(cacheManager.getCacheNames(), containsInAnyOrder("foobar"));
   assertThat(cacheManager.getCacheNames(), hasSize(1));
 }
  @Setup
  public void setup(TestContext testContext) throws Exception {
    this.testContext = testContext;
    targetInstance = testContext.getTargetInstance();
    testId = testContext.getTestId();

    integrityMap = targetInstance.getMap(basename + "Integrity");
    stressMap = targetInstance.getMap(basename + "Stress");

    integrityThreads = new MapIntegrityThread[mapIntegrityThreadCount];
    value = new byte[valueSize];

    Random random = new Random();
    random.nextBytes(value);

    if (mapLoad && isMemberNode(targetInstance)) {
      PartitionService partitionService = targetInstance.getPartitionService();
      final Set<Partition> partitionSet = partitionService.getPartitions();
      for (Partition partition : partitionSet) {
        while (partition.getOwner() == null) {
          Thread.sleep(1000);
        }
      }
      LOGGER.info(testId + ": " + partitionSet.size() + " partitions");

      Member localMember = targetInstance.getCluster().getLocalMember();
      for (int i = 0; i < totalIntegrityKeys; i++) {
        Partition partition = partitionService.getPartition(i);
        if (localMember.equals(partition.getOwner())) {
          integrityMap.put(i, value);
        }
      }
      LOGGER.info(
          testId + ": integrityMap=" + integrityMap.getName() + " size=" + integrityMap.size());

      Config config = targetInstance.getConfig();
      MapConfig mapConfig = config.getMapConfig(integrityMap.getName());
      LOGGER.info(testId + ": " + mapConfig);
    }
  }
 @Before
 public void before() {
   config = instance.getConfig();
 }