@Test
  public void getCacheFilePath() {
    final String url = "store://some/url.bin";
    final String expectedPath = "/some/cache/file/path";
    Mockito.when(lookupTable.get(Key.forUrl(url))).thenReturn(expectedPath);

    String path = contentCache.getCacheFilePath(url);

    assertEquals("Paths must match", expectedPath, path);
  }
  @Test
  public void getContentUrl() {
    final File cacheFile = new File("/some/path");
    final String expectedUrl = "store://some/url";
    Mockito.when(lookupTable.get(Key.forCacheFile(cacheFile))).thenReturn(expectedUrl);

    String url = contentCache.getContentUrl(cacheFile);

    assertEquals("Content URLs should match", expectedUrl, url);
  }
Beispiel #3
0
  @Override
  public ContentReader getReader(String contentUrl) {
    Key url = Key.forUrl(contentUrl);
    if (memoryStore.contains(url)) {
      String path = memoryStore.get(url);

      // Getting the path for a URL from the memoryStore will reset the timeToIdle for
      // that URL. It is important to perform a reverse lookup as well to ensure that the
      // cache file path to URL mapping is also kept in the cache.
      memoryStore.get(Key.forCacheFile(path));

      File cacheFile = new File(path);
      if (cacheFile.exists()) {
        return new FileContentReader(cacheFile, contentUrl);
      }
    }

    throw new CacheMissException(contentUrl);
  }
  @Test
  public void remove() {
    final String url = "store://some/url.bin";
    final String path = "/some/path";
    Mockito.when(lookupTable.get(Key.forUrl(url))).thenReturn(path);

    contentCache.remove(url);

    Mockito.verify(lookupTable).remove(Key.forUrl(url));
    Mockito.verify(lookupTable).remove(Key.forCacheFile(path));
  }
  private static NodeRef getRootNodeRef() {
    NodeRef rootNodeRef = singletonCache.get(KEY_WEBDAV_ROOT_NODEREF);

    if (rootNodeRef == null) {
      rootNodeRef =
          tenantService.getRootNode(
              nodeService, searchService, namespaceService, rootPath, defaultRootNode);
      singletonCache.put(KEY_WEBDAV_ROOT_NODEREF, rootNodeRef);
    }

    return rootNodeRef;
  }
  @Test(expected = CacheMissException.class)
  public void getReaderForItemInCacheButMissingContentFile() {
    final String url = "store://content/url.bin";
    Mockito.when(lookupTable.contains(Key.forUrl(url))).thenReturn(true);
    final String path = "/no/content/file/at/this/path.bin";
    Mockito.when(lookupTable.get(Key.forUrl(url))).thenReturn(path);

    try {
      contentCache.getReader(url);
    } finally {
      // Important the get(path) was called, so that the timeToIdle is reset
      // for the 'reverse lookup' as well as the URL to path mapping.
      Mockito.verify(lookupTable).get(Key.forCacheFile(path));
    }
  }
Beispiel #7
0
  /* (non-Javadoc)
   * @see org.alfresco.repo.tenant.TenantService#getTenant(java.lang.String)
   */
  public Tenant getTenant(String tenantDomain) {
    tenantDomain = getTenantDomain(tenantDomain);
    Tenant tenant = tenantsCache.get(tenantDomain);
    if (tenant == null) {
      // backed by TenantAdminService - update this cache, e.g. could have been invalidated and/or
      // expired
      if (tenantAdminService != null) {
        tenant = tenantAdminService.getTenant(tenantDomain);
        if (tenant == null) {
          throw new AlfrescoRuntimeException("No such tenant " + tenantDomain);
        } else {
          putTenant(tenantDomain, tenant);
        }
      }
    }

    return tenant;
  }
  @Test
  public void canGetReaderForItemInCacheHavingLiveFile() {
    final String url = "store://content/url.bin";
    Mockito.when(lookupTable.contains(Key.forUrl(url))).thenReturn(true);
    final String path = tempfile().getAbsolutePath();
    Mockito.when(lookupTable.get(Key.forUrl(url))).thenReturn(path);

    FileContentReader reader = (FileContentReader) contentCache.getReader(url);

    assertEquals("Reader should have correct URL", url, reader.getContentUrl());
    assertEquals(
        "Reader should be for correct cached content file",
        path,
        reader.getFile().getAbsolutePath());
    // Important the get(path) was called, so that the timeToIdle is reset
    // for the 'reverse lookup' as well as the URL to path mapping.
    Mockito.verify(lookupTable).get(Key.forCacheFile(path));
  }
Beispiel #9
0
 /**
  * Get a content URL from the cache - keyed by File.
  *
  * @param file
  * @return
  */
 public String getContentUrl(File file) {
   return memoryStore.get(Key.forCacheFile(file));
 }
Beispiel #10
0
 /**
  * Get the path of a cache file for the given content URL - will return null if there is no entry
  * in the cache for the specified URL.
  *
  * @param contentUrl
  * @return cache file path
  */
 public String getCacheFilePath(String contentUrl) {
   return memoryStore.get(Key.forUrl(contentUrl));
 }
Beispiel #11
0
 // Not part of the ContentCache interface as this breaks encapsulation.
 // Handy method for tests though, since it allows us to find out where
 // the content was cached.
 protected String cacheFileLocation(String url) {
   return memoryStore.get(Key.forUrl(url));
 }