Esempio n. 1
0
  @Test
  public void testConfigFileHonorsClusteringOff() {
    final CacheManager cacheManager =
        new CacheManager(
            CacheManager.class.getResourceAsStream("/terracotta/ehcache-event-replication.xml"));
    try {
      final Cache cache = cacheManager.getCache("replication");
      assertThat(cache, notNullValue());
      final TerracottaConfiguration terracottaConfiguration =
          cache.getCacheConfiguration().getTerracottaConfiguration();
      assertThat(terracottaConfiguration, notNullValue());
      assertThat(terracottaConfiguration.isClustered(), is(false));
      final List eventListenerConfigurations =
          cache.getCacheConfiguration().getCacheEventListenerConfigurations();
      assertThat(eventListenerConfigurations, notNullValue());
      assertThat(eventListenerConfigurations.size(), is(1));
      assertThat(
          ((CacheConfiguration.CacheEventListenerFactoryConfiguration)
                  eventListenerConfigurations.get(0))
              .getFullyQualifiedClassPath(),
          equalTo(TerracottaCacheEventReplicationFactory.class.getName()));
      cache.put(new Element("key", "value"));
      assertThat((String) cache.get("key").getValue(), equalTo("value"));

    } finally {
      cacheManager.shutdown();
    }
  }
  @Around("findAllComPendendias()")
  public Object findAllTurmasComPendenciasMethodInterceptor(ProceedingJoinPoint joinPoint)
      throws Throwable {
    Object result = null;
    CacheManager cacheManager =
        CacheManager.create(new ClassPathResource("echache.xml").getInputStream());
    Cache cache = cacheManager.getCache("turmas-pendencias-cache");

    Object[] args = joinPoint.getArgs();

    if (args[0] == null || args[1] == null) {
      result = joinPoint.proceed();
      return result;
    }
    SimpleDateFormat df = new SimpleDateFormat("yyyy");
    String exercicio = df.format((Date) args[0]);
    String organizacao = ((Long) args[1]).toString();

    String key = exercicio + "-" + organizacao;
    Element element = cache.get(key);

    if (element == null) {
      result = joinPoint.proceed();
      cache.put(new Element(key, result));
    } else {
      Logger.getLogger(this.getClass().getName())
          .log(Level.INFO, "Dados presentes no cache, não foi necessário acesso ao banco de dados");
      result = element.getValue();
    }
    return result;
  }
 /** @see com.dianping.cache.core.CacheClient#clear() */
 @Override
 public void clear() {
   defaultBlockingCache.removeAll();
   for (String cacheName : manager.getCacheNames()) {
     manager.getCache(cacheName).removeAll();
   }
 }
Esempio n. 4
0
  /** Drive everything to point of breakage within a 64MB VM. */
  public void xTestHugePutsBreaksAsynchronous() throws CacheException, InterruptedException {

    // Give everything a chance to startup
    StopWatch stopWatch = new StopWatch();
    Integer index = null;
    for (int i = 0; i < 500; i++) {
      for (int j = 0; j < 1000; j++) {
        index = Integer.valueOf(((1000 * i) + j));
        cache1.put(
            new Element(
                index,
                "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
                    + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
                    + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
                    + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
                    + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"));
      }
    }
    long elapsed = stopWatch.getElapsedTime();
    long putTime = ((elapsed / 1000));
    LOG.info("Put Elapsed time: " + putTime);
    // assertTrue(putTime < 8);

    assertEquals(100000, cache1.getSize());

    Thread.sleep(100000);
    assertEquals(20000, manager2.getCache("sampleCache1").getSize());
    assertEquals(20000, manager3.getCache("sampleCache1").getSize());
    assertEquals(20000, manager4.getCache("sampleCache1").getSize());
    assertEquals(20000, manager5.getCache("sampleCache1").getSize());
  }
Esempio n. 5
0
  /**
   * {@inheritDoc} Sets up two caches: cache1 is local. cache2 is to be receive updates
   *
   * @throws Exception
   */
  @Override
  @Before
  public void setUp() throws Exception {

    // Required to get SoftReference tests to pass. The VM clean up SoftReferences rather than
    // allocating
    // memory to -Xmx!
    //        forceVMGrowth();
    //        System.gc();
    MulticastKeepaliveHeartbeatSender.setHeartBeatInterval(1000);

    manager1 = new CacheManager(AbstractCachePerfTest.TEST_CONFIG_DIR + "ehcache-distributed1.xml");
    manager2 = new CacheManager(AbstractCachePerfTest.TEST_CONFIG_DIR + "ehcache-distributed2.xml");
    manager3 = new CacheManager(AbstractCachePerfTest.TEST_CONFIG_DIR + "ehcache-distributed3.xml");
    manager4 = new CacheManager(AbstractCachePerfTest.TEST_CONFIG_DIR + "ehcache-distributed4.xml");
    manager5 = new CacheManager(AbstractCachePerfTest.TEST_CONFIG_DIR + "ehcache-distributed5.xml");

    // manager6 = new CacheManager(AbstractCacheTest.TEST_CONFIG_DIR +
    // "distribution/ehcache-distributed-jndi6.xml");

    // allow cluster to be established
    Thread.sleep(1020);

    cache1 = manager1.getCache(cacheName);
    cache1.removeAll();

    cache2 = manager2.getCache(cacheName);
    cache2.removeAll();

    // enable distributed removeAlls to finish
    Thread.sleep(1500);
  }
Esempio n. 6
0
  @PostConstruct
  public void initialize() {
    stats = new Stats();

    boolean cacheExists = cacheManager.cacheExists(getName());

    if (cacheExists) {
      if (failOnDuplicateCache) {
        throw new RuntimeException("A previous cache with name [" + getName() + "] exists.");
      } else {
        log.warn("skip duplicate cache " + getName());
        ehcache = cacheManager.getCache(getName());
      }
    }

    if (!cacheExists) {
      ehcache =
          new Cache(
              getName(),
              getMaxElementsInMemory(),
              getMemoryStoreEvictionPolicy(),
              isOverflowToDisk(),
              getDiskStorePath(),
              isEternal(),
              getTimeToLiveSeconds(),
              getTimeToIdleSeconds(),
              isDiskPersistent(),
              getDiskExpiryThreadIntervalSeconds(),
              null);

      cacheManager.addCache(ehcache);
      ehcache.setStatisticsEnabled(statisticsEnabled);
    }
  }
  /** ** Private Methods ** */
  private CacheEntry getCache(ProceedingJoinPoint pjp) {

    String name = getCacheName(pjp);

    CacheEntry entry = _entries.get(name);

    if (entry == null) {
      Method method = _cacheableMethodKeyFactoryManager.getMatchingMethodForJoinPoint(pjp);
      CacheableMethodKeyFactory keyFactory = getKeyFactory(pjp, method);
      boolean valueSerializable = isValueSerializable(pjp, method);
      Cache cache = _cacheManager.getCache(name);
      if (cache == null) {
        cache = createCache(pjp, name);
        if (cache == null) {
          _cacheManager.addCache(name);
          cache = _cacheManager.getCache(name);
        } else {
          _cacheManager.addCache(cache);
        }
      }
      entry = new CacheEntry(keyFactory, valueSerializable, cache);
      _entries.put(name, entry);
    }
    return entry;
  }
  @Bean
  public CacheManager cacheManager() {
    log.debug("Starting Ehcache");
    cacheManager = net.sf.ehcache.CacheManager.create();
    cacheManager
        .getConfiguration()
        .setMaxBytesLocalHeap(
            env.getProperty("cache.ehcache.maxBytesLocalHeap", String.class, "16M"));
    log.debug("Registering Ehcache Metrics gauges");
    Set<EntityType<?>> entities = entityManager.getMetamodel().getEntities();
    for (EntityType<?> entity : entities) {

      String name = entity.getName();
      if (name == null || entity.getJavaType() != null) {
        name = entity.getJavaType().getName();
      }
      Assert.notNull(name, "entity cannot exist without a identifier");

      net.sf.ehcache.Cache cache = cacheManager.getCache(name);
      if (cache != null) {
        cache
            .getCacheConfiguration()
            .setTimeToLiveSeconds(env.getProperty("cache.timeToLiveSeconds", Long.class, 3600L));
        net.sf.ehcache.Ehcache decoratedCache =
            InstrumentedEhcache.instrument(metricRegistry, cache);
        cacheManager.replaceCacheWithDecoratedCache(cache, decoratedCache);
      }
    }
    EhCacheCacheManager ehCacheManager = new EhCacheCacheManager();
    ehCacheManager.setCacheManager(cacheManager);
    return ehCacheManager;
  }
  protected static CacheManager getCacheManagerMaxbytes() {
    Configuration configuration = new Configuration();
    configuration.setName("testCacheManagerProgrammatic");
    configuration.setMaxBytesLocalDisk("10M");
    configuration.setMaxBytesLocalHeap("5M");
    TerracottaClientConfiguration terracottaConfiguration =
        new TerracottaClientConfiguration().url(CLUSTER_URL);
    configuration.addTerracottaConfig(terracottaConfiguration);
    CacheConfiguration myCache =
        new CacheConfiguration()
            .eternal(false)
            .name("testCache2")
            .terracotta(new TerracottaConfiguration());
    configuration.addCache(myCache);
    ManagementRESTServiceConfiguration managementRESTServiceConfiguration =
        new ManagementRESTServiceConfiguration();
    managementRESTServiceConfiguration.setBind("0.0.0.0:" + STANDALONE_REST_AGENT_PORT);
    managementRESTServiceConfiguration.setEnabled(true);
    configuration.addManagementRESTService(managementRESTServiceConfiguration);

    CacheManager mgr = new CacheManager(configuration);
    Cache exampleCache = mgr.getCache("testCache2");
    assert (exampleCache != null);
    return mgr;
  }
  @Test
  public void testBasicReplication() throws Exception {
    LOG.info("START TEST");

    final Ehcache cache1 = manager1.getEhcache(cacheName);
    final Ehcache cache2 = manager2.getEhcache(cacheName);
    final Ehcache cache3 = manager3.getEhcache(cacheName);
    final Ehcache cache4 = manager4.getEhcache(cacheName);

    for (int i = 0; i < NBR_ELEMENTS; i++) {
      cache1.put(new Element(i, "testdat"));
    }

    // Wait up to 3 seconds for the caches to become coherent
    CacheTestUtilities.waitForReplication(NBR_ELEMENTS, MAX_WAIT_TIME, cache2, cache3, cache4);

    assertEquals(NBR_ELEMENTS, cache1.getKeys().size());
    assertEquals(NBR_ELEMENTS, cache2.getKeys().size());
    assertEquals(NBR_ELEMENTS, cache3.getKeys().size());
    assertEquals(NBR_ELEMENTS, cache4.getKeys().size());

    cache1.removeAll();

    // Wait up to 3 seconds for the caches to become coherent
    CacheTestUtilities.waitForReplication(0, MAX_WAIT_TIME, cache2, cache3, cache4);

    assertEquals(0, cache1.getKeys().size());
    assertEquals(0, cache2.getKeys().size());
    assertEquals(0, cache3.getKeys().size());
    assertEquals(0, cache4.getKeys().size());

    LOG.info("END TEST");
  }
 @Bean
 public net.sf.ehcache.CacheManager customEhCacheCacheManager() {
   net.sf.ehcache.CacheManager cacheManager = mock(net.sf.ehcache.CacheManager.class);
   given(cacheManager.getStatus()).willReturn(Status.STATUS_ALIVE);
   given(cacheManager.getCacheNames()).willReturn(new String[0]);
   return cacheManager;
 }
  public void testSimultaneousPutRemove() throws InterruptedException {
    cacheName = SAMPLE_CACHE2; // Synced one
    Ehcache cache1 = manager1.getEhcache(cacheName);
    Ehcache cache2 = manager2.getEhcache(cacheName);

    Serializable key = "1";
    Serializable value = new Date();
    Element element = new Element(key, value);

    // Put
    cache1.put(element);
    Thread.currentThread().sleep(1000);
    cache2.remove(element.getKey());
    Thread.currentThread().sleep(1000);

    assertNull(cache1.get(element.getKey()));
    manager1.clearAll();
    Thread.currentThread().sleep(1000);

    cache2.put(element);
    cache2.remove(element.getKey());
    Thread.currentThread().sleep(1000);
    cache1.put(element);
    Thread.currentThread().sleep(1000);
    assertNotNull(cache2.get(element.getKey()));

    manager1.clearAll();
    Thread.currentThread().sleep(1000);
  }
  protected static CacheManager getCacheManagerMaxEntries() {
    Configuration configuration = new Configuration();
    configuration.setName("testCacheManager");
    configuration.addTerracottaConfig(new TerracottaClientConfiguration().url(CLUSTER_URL));
    CacheConfiguration defaultCacheConfiguration =
        new CacheConfiguration()
            .eternal(true)
            .terracotta(new TerracottaConfiguration())
            .maxEntriesLocalHeap(10000);
    CacheConfiguration cacheConfiguration =
        new CacheConfiguration()
            .name("testCache")
            .terracotta(new TerracottaConfiguration())
            .maxEntriesLocalHeap(10000);
    configuration.setDefaultCacheConfiguration(defaultCacheConfiguration);
    configuration.addCache(cacheConfiguration);
    ManagementRESTServiceConfiguration managementRESTServiceConfiguration =
        new ManagementRESTServiceConfiguration();
    managementRESTServiceConfiguration.setBind("0.0.0.0:" + STANDALONE_REST_AGENT_PORT);
    managementRESTServiceConfiguration.setEnabled(true);
    configuration.addManagementRESTService(managementRESTServiceConfiguration);

    CacheManager mgr = new CacheManager(configuration);
    Cache exampleCache = mgr.getCache("testCache");
    assert (exampleCache != null);
    return mgr;
  }
  @Around("findTurmaEfetiva()")
  public Object findTurmaEfetivaMethodInterceptor(ProceedingJoinPoint joinPoint) throws Throwable {
    Object result = null;
    CacheManager cacheManager =
        CacheManager.create(new ClassPathResource("echache.xml").getInputStream());
    Cache cache = cacheManager.getCache("turmas-efetivas-cache");

    Object[] args = joinPoint.getArgs();

    Long turmaId = (Long) args[0];

    Element element = cache.get(turmaId);

    if (element == null) {
      result = joinPoint.proceed();
      cache.put(new Element(turmaId, result));

    } else {
      Logger.getLogger(this.getClass().getName())
          .log(
              Level.INFO,
              "Dados presentes no cache de turmas, não foi necessário acesso ao banco de dados");
      result = element.getValue();
    }
    return result;
  }
Esempio n. 15
0
 @Override
 public EhCache buildCache(CacheSetting setting) throws CacheException {
   String name = StringUtil.joinString(setting.getRegion(), setting.getConfigKey());
   EhCache ehcache = cacheManager.get(name);
   if (ehcache == null) {
     try {
       synchronized (cacheManager) {
         ehcache = cacheManager.get(name);
         if (ehcache == null) {
           // log.debug("Could not find configuration [" + name
           // + "]; using defaults.");
           Ehcache ehcache2 = manager.addCacheIfAbsent(name);
           if (ehcache2 != null) {
             if (setting.getCacheExpire() == CacheExpire.SlidingTime) {
               ehcache2.getCacheConfiguration().setTimeToIdleSeconds(setting.getExpireTime());
               ehcache2.getCacheConfiguration().setTimeToLiveSeconds(0);
             } else if (setting.getCacheExpire() == CacheExpire.AbsoluteTime) {
               ehcache2.getCacheConfiguration().setTimeToLiveSeconds(setting.getExpireTime());
               ehcache2.getCacheConfiguration().setTimeToIdleSeconds(0);
             }
           }
           Cache cache = manager.getCache(name);
           // log.debug("started EHCache region: " + name);
           LoggerFactory.getLogger(this.getClass()).info("init ehcache " + cache);
           ehcache = new EhCache(cache, setting);
           cacheManager.put(name, ehcache);
         }
       }
     } catch (Exception e) {
       throw new CacheException(e);
     }
   }
   return ehcache;
 }
  @Test
  public void testParallelShutdown() throws Exception {
    final CacheManager manager =
        new CacheManager(
            new Configuration()
                .name("testEqualsDriver")
                .cache(
                    new CacheConfiguration()
                        .name("parallel")
                        .maxBytesLocalHeap(64, MemoryUnit.MEGABYTES)));
    Cache parallel = manager.getCache("parallel");
    CacheDriver loadParallel =
        CacheLoader.load(ehcache(parallel))
            .using(StringGenerator.integers(), ByteArrayGenerator.fixedSize(128))
            .sequentially()
            .untilFilled();
    final CacheDriver driver = ParallelDriver.inParallel(4, loadParallel);

    await()
        .atMost(20, TimeUnit.SECONDS)
        .until(
            new Callable<Boolean>() {
              @Override
              public Boolean call() throws Exception {
                driver.run();
                return true;
              }
            });
    manager.shutdown();
  }
Esempio n. 17
0
 /** Basically does the same as CacheManager.getCache() except that this method is lock free. */
 private static CacheManager getCacheManager(String cacheManagerName) {
   for (CacheManager cacheManager : CacheManager.ALL_CACHE_MANAGERS) {
     if (cacheManager.getName().equals(cacheManagerName)) {
       return cacheManager;
     }
   }
   return null;
 }
Esempio n. 18
0
 private void updateSchoolCache(SchoolAccount accnt) {
   cacheManager
       .getCache(CacheVariables.CACHE_SCHOOL_ACCOUNTS_BY_USERNAME)
       .put(new Element(accnt.getUsername(), accnt));
   cacheManager
       .getCache(CacheVariables.CACHE_ACCOUNTS_BY_UUID)
       .put(new Element(accnt.getUuid(), accnt));
 }
 /** Does a down cache manager in the cluster get removed? */
 @Test
 public void testRemoteCachePeersDetectsDownCacheManager() throws InterruptedException {
   // Drop a CacheManager from the cluster
   manager3.shutdown();
   // Allow change detection to occur. Heartbeat 1 second and is not stale until 5000
   waitForClusterMembership(
       11020, TimeUnit.MILLISECONDS, Arrays.asList(manager1.getCacheNames()), manager1, manager2);
 }
Esempio n. 20
0
 static {
   if (eternalCache == null) {
     eternalCache = CacheManager.getInstance().getCache("eternalCache");
   }
   if (dictCache == null) {
     dictCache = CacheManager.getInstance().getCache("dictCache");
   }
 }
Esempio n. 21
0
 public static synchronized Cache getInstance() {
   if (ehCache == null) {
     logger.info("The first time to create cache!");
     CacheManager manager = CacheManager.create();
     ehCache = manager.getCache("ehcache");
   }
   return ehCache;
 }
 private void clearChache() throws IOException {
   CacheManager cacheManager =
       CacheManager.create(new ClassPathResource("echache.xml").getInputStream());
   Cache cache1 = cacheManager.getCache("turmas-efetivas-cache");
   Cache cache2 = cacheManager.getCache("turmas-pendencias-cache");
   cache1.removeAll();
   cache2.removeAll();
 }
Esempio n. 23
0
 /**
  * 获得一个Cache,没有则创建一个。
  *
  * @param cacheName
  * @return
  */
 private static Cache getCache(String cacheName) {
   Cache cache = cacheManager.getCache(cacheName);
   if (cache == null) {
     cacheManager.addCache(cacheName);
     cache = cacheManager.getCache(cacheName);
     cache.getCacheConfiguration().setEternal(true);
   }
   return cache;
 }
Esempio n. 24
0
    private static Cache[] allCaches(CacheManager cacheManager) {
      int i = 0;
      Cache[] caches = new Cache[cacheManager.getCacheNames().length];
      for (String name : cacheManager.getCacheNames()) {
        caches[i++] = cacheManager.getCache(name);
      }

      return caches;
    }
Esempio n. 25
0
 public Cache getEhCache() {
   Cache cache = ehcacheManager.getCache(name);
   if (null == cache) {
     ehcacheManager.addCache(name);
     return ehcacheManager.getCache(name);
   } else {
     return cache;
   }
 }
 public void testConfig() throws InterruptedException {
   cacheName = SAMPLE_CACHE_NOREP;
   Ehcache cache1 = manager1.getEhcache(cacheName);
   Ehcache cache2 = manager2.getEhcache(cacheName);
   Element element = new Element(new Integer(1), new Date());
   cache2.put(element);
   Thread.currentThread().sleep(1000);
   assertTrue(cache1.getKeys().size() == 0 && cache2.getKeys().size() == 1);
 }
Esempio n. 27
0
 private void reconfigureCache(String name, JHipsterProperties jHipsterProperties) {
   net.sf.ehcache.Cache cache = cacheManager.getCache(name);
   if (cache != null) {
     cache
         .getCacheConfiguration()
         .setTimeToLiveSeconds(jHipsterProperties.getCache().getTimeToLiveSeconds());
     net.sf.ehcache.Ehcache decoratedCache = InstrumentedEhcache.instrument(metricRegistry, cache);
     cacheManager.replaceCacheWithDecoratedCache(cache, decoratedCache);
   }
 }
Esempio n. 28
0
 /**
  * 清除缓存
  *
  * @param cacheName
  * @return
  */
 public boolean clearCache(String cacheName) {
   CacheManager cacheManagerObject = cacheManager.getObject();
   Cache cache = cacheManagerObject.getCache(cacheName);
   if (cache != null) {
     cache.removeAll();
     return Boolean.TRUE;
   } else {
     return Boolean.FALSE;
   }
 }
Esempio n. 29
0
  /** Does the RMI listener stop? */
  @Test
  public void testListenerShutsdown() {
    CacheManagerPeerListener cachePeerListener = manager1.getCachePeerListener("RMI");
    List cachePeers1 = cachePeerListener.getBoundCachePeers();
    assertEquals(1, cachePeers1.size());
    assertEquals(Status.STATUS_ALIVE, cachePeerListener.getStatus());

    manager1.shutdown();
    assertEquals(Status.STATUS_SHUTDOWN, cachePeerListener.getStatus());
  }
 public void tearDown() throws Exception {
   LOG.debug("Tearing down cm1");
   manager1.shutdown();
   LOG.debug("Tearing down cm2");
   manager2.shutdown();
   LOG.debug("Tearing down cm3");
   manager3.shutdown();
   LOG.debug("Tearing down cm4");
   manager4.shutdown();
 }